@isnap/sdk 1.3.0 → 1.4.0-next.204

package/dist/generated/openapi.d.ts

@@ -387,7 +387,7 @@ export interface paths {
         };
         /**
          * List available lines (public marketplace)
-         * @description Browse the marketplace inventory of unassigned lines. Filter by billing tier, area code, country code, status. Returns only `status: available` and never the iSnap-internal `shared_pool` tier. Unauthenticated — partners use this in prospecting / quote flows.
+         * @description Browse the marketplace inventory of unassigned lines. Filter by billing tier, area code, country code, state, country. Returns only `status: available` and never the iSnap-internal `shared_pool` tier — `?status=` therefore accepts `available` alone and refuses any other status with a 400, rather than answering with a list you did not ask for (WHA-2777). Unauthenticated — partners use this in prospecting / quote flows.
          */
         get: {
             parameters: {
@@ -399,6 +399,7 @@ export interface paths {
                     state?: string;
                     /** @description Country filter — ISO alpha-2 code or country name. */
                     country?: string;
+                    /** @description Comma-separated set of statuses to filter on. Every member must be one of: available — anything else is a 400, never an empty list. Omitted or blank means no status filter. */
                     status?: string;
                     page?: number;
                     limit?: number;
@@ -551,7 +552,7 @@ export interface paths {
         };
         /**
          * Get line details (public marketplace)
-         * @description Fetch a single line by its `line_<base62>` id. Available unauthenticated for the marketplace browsing flow; partner-private metadata still requires API key access via `GET /v1/lines/my`.
+         * @description Fetch a single line by its `line_<base62>` id. Available unauthenticated for the marketplace browsing flow, where the `phone_number` is masked so the inventory cannot be scraped. Authenticate with your API key (or dashboard JWT) and, when you own the line, the `phone_number` comes back unmasked — the same full number `GET /v1/lines/my` returns (WHA-3030). A credential that does not own the line, or none at all, still gets the masked number.
          */
         get: {
             parameters: {
@@ -623,8 +624,8 @@ export interface paths {
         options?: never;
         head?: never;
         /**
-         * Update line metadata
-         * @description Merge-patch the line's free-form `metadata` tag object. Pass `null` for a key to delete it; pass a new value to overwrite. Metadata is echoed on every `line.*` webhook so partners can attribute events back to their own customer IDs.
+         * Update a line
+         * @description Update the line's free-form `metadata` tag object, its billing anchor, or both. **`metadata`** is a MERGE-patch: pass `null` for a key to delete it, a new value to overwrite. It is echoed on every `line.*` webhook so partners can attribute events back to their own customer IDs. **`billing_anchor_at`** is the date the customer who pays for this line is billed on: a change takes effect at the NEXT occurrence and never rewrites a period already billed, and `null` clears it so the line falls back to its activation instant. Send at least one of the two — a body that sets neither is refused with `no_fields_to_patch`.
          */
         patch: {
             parameters: {
@@ -1059,7 +1060,7 @@ export interface paths {
         put?: never;
         /**
          * Activate a reserved line
-         * @description Commit a `reserved` line to `active`. Wholesale partners (no Stripe checkout surface) use this as the second phase of reserve→activate — they reserve, bill their own end-user, then activate within the 15-minute window with no per-line Stripe sub (EOM-metered), and may pick the INBOUND product via `inbound_only` (a line that cannot initiate — the contact must message first, after which the exchange is unrestricted; not receive-only). Direct callers get the test/dev mock-sub shortcut (production direct activation happens via the Stripe webhook on `checkout.session.completed`); `inbound_only` is ignored for them (theirs comes from the checkout price).
+         * @description Commit a `reserved` line to `active`. **Wholesale partners only** (no Stripe checkout surface): this is the second phase of reserve→activate — they reserve, bill their own end-user, then activate within the 15-minute window with no per-line Stripe sub (EOM-metered), and may pick the INBOUND product via `inbound_only` (a line that cannot initiate — the contact must message first, after which the exchange is unrestricted; not receive-only). Pass `billing_anchor_at` to bill this line on the date your own customer is billed on rather than on its activation instant — one full month at each occurrence, with a credit at the first one for the days the activation month had already paid for past it. Direct customers get `402 checkout_required`: their line is activated by the `checkout.session.completed` webhook once `POST /v1/billing/checkout` is paid, which is what mints the Stripe subscription that bills them (§2.5 Flow A). `inbound_only` is meaningless for them — theirs comes from the checkout price.
          */
         post: {
             parameters: {
@@ -1109,6 +1110,15 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
+                /** @description Payment required — no billing relationship entitles this call */
+                402: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
                 /** @description Forbidden — caller authenticated but not allowed */
                 403: {
                     headers: {
@@ -1496,7 +1506,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/v1/lines/{id}/release": {
+    "/v1/lines/{id}/variant": {
         parameters: {
             query?: never;
             header?: never;
@@ -1506,8 +1516,8 @@ export interface paths {
         get?: never;
         put?: never;
         /**
-         * Release a line back to the marketplace
-         * @description Cancel the line's ownership and return it to `available`. Cancels the underlying Stripe subscription at period end. The caller must own the line. See `/concepts/billing` for the proration rules.
+         * Switch a rental line between inbound-only and two-way
+         * @description Move a rental line you own between the INBOUND product (`inbound_only: true` — the line may only message a handle that has messaged it first; it is NOT receive-only) and the TWO-WAY product, **keeping the same phone number, hardware and device session**. `effective` says WHEN: `now` (the default, and the only behaviour before the field existed) applies it to the very next send; `next_anchor` stores it against the line's next billing anchor, leaves `inbound_only` alone, and surfaces the change as `pending_variant` on the line — which is what a DOWNGRADE needs, so the customer keeps the product they have already paid for through the month. Idempotent on the value in both modes: asking for the variant the line already has (or re-scheduling the change already pending) returns 200 and writes nothing. **A scheduled call can therefore legitimately answer `pending_variant: null`** — scheduling the variant the line ALREADY carries writes nothing, because nothing is pending: the line will still be on that variant at the anchor. That is a truthful 200, not a failure. Tell it apart from a dropped-field failure by reading the top-level `inbound_only`: equal to what you asked for means already-at-target; different means your `effective` never reached this endpoint and the change was applied immediately. `not_before` (optional ISO instant, `next_anchor` only, default now) is the earliest instant the change may take effect; iSnap schedules it at the first anchor occurrence AT OR AFTER it, so a quarterly or annual customer keeps their product for the whole period they paid for instead of losing it at the next anchor. A `not_before` in the past is refused with `400 not_before_in_the_past` rather than clamped. Refused with 409 on a non-rental line (`not_a_rental_line`), on a line that is not `active` (`line_not_active`), on a line carrying an iSnap Stripe subscription (`variant_bound_to_stripe_price`) — there the subscription's price is the variant and changing the subscription is how it moves — and, when scheduling, on a line that already has a DIFFERENT change pending (`variant_change_already_pending`; cancel it first). Emits `line.variant_changed` on an immediate change and `line.variant_scheduled` on a scheduled one.
          */
         post: {
             parameters: {
@@ -1518,9 +1528,13 @@ export interface paths {
                 };
                 cookie?: never;
             };
-            requestBody?: never;
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["SetLineVariant"];
+                };
+            };
             responses: {
-                /** @description Line released */
+                /** @description Line. With `effective: "now"` its `inbound_only` reflects the requested variant; with `effective: "next_anchor"` `inbound_only` is unchanged and `pending_variant` carries the requested variant and the date it applies. */
                 200: {
                     headers: {
                         [name: string]: unknown;
@@ -1571,6 +1585,15 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
+                /** @description Conflict — concurrent or terminal state */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
                 /** @description Too many requests — rate limit exceeded */
                 429: {
                     headers: {
@@ -1591,24 +1614,11 @@ export interface paths {
                 };
             };
         };
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
-    "/v1/lines/{id}/quota": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
         /**
-         * Get a line's quota snapshot
-         * @description Five-bucket quota snapshot: new-contacts, known-contacts, total daily messages, hourly, and minute counters with their effective limits plus 80%-warning flags. Drives the dashboard usage panel and partner self-service throttle decisions.
+         * Cancel a scheduled variant change
+         * @description Call off the variant change scheduled for this line's next billing anchor (`POST /v1/lines/{id}/variant` with `effective: 'next_anchor'`). The line's live `inbound_only` is never touched by this call — it was never moved by the scheduling either — so the only effect is that `pending_variant` becomes `null` and nothing happens at the anchor. Answers `404 no_pending_variant_change` when the line carries no pending change, which includes a change the anchor has already applied; a change applied while this request was in flight is `409 variant_change_already_applied`. Succeeds on a suspended or cancelled line: withdrawing an instruction must never be blocked by the state that made it moot. Emits `line.variant_unscheduled`.
          */
-        get: {
+        delete: {
             parameters: {
                 query?: never;
                 header?: never;
@@ -1619,14 +1629,12 @@ export interface paths {
             };
             requestBody?: never;
             responses: {
-                /** @description 5-bucket quota snapshot */
-                200: {
+                /** @description Scheduled variant change cancelled */
+                204: {
                     headers: {
                         [name: string]: unknown;
                     };
-                    content: {
-                        "application/json": components["schemas"]["QuotaEnvelope"];
-                    };
+                    content?: never;
                 };
                 /** @description Bad request — validation failed */
                 400: {
@@ -1664,6 +1672,15 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
+                /** @description Conflict — concurrent or terminal state */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
                 /** @description Too many requests — rate limit exceeded */
                 429: {
                     headers: {
@@ -1684,47 +1701,52 @@ export interface paths {
                 };
             };
         };
-        put?: never;
-        post?: never;
-        delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/v1/lines/{id}/queue": {
+    "/v1/lines/{id}/terminate": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
+        get?: never;
+        put?: never;
         /**
-         * Inspect a line's queued and scheduled messages
-         * @description Cursor-paginated queue snapshot: per-row `to` / `body` / `status` (`queued` / `scheduled` / `delivered_to_device`) + the schedule reason and the activity-curve hour. Companion to `GET /v1/lines/{id}/quota` for partners debugging delivery delays.
+         * Terminate a line you own
+         * @description Permanently END an active line the caller owns — the self-serve counterpart to the admin terminate. Use this when your own customer cancels: `/release` only returns a *reserved* marketplace line to the shelf, while this ends a live `rental` line or a virtual `shared` line for good. The line flips to the terminal `cancelled` status and keeps its owner (who held it when it died is history, not a shelf return); queued messages fail with `carrier_terminated`, shared-fleet bindings are released (`binding.released`), device sessions are revoked, and `line.disconnected` fires with `reason: customer_initiated`. Billing stops in both shapes: a per-line Stripe subscription is cancelled immediately (not at period end), and a wholesale partner's end-of-month active-line count drops the line in the same breath. Dedicated hardware goes back to iSnap stock — the eSIM and Apple ID are recycled, never scrapped, because a customer ending a rental says nothing about whether the carrier plan is still good. **Idempotent**: terminating an already-terminated line returns 200 with the line unchanged and fires nothing a second time. Only an `active` or `suspended` line — the ones you are actually being billed for — is terminable: a merely `reserved` line is a 15-minute hold you give back with `/release`, and a `provisioning` pre-order line is cancelled through `/v1/pre-orders/{id}/cancel`. A BYOD line is terminable like any other: its device session is revoked, so the bridge or phone stops serving it, and it leaves the billable set; a direct customer's slot is freed for a new pairing. Owned test lines are refused (403) until converted back with `/convert-from-test`.
          */
-        get: {
+        post: {
             parameters: {
-                query?: {
-                    limit?: number;
-                    cursor?: string;
-                    status?: "queued" | "scheduled" | "delivered_to_device";
-                };
+                query?: never;
                 header?: never;
                 path: {
                     id: string;
                 };
                 cookie?: never;
             };
-            requestBody?: never;
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["TerminateLine"];
+                };
+            };
             responses: {
-                /** @description Queue inspection — summary + paginated items */
+                /** @description Line terminated (or already terminated — the call is idempotent). Returns the line at its terminal `cancelled` status. */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["QueueEnvelope"];
+                        "application/json": {
+                            /** @enum {boolean} */
+                            success: true;
+                            data: components["schemas"]["Line"];
+                            trace_id: string;
+                            request_id: string;
+                        };
                     };
                 };
                 /** @description Bad request — validation failed */
@@ -1763,6 +1785,15 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
+                /** @description Conflict — concurrent or terminal state */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
                 /** @description Too many requests — rate limit exceeded */
                 429: {
                     headers: {
@@ -1783,26 +1814,26 @@ export interface paths {
                 };
             };
         };
-        put?: never;
-        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/v1/lines/{id}/health": {
+    "/v1/lines/{id}/cancel": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
+        get?: never;
+        put?: never;
         /**
-         * Get a BYOD line's health snapshot
-         * @description BYOD-only health rollup. `state` (`active` / `degraded` / `offline`) is derived from the device's fundamental capabilities — min(send_text, imessage) — with offline (no heartbeat) taking precedence. Also returns `runtime_capabilities` (the per-key tri-valued descriptor the device last reported), last heartbeat timestamp, daily quota headroom, Apple-ID-flagged flag, last-error string, bridge version. Rental tiers receive 403 `rental_health_not_exposed` — they don't own the hardware and surfacing transient state creates support-ticket noise.
+         * Cancel a line at its next billing anniversary
+         * @description Schedule the END of a line you own for its next billing anniversary, and keep using it until then. This is the verb for "my own customer cancelled": the month is already paid for and iSnap never prorates, so terminating on the spot would destroy days you have bought. The line stays fully `active` — it sends, receives and bills exactly as before — and iSnap terminates it itself when `cancel_at` arrives, firing `line.terminated` with `origin: scheduled_cancellation`. The date is the next occurrence of `anniversary_at` strictly after now, clamped to the last day of a shorter month (a line taken on the 31st renews on the 28th in February and on the 31st again in March — the clamp never sticks). **Idempotent**: cancelling an already-cancelled line returns the SAME `cancel_at`, never a recomputed one, so a retry that happens to cross the anniversary cannot push your own cancellation a month into the future. Undo it with `/uncancel` any time before the date. Refused with 409 `line_has_no_anniversary` on a line that has none — state it with `/anniversary`, or end the line now with `/terminate`. Rental, shared and BYOD lines are all cancellable; a BYOD line is terminated at its date like the others.
          */
-        get: {
+        post: {
             parameters: {
                 query?: never;
                 header?: never;
@@ -1813,13 +1844,19 @@ export interface paths {
             };
             requestBody?: never;
             responses: {
-                /** @description BYOD line health snapshot */
+                /** @description Cancellation scheduled (or already scheduled — the call is idempotent). Returns the line, still `active`, with `cancel_at` set. */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["LineHealthEnvelope"];
+                        "application/json": {
+                            /** @enum {boolean} */
+                            success: true;
+                            data: components["schemas"]["Line"];
+                            trace_id: string;
+                            request_id: string;
+                        };
                     };
                 };
                 /** @description Bad request — validation failed */
@@ -1858,6 +1895,15 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
+                /** @description Conflict — concurrent or terminal state */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
                 /** @description Too many requests — rate limit exceeded */
                 429: {
                     headers: {
@@ -1878,26 +1924,26 @@ export interface paths {
                 };
             };
         };
-        put?: never;
-        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/v1/lines/{id}/config": {
+    "/v1/lines/{id}/uncancel": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
+        get?: never;
+        put?: never;
         /**
-         * Get a line's effective send configuration
-         * @description Return the resolved send configuration for this line — tier defaults merged with per-line overrides. Surfaces effective quota caps, timezone, activity-curve target hour, and the `overridden_keys` list so partners can see which fields they've customised.
+         * Undo a scheduled cancellation
+         * @description Clear a pending cancellation: `cancel_at` goes back to `null` and the line resumes renewing at its anniversary like any other. Nothing about the line changed while it was cancelled — it never stopped working — so there is nothing to restore. **A no-op on a line that is not cancelled**: 200 with the line and `cancel_at: null`, which is the honest answer to "make sure this line is not cancelled" and lets a reconciliation loop run without treating its own success as an error. Refused with 409 `line_already_terminated` once the anniversary has passed and iSnap has ended the line — that cannot be undone; order a new line instead.
          */
-        get: {
+        post: {
             parameters: {
                 query?: never;
                 header?: never;
@@ -1908,13 +1954,19 @@ export interface paths {
             };
             requestBody?: never;
             responses: {
-                /** @description Effective config (tier defaults + per-line overrides) */
+                /** @description Cancellation cleared, or the line was not cancelled. Returns the line with `cancel_at: null`. */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["LineConfigEnvelope"];
+                        "application/json": {
+                            /** @enum {boolean} */
+                            success: true;
+                            data: components["schemas"]["Line"];
+                            trace_id: string;
+                            request_id: string;
+                        };
                     };
                 };
                 /** @description Bad request — validation failed */
@@ -1953,6 +2005,15 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
+                /** @description Conflict — concurrent or terminal state */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
                 /** @description Too many requests — rate limit exceeded */
                 429: {
                     headers: {
@@ -1973,16 +2034,26 @@ export interface paths {
                 };
             };
         };
-        put?: never;
-        post?: never;
         delete?: never;
         options?: never;
         head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/lines/{id}/anniversary": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
         /**
-         * Update a line's send configuration
-         * @description Merge-patch the line's per-line config overrides (quota caps, timezone, activity curve). Pass `null` for a key to revert it to the tier default. Validates the activity curve sums to 1.0 and rejects an unknown timezone with 400.
+         * State the day you took this line
+         * @description Record the instant you took this line, which becomes the day of the month it renews on and the date `/cancel` waits for. **This is for lines migrated from your own system**, whose real start date iSnap cannot know: a line taken through the iSnap API is stamped automatically at activation and needs no call. A BYOD line is accepted here even though `/cancel` refuses it: it is on the same monthly meter and carries an anniversary, iSnap simply has no way to end it for you at that date yet. Overwrites an existing anniversary — a date somebody states beats a date iSnap inferred — but is refused with 409 `line_cancellation_pending` while a cancellation is scheduled, because that `cancel_at` was computed from the anniversary you are replacing and would otherwise end the line on a day nothing explains: uncancel, set the date, cancel again. Audited as `line.anniversary_set` with the previous value.
          */
-        patch: {
+        post: {
             parameters: {
                 query?: never;
                 header?: never;
@@ -1993,17 +2064,23 @@ export interface paths {
             };
             requestBody?: {
                 content: {
-                    "application/json": components["schemas"]["LineConfigPatch"];
+                    "application/json": components["schemas"]["SetLineAnniversary"];
                 };
             };
             responses: {
-                /** @description Updated effective config (merged) + overridden_keys */
+                /** @description Anniversary recorded. Returns the line with the new `anniversary_at`. */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["LineConfigEnvelope"];
+                        "application/json": {
+                            /** @enum {boolean} */
+                            success: true;
+                            data: components["schemas"]["Line"];
+                            trace_id: string;
+                            request_id: string;
+                        };
                     };
                 };
                 /** @description Bad request — validation failed */
@@ -2042,6 +2119,15 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
+                /** @description Conflict — concurrent or terminal state */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
                 /** @description Too many requests — rate limit exceeded */
                 429: {
                     headers: {
@@ -2062,39 +2148,49 @@ export interface paths {
                 };
             };
         };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
         trace?: never;
     };
-    "/v1/pre-orders": {
+    "/v1/lines/{id}/release": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
+        get?: never;
+        put?: never;
         /**
-         * List pre-orders
-         * @description Cursor-paginated list of the caller's pre-orders. Filter by status (`pending`, `provisioning`, `ready`, `fulfilled`, `cancelled`, `refunded`) to surface only the ones the dashboard needs.
+         * Release a line back to the marketplace
+         * @description Cancel the line's ownership and return it to `available`. Cancels the underlying Stripe subscription at period end. The caller must own the line. See `/concepts/billing` for the proration rules.
          */
-        get: {
+        post: {
             parameters: {
-                query?: {
-                    status?: "draft" | "pending" | "provisioning" | "ready" | "fulfilled" | "cancelled" | "refunded";
-                    cursor?: string;
-                    limit?: number;
-                };
+                query?: never;
                 header?: never;
-                path?: never;
+                path: {
+                    id: string;
+                };
                 cookie?: never;
             };
             requestBody?: never;
             responses: {
-                /** @description Pre-order list */
+                /** @description Line released */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["PreOrderList"];
+                        "application/json": {
+                            /** @enum {boolean} */
+                            success: true;
+                            data: components["schemas"]["Line"];
+                            trace_id: string;
+                            request_id: string;
+                        };
                     };
                 };
                 /** @description Bad request — validation failed */
@@ -2115,6 +2211,24 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
+                /** @description Forbidden — caller authenticated but not allowed */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
                 /** @description Too many requests — rate limit exceeded */
                 429: {
                     headers: {
@@ -2135,12 +2249,556 @@ export interface paths {
                 };
             };
         };
-        put?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/lines/{id}/quota": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
         /**
-         * Create a pre-order (draft)
-         * @description Place a pre-order as a `draft` (WHA-1155). A draft has NO side effects — no provisioning line, no procurement, no Stripe charge — so the partner can hold intent / bill its own end-user first. Call `POST /v1/pre-orders/{id}/confirm` to engage the month and start procurement. `inbound_only` is remembered for confirm.
+         * Get a line's quota snapshot
+         * @description Five-bucket quota snapshot: new-contacts, known-contacts, total daily messages, hourly, and minute counters with their effective limits plus 80%-warning flags, alongside the reply lane's rolling budget. Each bucket also reports `*_frees_at` — the instant it drops back under its limit, or `null` when it has room now. Drives the dashboard usage panel and partner self-service throttle decisions.
          */
-        post: {
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description 5-bucket quota snapshot */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["QuotaEnvelope"];
+                    };
+                };
+                /** @description Bad request — validation failed */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Unauthenticated — missing or invalid bearer token */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Forbidden — caller authenticated but not allowed */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Too many requests — rate limit exceeded */
+                429: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/lines/{id}/queue": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Inspect a line's queued and scheduled messages
+         * @description Cursor-paginated queue snapshot: per-row `to` / `body` / `status` (`queued` / `scheduled` / `delivered_to_device`) + the schedule reason and the activity-curve hour. Companion to `GET /v1/lines/{id}/quota` for partners debugging delivery delays.
+         */
+        get: {
+            parameters: {
+                query?: {
+                    limit?: number;
+                    cursor?: string;
+                    status?: "queued" | "scheduled" | "delivered_to_device";
+                };
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Queue inspection — summary + paginated items */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["QueueEnvelope"];
+                    };
+                };
+                /** @description Bad request — validation failed */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Unauthenticated — missing or invalid bearer token */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Forbidden — caller authenticated but not allowed */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Too many requests — rate limit exceeded */
+                429: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/lines/{id}/health": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get a BYOD line's health snapshot
+         * @description BYOD-only health rollup. `state` (`active` / `degraded` / `offline`) is derived from the device's fundamental capabilities — min(send_text, imessage) — with offline (no heartbeat) taking precedence. Also returns `runtime_capabilities` (the per-key tri-valued descriptor the device last reported), last heartbeat timestamp, daily quota headroom, Apple-ID-flagged flag, last-error string, bridge version. Rental tiers receive 403 `rental_health_not_exposed` — they don't own the hardware and surfacing transient state creates support-ticket noise.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description BYOD line health snapshot */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["LineHealthEnvelope"];
+                    };
+                };
+                /** @description Bad request — validation failed */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Unauthenticated — missing or invalid bearer token */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Forbidden — caller authenticated but not allowed */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Too many requests — rate limit exceeded */
+                429: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/lines/{id}/config": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get a line's effective send configuration
+         * @description Return the resolved send configuration for this line — tier defaults merged with per-line overrides. Surfaces effective quota caps, timezone, activity-curve target hour, and the `overridden_keys` list so partners can see which fields they've customised.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Effective config (tier defaults + per-line overrides) */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["LineConfigEnvelope"];
+                    };
+                };
+                /** @description Bad request — validation failed */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Unauthenticated — missing or invalid bearer token */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Forbidden — caller authenticated but not allowed */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Too many requests — rate limit exceeded */
+                429: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        /**
+         * Update a line's send configuration
+         * @description Merge-patch the line's per-line config overrides (quota caps, timezone, activity curve). Pass `null` for a key to revert it to the tier default. Validates the activity curve sums to 1.0 and rejects an unknown timezone with 400.
+         */
+        patch: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["LineConfigPatch"];
+                };
+            };
+            responses: {
+                /** @description Updated effective config (merged) + overridden_keys */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["LineConfigEnvelope"];
+                    };
+                };
+                /** @description Bad request — validation failed */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Unauthenticated — missing or invalid bearer token */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Forbidden — caller authenticated but not allowed */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Too many requests — rate limit exceeded */
+                429: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+            };
+        };
+        trace?: never;
+    };
+    "/v1/pre-orders": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List pre-orders
+         * @description Cursor-paginated list of the caller's pre-orders. Filter by status (`draft`, `provisioning`, `fulfilled`, `cancelled`) to surface only the ones the dashboard needs.
+         */
+        get: {
+            parameters: {
+                query?: {
+                    status?: "draft" | "provisioning" | "fulfilled" | "cancelled";
+                    cursor?: string;
+                    limit?: number;
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Pre-order list */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["PreOrderList"];
+                    };
+                };
+                /** @description Bad request — validation failed */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Unauthenticated — missing or invalid bearer token */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Too many requests — rate limit exceeded */
+                429: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        /**
+         * Create a pre-order (draft)
+         * @description Place a pre-order as a `draft` (WHA-1155). A draft has NO side effects — no provisioning line, no procurement, no Stripe charge — so the partner can hold intent / bill its own end-user first. Call `POST /v1/pre-orders/{id}/confirm` to engage the month and start procurement. A pre-order carries the area codes you would accept, in order of preference, the plan (`inbound_only`), which is remembered for confirm and read back on every response, and optionally the SKU (`billing_tier`). The tier and the plan are ORTHOGONAL — `rental_iphone` covers both the outbound and the inbound product, which is what `inbound_only` selects — so naming both is never a contradiction. `billing_tier` is optional because a pre-order that omits it is still `rental_iphone`, the only tier this flow mints; when named it is ANSWERED, never discarded: `rental_android` is `400 android_rental_not_purchasable` (no Android product exists in the Stripe catalogue, WHA-2474) and a tier no pre-order can procure — BYOD, virtual shared, pool — is `400 tier_not_pre_orderable`, naming the endpoint to call instead (WHA-2949). The body is otherwise STRICT (WHA-2644) — any other property is a `400`, including `quantity` and `metadata`, which earlier revisions of this contract documented and the server silently discarded.
+         */
+        post: {
             parameters: {
                 query?: never;
                 header?: never;
@@ -2150,18 +2808,107 @@ export interface paths {
             requestBody?: {
                 content: {
                     "application/json": {
-                        /** @enum {string} */
-                        billing_tier: "rental_iphone" | "rental_android";
                         /** @default [] */
                         preferred_area_codes?: string[];
                         /** @default false */
                         inbound_only?: boolean;
+                        /** @enum {string} */
+                        billing_tier?: "rental_iphone" | "rental_android" | "byod_imessage" | "byod_android" | "shared_pool" | "shared_imessage";
+                        /**
+                         * Format: date-time
+                         * @description The billing anchor of the customer who pays for this line (ISO-8601, UTC) — the ONE date it is billed on. Its day of the month becomes the line’s billing day, clamped to the last day of a shorter month; the time of day is kept, because the anchor is an instant and not a calendar day. State the date your own customer is billed on and every line they hold moves together: at each occurrence the line is charged one full month, and at the FIRST occurrence after activation it is credited for the days the activation month had already paid for past it, at the activation rate. Omit it and the line is billed on its activation instant, which is the behaviour of every line provisioned before anchors existed. Refused (400 `billing_anchor_too_far`) more than 31 days after the activation — that would make the first period longer than a month.
+                         * @example 2026-09-11T09:15:00Z
+                         */
+                        billing_anchor_at?: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Pre-order draft created */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @enum {boolean} */
+                            success: true;
+                            data: components["schemas"]["PreOrder"];
+                            trace_id: string;
+                            request_id: string;
+                        };
+                    };
+                };
+                /** @description Bad request — validation failed */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Unauthenticated — missing or invalid bearer token */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Too many requests — rate limit exceeded */
+                429: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
                     };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/pre-orders/{id}/confirm": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Confirm a pre-order draft
+         * @description Confirm a `draft` pre-order (WHA-1155). The binding step: engages the one-month commitment (full month, no proration) and triggers procurement — mints the `provisioning` line + fulfillment task, notifies ops, and (for direct customers) creates the first-month Stripe payment intent, returned as `stripe_client_secret`. Only a draft can be confirmed.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
                 };
+                cookie?: never;
             };
+            requestBody?: never;
             responses: {
-                /** @description Pre-order draft created */
-                201: {
+                /** @description Pre-order confirmed (now provisioning) */
+                200: {
                     headers: {
                         [name: string]: unknown;
                     };
@@ -2193,6 +2940,15 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
+                /** @description Not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
                 /** @description Too many requests — rate limit exceeded */
                 429: {
                     headers: {
@@ -2219,20 +2975,18 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/v1/pre-orders/{id}/confirm": {
+    "/v1/pre-orders/{id}": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get?: never;
-        put?: never;
         /**
-         * Confirm a pre-order draft
-         * @description Confirm a `draft` pre-order (WHA-1155). The binding step: engages the one-month commitment (full month, no proration) and triggers procurement — mints the `provisioning` line + fulfillment task, notifies ops, and (for direct customers) creates the first-month Stripe payment intent, returned as `stripe_client_secret`. Only a draft can be confirmed.
+         * Get a pre-order
+         * @description Fetch a single pre-order, including its current status, the linked Stripe payment intent, and the fulfilled-line reference if the procurement has completed.
          */
-        post: {
+        get: {
             parameters: {
                 query?: never;
                 header?: never;
@@ -2243,7 +2997,7 @@ export interface paths {
             };
             requestBody?: never;
             responses: {
-                /** @description Pre-order confirmed (now provisioning) */
+                /** @description Pre-order */
                 200: {
                     headers: {
                         [name: string]: unknown;
@@ -2305,24 +3059,28 @@ export interface paths {
                 };
             };
         };
+        put?: never;
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/v1/pre-orders/{id}": {
+    "/v1/pre-orders/{id}/cancel": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
+        get?: never;
+        put?: never;
         /**
-         * Get a pre-order
-         * @description Fetch a single pre-order, including its current status, the linked Stripe payment intent, and the fulfilled-line reference if the procurement has completed.
+         * Cancel a pre-order draft
+         * @description Cancel an unconfirmed `draft` pre-order (WHA-1155) — free, nothing was provisioned or charged. A CONFIRMED pre-order cannot be cancelled here (the month is committed, full month no proration); release its provisioned line through the standard line endpoint `POST /v1/lines/{id}/release` instead.
          */
-        get: {
+        post: {
             parameters: {
                 query?: never;
                 header?: never;
@@ -2333,7 +3091,7 @@ export interface paths {
             };
             requestBody?: never;
             responses: {
-                /** @description Pre-order */
+                /** @description Pre-order cancelled */
                 200: {
                     headers: {
                         [name: string]: unknown;
@@ -2375,6 +3133,15 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
+                /** @description Conflict — concurrent or terminal state */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
                 /** @description Too many requests — rate limit exceeded */
                 429: {
                     headers: {
@@ -2395,15 +3162,112 @@ export interface paths {
                 };
             };
         };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/billing/checkout": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
         put?: never;
-        post?: never;
+        /**
+         * Start a Stripe Checkout for a reserved line
+         * @description Create a Stripe Checkout Session for the line previously reserved by `POST /v1/lines/{id}/reserve`. Returns the hosted checkout URL — redirect the customer there. The webhook handler activates the line once the session completes.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Line to check out. Send the `line_<base62>` public ID returned by `POST /v1/lines/{id}/reserve`; the internal UUID is also accepted for backward compatibility. Must be status `reserved`.
+                         * @example line_2k9Qp7RtY4mNb8VcXs3Wd6Lf1
+                         */
+                        line_id: string;
+                        /**
+                         * @description Buy the INBOUND rental product instead of the outbound one. An inbound line cannot INITIATE a conversation — the contact must message first, after which the exchange is unrestricted; it is NOT receive-only. Rental tiers only. The chosen Stripe price is the source of truth: `lines.inbound_only` is re-derived from its lookup_key on `customer.subscription.created/updated`.
+                         * @default false
+                         */
+                        inbound_only?: boolean;
+                    };
+                };
+            };
+            responses: {
+                /** @description Checkout session */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Checkout"];
+                    };
+                };
+                /** @description Bad request — validation failed */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Unauthenticated — missing or invalid bearer token */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Too many requests — rate limit exceeded */
+                429: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+            };
+        };
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/v1/pre-orders/{id}/cancel": {
+    "/v1/billing/byod-checkout": {
         parameters: {
             query?: never;
             header?: never;
@@ -2413,33 +3277,108 @@ export interface paths {
         get?: never;
         put?: never;
         /**
-         * Cancel a pre-order draft
-         * @description Cancel an unconfirmed `draft` pre-order (WHA-1155) — free, nothing was provisioned or charged. A CONFIRMED pre-order cannot be cancelled here (the month is committed, full month no proration); release its provisioned line through the standard line endpoint `POST /v1/lines/{id}/release` instead.
+         * Start a Stripe Checkout for BYOD slots
+         * @description Create a Stripe Checkout Session for the BYOD subscription product (`$15/mo`, `$40.50/quarter` or `$150/yr` per slot, `device_count` slots). All three cadences the BYOP catalogue carries are sellable — `GET /pricing` publishes the amount of each. The completed session writes a `byod_subscriptions` row that `POST /v1/byod/pair` reads to enforce slot capacity.
          */
         post: {
             parameters: {
                 query?: never;
                 header?: never;
-                path: {
-                    id: string;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["ByodCheckoutBody"];
+                };
+            };
+            responses: {
+                /** @description BYOD checkout session */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ByodCheckoutEnvelope"];
+                    };
+                };
+                /** @description Bad request — validation failed */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Unauthenticated — missing or invalid bearer token */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Too many requests — rate limit exceeded */
+                429: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
                 };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/billing/mac-checkout": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Start a Stripe Checkout for hosted macOS sessions
+         * @description Create a Stripe Checkout Session for `quantity` rented macOS sessions, priced on a graduated ladder ($35/$30/$25/$20 per session across the 1–10 / 11–30 / 31–50 / 51+ bands). Two rules are enforced here and nowhere else: the quantity must be a whole number of packs at or above the one-pack minimum (`422 mac_quantity_not_a_pack`, the divisor echoed as `issues[0].min`), and a rented session hosts the bridge for one BYOP iPhone so sessions may not exceed the account’s BYOP lines (`422 mac_sessions_exceed_byop_lines`). Stripe’s hosted UI cannot change the quantity afterwards — use `PATCH /v1/billing/subscriptions/{id}`, which applies the same two rules.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
                 cookie?: never;
             };
-            requestBody?: never;
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["MacCheckoutBody"];
+                };
+            };
             responses: {
-                /** @description Pre-order cancelled */
+                /** @description macOS session checkout */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": {
-                            /** @enum {boolean} */
-                            success: true;
-                            data: components["schemas"]["PreOrder"];
-                            trace_id: string;
-                            request_id: string;
-                        };
+                        "application/json": components["schemas"]["MacCheckoutEnvelope"];
                     };
                 };
                 /** @description Bad request — validation failed */
@@ -2469,8 +3408,8 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
-                /** @description Conflict — concurrent or terminal state */
-                409: {
+                /** @description Unprocessable — domain rule violation */
+                422: {
                     headers: {
                         [name: string]: unknown;
                     };
@@ -2504,7 +3443,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/v1/billing/checkout": {
+    "/v1/billing/subscriptions/{id}": {
         parameters: {
             query?: never;
             header?: never;
@@ -2513,41 +3452,29 @@ export interface paths {
         };
         get?: never;
         put?: never;
+        post?: never;
         /**
-         * Start a Stripe Checkout for a reserved line
-         * @description Create a Stripe Checkout Session for the line previously reserved by `POST /v1/lines/{id}/reserve`. Returns the hosted checkout URL — redirect the customer there. The webhook handler activates the line once the session completes.
+         * Cancel a subscription
+         * @description Schedule the subscription to cancel at the end of the current billing period. The line remains active until the period rolls over; the partner sees the `cancel_at_period_end: true` flag in `GET /v1/billing/subscriptions` until then.
          */
-        post: {
+        delete: {
             parameters: {
                 query?: never;
                 header?: never;
-                path?: never;
-                cookie?: never;
-            };
-            requestBody?: {
-                content: {
-                    "application/json": {
-                        /**
-                         * @description Line to check out. Send the `line_<base62>` public ID returned by `POST /v1/lines/{id}/reserve`; the internal UUID is also accepted for backward compatibility. Must be status `reserved`.
-                         * @example line_2k9Qp7RtY4mNb8VcXs3Wd6Lf1
-                         */
-                        line_id: string;
-                        /**
-                         * @description Buy the INBOUND rental product instead of the outbound one. An inbound line cannot INITIATE a conversation — the contact must message first, after which the exchange is unrestricted; it is NOT receive-only. Rental tiers only. The chosen Stripe price is the source of truth: `lines.inbound_only` is re-derived from its lookup_key on `customer.subscription.created/updated`.
-                         * @default false
-                         */
-                        inbound_only?: boolean;
-                    };
+                path: {
+                    id: string;
                 };
+                cookie?: never;
             };
+            requestBody?: never;
             responses: {
-                /** @description Checkout session */
+                /** @description Subscription cancelled */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["Checkout"];
+                        "application/json": components["schemas"]["BillingMessage"];
                     };
                 };
                 /** @description Bad request — validation failed */
@@ -2577,6 +3504,15 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
+                /** @description Conflict — concurrent or terminal state */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
                 /** @description Too many requests — rate limit exceeded */
                 429: {
                     headers: {
@@ -2597,45 +3533,34 @@ export interface paths {
                 };
             };
         };
-        delete?: never;
         options?: never;
         head?: never;
-        patch?: never;
-        trace?: never;
-    };
-    "/v1/billing/byod-checkout": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        get?: never;
-        put?: never;
         /**
-         * Start a Stripe Checkout for BYOD slots
-         * @description Create a Stripe Checkout Session for the BYOD subscription product (`$15/mo` or `$150/yr` per slot, `device_count` slots). The completed session writes a `byod_subscriptions` row that `POST /v1/byod/pair` reads to enforce slot capacity.
+         * Change a subscription’s quantity
+         * @description Set the quantity on the subscription’s single quantity-adjustable item — hosted macOS sessions, or BYOP slots. Both directions of the 1:1 rule are enforced: raising sessions above the account’s BYOP lines is `422 mac_sessions_exceed_byop_lines`, and lowering BYOP below the macOS sessions already rented is `422 byop_reduction_strands_mac_sessions`. A macOS quantity must additionally be a whole pack (`422 mac_quantity_not_a_pack`). A subscription that does not carry exactly one adjustable item — a per-line rental, or a wholesale master subscription whose quantities are pushed by metering — is refused `409 subscription_not_quantity_adjustable`.
          */
-        post: {
+        patch: {
             parameters: {
                 query?: never;
                 header?: never;
-                path?: never;
+                path: {
+                    id: string;
+                };
                 cookie?: never;
             };
             requestBody?: {
                 content: {
-                    "application/json": components["schemas"]["ByodCheckoutBody"];
+                    "application/json": components["schemas"]["SubscriptionQuantityBody"];
                 };
             };
             responses: {
-                /** @description BYOD checkout session */
+                /** @description Quantity updated */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["ByodCheckoutEnvelope"];
+                        "application/json": components["schemas"]["SubscriptionQuantityEnvelope"];
                     };
                 };
                 /** @description Bad request — validation failed */
@@ -2656,8 +3581,8 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
-                /** @description Too many requests — rate limit exceeded */
-                429: {
+                /** @description Forbidden — caller authenticated but not allowed */
+                403: {
                     headers: {
                         [name: string]: unknown;
                     };
@@ -2665,8 +3590,8 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
-                /** @description Internal server error */
-                500: {
+                /** @description Not found */
+                404: {
                     headers: {
                         [name: string]: unknown;
                     };
@@ -2674,45 +3599,8 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
-            };
-        };
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
-    "/v1/billing/subscriptions": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        /**
-         * List Stripe subscriptions
-         * @description Return every active Stripe subscription on the authenticated user's customer record — both per-line rental subs and BYOD slot subs. Period boundaries, line link, price ID, and cancellation flag are surfaced verbatim from Stripe.
-         */
-        get: {
-            parameters: {
-                query?: never;
-                header?: never;
-                path?: never;
-                cookie?: never;
-            };
-            requestBody?: never;
-            responses: {
-                /** @description Subscription list */
-                200: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["SubscriptionListEnvelope"];
-                    };
-                };
-                /** @description Bad request — validation failed */
-                400: {
+                /** @description Conflict — concurrent or terminal state */
+                409: {
                     headers: {
                         [name: string]: unknown;
                     };
@@ -2720,8 +3608,8 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
-                /** @description Unauthenticated — missing or invalid bearer token */
-                401: {
+                /** @description Unprocessable — domain rule violation */
+                422: {
                     headers: {
                         [name: string]: unknown;
                     };
@@ -2749,15 +3637,9 @@ export interface paths {
                 };
             };
         };
-        put?: never;
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
         trace?: never;
     };
-    "/v1/billing/invoices": {
+    "/v1/billing/subscriptions": {
         parameters: {
             query?: never;
             header?: never;
@@ -2765,8 +3647,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * List Stripe invoices
-         * @description List the authenticated user's Stripe invoices in reverse-chronological order. Each invoice exposes the period boundaries (unix seconds), the integer-cent amounts, the hosted invoice URL, and the PDF link.
+         * List Stripe subscriptions
+         * @description Return every active Stripe subscription on the authenticated user's customer record — both per-line rental subs and BYOD slot subs. Period boundaries, line link, price ID, and cancellation flag are surfaced verbatim from Stripe.
          */
         get: {
             parameters: {
@@ -2777,13 +3659,13 @@ export interface paths {
             };
             requestBody?: never;
             responses: {
-                /** @description Invoice list */
+                /** @description Subscription list */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["InvoiceListEnvelope"];
+                        "application/json": components["schemas"]["SubscriptionListEnvelope"];
                     };
                 };
                 /** @description Bad request — validation failed */
@@ -2832,38 +3714,33 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/v1/billing/subscriptions/{id}": {
+    "/v1/billing/invoices": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get?: never;
-        put?: never;
-        post?: never;
         /**
-         * Cancel a subscription
-         * @description Schedule the subscription to cancel at the end of the current billing period. The line remains active until the period rolls over; the partner sees the `cancel_at_period_end: true` flag in `GET /v1/billing/subscriptions` until then.
+         * List Stripe invoices
+         * @description List the authenticated user's Stripe invoices in reverse-chronological order. Each invoice exposes the period boundaries (unix seconds), the integer-cent amounts, the hosted invoice URL, and the PDF link.
          */
-        delete: {
+        get: {
             parameters: {
                 query?: never;
                 header?: never;
-                path: {
-                    id: string;
-                };
+                path?: never;
                 cookie?: never;
             };
             requestBody?: never;
             responses: {
-                /** @description Subscription cancelled */
+                /** @description Invoice list */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["BillingMessage"];
+                        "application/json": components["schemas"]["InvoiceListEnvelope"];
                     };
                 };
                 /** @description Bad request — validation failed */
@@ -2884,24 +3761,6 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
-                /** @description Not found */
-                404: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ErrorEnvelope"];
-                    };
-                };
-                /** @description Conflict — concurrent or terminal state */
-                409: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ErrorEnvelope"];
-                    };
-                };
                 /** @description Too many requests — rate limit exceeded */
                 429: {
                     headers: {
@@ -2922,6 +3781,9 @@ export interface paths {
                 };
             };
         };
+        put?: never;
+        post?: never;
+        delete?: never;
         options?: never;
         head?: never;
         patch?: never;
@@ -3242,15 +4104,21 @@ export interface paths {
         };
         /**
          * List messages
-         * @description Cursor-paginated list of messages, newest first. Each item carries the full `MessageV1` shape — partners can write a uniform handler over both `GET /v1/messages` and `GET /v1/messages/{id}`. Filter by `line_id`, `status`, `direction`, or `kind` (`message` drops the separate reaction/voice rows for a clean feed; `reaction`/`voice` fetch only those; omit for all kinds); pass an opaque `cursor` from the previous page's `next_cursor` to advance.
+         * @description Cursor-paginated list of messages, newest first by default. Each item carries the full `MessageV1` shape — partners can write a uniform handler over both `GET /v1/messages` and `GET /v1/messages/{id}`. Filter by `line_id`, `status`, `direction`, or `kind` (`message` drops the separate reaction/voice rows for a clean feed; `reaction`/`voice` fetch only those; omit for all kinds); pass an opaque `cursor` from the previous page's `next_cursor` to advance. `sort=scheduled_for` serves the queue in departure order instead (rows with no `scheduled_for` last in either direction); `order` flips the direction. A cursor belongs to the sort it was minted for — replaying it under a different `sort`/`order` restarts from the first page.
          */
         get: {
             parameters: {
                 query?: {
                     line_id?: string;
-                    status?: "queued" | "sent" | "delivered" | "read" | "failed";
+                    status?: "queued" | "scheduled" | "sent" | "delivered" | "read" | "failed" | "cancelled";
                     direction?: "outbound" | "inbound";
+                    since?: string;
+                    until?: string;
                     kind?: "message" | "voice" | "reaction";
+                    /** @description Ordering key. `created_at` (default) is arrival order; `scheduled_for` is departure order — the same instant the `scheduled_for` field reads back, with rows that have none last in both directions. */
+                    sort?: "created_at" | "scheduled_for";
+                    /** @description Ordering direction. Defaults to `desc` for `sort=created_at` (newest first) and `asc` for `sort=scheduled_for` (soonest first). */
+                    order?: "asc" | "desc";
                     cursor?: string;
                     limit?: number;
                 };
@@ -3926,7 +4794,7 @@ export interface paths {
                         };
                     };
                 };
-                /** @description Bad request — validation failed */
+                /** @description Bad request. `validation_failed` — the body does not match the schema. `webhook_url_not_allowed` — the URL is refused by the SSRF guard; `error.issues[0].code` names why: `not_https` (only https:// is accepted), `ssrf_blocked` (the host is, or resolves to, a loopback, link-local, private, carrier-grade NAT or otherwise non-public address — every resolved address is checked), `dns_failed` (the host does not resolve) or `invalid_url`. The same guard runs again before every delivery: a subscription whose host later resolves to a non-public address gets no request, and is suspended. */
                 400: {
                     headers: {
                         [name: string]: unknown;
@@ -4156,7 +5024,7 @@ export interface paths {
                         "application/json": components["schemas"]["WebhookV1Envelope"];
                     };
                 };
-                /** @description Bad request — validation failed */
+                /** @description Bad request. `validation_failed` — the body does not match the schema. `webhook_url_not_allowed` — the URL is refused by the SSRF guard; `error.issues[0].code` names why: `not_https` (only https:// is accepted), `ssrf_blocked` (the host is, or resolves to, a loopback, link-local, private, carrier-grade NAT or otherwise non-public address — every resolved address is checked), `dns_failed` (the host does not resolve) or `invalid_url`. The same guard runs again before every delivery: a subscription whose host later resolves to a non-public address gets no request, and is suspended. */
                 400: {
                     headers: {
                         [name: string]: unknown;
@@ -4757,22 +5625,101 @@ export interface paths {
                 };
             };
             responses: {
-                /** @description Lookup result — cache hit, fast probe, or an un-probed miss */
+                /** @description Lookup result — cache hit, fast probe, or an un-probed miss */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["LookupEnvelope"];
+                    };
+                };
+                /** @description Lookup pending — a device probe was dispatched but had not answered within the wait budget; re-poll the same request after `retry_after` seconds */
+                202: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["LookupEnvelope"];
+                    };
+                };
+                /** @description Bad request — validation failed */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Unauthenticated — missing or invalid bearer token */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Too many requests — rate limit exceeded */
+                429: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/attention": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * What currently needs attention on the caller's lines
+         * @description Every line of yours with something wrong: an open incident, a degraded health state, or a fleet probe that has flagged its hardware. One entry per LINE — two faults on one number are one entry. **A BYOD line appears immediately** and carries its reasons. **A rental, pool or shared line appears only once the fault has lasted 15 minutes** (`RENTAL_DURABLE_OFFLINE_MINUTES`, the same threshold as the durable `line.offline` webhook) and carries `reasons: []` with `detail_withheld: true` — per §4.4 a customer with no access to the hardware is told the line is unavailable and being resolved, never which check on which machine failed. `since` is when the fault started; it is null when the underlying detector has no anchor for it. A line-scoped API key sees only the lines in its allowlist.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Lines needing attention, longest-standing first */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["LookupEnvelope"];
-                    };
-                };
-                /** @description Lookup pending — a device probe was dispatched but had not answered within the wait budget; re-poll the same request after `retry_after` seconds */
-                202: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["LookupEnvelope"];
+                        "application/json": {
+                            /** @enum {boolean} */
+                            success: true;
+                            data: components["schemas"]["AttentionList"];
+                            trace_id: string;
+                            request_id: string;
+                        };
                     };
                 };
                 /** @description Bad request — validation failed */
@@ -4813,6 +5760,8 @@ export interface paths {
                 };
             };
         };
+        put?: never;
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
@@ -5407,8 +6356,246 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
-                /** @description Not found */
-                404: {
+                /** @description Not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Too many requests — rate limit exceeded */
+                429: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/trial/init": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Start a trial session
+         * @description Create a pairing-pending trial session owned by the caller (dashboard JWT for direct self-serve, or an API key for wholesale/SDK). Returns a one-time pairing token the partner embeds in their onboarding UI; the recipient claims it by sending an inbound message that links them to a pool line. Direct accounts may hold only one live trial at a time.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["TrialInitBody"];
+                };
+            };
+            responses: {
+                /** @description Trial session created — pairing pending */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["TrialInitEnvelope"];
+                    };
+                };
+                /** @description Bad request — validation failed */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Unauthenticated — missing or invalid bearer token */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Conflict — concurrent or terminal state */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Too many requests — rate limit exceeded */
+                429: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/trial/status": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Check trial pairing status
+         * @description Token-keyed public lookup. Returns the current trial state — `pairing_pending` while waiting for the recipient's first inbound, `paired` once linked, `expired` after the pairing window. On first poll after `paired` the response also reveals the `trial_api_key` (`isnap_test_*`) for the partner to embed.
+         */
+        get: {
+            parameters: {
+                query: {
+                    token: string;
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Current trial status */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["TrialStatusEnvelope"];
+                    };
+                };
+                /** @description Bad request — validation failed */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Too many requests — rate limit exceeded */
+                429: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/trial/activity": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get trial activity counters
+         * @description Trial-key-only snapshot of the dormancy and outbound-without-inbound counters. Partner dashboards poll this to render the trial's live state ("3/10 sends since last inbound", dormancy timer remaining).
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Trial activity snapshot */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["TrialActivityEnvelope"];
+                    };
+                };
+                /** @description Bad request — validation failed */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Unauthenticated — missing or invalid bearer token */
+                401: {
                     headers: {
                         [name: string]: unknown;
                     };
@@ -5436,13 +6623,15 @@ export interface paths {
                 };
             };
         };
+        put?: never;
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/v1/trial/init": {
+    "/v1/trial/{trial_id}/revoke": {
         parameters: {
             query?: never;
             header?: never;
@@ -5452,29 +6641,32 @@ export interface paths {
         get?: never;
         put?: never;
         /**
-         * Start a trial session
-         * @description Create a pairing-pending trial session owned by the caller (dashboard JWT for direct self-serve, or an API key for wholesale/SDK). Returns a one-time pairing token the partner embeds in their onboarding UI; the recipient claims it by sending an inbound message that links them to a pool line. Direct accounts may hold only one live trial at a time.
+         * Revoke a trial session
+         * @description Terminate a trial owned by the caller, freeing its pool-line slot (the same handle can immediately start a fresh trial) and invalidating its trial API key. Idempotent — revoking an already-revoked trial returns `already_revoked: true` with a 200. A trial the caller does not own returns 404 (no existence leak). Per-partner rebind policy (WHA-1642) applies ONLY to `reason: rebind` (`partner`/`admin` always pass): a partner with rebind disabled gets 403 `rebind_not_allowed`, and one over its daily rebind cap gets 429 `rebind_cap_reached` carrying `retry_at`.
          */
         post: {
             parameters: {
                 query?: never;
                 header?: never;
-                path?: never;
+                path: {
+                    /** @description The trl_<base62> public id returned by POST /v1/trial/init. */
+                    trial_id: string;
+                };
                 cookie?: never;
             };
             requestBody?: {
                 content: {
-                    "application/json": components["schemas"]["TrialInitBody"];
+                    "application/json": components["schemas"]["TrialRevokeBody"];
                 };
             };
             responses: {
-                /** @description Trial session created — pairing pending */
-                201: {
+                /** @description Trial revoked (idempotent) */
+                200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["TrialInitEnvelope"];
+                        "application/json": components["schemas"]["TrialRevokeEnvelope"];
                     };
                 };
                 /** @description Bad request — validation failed */
@@ -5495,8 +6687,26 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
-                /** @description Conflict — concurrent or terminal state */
-                409: {
+                /** @description Forbidden — caller authenticated but not allowed */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Unprocessable — domain rule violation */
+                422: {
                     headers: {
                         [name: string]: unknown;
                     };
@@ -5530,35 +6740,39 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/v1/trial/status": {
+    "/v1/byod/pair": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
+        get?: never;
+        put?: never;
         /**
-         * Check trial pairing status
-         * @description Token-keyed public lookup. Returns the current trial state — `pairing_pending` while waiting for the recipient's first inbound, `paired` once linked, `expired` after the pairing window. On first poll after `paired` the response also reveals the `trial_api_key` (`isnap_test_*`) for the partner to embed.
+         * Start a BYOD pairing flow
+         * @description Mint a one-time activation code plus the stable per-platform bridge-installer download links for a customer-owned Mac+iPhone or Android device. The customer runs the bridge, enters the code, and the device-side `POST /device/activate` consumes it to mint a `byod_imessage` or `byod_android` line — the platform is derived there from what the bridge reports.
          */
-        get: {
+        post: {
             parameters: {
-                query: {
-                    token: string;
-                };
+                query?: never;
                 header?: never;
                 path?: never;
                 cookie?: never;
             };
-            requestBody?: never;
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["ByodPairBody"];
+                };
+            };
             responses: {
-                /** @description Current trial status */
-                200: {
+                /** @description Activation code + bridge download URL */
+                201: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["TrialStatusEnvelope"];
+                        "application/json": components["schemas"]["ByodPairEnvelope"];
                     };
                 };
                 /** @description Bad request — validation failed */
@@ -5570,6 +6784,15 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
+                /** @description Unauthenticated — missing or invalid bearer token */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
                 /** @description Not found */
                 404: {
                     headers: {
@@ -5599,26 +6822,26 @@ export interface paths {
                 };
             };
         };
-        put?: never;
-        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/v1/trial/activity": {
+    "/v1/macos-sessions/rent": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
+        get?: never;
+        put?: never;
         /**
-         * Get trial activity counters
-         * @description Trial-key-only snapshot of the dormancy and outbound-without-inbound counters. Partner dashboards poll this to render the trial's live state ("3/10 sends since last inbound", dormancy timer remaining).
+         * Rent a hosted macOS session
+         * @description Take one hosted macOS session out of iSnap stock on the calling wholesale partner’s account. The tenancy starts immediately and `anniversary_at` is stamped with the day it was taken — that day of the month is what the session bills on, clamped to the last day of shorter months. Returns `409 no_macos_session_in_stock` when no confirmed, unrented session sits on a delivered Mac; iSnap provisions one and attaches it, and no request needs to be repeated. Direct customers do not use this verb — they buy sessions through `POST /v1/billing/mac-checkout` and are refused here with `403 not_a_wholesale_partner`.
          */
-        get: {
+        post: {
             parameters: {
                 query?: never;
                 header?: never;
@@ -5627,13 +6850,13 @@ export interface paths {
             };
             requestBody?: never;
             responses: {
-                /** @description Trial activity snapshot */
-                200: {
+                /** @description The rented session */
+                201: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["TrialActivityEnvelope"];
+                        "application/json": components["schemas"]["MacosSessionEnvelope"];
                     };
                 };
                 /** @description Bad request — validation failed */
@@ -5654,6 +6877,24 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
+                /** @description Forbidden — caller authenticated but not allowed */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
+                /** @description Conflict — concurrent or terminal state */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
                 /** @description Too many requests — rate limit exceeded */
                 429: {
                     headers: {
@@ -5674,15 +6915,13 @@ export interface paths {
                 };
             };
         };
-        put?: never;
-        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/v1/trial/{trial_id}/revoke": {
+    "/v1/macos-sessions/{id}/cancel": {
         parameters: {
             query?: never;
             header?: never;
@@ -5692,32 +6931,27 @@ export interface paths {
         get?: never;
         put?: never;
         /**
-         * Revoke a trial session
-         * @description Terminate a trial owned by the caller, freeing its pool-line slot (the same handle can immediately start a fresh trial) and invalidating its trial API key. Idempotent — revoking an already-revoked trial returns `already_revoked: true` with a 200. A trial the caller does not own returns 404 (no existence leak). Per-partner rebind policy (WHA-1642) applies ONLY to `reason: rebind` (`partner`/`admin` always pass): a partner with rebind disabled gets 403 `rebind_not_allowed`, and one over its daily rebind cap gets 429 `rebind_cap_reached` carrying `retry_at`.
+         * Cancel a rented macOS session
+         * @description End the tenancy at its next anniversary. The session stays usable and keeps billing until `cancel_at`, which is the next occurrence of `anniversary_at` strictly after the cancellation — so cancelling ON the anniversary buys the month that starts that day, never zero days. Idempotent: a second call returns the `cancel_at` the first one set rather than pushing it a month further out. Only the renting partner may cancel; every other caller gets `404`.
          */
         post: {
             parameters: {
                 query?: never;
                 header?: never;
                 path: {
-                    /** @description The trl_<base62> public id returned by POST /v1/trial/init. */
-                    trial_id: string;
+                    id: string;
                 };
                 cookie?: never;
             };
-            requestBody?: {
-                content: {
-                    "application/json": components["schemas"]["TrialRevokeBody"];
-                };
-            };
+            requestBody?: never;
             responses: {
-                /** @description Trial revoked (idempotent) */
+                /** @description The cancelled session */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["TrialRevokeEnvelope"];
+                        "application/json": components["schemas"]["MacosSessionEnvelope"];
                     };
                 };
                 /** @description Bad request — validation failed */
@@ -5738,15 +6972,6 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
-                /** @description Forbidden — caller authenticated but not allowed */
-                403: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ErrorEnvelope"];
-                    };
-                };
                 /** @description Not found */
                 404: {
                     headers: {
@@ -5756,8 +6981,8 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
-                /** @description Unprocessable — domain rule violation */
-                422: {
+                /** @description Conflict — concurrent or terminal state */
+                409: {
                     headers: {
                         [name: string]: unknown;
                     };
@@ -5791,7 +7016,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/v1/byod/pair": {
+    "/v1/macos-sessions/{id}/uncancel": {
         parameters: {
             query?: never;
             header?: never;
@@ -5801,29 +7026,27 @@ export interface paths {
         get?: never;
         put?: never;
         /**
-         * Start a BYOD pairing flow
-         * @description Mint a one-time activation code plus the stable per-platform bridge-installer download links for a customer-owned Mac+iPhone or Android device. The customer runs the bridge, enters the code, and the device-side `POST /device/activate` consumes it to mint a `byod_imessage` or `byod_android` line — the platform is derived there from what the bridge reports.
+         * Keep a cancelled macOS session
+         * @description Withdraw a pending cancellation, clearing `cancel_at` and leaving `anniversary_at` untouched — the billing day does not move. Idempotent on a session that is not cancelled. Only possible before the release runs: once `cancel_at` has passed the paid month is over and this answers `409 macos_session_cancellation_already_due` — the release is hourly, so there is a window in which the date has passed and the session is still rented, and un-cancelling inside it would hold a seat the monthly tally has already stopped billing. After the release has run the tenancy is gone and this returns `404`; the session must be rented again.
          */
         post: {
             parameters: {
                 query?: never;
                 header?: never;
-                path?: never;
-                cookie?: never;
-            };
-            requestBody?: {
-                content: {
-                    "application/json": components["schemas"]["ByodPairBody"];
+                path: {
+                    id: string;
                 };
+                cookie?: never;
             };
+            requestBody?: never;
             responses: {
-                /** @description Activation code + bridge download URL */
-                201: {
+                /** @description The session, no longer cancelled */
+                200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["ByodPairEnvelope"];
+                        "application/json": components["schemas"]["MacosSessionEnvelope"];
                     };
                 };
                 /** @description Bad request — validation failed */
@@ -5853,6 +7076,15 @@ export interface paths {
                         "application/json": components["schemas"]["ErrorEnvelope"];
                     };
                 };
+                /** @description Conflict — concurrent or terminal state */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorEnvelope"];
+                    };
+                };
                 /** @description Too many requests — rate limit exceeded */
                 429: {
                     headers: {
@@ -5888,7 +7120,7 @@ export interface paths {
         };
         /**
          * Get the app/bridge download manifest (public)
-         * @description Per-platform installer URL, advertised bridge version, and availability. Requires no pairing and no auth — use it for setup guides, "add a device" flows, reinstalls, and update prompts. The URLs are the same stable 302-redirect endpoints `POST /v1/byod/pair` returns in `download_urls`, and `version` is the same string it returns as `bridge_version`; both surfaces derive from one builder so they cannot drift.
+         * @description Per-platform installer URL, published version, and availability. Requires no pairing and no auth — use it for setup guides, "add a device" flows, reinstalls, and update prompts. The URLs are the same stable 302-redirect endpoints `POST /v1/byod/pair` returns in `download_urls`, built by one shared builder so they cannot drift. `version` is read from the release feed beside the artifact the redirect resolves to, and is `null` when that feed publishes nothing — never a configured placeholder.
          */
         get: {
             parameters: {
@@ -5996,7 +7228,7 @@ export interface components {
             state_name: string | null;
             /** @enum {string} */
             billing_tier: "rental_iphone" | "rental_android" | "byod_imessage" | "byod_android" | "shared_pool" | "shared_imessage";
-            /** @description True when the customer owns the underlying hardware (BYOD billing tiers). BYOD lines expose the full line-health surface (offline/degraded events, GET /v1/lines/{id}/health). Rental lines (false) only emit durable, actionable events to keep customers out of transient infrastructure noise they cannot act on. */
+            /** @description True when the customer owns the underlying hardware (BYOD billing tiers). BYOD lines expose the full line-health surface: GET /v1/lines/{id}/health, the immediate line.offline/line.connected with their diagnostic fields, and the device-health-flux events line.degraded and line.capability_changed. Rental lines (false) are told about DURABLE connectivity changes only, and with NO diagnostic detail by design — line.disconnected always; line.offline once an outage has lasted ≥15 minutes (durable:true, carrying only line_id and detected_at — present it as "line temporarily unavailable, being resolved by the provider"); line.connected on hand-over and on recovery from a surfaced outage — never a transient blip, and never the BYOD-only device-health-flux events they cannot act on. */
             byod: boolean;
             /** @description True when the line cannot INITIATE a conversation: the contact must send the first message, after which the exchange is unrestricted in both directions. It is NOT receive-only — the line replies, reacts and sends attachments normally once contacted. Messaging a handle that has never contacted the line is rejected with 403 outbound_first_forbidden, per recipient and with no time limit once unlocked. Cheaper than the outbound tier; always false on BYOD/pool lines. */
             inbound_only: boolean;
@@ -6010,6 +7242,19 @@ export interface components {
             stripe_subscription_id: string | null;
             activated_at: string | null;
             expires_at: string | null;
+            /** @description The day you took this line, and therefore the day of the month it renews on: billed once per month at this instant, never prorated. Stamped when the line becomes yours; `null` means the line has no per-line anniversary — a direct customer's line renews on its Stripe subscription's own anchor, and a pool line is billed to nobody. Set it explicitly with POST /v1/lines/{id}/anniversary for a line you migrated from your own system, whose real start date iSnap cannot know. */
+            anniversary_at: string | null;
+            /** @description The anniversary occurrence at which iSnap will END this line, set by POST /v1/lines/{id}/cancel and cleared by POST /v1/lines/{id}/uncancel. The line stays fully active and usable until this instant — the month is already paid for and is never prorated — and iSnap terminates it itself when the date arrives. `null` means the line is not cancelled. It survives the termination it schedules, so a `cancelled` line still says which date ended it. */
+            cancel_at: string | null;
+            /** @description The billing anchor you stated for this line — the date the customer who pays for it is billed on. Every line that customer holds moves on this same date, so their period and your invoice advance together. `null` means you stated nothing, NOT that the line has no billing date: it then falls back to the activation instant, which is how every line was billed before anchors existed. Set it at provisioning (`POST /v1/pre-orders`, `POST /v1/lines/{id}/activate`) or change it later with `PATCH /v1/lines/{id}` — a change takes effect at the NEXT anchor and never rewrites a period already billed. */
+            billing_anchor_at: string | null;
+            /** @description The next instant this line will be billed on, derived from the anchor above (or from the activation instant when you stated none) and clamped to the last day of a shorter month — a line anchored on the 31st bills on the 28th in February and on the 31st again in March, the clamp never sticks. At that instant the line is charged one full month at the product it carries then; at the FIRST occurrence after activation it is also credited for the days the activation month had already paid for past it, at the activation rate. `null` when the line will not be billed again: never activated, not in a billable status, or cancelled on or before that occurrence. */
+            next_anchor_at: string | null;
+            /** @description The variant change scheduled for this line's next billing anchor, or `null` when none is pending. `inbound_only` is the value the line WILL carry — the live value stays in the top-level `inbound_only` field until `effective_at` arrives, because the line keeps serving the product it is being billed for until then. Schedule one with POST /v1/lines/{id}/variant and `effective: 'next_anchor'`; cancel it with DELETE /v1/lines/{id}/variant. It is cleared when the change is applied, when it is cancelled, and when the line leaves its owner. */
+            pending_variant: {
+                inbound_only: boolean;
+                effective_at: string;
+            } | null;
             created_at: string;
             metadata: {
                 [key: string]: unknown;
@@ -6020,6 +7265,31 @@ export interface components {
             shared: boolean;
             fulfillment_status?: string | null;
         };
+        MacosSession: {
+            /** @example mcs_7Kd2Nq8Rb4Xw1Ty6Ue9Ao3Ph5 */
+            id: string;
+            /** @description Whether this session is currently rented by the calling partner. `false` once it has been released back to iSnap stock. */
+            rented: boolean;
+            /**
+             * Format: date-time
+             * @description The day the session was taken, and the day of the month it bills on. Null once the session is released. A day-of-month past the end of a shorter month bills on that month’s last day.
+             * @example 2026-09-07T14:32:00.000Z
+             */
+            anniversary_at: string | null;
+            /**
+             * Format: date-time
+             * @description When the tenancy ends — always the next occurrence of `anniversary_at` after the cancellation. Null when the session is not cancelled. The session stays usable and keeps billing until this instant.
+             * @example 2026-10-07T14:32:00.000Z
+             */
+            cancel_at: string | null;
+            /**
+             * @description `pending_provisioning` while the Mac hosting the session has not been delivered yet; `created` once it has.
+             * @enum {string}
+             */
+            status: "created" | "pending_provisioning";
+            /** Format: date-time */
+            created_at: string;
+        };
         ApiKey: {
             /** Format: uuid */
             id: string;
@@ -6066,16 +7336,54 @@ export interface components {
         };
         ActivateLine: {
             inbound_only?: boolean;
+            /**
+             * Format: date-time
+             * @description The billing anchor of the customer who pays for this line (ISO-8601, UTC) — the ONE date it is billed on. Its day of the month becomes the line’s billing day, clamped to the last day of a shorter month; the time of day is kept, because the anchor is an instant and not a calendar day. State the date your own customer is billed on and every line they hold moves together: at each occurrence the line is charged one full month, and at the FIRST occurrence after activation it is credited for the days the activation month had already paid for past it, at the activation rate. Omit it and the line is billed on its activation instant, which is the behaviour of every line provisioned before anchors existed. Refused (400 `billing_anchor_too_far`) more than 31 days after the activation — that would make the first period longer than a month.
+             * @example 2026-09-11T09:15:00Z
+             */
+            billing_anchor_at?: string;
         };
         TransferOwnership: {
             /** Format: uuid */
             to_user_id: string;
             preserve_device_session?: boolean;
         };
+        SetLineVariant: {
+            /** @description True for the INBOUND product: the line may then only message a handle that has messaged it FIRST (`outbound_first_forbidden`), and once that handle has, the exchange is unrestricted in both directions. It is NOT receive-only. False for the two-way product. Rental lines only. */
+            inbound_only: boolean;
+            /**
+             * @description WHEN the variant moves. `now` (the default, and the only behaviour before this field existed) writes the variant immediately and it applies to the very next send. `next_anchor` stores the change against the line's next billing anchor and applies nothing today: `inbound_only` keeps its current value, the line keeps serving the product it is being billed for, and `pending_variant` on the line read carries what will change and when. Use `next_anchor` for a DOWNGRADE, so the customer keeps the two-way product through the month they have already paid for; use `now` for an upgrade. A scheduled change is cancelled with DELETE /v1/lines/{id}/variant, and an immediate change does NOT cancel one — the two are separate acts.
+             * @enum {string}
+             */
+            effective?: "now" | "next_anchor";
+            /**
+             * Format: date-time
+             * @description Only meaningful with `effective: "next_anchor"`. The earliest instant the change may take effect (ISO-8601, UTC); defaults to now. iSnap schedules it at the FIRST anchor occurrence at or after this instant, with the anchor's own day-of-month clamp applied — so state your customer's paid-period end and let iSnap resolve the occurrence rather than computing one yourself. For a monthly customer that is the next anchor, which is the default; for a quarterly or annual customer it is the occurrence three or twelve months out, and the line keeps its two-way capability for the whole period they have paid for. The resolved instant comes back as `pending_variant.effective_at`. An instant in the past is refused with 400 `not_before_in_the_past`.
+             * @example 2027-08-11T14:30:00Z
+             */
+            not_before?: string;
+        };
+        TerminateLine: {
+            reason?: string;
+        };
+        SetLineAnniversary: {
+            /**
+             * Format: date-time
+             * @description The instant you took this line (ISO-8601, UTC). Its day of the month becomes the line’s renewal day and the date a cancellation waits for; the time of day is kept, because the anniversary is an instant and not a calendar day. Use this for a line migrated from your own system, whose real start date iSnap cannot know — for a line taken through the iSnap API it is stamped automatically and does not need stating. A BYOD line carries one too — it is on the same monthly meter — even though iSnap cannot end it for you at that date. Refused (409 `line_cancellation_pending`) while the line carries a `cancel_at`, which was computed from the anniversary you are replacing: uncancel first, set the date, cancel again.
+             * @example 2026-07-02T09:15:00Z
+             */
+            anniversary_at: string;
+        };
         PatchLine: {
-            metadata: {
+            metadata?: {
                 [key: string]: unknown;
             };
+            /**
+             * Format: date-time
+             * @description The billing anchor of the customer who pays for this line (ISO-8601, UTC) — the ONE date it is billed on. Its day of the month becomes the line’s billing day, clamped to the last day of a shorter month; the time of day is kept, because the anchor is an instant and not a calendar day. State the date your own customer is billed on and every line they hold moves together: at each occurrence the line is charged one full month, and at the FIRST occurrence after activation it is credited for the days the activation month had already paid for past it, at the activation rate. Omit it and the line is billed on its activation instant, which is the behaviour of every line provisioned before anchors existed. Refused (400 `billing_anchor_too_far`) more than 31 days after the activation — that would make the first period longer than a month.
+             * @example 2026-09-11T09:15:00Z
+             */
+            billing_anchor_at?: string | null;
         };
         QuotaEnvelope: {
             /** @enum {boolean} */
@@ -6096,6 +7404,14 @@ export interface components {
             hourly_message_limit: number;
             minute_messages_used: number;
             minute_message_limit: number;
+            daily_replies_used: number;
+            daily_reply_limit: number;
+            minute_frees_at: string | null;
+            hourly_frees_at: string | null;
+            daily_total_frees_at: string | null;
+            daily_new_frees_at: string | null;
+            daily_known_frees_at: string | null;
+            daily_reply_frees_at: string | null;
             buckets_warning: components["schemas"]["BucketsWarning"];
         };
         BucketsWarning: {
@@ -6135,6 +7451,8 @@ export interface components {
             hourly_message_limit: number;
             minute_messages_used: number;
             minute_message_limit: number;
+            daily_replies_used: number;
+            daily_reply_limit: number;
             buckets_warning: components["schemas"]["BucketsWarning"];
         };
         QueueItem: {
@@ -6148,6 +7466,7 @@ export interface components {
             queue_position: number;
             is_new_contact: boolean | null;
             target_activity_hour: number | null;
+            timezone: string;
             created_at: string;
         };
         LineHealthEnvelope: {
@@ -6201,6 +7520,9 @@ export interface components {
             min_inter_message_seconds: number;
             min_inter_new_contact_seconds: number;
             max_queue_depth: number;
+            reply_window_hours: number;
+            reply_max_per_inbound: number;
+            daily_reply_limit: number;
             timezone: string;
             activity_curve: {
                 hour: number;
@@ -6213,6 +7535,9 @@ export interface components {
             daily_total_message_limit: components["schemas"]["LineConfigKnobBounds"];
             hourly_message_limit: components["schemas"]["LineConfigKnobBounds"];
             minute_message_limit: components["schemas"]["LineConfigKnobBounds"];
+            reply_window_hours: components["schemas"]["LineConfigKnobBounds"];
+            reply_max_per_inbound: components["schemas"]["LineConfigKnobBounds"];
+            daily_reply_limit: components["schemas"]["LineConfigKnobBounds"];
         };
         LineConfigKnobBounds: {
             current: number;
@@ -6232,6 +7557,9 @@ export interface components {
             min_inter_message_seconds?: number;
             min_inter_new_contact_seconds?: number;
             max_queue_depth?: number;
+            reply_window_hours?: number;
+            reply_max_per_inbound?: number;
+            daily_reply_limit?: number;
             timezone?: string;
             activity_curve?: {
                 hour: number;
@@ -6241,20 +7569,19 @@ export interface components {
         PreOrder: {
             /** Format: uuid */
             id: string;
-            /** @enum {string} */
-            billing_tier: "rental_iphone" | "rental_android";
             preferred_area_codes: string[];
+            inbound_only: boolean;
+            /** @description The billing anchor you stated when placing this pre-order, carried onto the line at confirm. `null` means you stated none and the line is billed on its activation instant. */
+            billing_anchor_at: string | null;
             status: components["schemas"]["PreOrderStatus"];
-            stripe_payment_intent_id: string | null;
             stripe_client_secret: string | null;
-            amount: number;
             estimated_fulfillment: string | null;
             device_status?: components["schemas"]["DeviceFulfillmentStatus"];
             created_at: string;
             updated_at: string;
         };
         /** @enum {string} */
-        PreOrderStatus: "draft" | "pending" | "provisioning" | "ready" | "fulfilled" | "cancelled" | "refunded";
+        PreOrderStatus: "draft" | "provisioning" | "fulfilled" | "cancelled";
         /** @enum {string|null} */
         DeviceFulfillmentStatus: "awaiting_hardware" | "received" | "setup_in_progress" | "ready" | "deployed" | null;
         PreOrderList: {
@@ -6298,11 +7625,71 @@ export interface components {
              */
             device_count: number;
             /**
-             * @description Stripe price cadence. Annual is 10x monthly (2 months free).
+             * @description Stripe price cadence. Quarterly is 2.7x monthly (10% off) and annual is 10x monthly (2 months free).
+             * @example monthly
+             * @enum {string}
+             */
+            billing_cycle: "monthly" | "quarterly" | "annual";
+        };
+        MacCheckoutEnvelope: {
+            /** @enum {boolean} */
+            success: true;
+            data: components["schemas"]["MacCheckoutResponse"];
+            trace_id: string;
+            request_id: string;
+        };
+        MacCheckoutResponse: {
+            /**
+             * Format: uri
+             * @description Hosted Stripe Checkout URL — redirect the customer here.
+             */
+            checkout_url: string;
+            /**
+             * Format: date-time
+             * @description Session expiry (ISO-8601). Stripe default is 24h.
+             */
+            expires_at: string;
+            /** @description Sessions ordered — echoed back as accepted. */
+            quantity: number;
+            /** @description The pack divisor in force, read from the Stripe Price’s `pack_size` metadata. Quantities must be whole multiples of it, at or above it. */
+            pack_size: number;
+            /** @description Recurring total per period in integer cents, from the Price’s graduated tier ladder. Excludes tax, proration and coupons. */
+            estimated_total_cents: number;
+        };
+        MacCheckoutBody: {
+            /**
+             * @description Number of hosted macOS sessions to rent. Must be a whole number of packs at or above the one-pack minimum — the pack size is read from the Stripe Price and echoed as `pack_size` in the response and in the `422` error `issues[0].min`. A quantity that is not a whole pack is refused `422 mac_quantity_not_a_pack`.
+             * @example 5
+             */
+            quantity: number;
+            /**
+             * @description Stripe price cadence for the session subscription.
              * @example monthly
              * @enum {string}
              */
-            billing_cycle: "monthly" | "annual";
+            billing_cycle: "monthly" | "quarterly" | "annual";
+        };
+        SubscriptionQuantityEnvelope: {
+            /** @enum {boolean} */
+            success: true;
+            data: components["schemas"]["SubscriptionQuantityResponse"];
+            trace_id: string;
+            request_id: string;
+        };
+        SubscriptionQuantityResponse: {
+            /** @description The Stripe subscription ID (`sub_*`). */
+            subscription_id: string;
+            /** @description The quantity now set on the adjustable item. */
+            quantity: number;
+            /** @description Recurring total per period in integer cents. `null` when the item’s Price carries no computable per-period total. Excludes tax, proration and coupons. */
+            estimated_total_cents: number | null;
+        };
+        SubscriptionQuantityBody: {
+            /**
+             * @description New quantity for the subscription’s single adjustable item — macOS sessions, or BYOP slots. Both products are subject to the 1:1 rule (see the `422` codes), and the macOS product additionally to the pack rule.
+             * @example 10
+             */
+            quantity: number;
         };
         SubscriptionListEnvelope: {
             /** @enum {boolean} */
@@ -6401,6 +7788,7 @@ export interface components {
             reactions: components["schemas"]["MessageReactionV1"][];
             scheduled_for: string | null;
             schedule_reason: string | null;
+            reply_lane: boolean;
             queue_info: {
                 queue_position: number;
                 is_new_contact: boolean;
@@ -6410,6 +7798,9 @@ export interface components {
                 daily_known_contact_limit: number;
                 daily_messages_used: number;
                 daily_total_message_limit: number;
+                reply_lane: boolean;
+                daily_replies_used: number;
+                daily_reply_limit: number;
                 messages_ahead_in_queue?: number;
                 daily_slot_of?: string;
                 target_activity_hour?: number;
@@ -6424,6 +7815,8 @@ export interface components {
             delivered_at: string | null;
             read_at: string | null;
             failed_at: string | null;
+            error_code: string | null;
+            error_message: string | null;
             cancelled_at: string | null;
         };
         /** @enum {string} */
@@ -6515,7 +7908,7 @@ export interface components {
          * @description A concrete event type (e.g. `message.received`), a family wildcard (`line.*`), or the catch-all `*`.
          * @enum {string}
          */
-        WebhookEventName: "message.queued" | "message.sent" | "message.delivered" | "message.read" | "message.failed" | "message.received" | "message.scheduled" | "message.cancelled" | "message.fallback_triggered" | "reaction.added" | "reaction.received" | "reaction.removed" | "line.connected" | "line.disconnected" | "line.offline" | "line.degraded" | "line.apple_id_flagged" | "line.quota_warning" | "line.quota_exceeded" | "line.capability_changed" | "typing_indicator.started" | "typing_indicator.stopped" | "trial.linked" | "trial.dormant" | "trial.reactivated" | "trial.bind_conflict" | "trial.revoked" | "binding.released" | "pre_order.fulfilled" | "pre_order.cancelled" | "pre_order.refunded" | "webhook.test" | "*" | "message.*" | "reaction.*" | "line.*" | "typing_indicator.*" | "trial.*" | "binding.*" | "pre_order.*" | "webhook.*";
+        WebhookEventName: "message.queued" | "message.sent" | "message.delivered" | "message.read" | "message.failed" | "message.received" | "message.scheduled" | "message.cancelled" | "message.fallback_triggered" | "reaction.added" | "reaction.received" | "reaction.removed" | "line.connected" | "line.disconnected" | "line.offline" | "line.degraded" | "line.apple_id_flagged" | "line.quota_warning" | "line.quota_exceeded" | "line.capability_changed" | "line.terminated" | "line.variant_changed" | "line.variant_scheduled" | "line.variant_unscheduled" | "typing_indicator.started" | "typing_indicator.stopped" | "trial.linked" | "trial.dormant" | "trial.reactivated" | "trial.bind_conflict" | "trial.revoked" | "binding.released" | "pre_order.fulfilled" | "pre_order.cancelled" | "macos_session.rented" | "macos_session.released" | "webhook.test" | "*" | "message.*" | "reaction.*" | "line.*" | "typing_indicator.*" | "trial.*" | "binding.*" | "pre_order.*" | "macos_session.*" | "webhook.*";
         WebhookList: {
             webhooks: components["schemas"]["Webhook"][];
         };
@@ -6663,6 +8056,17 @@ export interface components {
             handle: string;
             from_line_id?: string;
         };
+        AttentionList: {
+            entries: components["schemas"]["AttentionEntry"][];
+        };
+        AttentionEntry: {
+            line_id: string;
+            phone_number: string | null;
+            ownership: string;
+            since: string | null;
+            reasons: string[];
+            detail_withheld: boolean;
+        };
         AreaCodesEnvelope: {
             /** @enum {boolean} */
             success: true;
@@ -6681,6 +8085,27 @@ export interface components {
             region: string;
             /** @example US */
             country_code: string;
+            /**
+             * @description A ZIP code whose geography this area code serves — the postal address to use at purchase, and the address most likely to have the carrier assign this area code. `null` when no ZIP is on record for this code: choosing the address is then a judgement call for the operator, and this catalogue may not know of an overlay covering the code either, so no regional address can be assumed to yield it.
+             * @example 10019
+             */
+            purchase_zip: string | null;
+            /**
+             * @description Fallback ZIPs in the same geography, to retry with if the carrier rejects the primary. Empty when no ZIP is on record.
+             * @example [
+             *       "10021",
+             *       "10023"
+             *     ]
+             */
+            alt_zips: string[];
+            /**
+             * @description Other area codes IN THIS CATALOGUE that overlay the same geography. Non-empty means NO address can guarantee this specific code — the carrier may assign any code in the complex. An empty list is NOT the converse guarantee: it says only that no code this endpoint can offer is known to overlay this one, and an overlay outside the catalogue may still take the number.
+             * @example [
+             *       "646",
+             *       "917"
+             *     ]
+             */
+            shared_with: string[];
         };
         Country: {
             /** @example US */
@@ -6907,6 +8332,13 @@ export interface components {
                 [key: string]: unknown;
             };
         };
+        MacosSessionEnvelope: {
+            /** @enum {boolean} */
+            success: true;
+            data: components["schemas"]["MacosSession"];
+            trace_id: string;
+            request_id: string;
+        };
         AppManifestEnvelope: {
             /** @enum {boolean} */
             success: true;
@@ -6926,10 +8358,16 @@ export interface components {
              */
             url: string;
             /**
-             * @description Bridge version this deployment advertises — the same string `POST /v1/byod/pair` returns as `bridge_version`. Compare it against an installed version to offer an update.
-             * @example 2.0.1
+             * @description Version currently published for this platform, read from the release feed that sits beside the artifact `url` resolves to — so the number announced and the file served cannot name different releases. `null` when that feed publishes nothing or could not be read; `version_status` says which. Never a configured placeholder: a fabricated version makes a failed install and an uninformed console indistinguishable to whoever is checking. Compare it against an installed version to offer an update.
+             * @example 0.0.211
+             */
+            version: string | null;
+            /**
+             * @description Why `version` holds what it holds. `version` is non-null if and only if this is `published`, so a null is never ambiguous (WHA-2765). `none_published` — the feed answered and publishes no version (a 404, or a feed with no readable item): a real fact about the channel, render "version not published". `unreachable` — the feed could not be read (timeout, DNS failure, a body past the size cap): OUR fault or the update host's, and nobody knows what this channel publishes, so do not tell an operator the version is missing. `misconfigured` — an artifact URL is configured for the platform and no feed URL can be derived from it; someone must fix the deployment. `not_configured` — this deployment ships no artifact for the platform, which is the same fact `available: false` carries. Before this field the last three and the first were one indistinguishable `null`, so a broken appcast URL and a healthy pre-release channel rendered identically.
+             * @example published
+             * @enum {string}
              */
-            version: string;
+            version_status: "published" | "none_published" | "unreachable" | "misconfigured" | "not_configured";
             /**
              * @description False when this deployment has no artifact configured for the platform. The entry is still returned, so a consumer can hide the affordance instead of surfacing a link that 404s on click.
              * @example true