@reclaimprotocol/client 0.1.33 → 0.1.35

package/lib/types/openapi.gen.d.ts

@@ -11,8 +11,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Home — sign-in or Discover
-         * @description Signed in, renders Discover (see `GET /discover`). Signed out, renders the sign-in page; a signed-out link carrying Discover's `q` / `tag` redirects to `/discover` with them.
+         * Home — sign-in or the Dashboard
+         * @description Signed in, redirects to the Dashboard (`GET /orgs/{orgId}`) of the console's selected org, else the viewer's default org. Signed out, renders the sign-in page; a signed-out link carrying Discover's `q` / `tag` redirects to `/discover` with them.
          */
         get: operations["Index"];
         put?: never;
@@ -1110,6 +1110,8 @@ export interface paths {
          *     - `zkfetch` — a static informational page. zkFetch has no claimant
          *       step; nothing ever redirects a browser here by design.
          *
+         *     A session from `POST /verifications/ai-sessions` never redirects for now. While its lookup runs, the page shows a loading state and reloads itself. Then it shows the candidate pages, and asks the user to pick one when there are several (nothing happens after the pick yet). When the lookup failed, the page shows an error and closes itself after 5 seconds. A session that is no longer pending shows that it ended.
+         *     `redirectUrl`, `redirectUrlOptions`, `cancelRedirectUrl`, and `cancelRedirectUrlOptions` in the query are added to the session's `launchOptions`, where every Verification Client can read them, unless the session already has that option: options set at creation, or by an earlier visit, win. They're validated as at creation (`https:` only); an invalid one is a 400. The `portals` redirect carries the session's launch options, and any other query parameters, on to the portal.
          *     Sets `Referrer-Policy: no-referrer`, so a `sessionId` never rides along in a `Referer` header to wherever a client eventually redirects.
          */
         get: operations["SharePage"];
@@ -1235,8 +1237,8 @@ export interface paths {
         get: operations["FixWithAiRecovery"];
         put?: never;
         /**
-         * Create or reopen a billed AI repair session
-         * @description Creates one idempotent repair attempt for the selected failed provider. The source organization is charged only when a new child is created. Repeated requests reopen a pending or successful child. After a child ends in error, rejection, or expiry, a later request creates a new, separately billed attempt. The server derives the exact failed version and repair prompt.
+         * Create a billed AI repair session
+         * @description Creates a verification session that pins the selected failed provider's exact version with `preferAiAgent`, charged to the source organization. Its verification page runs the AI authoring agent instead of the stored recipe. A proven recipe is published for the provider's own organization, or submitted for admin review otherwise. Every request creates a new, separately billed session.
          */
         post: operations["CreateFixWithAiSession"];
         delete?: never;
@@ -1245,26 +1247,6 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/v/{sessionId}/fix-with-ai/activate": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        get?: never;
-        put?: never;
-        /**
-         * Start a pending AI repair after the verification page loads
-         * @description Idempotently queues a pending repair session. The server derives the claimant country from the request and publishes no browser credentials.
-         */
-        post: operations["ActivateFixWithAiRepair"];
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
     "/.well-known/jwks.json": {
         parameters: {
             query?: never;
@@ -1365,6 +1347,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/docs/agent-installation.md": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Agent installation instructions
+         * @description How to install the Reclaim MCP server in each supported coding agent, as Markdown for a coding agent to read: the exact commands or configuration per agent, how to verify the installation, and troubleshooting. It tells the agent to follow only the section for the client it runs in. Public.
+         */
+        get: operations["AgentInstallationMarkdown"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/login": {
         parameters: {
             query?: never;
@@ -1776,7 +1778,7 @@ export interface paths {
         get: operations["GetOrgKeypair"];
         /**
          * Set (or rotate) the organization's encryption keypair
-         * @description Upserts the organization's single Ethereum (secp256k1) encryption keypair. The body carries the org's **eth public key** — as an uncompressed hex string (`0x04`+128 hex) or a secp256k1 public JWK (`{kty:'EC', crv:'secp256k1', x, y}`) — and `canEncryptResult`. The matching private key never leaves the consumer. Setting overwrites the single row (and creates it for a keyless org). When `canEncryptResult` is true, terminal results are delivered as an ECIES ciphertext encrypted to this key; otherwise plaintext. Authenticated by the org's `OrgToken` or a human `BearerAuth` session for an active member of the org.
+         * @description Sets the organization's single Ethereum (secp256k1) encryption keypair. The body carries the org's **eth public key** — as an uncompressed hex string (`0x04`+128 hex) or a secp256k1 public JWK (`{kty:'EC', crv:'secp256k1', x, y}`) — and `canEncryptResult`. The matching private key never leaves the consumer. The call creates the key for a keyless org and is idempotent for the same key. If the org has a different key, it returns `409` unless `replace` is true. When `canEncryptResult` is true, terminal results are delivered as an ECIES ciphertext encrypted to this key; otherwise plaintext. Authenticated by the org's `OrgToken` or a human `BearerAuth` session for an active member of the org.
          */
         put: operations["SetOrgKeypair"];
         post?: never;
@@ -2038,6 +2040,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/orgs/{orgId}/billing/card": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Save a card for the organization
+         * @description Owner only. Returns a Stripe Checkout URL that only saves a card (no charge), creating the organization's Stripe customer on first use. The saved card becomes the default that plans and overage bill. Stripe returns the owner to the Billing tab with `?billing=card`.
+         */
+        post: operations["CreateCardSetupSession"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/orgs/{orgId}/billing/subscription": {
         parameters: {
             query?: never;
@@ -2334,7 +2356,7 @@ export interface paths {
         };
         /**
          * Get a specific provider version
-         * @description Fetches one exact canonical version. Trunk is public when the provider is public. Non-trunk versions are visible to admins and members of the provider's organization. A member of the organization that paid for a successful AI repair may also read only the exact `fixed` version created by that repair.
+         * @description Fetches one exact canonical version. Trunk is public when the provider is public. Non-trunk versions are visible to admins and members of the provider's organization.
          */
         get: operations["GetProviderVersion"];
         put?: never;
@@ -2490,12 +2512,26 @@ export interface paths {
         /**
          * Register a callback subscription
          * @description Registers a destination for verification results on the organization
-         *     the presented `OrgToken` resolves to. The body is just `callbackUrl`
-         *     and `events`. At least one subscription must exist for the org before a
-         *     verification session can be created. Delivery is scoped by org: terminal
-         *     results are ECIES-encrypted to the org's eth public key when its
-         *     `canEncryptResult` is enabled (see `PUT /orgs/{orgId}/keypair`), else
-         *     delivered as plaintext.
+         *     the presented `OrgToken` resolves to. At least one subscription must
+         *     exist for the org before you can create a verification session.
+         *     Delivery is scoped by org: terminal results are ECIES-encrypted to the
+         *     org's eth public key when its `canEncryptResult` is enabled (see
+         *     `PUT /orgs/{orgId}/keypair`), else delivered as plaintext.
+         *
+         *     To receive results at a URL, send `callbackUrl` and `events`. Builder
+         *     POSTs each delivery to that URL.
+         *
+         *     To read results without a public URL during local development, send
+         *     `deliveryMode: "pull"`. Builder keeps the deliveries and you read them
+         *     with `GET /verifications/callback-events`. A pull subscription is a
+         *     90-second lease: it receives events and satisfies the session-creation
+         *     check only while the lease is unexpired. Send the same request about
+         *     every 30 seconds to renew it, and call
+         *     `POST /verifications/callback-listener/release` when you stop. Production
+         *     needs a webhook subscription. An org has at most one pull subscription.
+         *     If it already exists, Builder renews it and returns it with status 200.
+         *     If the body includes `events`, they replace the subscription's events;
+         *     if it omits them, the existing events are kept.
          */
         post: operations["CreateCallbackSubscription"];
         delete?: never;
@@ -2504,6 +2540,86 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/verifications/callback-listener/release": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Release the pull listener
+         * @description Expires the organization's pull subscription lease immediately, so it stops receiving events and no longer satisfies the session-creation check. Stored events stay readable. Call it when the coding agent stops. It succeeds when no pull subscription exists or the lease has already expired.
+         */
+        post: operations["ReleaseCallbackListener"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/verifications/callback-events": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List events from the pull subscription
+         * @description Lists the deliveries of the organization's pull subscription, oldest
+         *     first. Use it to read verification results without a public URL.
+         *     Create the pull subscription with `POST /verifications/callback-subscriptions`
+         *     and `deliveryMode: "pull"`.
+         *
+         *     Each item's `envelope` is the body that Builder POSTs to a webhook
+         *     subscription, so you handle both the same way. For a pull
+         *     subscription, `envelope.timestamp` is the time Builder created the
+         *     delivery.
+         *
+         *     To poll, pass the previous response's `next` as `after`. `next` is
+         *     always set, and equals `after` when no new events exist. Treat cursors
+         *     as opaque. A cursor read is not complete: a delivery that commits after
+         *     a later one can be missed, because the cursor has already moved past
+         *     it. The reliable path is `pending=true` plus
+         *     `POST /verifications/callback-events/acknowledge`: acknowledge each
+         *     event you handled, and read `pending=true` without `after` so anything
+         *     missed shows up on the next read.
+         *
+         *     Builder keeps result payloads for seven days. Acknowledged events stay
+         *     readable until then.
+         */
+        get: operations["ListCallbackEvents"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/verifications/callback-events/acknowledge": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Acknowledge events from the pull subscription
+         * @description Marks pull deliveries as `delivered` so `GET /verifications/callback-events` with `pending=true` stops returning them. Builder keeps the payloads until the seven-day retention limit. Ids that are unknown, belong to another organization, or are already acknowledged are ignored.
+         */
+        post: operations["AcknowledgeCallbackEvents"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/verifications/callback-subscriptions/{subscriptionId}": {
         parameters: {
             query?: never;
@@ -2539,7 +2655,8 @@ export interface paths {
         put?: never;
         /**
          * Register a callback subscription on an organization
-         * @description Registers a destination for verification results on the organization. Caller must be an active member of the org. The body is just `callbackUrl` and `events`; delivery is scoped to the org and encrypted as an ECIES ciphertext (base64url) to the org's encryption credential when set, else delivered as plaintext.
+         * @description Registers a destination for verification results on the organization. Caller must be an active member of the org. Delivery is scoped to the org and encrypted as an ECIES ciphertext (base64url) to the org's encryption credential when set, else delivered as plaintext.
+         *     Send `callbackUrl` and `events` to receive results at a URL. Send `deliveryMode: "pull"` to keep results for reading with `GET /verifications/callback-events`. A pull subscription works only while its 90-second lease is unexpired, and each repeated request renews it. An org has at most one pull subscription. If it already exists, Builder returns it with status 200.
          */
         post: operations["CreateOrgCallbackSubscription"];
         delete?: never;
@@ -2679,7 +2796,7 @@ export interface paths {
         };
         /**
          * Verification outcomes by day, device, and country
-         * @description Organization-scoped creation cohorts in UTC. Outcomes are current at query time. Unknown device and country values have their own buckets.
+         * @description Organization-scoped creation cohorts in UTC. Outcomes are current at query time. Unknown device and country values have their own buckets. A signed-in browser asking for HTML is redirected to the org's Dashboard (`GET /orgs/{orgId}`), which shows these analytics, with the same query.
          */
         get: operations["GetOrgVerificationAnalytics"];
         put?: never;
@@ -2742,6 +2859,118 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/verifications/ai-sessions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Start an AI verification session from a prompt
+         * @description Starts a verification from a plain-language prompt, such as "verify
+         *     I'm a student at Manipal University", instead of a list of providers.
+         *     Builder creates the session at once and returns it, as
+         *     `POST /verifications/sessions` does. Send the user to its
+         *     `verificationUrl`. In the background, Builder looks up the
+         *     `candidates` (pages the user opens and signs in to) and the
+         *     `dataPoints` to verify there, usually within a few seconds. Poll
+         *     `GET /verifications/ai-sessions/{sessionId}` until its `status` is
+         *     `ready` or `failed`. The share page at `verificationUrl` shows a
+         *     loading state meanwhile.
+         *
+         *     Builder searches the provider catalog (public providers and your
+         *     organization's own providers) and the web. The web search finds a
+         *     portal the catalog lacks, or one that replaced a stale catalog page.
+         *     Builder caches a web result for a week, or for a day when it finds
+         *     nothing. A URL or domain in the prompt is a hint: pages on it rank
+         *     first.
+         *
+         *     Deterministic checks run before any AI model. Builder rejects a
+         *     prompt that contains a password, card number, or Aadhaar number, that
+         *     contains instructions for the AI, or that makes a sensitive claim,
+         *     without calling a model. Builder withholds personal values the prompt
+         *     states, such as a name, email address, phone number, or student ID,
+         *     from the model and from the cache.
+         *
+         *     Once the lookup is ready, the session's `context` holds the values
+         *     the prompt states, such as the user's name, merged with the `context`
+         *     you send. Your values take precedence.
+         *
+         *     On `201`, the session has no providers: the AI agent works out how to
+         *     verify. The organization needs a callback subscription. The session
+         *     uses one verification from the quota pool of the
+         *     `verificationClientUrl` client. A prompt the checks above reject
+         *     creates no session and is free. If the lookup then fails (the prompt
+         *     isn't a request to verify something about the user, no login page
+         *     is found, or the model or web search stays unavailable), Builder
+         *     refunds the verification, ends the session with status `error`, and
+         *     sends the failure to your `verification_error` callbacks. Builder
+         *     caches lookups, so a repeated prompt resolves faster, even when it
+         *     names a different person.
+         *
+         *         curl -X POST $BASE/verifications/ai-sessions \
+         *           -H "Authorization: Bearer $ORG_TOKEN" \
+         *           -H 'Content-Type: application/json' \
+         *           -d '{"prompt":"verify I am a student at Manipal University"}'
+         *
+         *     Errors:
+         *
+         *     - `400`: Builder rejects the prompt (for example, it targets an
+         *       internal host), `context` contains `attestationNonce` or
+         *       `attestationNonceData`, or `verificationClientUrl` isn't a
+         *       registered client.
+         *     - `409`: The organization has no callback subscription.
+         *     - `429` or `402`: The quota or credits are spent. The body has
+         *       `event: billing_required` and a terminal `sessionId`.
+         *
+         *     A failed lookup isn't an error of this request: it shows in the
+         *     `error` of `GET /verifications/ai-sessions/{sessionId}`.
+         */
+        post: operations["CreateAiVerificationSession"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/verifications/ai-sessions/{sessionId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get what an AI verification session's prompt resolved to
+         * @description Returns the lookup that `POST /verifications/ai-sessions` started for
+         *     the session. `status` is `resolving` until it finishes, then `ready`
+         *     with the pages and data points it found, or `failed` with an
+         *     `error`. Poll every second or two while it's `resolving`.
+         *
+         *     `candidates` lists the pages to open, best first, each with a
+         *     `source` of `catalog` or `web`. It usually has one page. It has
+         *     several (up to 3) only when their `confidence` values are within 0.1
+         *     of the best page's value. In that case, the user picks one on the
+         *     session's `verificationUrl`.
+         *
+         *     The `OrgToken` must resolve to the session's organization. To track
+         *     the session's status, call `GET /verifications/sessions/{sessionId}`.
+         *
+         *         curl $BASE/verifications/ai-sessions/$SESSION_ID \
+         *           -H "Authorization: Bearer $ORG_TOKEN"
+         */
+        get: operations["GetAiVerificationSession"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/verifications/sessions/{sessionId}": {
         parameters: {
             query?: never;
@@ -3240,6 +3469,64 @@ export interface components {
         ProviderID: string;
         /** Format: uuid */
         OrgID: string;
+        /** @description Body for `POST /verifications/ai-sessions`. */
+        CreateAiVerificationSessionRequest: {
+            /** @description What to verify, in plain language, such as "verify I'm a student at Manipal University". Builder rejects a prompt that contains credentials, card numbers, instructions for the AI, or a sensitive claim. */
+            prompt: string;
+            /** @description Values you already know, such as `{"fullName": "Asha Rao"}`. Builder merges them over the values the prompt states and returns the result in `context`. Must not contain `attestationNonce` or `attestationNonceData`; bind those after you create the session. Omit if you have none. */
+            context?: {
+                [key: string]: unknown;
+            };
+            /** @description Base URL of the registered verification client the user verifies with, as for `POST /verifications/sessions`. Builder charges this client's quota pool. If you omit it, Builder uses the default (`portals`) client. */
+            verificationClientUrl?: string;
+            /** @description ISO 3166-1 alpha-2 country code, such as `IN`. Builder searches the web from this country (Google's `gl` parameter), so portals for that country rank first. If you omit it, the search has no country preference. */
+            geoLocation?: string;
+        };
+        /** @description The lookup `POST /verifications/ai-sessions` started for a session: its status, and once `ready`, the pages to open and the data points to verify there. */
+        AiVerificationSession: {
+            /**
+             * Format: uuid
+             * @description ID of the verification session. To track the session, call `GET /verifications/sessions/{sessionId}`.
+             */
+            sessionId: string;
+            /**
+             * @description `resolving` while Builder looks up the pages and data points. `ready` when `candidates` and `dataPoints` are set. `failed` when the lookup failed: `error` says why, the session ended with status `error`, and its verification was refunded.
+             * @enum {string}
+             */
+            status: "resolving" | "ready" | "failed";
+            /** @description Why the lookup failed. Only when `status` is `failed`. Its `status` is 422 when the prompt isn't a request to verify something about the user, 404 when no login page was found, and 503 when the AI model or web search stayed unavailable. */
+            error?: components["schemas"]["Problem"];
+            /** @description Only when `status` is `ready`. The fewest data points that prove the prompt's claim, required data points first. A data point for a value the prompt states is always required. */
+            dataPoints?: {
+                /** @description Short camelCase name, such as `username`. */
+                name: string;
+                /** @description What the value is and why it proves the claim. */
+                description: string;
+                /** @description If `true`, the claim can be proven without this value, as with `isOptional` on a provider's `ResponseMatch`. If absent, the data point is required. */
+                isOptional?: boolean;
+            }[];
+            /** @description Values the signed-in account must show, such as `{"fullName": "Asha Rao"}`. Each key is the `dataPoints` name that the value pins. It combines the values the prompt states with the request's `context`. It's empty if neither has any. It's the session's `context`. If the prompt names a specific page, such as a post, `pageUrl` holds it: the page to open after the user logs in on the candidate's site. */
+            context: {
+                [key: string]: unknown;
+            };
+            /** @description Only when `status` is `ready`. Pages to open, best first. Each is the page that shows the data after the user signs in (it sends the user to sign in first), or else the sign-in page. Usually one page. Several pages appear only when the choice is ambiguous, such as a college with two or three student portals whose `confidence` values are within 0.1 of the best. In that case, the user picks one on the session's `verificationUrl`. At most one page per host. */
+            candidates?: components["schemas"]["ResolvedLoginPage"][];
+        };
+        /** @description A page for the user to open and sign in to. */
+        ResolvedLoginPage: {
+            /**
+             * Format: uri
+             * @description URL of the page to open. For a `web` page, Builder removes the query and fragment.
+             */
+            loginUrl: string;
+            /** @description Estimated likelihood, from 0 to 1, that signing in here shows the claim. Candidates below 0.5 are never returned. */
+            confidence: number;
+            /**
+             * @description Where the page came from. `catalog` is the page of a provider in the catalog (public, or your organization's own). `web` is a page that a web search found; it has no provider yet.
+             * @enum {string}
+             */
+            source: "catalog" | "web";
+        };
         /** @description A verification client id used as a filter. Hyphens are ignored. */
         VerificationClientIDFilter: string;
         /** @description An organization id used as a filter. Hyphens are ignored, so it matches with or without them; an id that matches no organization returns nothing. */
@@ -3744,6 +4031,11 @@ export interface components {
             /** @default false */
             canEncryptResult: boolean;
             label?: string;
+            /**
+             * @description Set to true to replace an existing, different public key. Without it, the call returns 409 when the organization already has another key. Results encrypted to the old key can no longer be decrypted.
+             * @default false
+             */
+            replace: boolean;
         };
         /** @description Body for `PUT /orgs/{orgId}/keypair`. Carries the org's eth public key as a secp256k1 public JWK. */
         OrgKeypairJwkRequest: {
@@ -3751,6 +4043,11 @@ export interface components {
             /** @default false */
             canEncryptResult: boolean;
             label?: string;
+            /**
+             * @description Set to true to replace an existing, different public key. Without it, the call returns 409 when the organization already has another key. Results encrypted to the old key can no longer be decrypted.
+             * @default false
+             */
+            replace: boolean;
         };
         /** @description Response of `POST /orgs/{orgId}/token`. The plaintext `orgSecret` is shown **only once** here; the server stores only its HMAC. Use it as `Authorization: Bearer <orgSecret>` (the `OrgToken` scheme). An org may hold several keys; issuing a new one does not affect the others. */
         OrgToken: {
@@ -5616,24 +5913,59 @@ export interface components {
              * @description The organization that owns this callback subscription.
              */
             orgId: string;
-            /** @description HTTP(S) endpoint that receives the event. It may contain `{{sessionId}}` and top-level session-context placeholders such as `{{orderId}}`. The Builder URI-encodes each value and stores the expanded URL when it creates the delivery. */
-            callbackUrl: string;
+            deliveryMode: components["schemas"]["CallbackDeliveryMode"];
+            /** @description HTTP(S) endpoint that receives the event. It may contain `{{sessionId}}` and top-level session-context placeholders such as `{{orderId}}`. The Builder URI-encodes each value and stores the expanded URL when it creates the delivery. Absent when `deliveryMode` is `pull`. */
+            callbackUrl?: string;
+            /** @description Present when `deliveryMode` is `pull`. The pull subscription receives events and satisfies the session-creation check only until this time. Renew it by repeating the create request. */
+            listenerExpiresAt?: components["schemas"]["Timestamp"];
             /** @description Events this subscription wants delivered — any subset of `VerificationEvent`. Builder terminal events are `verification_success`, `verification_rejected`, `verification_error`, `verification_cancelled`, and `session_expired`. Terminal result deliveries contain the signed result when one is available; non-terminal events deliver a plaintext notification. */
             events: components["schemas"]["VerificationEvent"][];
             createdAt: components["schemas"]["Timestamp"];
             updatedAt: components["schemas"]["Timestamp"];
         };
-        /** @description Body for `POST /verifications/callback-subscriptions`. The owning organization is resolved from the presented `OrgToken`; delivery is scoped to that org and encrypted to its credential when set. */
-        CreateCallbackSubscriptionRequest: {
+        /**
+         * @description How Builder delivers events. `webhook` POSTs each one to `callbackUrl`. `pull` keeps them for you to read with `GET /verifications/callback-events`.
+         * @enum {string}
+         */
+        CallbackDeliveryMode: "webhook" | "pull";
+        /** @description A subscription that Builder POSTs each delivery to. */
+        WebhookCallbackSubscriptionRequest: {
+            /**
+             * @description Omit it or send `webhook`.
+             * @enum {string}
+             */
+            deliveryMode?: "webhook";
             /** @description Callback URL or template. Supported placeholders are `{{sessionId}}` and top-level scalar context keys. */
             callbackUrl: string;
             events: components["schemas"]["VerificationEvent"][];
         };
-        /** @description Body for `POST /orgs/{orgId}/callback-subscriptions`. The owning organization comes from the path; bearer-authenticated and gated on org membership. Delivery is scoped to the org and encrypted to its credential when set. */
-        CreateOrgCallbackSubscriptionRequest: {
-            /** @description Callback URL or template. Supported placeholders are `{{sessionId}}` and top-level scalar context keys. */
-            callbackUrl: string;
-            events: components["schemas"]["VerificationEvent"][];
+        /** @description A subscription whose deliveries wait for you to read them. It has no URL. An org has at most one. */
+        PullCallbackSubscriptionRequest: {
+            /** @enum {string} */
+            deliveryMode: "pull";
+            /** @description Not allowed. A pull subscription has no URL. */
+            callbackUrl?: unknown;
+            /** @description Events to keep. Defaults to every event. */
+            events?: components["schemas"]["VerificationEvent"][];
+        };
+        /** @description Body for `POST /verifications/callback-subscriptions`. The owning organization is resolved from the presented `OrgToken`; delivery is scoped to that org and encrypted to its credential when set. Send `callbackUrl` for a webhook, or `deliveryMode: "pull"` for a subscription you read. */
+        CreateCallbackSubscriptionRequest: components["schemas"]["WebhookCallbackSubscriptionRequest"] | components["schemas"]["PullCallbackSubscriptionRequest"];
+        /** @description Body for `POST /orgs/{orgId}/callback-subscriptions`. The owning organization comes from the path; bearer-authenticated and gated on org membership. Delivery is scoped to the org and encrypted to its credential when set. Send `callbackUrl` for a webhook, or `deliveryMode: "pull"` for a subscription you read. */
+        CreateOrgCallbackSubscriptionRequest: components["schemas"]["WebhookCallbackSubscriptionRequest"] | components["schemas"]["PullCallbackSubscriptionRequest"];
+        /** @description One delivery waiting on the organization's pull subscription. */
+        CallbackEvent: {
+            /**
+             * Format: uuid
+             * @description Pass it to `POST /verifications/callback-events/acknowledge`.
+             */
+            id: string;
+            subscriptionId: components["schemas"]["SubscriptionID"];
+            sessionId: components["schemas"]["SessionID"];
+            event: components["schemas"]["VerificationEvent"];
+            /** @description `pending` until you acknowledge the event, then `delivered`. */
+            deliveryStatus: components["schemas"]["CallbackDeliveryStatus"];
+            createdAt: components["schemas"]["Timestamp"];
+            envelope: components["schemas"]["VerificationResultDelivery"];
         };
         /** @description Present only when the session's `mode` is `SANDBOX`. */
         SandboxLimits: {
@@ -5710,7 +6042,7 @@ export interface components {
             resolvedVersion: string;
             /** Format: uri */
             initialUrl: string;
-            /** @description Legacy-only preference. Builder clients always run the structured recipe and never enable AI or manual verification from this value. */
+            /** @description Effective AI-agent preference: the session's choice, else whether the version is an `llm` provider. When true, the Builder verification page runs the AI authoring agent instead of the structured recipe. */
             preferAiAgent: boolean;
             geoLocation?: string;
             jsUserScripts?: string;
@@ -5760,7 +6092,7 @@ export interface components {
             preferredLocale?: string;
             /** @description When the organization-bound legacy TEE nonce context was first stored. The nonce data itself is present in `context` as `attestationNonce` and `attestationNonceData`. */
             teeNonceBoundAt?: components["schemas"]["Timestamp"];
-            /** @description Legacy-only preference echoed for compatibility. Builder-mode clients run the structured recipe and do not enable AI or manual verification. */
+            /** @description The creator's AI-agent preference. When true, the Builder verification page runs the AI authoring agent instead of the structured recipe. */
             preferAiAgent?: boolean;
             /** @description Whether this session was created with diagnostic mode enabled (see CreateVerificationSessionRequest.diagnostics). Set once at creation and never changes afterward. Gates whether Builder records claimant IP addresses and how much detail diagnostic events carry; the `diag` parameter on `verificationUrl` mirrors this value and is not itself authoritative. */
             diagnostics: boolean;
@@ -5828,7 +6160,7 @@ export interface components {
             themeId?: components["schemas"]["ThemeID"];
             /** @description Optional locale override for this verification session. It takes precedence over the organization theme's preferred locale. */
             preferredLocale?: string;
-            /** @description Legacy-only preference. Builder mode runs the structured recipe and does not enable AI or manual verification. Omit this field for Builder-mode sessions; dual-mode clients may continue to interpret it only on their legacy path. */
+            /** @description When true, the Builder verification page runs the AI authoring agent instead of the providers' structured recipes. A proven recipe is published only for the provider's own organization; for any other provider it is submitted for admin review. Omit it to run the stored recipes. */
             preferAiAgent?: boolean;
             /** @description Optional; omit or send false for a normal session. Opts this session into diagnostic mode. A diagnostic session records more event detail, including personal data such as the claimant's IP addresses (see ClaimantDetails.network). Builder appends `diag=1` to the returned `verificationUrl` for a diagnostic session and strips any `diag` value the Consumer's own `verificationClientUrl` carries, so this field — not the URL — is the only way to turn diagnostics on. Treat a diagnostic verification URL as sensitive, and don't hand it to a claimant by default. */
             diagnostics?: boolean;
@@ -6034,7 +6366,7 @@ export interface components {
                 signature: string;
             }[];
         };
-        /** @description The JSON envelope POSTed to a callback subscription's `callbackUrl` (see the `verificationResult` webhook). `sessionId`, `event` and `timestamp` are unauthenticated plaintext routing hints; branch on `event` for the shape of `data`. **Terminal result events** carry the signed result — an ECIES ciphertext (base64url, secp256k1 + AES-256-GCM) wrapping the signed JWS when the org has an encryption credential, else the plaintext signed JWS — act only on the signature-verified contents. **Non-terminal events** carry a plaintext, **unsigned** progress notification — advisory only; the signed terminal result is the source of truth. */
+        /** @description The JSON envelope POSTed to a callback subscription's `callbackUrl` (see the `verificationResult` webhook), and returned as `envelope` by `GET /verifications/callback-events` for a pull subscription. `sessionId`, `event` and `timestamp` are unauthenticated plaintext routing hints; branch on `event` for the shape of `data`. **Terminal result events** carry the signed result — an ECIES ciphertext (base64url, secp256k1 + AES-256-GCM) wrapping the signed JWS when the org has an encryption credential, else the plaintext signed JWS — act only on the signature-verified contents. **Non-terminal events** carry a plaintext, **unsigned** progress notification — advisory only; the signed terminal result is the source of truth. */
         VerificationResultDelivery: {
             sessionId: components["schemas"]["SessionID"];
             /** @description The event that produced this delivery. */
@@ -6182,8 +6514,11 @@ export interface components {
         VerificationDelivery: {
             subscriptionId: components["schemas"]["SubscriptionID"];
             event: components["schemas"]["VerificationEvent"];
-            /** Format: uri */
-            callbackUrl: string;
+            /**
+             * Format: uri
+             * @description Absent for deliveries to a pull subscription.
+             */
+            callbackUrl?: string;
             deliveryStatus: components["schemas"]["CallbackDeliveryStatus"];
             attempts: number;
             lastAttemptAt?: components["schemas"]["Timestamp"];
@@ -6299,6 +6634,13 @@ export interface operations {
         requestBody?: never;
         responses: {
             200: components["responses"]["HTMLResponse"];
+            /** @description Signed in; redirects to the Dashboard. */
+            302: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
             default: components["responses"]["ProblemResponse"];
         };
     };
@@ -8013,6 +8355,14 @@ export interface operations {
                 api?: "2";
                 /** @description Backend-derived echo of the session's `diagnostics` field, carried through to the launched destination unchanged. See the same parameter on `VerificationPage`. */
                 diag?: "1";
+                /** @description Added to the session's `launchOptions` if it has none. */
+                redirectUrl?: string;
+                /** @description JSON `VerificationLaunchRedirectOptions`. Added to the session's `launchOptions` if it has none. */
+                redirectUrlOptions?: string;
+                /** @description Added to the session's `launchOptions` if it has none. */
+                cancelRedirectUrl?: string;
+                /** @description JSON `VerificationLaunchRedirectOptions`. Added to the session's `launchOptions` if it has none. */
+                cancelRedirectUrlOptions?: string;
             };
             header?: never;
             path: {
@@ -8179,7 +8529,7 @@ export interface operations {
                     "text/html": components["schemas"]["HtmlContent"];
                 };
             };
-            /** @description The new or existing repair session. */
+            /** @description The new repair session. */
             201: {
                 headers: {
                     [name: string]: unknown;
@@ -8191,28 +8541,6 @@ export interface operations {
             default: components["responses"]["ProblemResponse"];
         };
     };
-    ActivateFixWithAiRepair: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path: {
-                sessionId: components["schemas"]["SessionID"];
-            };
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description The repair was queued or was already active. */
-            204: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content?: never;
-            };
-            409: components["responses"]["ProblemResponse"];
-            default: components["responses"]["ProblemResponse"];
-        };
-    };
     JwksJson: {
         parameters: {
             query?: never;
@@ -8340,6 +8668,27 @@ export interface operations {
             default: components["responses"]["ProblemResponse"];
         };
     };
+    AgentInstallationMarkdown: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The guide as Markdown. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/markdown": string;
+                };
+            };
+            default: components["responses"]["ProblemResponse"];
+        };
+    };
     LoginPage: {
         parameters: {
             query?: {
@@ -8685,8 +9034,13 @@ export interface operations {
                 tab?: "overview" | "connect" | "integrate" | "providers" | "members" | "themes" | "settings" | "sessions" | "billing";
                 /** @description Integrate tab only. Which integration path to show: a coding agent over MCP, the client package, or plain HTTP. */
                 track?: "agent" | "sdk" | "http";
-                /** @description Integrate tab, agent track only. Which coding agent's install command to show. */
+                /**
+                 * @deprecated
+                 * @description Ignored.
+                 */
                 agent?: "claude" | "copilot" | "cursor" | "omp" | "opencode" | "codex" | "antigravity" | "others";
+                /** @description Integrate tab, agent track only. What users prove, as typed into the prompt's goal field. */
+                goal?: string;
                 /** @description Integrate tab: the providers to show in the examples in place of placeholder ids, for example when arriving from a provider page or a build page. Repeat to pass several. Dashboard tab: scopes the report to sessions that ran this provider (the first one); options come from `GET /orgs/{orgId}/providers/used`. */
                 providerId?: components["schemas"]["ProviderID"][];
                 /** @description Integrate tab, HTTP track only. Which Verification Client the create-session example targets. `auto` (the default) leaves `verificationClientUrl` out. */
@@ -8704,7 +9058,7 @@ export interface operations {
                 /** @description Providers tab only. Renders the New provider dialog already open, so a link from another page can land on it. */
                 newProvider?: boolean;
                 /** @description Post-checkout status signal set by Stripe redirect (`success_url` / `cancel_url`), the card-save flow, and the credit top-up. Drives a one-shot notice and deep-links to the Billing tab; nothing else about the page depends on it. */
-                billing?: "success" | "cancelled" | "changed" | "credits";
+                billing?: "success" | "cancelled" | "changed" | "credits" | "card";
             };
             header?: never;
             path: {
@@ -9164,6 +9518,7 @@ export interface operations {
             };
             400: components["responses"]["ProblemResponse"];
             403: components["responses"]["ForbiddenResponse"];
+            409: components["responses"]["ProblemResponse"];
             default: components["responses"]["ProblemResponse"];
         };
     };
@@ -9572,6 +9927,33 @@ export interface operations {
             default: components["responses"]["ProblemResponse"];
         };
     };
+    CreateCardSetupSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                orgId: components["schemas"]["OrgID"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Checkout session created */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** Format: uri */
+                        url: string;
+                    };
+                };
+            };
+            403: components["responses"]["ForbiddenResponse"];
+            default: components["responses"]["ProblemResponse"];
+        };
+    };
     CancelBillingSubscription: {
         parameters: {
             query?: never;
@@ -10472,6 +10854,15 @@ export interface operations {
             };
         };
         responses: {
+            /** @description The org's existing pull subscription */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CallbackSubscription"];
+                };
+            };
             /** @description Subscription created */
             201: {
                 headers: {
@@ -10484,6 +10875,85 @@ export interface operations {
             default: components["responses"]["ProblemResponse"];
         };
     };
+    ReleaseCallbackListener: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Released */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            default: components["responses"]["ProblemResponse"];
+        };
+    };
+    ListCallbackEvents: {
+        parameters: {
+            query?: {
+                /** @description Cursor from the `next` field of a previous response. Returns only events after it. Omit it to start from the oldest event. */
+                after?: string;
+                /** @description Maximum number of events to return. Defaults to 50. */
+                limit?: number;
+                /** @description Returns only events of this verification session. */
+                sessionId?: components["schemas"]["SessionID"];
+                /** @description When `true`, returns only events you have not acknowledged. Defaults to `false`. */
+                pending?: boolean;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Ok */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        items: components["schemas"]["CallbackEvent"][];
+                        /** @description Cursor to pass as `after` on the next request. Equals `after` when `items` is empty, and `0` when you passed no `after`. */
+                        next: string;
+                    };
+                };
+            };
+            default: components["responses"]["ProblemResponse"];
+        };
+    };
+    AcknowledgeCallbackEvents: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description The `id` of each `CallbackEvent` to acknowledge. */
+                    ids: string[];
+                };
+            };
+        };
+        responses: {
+            /** @description Acknowledged */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            default: components["responses"]["ProblemResponse"];
+        };
+    };
     DeleteCallbackSubscription: {
         parameters: {
             query?: never;
@@ -10548,6 +11018,15 @@ export interface operations {
             };
         };
         responses: {
+            /** @description The org's existing pull subscription */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CallbackSubscription"];
+                };
+            };
             /** @description Subscription created */
             201: {
                 headers: {
@@ -10768,10 +11247,16 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "text/html": components["schemas"]["HtmlContent"];
                     "application/json": components["schemas"]["VerificationAnalytics"];
                 };
             };
+            /** @description A browser; redirects to the org's Dashboard. */
+            302: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
             403: components["responses"]["ForbiddenResponse"];
             default: components["responses"]["ProblemResponse"];
         };
@@ -10816,7 +11301,7 @@ export interface operations {
                     "application/problem+json": components["schemas"]["Problem"];
                 };
             };
-            /** @description No callback subscription exists for the organization. Register one first via `POST /verifications/callback-subscriptions` (or `POST /orgs/{orgId}/callback-subscriptions`). */
+            /** @description No callback subscription exists for the organization. Register one first via `POST /verifications/callback-subscriptions` (or `POST /orgs/{orgId}/callback-subscriptions`). A pull subscription satisfies this check only while its listener lease is unexpired. */
             409: {
                 headers: {
                     [name: string]: unknown;
@@ -10837,6 +11322,90 @@ export interface operations {
             default: components["responses"]["ProblemResponse"];
         };
     };
+    CreateAiVerificationSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateAiVerificationSessionRequest"];
+            };
+        };
+        responses: {
+            /** @description Session created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["VerificationSession"];
+                };
+            };
+            /** @description Overage is paused: the organization is past its plan allowance, and its prepaid credits and credit-exhaustion allowance are spent (`event: billing_required`). */
+            402: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["Problem"];
+                };
+            };
+            /** @description The organization has no callback subscription. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["Problem"];
+                };
+            };
+            /** @description The verification quota is exceeded (`event: billing_required` with a terminal `sessionId`). */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["Problem"];
+                };
+            };
+            default: components["responses"]["ProblemResponse"];
+        };
+    };
+    GetAiVerificationSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                sessionId: components["schemas"]["SessionID"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Ok */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AiVerificationSession"];
+                };
+            };
+            /** @description No session with this ID, or the session wasn't created by `POST /verifications/ai-sessions`. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["Problem"];
+                };
+            };
+            default: components["responses"]["ProblemResponse"];
+        };
+    };
     GetVerificationSession: {
         parameters: {
             query?: never;