@zarel-ai/sdk 0.6.0

package/dist/generated/runtime.d.ts

@@ -0,0 +1,4020 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+export interface paths {
+    "/runtime/llm/services": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List the LLM services the actor is authorized to use in `?scope=`
+         * @description FR-B02 no-leak: returns ONLY services for which the actor has a
+         *     `use` policy in the requested scope. There is no separate
+         *     "all services" endpoint — operators see everything because their
+         *     contract policies grant them `use` on every service.
+         */
+        get: operations["listLlmServices"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/llm/services/{name}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                name: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Get one LLM service by name (only if authorized in `?scope=`)
+         * @description FR-B02 no-leak: a service the actor cannot use in `?scope=` returns
+         *     404 indistinguishable from "doesn't exist". The response body never
+         *     reveals whether the row exists for unauthorized actors.
+         */
+        get: operations["getLlmService"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/llm/credentials": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List masked metadata for credentials the actor can manage */
+        get: operations["listLlmCredentials"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/llm/credentials/{service_name}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                service_name: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Get masked metadata for one credential
+         * @description Plaintext is NEVER returned. Returns 404 indistinguishable from "doesn't exist" when not authorized (FR-B02).
+         */
+        get: operations["getLlmCredential"];
+        /**
+         * Set / replace a credential (write-only on `api_key`)
+         * @description Body: `{ api_key, base_url? }`. Server encrypts with the per-tenant
+         *     DEK, computes a 4-char fingerprint, and writes a sanitised audit row
+         *     (no ciphertext / IV / fingerprint, FR-I06). The plaintext is consumed
+         *     and discarded — no read endpoint can retrieve it (FR-I04).
+         *
+         *     Possible 4xx codes:
+         *       - `INVALID_API_KEY` (400): empty / too long / non-printable.
+         *       - `UNKNOWN_LLM_SERVICE` (404): service does not exist in catalog
+         *         (only returned to authorized callers).
+         *       - `PROVIDER_NOT_ALLOWED` (403, ADR-0102 S5b-a): the service's
+         *         provider is outside the tenant's allowed providers (the bounds on
+         *         the `manage_credentials` grant). Only reachable by holders of the
+         *         grant — the no-leak 404 below still applies first.
+         *       - 404 indistinguishable from "doesn't exist" when the actor lacks
+         *         `manage_credentials` (FR-B02 / SEC.V12 — never 403).
+         */
+        put: operations["setLlmCredential"];
+        post?: never;
+        /**
+         * Remove a credential (FR-I07 safeguard)
+         * @description Returns 409 `CREDENTIAL_IN_USE` when any active session is pinned to
+         *     the service. Operators must close the pinned sessions first. Returns
+         *     404 indistinguishable from "doesn't exist" when the actor lacks
+         *     `manage_credentials` (FR-B02).
+         */
+        delete: operations["deleteLlmCredential"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/embedding-credentials": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List masked metadata for the tenant's embedding credentials (per declared service)
+         * @description Returns one masked-metadata row per stored (tenant, embedding service).
+         *     Plaintext is NEVER returned. Authorization: tenant-level superuser;
+         *     unauthorized callers receive an empty list (SEC.V12 no-leak, never 403).
+         */
+        get: operations["listEmbeddingCredentials"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/embedding-credentials/{service_name}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The DECLARED embedding-service name from `embeddings.services[]`
+                 *     (FR-023) — not the provider. A provider is not an identity: two
+                 *     services may share one, and the credential keys to a declaration that
+                 *     exists. The provider is resolved from that declaration server-side.
+                 */
+                service_name: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Get masked metadata for one embedding service's credential
+         * @description Plaintext is NEVER returned. 404 indistinguishable from "not configured" when not authorized (SEC.V12).
+         */
+        get: operations["getEmbeddingCredential"];
+        /**
+         * Set / replace an embedding service's credential (write-only on the secret)
+         * @description Body is the credential blob for the provider the DECLARED service names —
+         *     `{ apiKey, base_url? }` for apiKey providers (gemini, openai,
+         *     anthropic-via-Voyage) or `{ accessKeyId, secretAccessKey, region,
+         *     sessionToken? }` for bedrock. The server resolves the provider from
+         *     `embeddings.services[]`, validates against that provider's registry
+         *     credential schema, encrypts with the per-tenant DEK, computes a
+         *     fingerprint, and writes a sanitised audit row. The secret is consumed and
+         *     never retrievable.
+         *
+         *     Possible 4xx codes:
+         *       - `INVALID_CREDENTIAL` (400): blob fails the resolved provider's schema.
+         *       - `UNKNOWN_EMBEDDING_SERVICE` (404): no live `embeddings.services[]`
+         *         entry of that name — a secret must key to a declaration that exists
+         *         (FR-022). Only reachable by authorized callers.
+         *       - `PROVIDER_NOT_ALLOWED` (403, ADR-0102 S5b-a): the declared service's
+         *         provider is outside the tenant's allowed embedding providers (the
+         *         bounds on the `manage_credentials` grant). Only reachable by grant holders.
+         *       - 404 indistinguishable from "not configured" when not authorized (SEC.V12 — never 403).
+         */
+        put: operations["setEmbeddingCredential"];
+        post?: never;
+        /**
+         * Remove an embedding service's credential (soft-delete + sensitive wipe)
+         * @description Soft-deletes the row and wipes the sensitive columns; the
+         *     embedding_similarity gate falls through on subsequent turns for that
+         *     service. 404 indistinguishable from "not configured" when not authorized.
+         */
+        delete: operations["deleteEmbeddingCredential"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/records/{entity_name}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                entity_name: components["parameters"]["EntityNamePath"];
+            };
+            cookie?: never;
+        };
+        /** List records for an entity (filterable, sortable, paginated) */
+        get: operations["listRuntimeRecords"];
+        put?: never;
+        /**
+         * Create a record
+         * @description ADR-0127 (Option B strict) — this bare surface serves ONLY verbs with no
+         *     named action. A governed verb is rejected `400 action_required`; dispatch
+         *     it via `POST /runtime/actions/{name}` instead.
+         */
+        post: operations["createRuntimeRecord"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/records/{entity_name}/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                entity_name: components["parameters"]["EntityNamePath"];
+                id: string;
+            };
+            cookie?: never;
+        };
+        /** Get a record */
+        get: operations["getRuntimeRecord"];
+        put?: never;
+        post?: never;
+        /**
+         * Delete a record
+         * @description ADR-0127 (Option B strict) — a governed verb is rejected `400
+         *     action_required`; dispatch it via `POST /runtime/actions/{name}`.
+         */
+        delete: operations["deleteRuntimeRecord"];
+        options?: never;
+        head?: never;
+        /**
+         * Merge-patch a record
+         * @description ADR-0127 (Option B strict) — a governed verb is rejected `400
+         *     action_required`; dispatch it via `POST /runtime/actions/{name}`.
+         */
+        patch: operations["patchRuntimeRecord"];
+        trace?: never;
+    };
+    "/runtime/records/counter/{entity_name}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                entity_name: components["parameters"]["EntityNamePath"];
+            };
+            cookie?: never;
+        };
+        /** Read the record counter for an entity (runtime-readonly) */
+        get: operations["getRuntimeRecordsCounter"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/state-machine/instances": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List state-machine instances (readonly) */
+        get: operations["listStateMachineInstances"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/state-machine/instances/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        /** Get a state-machine instance */
+        get: operations["getStateMachineInstance"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/state-machine/events": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List state-machine events (readonly; filter by entity_name / instance_id) */
+        get: operations["listStateMachineEvents"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/state-machine/events/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        /** Get a state-machine event */
+        get: operations["getStateMachineEvent"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/state-machine/transition-requests": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List transition requests (filter by status / role) */
+        get: operations["listTransitionRequests"];
+        put?: never;
+        /** Create a transition request */
+        post: operations["createTransitionRequest"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/state-machine/transition-requests/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        /** Get a transition request */
+        get: operations["getTransitionRequest"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        /** Resolve a pending transition request (approve/reject) */
+        patch: operations["resolveTransitionRequest"];
+        trace?: never;
+    };
+    "/runtime/actions/{name}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Action name from the tenant contract `actions[]` block. */
+                name: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Dispatch a YAML-declared action
+         * @description Resolves `name` against the tenant's `actions[]`, derives the
+         *     underlying `(entity, verb)` pair, and dispatches through the existing
+         *     `RecordCrudService`. Returns the dispatched record (or `null` for
+         *     `delete` verbs) plus a `resolved_via_action` telemetry tag.
+         *
+         *     ADR-0127 — this is the governed dispatch surface: the resolved action's
+         *     identity is carried to the deterministic write floor, which evaluates
+         *     capability / phase / precondition / confirmation before persistence. A
+         *     blocked write returns a typed outcome (`422 phase_not_allowed` /
+         *     `422 precondition_failed`); a write a `confirm` guard pauses returns
+         *     `409 confirmation_required` (see the confirmation round-trip below).
+         */
+        post: operations["dispatchAction"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/flows/instances": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List flow instances (readonly)
+         * @description Owner-scoped to the calling actor unless the caller holds the `view_flows`
+         *     runtime system action. `flow` NARROWS the listing; it never widens it —
+         *     the owner scope is applied independently of any filter.
+         */
+        get: operations["listFlowInstances"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/flows/instances/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        /** Get a flow instance */
+        get: operations["getFlowInstance"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/flows/events": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List flow events (readonly)
+         * @description The appended flow lifecycle log — where per-step history lives (a run row
+         *     carries none). Ordered by the hash chain's `seq`, which is the only total
+         *     order the log has. Same visibility rule as `/runtime/flows/instances`:
+         *     owner-scoped unless the caller holds `view_flows`, applied independently
+         *     of any filter. Pass `instance_id` for one run's trace.
+         */
+        get: operations["listFlowEvents"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/flows/events/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        /** Get a flow event */
+        get: operations["getFlowEvent"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/flows/callbacks": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List pending flow callbacks (authenticated) */
+        get: operations["listFlowCallbacks"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/flows/callbacks/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        /** Get a flow callback (authenticated) */
+        get: operations["getFlowCallback"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        /**
+         * Resolve a flow callback
+         * @description **Public endpoint.** The `id` is the opaque capability token supplied
+         *     to the external system at flow registration; no JWT is required.
+         *
+         *     Returns a **flat** `{success, message?}` ack (no `data`, NOT
+         *     envelope-wrapped) — the SDK returns it whole (codegen-unwrap: no-unwrap).
+         */
+        patch: operations["resolveFlowCallback"];
+        trace?: never;
+    };
+    "/runtime/events/subscriptions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List webhook subscriptions */
+        get: operations["listEventSubscriptions"];
+        put?: never;
+        /** Create a webhook subscription */
+        post: operations["createEventSubscription"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/events/subscriptions/{subscription_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                subscription_id: number;
+            };
+            cookie?: never;
+        };
+        /** Get a subscription */
+        get: operations["getEventSubscription"];
+        put?: never;
+        post?: never;
+        /** Deactivate a subscription */
+        delete: operations["deactivateEventSubscription"];
+        options?: never;
+        head?: never;
+        /** Merge-patch a subscription */
+        patch: operations["patchEventSubscription"];
+        trace?: never;
+    };
+    "/runtime/events/delivery": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List event deliveries (runtime log) */
+        get: operations["listEventDeliveries"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/events/delivery/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        /** Get an event delivery */
+        get: operations["getEventDelivery"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/conversation/sessions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List conversation sessions for the authenticated user */
+        get: operations["listConversationSessions"];
+        put?: never;
+        /**
+         * Create a conversation session (no lazy creation per FR-C07)
+         * @description Body: `{ channel_name, roles_snapshot[], scope, llm_service?, user_name?, metadata? }`.
+         *
+         *     The SERVER assigns `session_key` and returns it on the response. A body
+         *     that CARRIES one is refused `400` — a client-chosen key was guessable,
+         *     squattable by another tenant user, and an existence oracle. This block
+         *     documented `session_key` as a request field, so an integrator following
+         *     it wrote a client that was 400'd on every call; the SDK did exactly that
+         *     until the two halves were reconciled.
+         *
+         *     Precondition enforced (FR-C09, operations gate relaxed by ADR-0112):
+         *     the actor must have ≥1 authorized `use` policy on some service in
+         *     `scope` — governed conversation is itself the value, so no entity/flow
+         *     operation is required. Possible 4xx codes: `INVALID_SCOPE` (400 — also
+         *     returned for any other malformed body, including one carrying
+         *     `session_key`), `SESSION_USER_MISMATCH` (403),
+         *     `SESSION_CHANNEL_MISMATCH` (403), `LLM_SERVICE_UNAUTHORIZED` (403),
+         *     `NO_AUTHORIZED_LLM_SERVICE_FOR_SCOPE` (403), `UNKNOWN_LLM_SERVICE`
+         *     (404). `SESSION_KEY_CONFLICT` (409) is retained but unreachable short of
+         *     a UUID collision, since the caller no longer chooses the key.
+         */
+        post: operations["createConversationSession"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/conversation/sessions/{session_key}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_key: string;
+            };
+            cookie?: never;
+        };
+        /** Get a conversation session with turns */
+        get: operations["getConversationSession"];
+        put?: never;
+        post?: never;
+        /** Soft-delete a conversation session (marks status='cleared') */
+        delete: operations["clearConversationSession"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/conversation/sessions/{session_key}/turns": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_key: string;
+            };
+            cookie?: never;
+        };
+        /** List turns for a session */
+        get: operations["listConversationTurns"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/conversation/sessions/{session_key}/turns/{turn_number}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_key: string;
+                turn_number: number;
+            };
+            cookie?: never;
+        };
+        /** Get a specific turn */
+        get: operations["getConversationTurn"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/conversation/sessions/{session_key}/actions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_key: string;
+            };
+            cookie?: never;
+        };
+        /** List actions triggered by a session */
+        get: operations["listConversationActions"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/conversation/sessions/{session_key}/actions/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_key: string;
+                id: string;
+            };
+            cookie?: never;
+        };
+        /** Get an action record */
+        get: operations["getConversationAction"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/entities/{entity_name}/recompute": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                entity_name: components["parameters"]["EntityNamePath"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Recompute derived fields for every record of an entity
+         * @description Rewrites the computed fields of every `runtime.records` row of the
+         *     entity. ADR-0098 D9: this operates on RUNTIME state, so it lives on the
+         *     runtime plane alongside the MCP `recompute_entity` tool, which shares its
+         *     implementation and its authority (the `entities` contract section).
+         */
+        post: operations["recomputeEntity"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/channel-bindings/{id}/verify": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Verify a channel binding
+         * @description ADR-0141 FR-031. Flips a channel binding from `unverified` to `verified` —
+         *     the elevation signal channel-binding resolution reads.
+         *
+         *     Authorized by the `verify_channel_binding` runtime SYSTEM ACTION, and by
+         *     nothing else: the caller needs no `update` grant on
+         *     `records/channel_identities`. That is the point of the operation. The
+         *     binding entity is the product's declaration, so the tenant cannot extend it
+         *     with the role-gated transition it used to supply; verification was
+         *     previously a PATCH authorized by the generic entity `update` grant — the
+         *     same grant that reaches `user_name`, the field that decides who someone is.
+         *
+         *     Only the three verification fields are written. The request body may carry
+         *     `verification_method` (a free-form string recording HOW the binding was
+         *     verified); `verification_status` and `verified_at` are set by the server.
+         */
+        post: operations["verifyChannelBinding"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/roles/assignments": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List role assignments */
+        get: operations["listRoleAssignments"];
+        put?: never;
+        /**
+         * Assign a role to a user
+         * @description ADR-0102 S4 (FR-016): owner-marked roles (the plan envelope) are
+         *     platform-managed — assigning a user to one is rejected. The assigned
+         *     user must exist as a live `users` record (DB user-existence trigger).
+         */
+        post: operations["createRoleAssignment"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/roles/assignments/{user_name}/{role_name}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                user_name: string;
+                role_name: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /**
+         * Revoke a role from a user
+         * @description ADR-0102 S4 (FR-016): revoking an owner-marked assignment would
+         *     destroy the tenant's envelope anchor — rejected.
+         */
+        delete: operations["deleteRoleAssignment"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/conversation/send": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Send a natural-language message to the cognitive agent
+         * @description Service endpoint — not CRUD-derivable. The LLM orchestrator compiles
+         *     an intent, validates it against the tenant contract, and executes it
+         *     via MCP tools.
+         *
+         *     SpecKit 010 / ADR-0087:
+         *       - Sessions are no longer lazily created — `session_key` MUST refer
+         *         to a session previously created via `POST /runtime/conversation/sessions`
+         *         (FR-C07). Unknown keys return `SESSION_NOT_FOUND` (404).
+         *       - Optional `llm_service` overrides the session's pinned service for
+         *         this turn (FR-C04). Must be authorized for the actor in the
+         *         session's scope.
+         *       - Possible error codes:
+         *           - `SESSION_NOT_FOUND` (404): unknown `session_key`.
+         *           - `LLM_SERVICE_UNAUTHORIZED` (403): actor lacks `use` on the
+         *             requested service in the session's scope.
+         *           - `INTENT_OUT_OF_SCOPE` (422): the LLM emitted an intent
+         *             outside the session's scope partition (FR-H06 backstop).
+         *           - `NO_CREDENTIAL_CONFIGURED` (412): the resolved service has
+         *             no credential configured.
+         */
+        post: operations["runtimeConversationSend"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/channels/mint": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Mint a short-TTL anonymous party token (channel-ops)
+         * @description Service endpoint (ADR-0133 §B.4 / decision 5). One of the FOUR
+         *     channel-ops routes, and the ONLY routes that accept a `channel`-class
+         *     ingress credential (`token_class='channel'`). The asymmetry is
+         *     enforced by the class-aware pipeline: a tenant token is rejected here,
+         *     and a channel credential is rejected on every other runtime route.
+         *
+         *     The channel is taken from the CREDENTIAL, never from the body — a
+         *     gateway can only ever mint into its own channel. The body is strict:
+         *     `{ party_ref }` and nothing else. Any role/privilege claim alongside
+         *     `party_ref` fails validation before the mint and returns 422
+         *     `MINT_CLAIM_REJECTED` (QI-003) — a channel names a party, it never
+         *     grants that party authority.
+         *
+         *     The response is a **bare** body (no `{success,data}` envelope); the
+         *     SDK returns it whole (codegen-unwrap: no-unwrap).
+         */
+        post: operations["runtimeChannelsMint"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/channels/directives/stream": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * SSE liveness stream of new egress directives (channel-ops)
+         * @description Service endpoint (ADR-0133 §B.4 / decision 5) — the `subscribe`
+         *     capability. Channel-ops route: `channel`-class credential only.
+         *
+         *     The stream is server-side filtered to the credential's OWN
+         *     `(tenant, channel)`: a subscriber never observes another channel's
+         *     directive metadata (QI-006). Notification transport ONLY — durability
+         *     is the outbox + sweep, so a missed frame is never a lost directive.
+         *
+         *     The wire is a `text/event-stream` carrying `channel.directive_created`
+         *     frames whose `data` is `{directive_id}` — an id, never content. The
+         *     body itself is fetched separately via
+         *     `GET /runtime/channels/directives/{id}/content` (notify-then-fetch).
+         *     A `:heartbeat` comment is emitted every 30 seconds to keep the
+         *     connection alive.
+         */
+        get: operations["runtimeChannelsSubscribe"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/channels/directives/{id}/content": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Egress directive id (ADR-0133 §B.4) */
+                id: components["parameters"]["ChannelDirectiveIdPath"];
+            };
+            cookie?: never;
+        };
+        /**
+         * Fetch (= claim) an egress directive and its content (channel-ops)
+         * @description Service endpoint (ADR-0133 §B.4 / decision 5) — the `fetch` capability.
+         *     Channel-ops route: `channel`-class credential only.
+         *
+         *     **fetch = claim**: this single call takes the delivery lease AND
+         *     returns the turn body. Notify-then-fetch forces every send through
+         *     here, which is what keeps the capability set closed at four (there is
+         *     no separate `claim` op). The lease is keyed by the credential's `jti`
+         *     (its stable lease identity) and expires after a bounded TTL, so a dead
+         *     adapter cannot strand a directive.
+         *
+         *     A directive addressed to another channel is 403 — never readable
+         *     (QI-006). The response is a **bare** body (no `{success,data}`
+         *     envelope); the SDK returns it whole (codegen-unwrap: no-unwrap).
+         */
+        get: operations["runtimeChannelsFetch"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/channels/directives/{id}/send-result": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Egress directive id (ADR-0133 §B.4) */
+                id: components["parameters"]["ChannelDirectiveIdPath"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Report (= ack) the terminal send result of a directive (channel-ops)
+         * @description Service endpoint (ADR-0133 §B.4 / decision 5) — the `report`
+         *     capability. Channel-ops route: `channel`-class credential only.
+         *
+         *     **report = ack**: the terminal transition plus the lease release.
+         *     Idempotent under redelivery — re-reporting an already-terminal
+         *     directive returns its existing status unchanged (QI-005b).
+         *
+         *     A terminal report also appends the `channel.egress` boundary row to
+         *     the `channels` hash chain (ADR-0133 §B.7 / FR-E01), metadata-only.
+         *     `provider_message_id` MUST already be hashed by the adapter
+         *     (FR-E03): an address-shaped value is refused by the audit schema
+         *     (QI-001) and the row is skipped rather than leaking an address.
+         *
+         *     A directive belonging to another channel is 403 (QI-006); a lost lease
+         *     is 409, so the adapter aborts rather than assuming success. The
+         *     response is a **bare** body (no `{success,data}` envelope); the SDK
+         *     returns it whole (codegen-unwrap: no-unwrap).
+         */
+        post: operations["runtimeChannelsReport"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/tools": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List tools available to the authenticated user
+         * @description Returns a `UserToolCatalog` filtered to the calling user's roles.
+         *     Includes entity-CRUD tools (list_*, create_*, get_*, update_*, delete_*)
+         *     and — for every (entity, field) whose contract declares a non-empty
+         *     `transitions[]` block and for which the user's roles intersect
+         *     `R(entity, field)` — the dynamic state-machine trio:
+         *       - request_{entity}_{field}_transition
+         *       - resolve_{entity}_{field}_transition_request
+         *       - list_{entity}_{field}_pending_transition_requests
+         *     Structured per-trio metadata lives in `UserToolCatalog.transitions`.
+         *     See ADR-0081.
+         */
+        get: operations["runtimeToolsList"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/authorizations/effective": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Effective authorizations of the authenticated actor (ADR-0102 §6, S3b)
+         * @description Self-scoped introspection: returns what the authorization engine
+         *     actually decides for the CALLING actor — assigned roles (+ implicit
+         *     `self`), the contract sections they can manage (`update` policies),
+         *     the runtime system actions they hold (e.g. `view_traces`,
+         *     `manage_role_assignments`), and per-entity record permissions (actions +
+         *     per-action field restrictions; `null` = all fields). Derived by the
+         *     same canonical resolvers the enforcement paths use, so the response
+         *     can never drift from enforcement. There is NO actor parameter —
+         *     identity comes exclusively from the verified token.
+         */
+        get: operations["runtimeEffectiveAuthorizations"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/mcp": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * MCP streamable-HTTP transport endpoint (stateless JSON-RPC)
+         * @description Stateless MCP "Streamable HTTP" transport. Each POST carries one MCP
+         *     JSON-RPC message; the server replies either application/json or a
+         *     text/event-stream (its choice per request). Authenticated by the same
+         *     runtime tenant JWT as the REST API (aud='runtime-api',
+         *     token_class='tenant'), bound to the {tenant}.zarel.local subdomain
+         *     (canon §10.4 / ADR-0041). Spec-1 (mcp runtime-plane exposure) replaced
+         *     the fictional GET /runtime/mcp/stream SSE path with this POST transport
+         *     served by mcp-server-http.
+         */
+        post: operations["runtimeMcp"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/tools/mcp/list": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List MCP tools accessible to the authenticated tenant
+         * @description Returns the MCP-layer `McpToolDefinition` list filtered to the tools
+         *     the user can see. Dynamic state-machine trio entries appear as
+         *     first-class peers to entity-CRUD tools (ADR-0081). Transition tools
+         *     are emitted dynamically from the contract per-(entity, field); the
+         *     legacy closed set of three generic transition tools is removed (see
+         *     CHANGELOG for the transition).
+         */
+        get: operations["runtimeToolsMcpList"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/tools/call": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Invoke a tool directly by name */
+        post: operations["runtimeToolsCall"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/health": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Liveness / readiness check */
+        get: operations["getHealth"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/metrics": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Operational metrics snapshot */
+        get: operations["getMetrics"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api-keys": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List API keys (masked metadata)
+         * @description Bounded fidelity declaration (see `createApiKey`). Returns a **bare**
+         *     array of masked key metadata — the SDK returns it whole (no-unwrap).
+         */
+        get: operations["listApiKeys"];
+        put?: never;
+        /**
+         * Create an API key
+         * @description Bounded fidelity declaration for the three `/api-keys` endpoints the SDK
+         *     already calls (ADR-0109 codegen-unwrap follow-up) — NOT the broader
+         *     ADR-0072 `/api-keys` redesign. The response is a **bare** body carrying
+         *     the one-time plaintext `key`; the SDK returns it whole (no-unwrap).
+         */
+        post: operations["createApiKey"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api-keys/{key_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                key_id: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /**
+         * Revoke an API key
+         * @description Bounded fidelity declaration (see `createApiKey`). Returns a **flat**
+         *     `{success:true}` ack (no `data`, not envelope-wrapped) — the SDK returns
+         *     it whole (no-unwrap).
+         */
+        delete: operations["deleteApiKey"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/state-machine/replay": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Replay a state-machine instance against a new configuration
+         * @description Service endpoint (spec-051 US4 — moved from the legacy
+         *     `/workflows/replay`). The handler delegates to the MCP
+         *     `replay_workflow` tool and unwraps its JSON envelope.
+         */
+        post: operations["runtimeStateMachineReplay"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/events/stream": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Server-sent events stream for real-time tenant events
+         * @description Service endpoint. Supports `Last-Event-ID` for reconnection; sends a
+         *     heartbeat comment every 30 seconds to keep the connection alive.
+         *
+         *     The wire is a `text/event-stream` of named SSE frames; each frame's
+         *     `data` is a JSON envelope `{entity, record_id, payload, timestamp}`. The
+         *     only event with a fixed payload is `conversation.turn_created`, typed by
+         *     `RuntimeSseConversationTurnCreatedData` (envelope) /
+         *     `RuntimeSseConversationTurnCreatedPayload` (payload) under `components.schemas`;
+         *     all other events carry tenant-defined payloads.
+         */
+        get: operations["streamEvents"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/traces/{trace_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                trace_id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Full chronology of one agent dispatch (Spec-020 US1)
+         * @description Returns the trace header (tenant, session, deployed spec version +
+         *     hash, actor, flow, started_at, duration, outcome) plus the ordered
+         *     `events[]` covering the eight pipeline stages: `topic_gate`,
+         *     `intent_scoring`, `envelope`, `gatekeeper`, `preconditions`,
+         *     `hitl`, `execution`, `audit`.
+         *
+         *     ADR-0127 (US4) — the `gatekeeper` and `preconditions` events are emitted
+         *     from the deterministic write floor's REAL recorded verdict (`allowed` /
+         *     `denied` / `requires_confirmation`, with the typed reason and any failed
+         *     preconditions), not inferred from the terminal outcome.
+         *
+         *     Authorization (FR-006, originator gate): a trace is visible to its
+         *     originator and to superusers; everyone else gets `404
+         *     trace_not_found` indistinguishable from a genuine miss.
+         *
+         *     Pre-feature traces (FR-007): sessions originated before spec-020
+         *     deployment have no `trace_id` and return `404
+         *     legacy_trace_not_available`. There is no retroactive backfill.
+         */
+        get: operations["getTrace"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/traces": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Paginated trace summary list (Spec-020 US1)
+         * @description Filters: `flow`, `user`, `from`, `to`, `outcome`, `limit` (default
+         *     50, max 500), `cursor`. Returns `{ traces: TraceSummary[],
+         *     next_cursor: string | null }`.
+         *
+         *     Visibility is applied where the page is CHOSEN, not after it: the
+         *     originator restriction runs in the query, before `LIMIT`, so every
+         *     row of a page is a row the caller may see and `next_cursor` — which
+         *     anchors on the last row — has nothing to disclose. (This
+         *     description previously said the cursor anchors at the last DB row
+         *     "visible or not". That was accurate about the old behaviour and
+         *     the old behaviour handed one caller another caller's `trace_id`
+         *     and `started_at` in cleartext.)
+         *
+         *     `duration_basis` says WHICH WINDOW each timing field was measured
+         *     over, because this endpoint and `GET /runtime/traces/{trace_id}`
+         *     answer different questions about the same trace:
+         *
+         *       * `anchor_evidence` (this endpoint) — the span of the trace's
+         *         anchoring evidence: its conversation turns, or for a REST-only
+         *         governed write its gatekeeper verdicts. "How long did the
+         *         caller wait." A late webhook retry cannot make a fast
+         *         conversation look slow in a page you scan for slow ones.
+         *       * `all_evidence` (the single-trace read) — the span of every
+         *         recorded event, deliveries and record writes included. "How
+         *         long until everything this request caused had settled."
+         *
+         *     A conversation answered in 6 s whose delivery settles at 40 s
+         *     reports 6 s here and 40 s there. Both are true; the field is how
+         *     you tell which you are reading.
+         */
+        get: operations["queryTraces"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/traces/{trace_id}/replay": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                trace_id: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Re-run deterministic governance stages against the proposed spec
+         * @description Body: `{ against_current_spec?: boolean }`. Returns side-by-side
+         *     comparison of original vs replayed stages with `deterministic_match`
+         *     boolean and `stages_diverged[]`. The originator gate (FR-006)
+         *     applies — replay leaks the trace's content, so the same
+         *     visibility rule that governs the trace fetch route applies here.
+         */
+        post: operations["replayTrace"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/traces/{trace_id}/bundle": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                trace_id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Download a signed evidence bundle (.tar.gz)
+         * @description Streams the bundle as `application/gzip` with attachment
+         *     `Content-Disposition`. Contents per ADR-0090: `README.md`,
+         *     `trace.json`, `trace.pdf`, `spec/{deployed_at_execution.yaml,.hash}`,
+         *     `entities_snapshot.json`, `replay_attestation.json`, `manifest.sig`
+         *     (Ed25519 over the canonical JSON of `manifest.json` per RFC 8785).
+         *
+         *     Soft cap 50 MB / hard cap 200 MB after compression. Past the hard
+         *     cap returns `error.code = bundle_too_large` (FR-035a). Originator
+         *     gate enforced same as trace fetch.
+         */
+        get: operations["getTraceBundle"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/audit/{log}/evidence": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The event log whose hash-chain to export. */
+                log: "state_machine" | "flows";
+            };
+            cookie?: never;
+        };
+        /**
+         * Download a signed audit tamper-evidence bundle (.tar.gz)
+         * @description ADR-0108. Streams a self-contained, offline-verifiable evidence bundle
+         *     for the tenant's `{log}` cryptographic hash-chain as `application/gzip`
+         *     with attachment `Content-Disposition`. Contents: `events.json` (the RAW
+         *     event content + chain columns `seq`/`prev_hash`/`event_hash`, so the
+         *     verifier recomputes the canonical bytes itself), `checkpoints.json` (the
+         *     covering Ed25519-signed checkpoints), `anchors.json` (ADR-0115: external
+         *     RFC 3161 TSA anchors over the checkpoints' Merkle roots + this tenant's
+         *     inclusion paths — present only for already-anchored windows; absent
+         *     windows verify as the un-anchored tail), `README.md`, `manifest.json` +
+         *     `manifest.sig` (Ed25519 over the canonical JSON of the manifest, which
+         *     hashes every file incl. `anchors.json`, ADR-0090). Verify offline with
+         *     `zarel verify <bundle> --keys <trust-keys.json>` (add `--tsa-roots
+         *     <pinned.pem>` to also verify external anchoring, ADR-0115).
+         *
+         *     Authorization: gated by the `view_traces` runtime-system action (an
+         *     evidence bundle exposes the full event content for the tenant, same as
+         *     the trace bundle). An unauthorized actor receives an opaque 404. Tenant
+         *     is taken from the verified JWT, never the path.
+         *
+         *     Bounded read (ADR-0108 follow-up): the optional `from`/`to` query
+         *     parameters restrict the export to an inclusive `seq` range. A request
+         *     whose selected range exceeds the per-bundle event cap is refused with
+         *     `413` — narrow it via `from`/`to`. For a partial range, only checkpoints
+         *     anchored within the slice are included so the slice verifies cleanly.
+         */
+        get: operations["getAuditEvidenceBundle"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/audit/{log}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The audit row-table to list. */
+                log: "binding_violations" | "topic_refusals";
+            };
+            cookie?: never;
+        };
+        /**
+         * Paginated, filterable listing of a privacy-preserving audit row-table (GTM M1)
+         * @description Lists rows of the tenant's `{log}` audit table — `binding_violations`
+         *     (ADR-0106 Amendment A1, blocked field-binding parameter-injection
+         *     attempts) or `topic_refusals` (ADR-0107, blocked regulatory-boundary
+         *     refusals). Each row exposes only a non-reversible SHA-256 hash + a
+         *     deterministic PII-mask of the offending value — NEVER the raw value (it
+         *     is never stored). Newest-first, cursor-paginated. Response body (inside
+         *     the success envelope): `{ items: <row>[], next_cursor: string | null }`
+         *     where `<row>` is `BindingViolationAuditRow` or `TopicRefusalAuditRow`.
+         *
+         *     Authorization: gated by the `view_traces` runtime-system action (the same
+         *     gate as `/runtime/traces` and `/runtime/audit/{log}/evidence`).
+         *     Authorization + known-log are checked BEFORE filter validation, so an
+         *     unauthorized actor OR an unknown log receives an opaque `404` — even with
+         *     a malformed filter — and cannot probe filter validity. There is no
+         *     per-row originator gate: any holder of `view_traces` sees all tenant
+         *     rows. Tenant is taken from the verified JWT, never the path. Distinct
+         *     from `/runtime/audit/{log}/evidence` (ADR-0108), whose `{log}` is the
+         *     event hash-chains `state_machine | flows`.
+         */
+        get: operations["listAuditLog"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/.well-known/zarel-trust-keys.json": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Public Ed25519 trust-keys manifest (ADR-0090)
+         * @description Public, unauthenticated endpoint listing every bundle-signing
+         *     public key (current + archived) keyed by `kid`. Standalone
+         *     verifiers (`zarel verify <bundle>`) resolve the bundle's `kid` →
+         *     public key via this file with no online runtime access.
+         *
+         *     Rotation is by append: new entry with new `kid`, previous entry's
+         *     `valid_until` set to rotation timestamp. Archived entries are
+         *     never deleted so older bundles continue to verify.
+         */
+        get: operations["getTrustKeysManifest"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/imports/snapshot": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Bulk-import tenant data from a structured payload */
+        post: operations["runtimeImportsSnapshot"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/records/{entity_name}/bulk": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                entity_name: components["parameters"]["EntityNamePath"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Bulk-create records for an entity */
+        post: operations["bulkImportRuntimeRecords"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/receipts": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List the authenticated end-user's own governance receipts (Desk Spec 3)
+         * @description Lists the CALLER'S OWN governance receipts — normalized over the three
+         *     audit signals: topic refusals (ADR-0107), binding violations (ADR-0106
+         *     A1), and validation violations (ADR-0111). Each receipt is a discriminated
+         *     union by `signal` carrying a composite id (`<signal>:<uuid>`), the request
+         *     correlation `trace_id`, a non-reversible `proof` (hash + masked value +
+         *     contract version, per signal), and a per-signal `detail`. NEVER the raw
+         *     value (it is never stored) and NEVER `tenant_name`.
+         *
+         *     ALWAYS scoped server-side to `created_by = the token actor` — never a
+         *     client parameter. Unlike the operator `/runtime/audit/{log}` (tenant-wide,
+         *     `view_traces`-gated), this surface is the caller's own data and requires
+         *     NO `view_traces`: any authenticated tenant end-user may read their own
+         *     receipts. Newest-first across all signals, keyset cursor-paginated.
+         */
+        get: operations["listReceipts"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        /**
+         * @description One blocked field-binding parameter-injection attempt (ADR-0106 A1).
+         *     Privacy-preserving: only the SHA-256 hash + PII-mask of the offending
+         *     value are present — never the raw value.
+         */
+        BindingViolationAuditRow: {
+            /** Format: uuid */
+            id: string;
+            entity: string;
+            field: string;
+            /** @enum {string} */
+            binding_mode: "bind" | "assert" | "immutable";
+            reason: string;
+            input_sha256: string;
+            input_masked: string;
+            path_context: string | null;
+            trace_id: string;
+            created_by: string;
+            /** Format: date-time */
+            created_at: string;
+        };
+        /**
+         * @description One blocked regulatory-boundary hard refusal (ADR-0107).
+         *     Privacy-preserving: only the SHA-256 hash + PII-mask of the input are
+         *     present — never the raw input.
+         */
+        TopicRefusalAuditRow: {
+            /** Format: uuid */
+            id: string;
+            channel_name: string | null;
+            verdict: string;
+            category: string;
+            /** @enum {string} */
+            reason: "matched" | "no_verdict" | "unscored";
+            confidence: number | null;
+            strategy: string | null;
+            fallback_used: boolean;
+            contract_version: number;
+            input_sha256: string;
+            input_masked: string;
+            latency_ms: number | null;
+            trace_id: string;
+            created_by: string;
+            /** Format: date-time */
+            created_at: string;
+        };
+        /**
+         * @description The canonical response envelope. `data` holds the payload (shape
+         *     depends on the operation — consult the DDL + `schema.json` for the
+         *     exact per-resource shape) and `message` is an optional human
+         *     summary.
+         */
+        SuccessEnvelope: {
+            success: boolean;
+            data?: unknown;
+            message?: string;
+        };
+        ErrorResponse: {
+            error: {
+                /** @enum {string} */
+                type: "invalid_request" | "authentication_error" | "authorization_error" | "not_found" | "conflict" | "rate_limit_exceeded" | "internal_error" | "precondition_failed" | "not_implemented" | "payload_too_large";
+                code: string;
+                message: string;
+                request_id?: string;
+            };
+        };
+        /**
+         * @description Tenant-class JWT payload. Spec-019 FR-A06 removed the `roles` claim;
+         *     authorization is DB-resolved fresh per request via
+         *     `permissionService.getUserRoles`, never derived from JWT claims.
+         *     See `runtime/packages/runtime-api/src/domain/auth/credential-claims.ts`
+         *     for the canonical schema.
+         */
+        JwtPayload: {
+            sub: string;
+            tenant_name: string;
+            user_name: string;
+            iat: number;
+            exp: number;
+            jti: string;
+            /** @enum {string} */
+            token_class?: "tenant";
+            /** @enum {string} */
+            iss?: "platform-api";
+            /** @enum {string} */
+            aud?: "runtime-api";
+        };
+        LlmCredentialMetadata: {
+            /** @description LLM service name (FK into `llm.services[]`). */
+            service_name: string;
+            /**
+             * @description "••••" + last 4 chars of the fingerprint. The plaintext key is NEVER returned (FR-I04).
+             * @example ••••WXYZ
+             */
+            api_key_masked: string;
+            /** @description Whether a base_url override is configured for this credential. */
+            has_base_url: boolean;
+            created_by: string;
+            updated_by: string;
+            /** Format: date-time */
+            created_at: string;
+            /** Format: date-time */
+            updated_at: string;
+        };
+        EmbeddingCredentialMetadata: {
+            tenant_name: string;
+            /**
+             * @description The declared `embeddings.services[].name` this credential keys to
+             *     (FR-023). Deliberately NOT a provider enum: the credential keys to a
+             *     declaration, and reporting the provider here was the response half of
+             *     the conflation that made the write unstorable. The provider is a
+             *     property of the declaration, readable from the embeddings catalog.
+             */
+            service_name: string;
+            /**
+             * @description "••••" + the credential fingerprint. The secret is NEVER returned.
+             * @example ••••WXYZ
+             */
+            credential_masked: string;
+            created_by: string;
+            updated_by: string;
+            /** Format: date-time */
+            created_at: string;
+            /** Format: date-time */
+            updated_at: string;
+        };
+        LlmService: {
+            /** @description Stable id (slug). Unique per tenant. */
+            name: string;
+            /** @enum {string} */
+            provider: "anthropic" | "bedrock" | "gemini" | "openai";
+            /** @description Provider-specific model id (e.g., `gemini-2.0-flash`). */
+            model: string;
+            /** @description Lower wins. Tie-breaker is YAML declaration order (`position` ASC). */
+            priority: number;
+            /** @description YAML declaration index. Used as priority tie-breaker. */
+            position: number;
+            /** @description Per-service override; absent when null (FR-A06). */
+            temperature?: number;
+            /** @description Per-service override; absent when null (FR-A06). */
+            max_tokens?: number;
+            /** @description Per-service override of the intent-confidence floor; absent when null (FR-A06). Resolution order is flow → this → the tenant's `llm.confidence_threshold` → the single named code default. */
+            confidence_threshold?: number;
+        };
+        UserVisibleAction: {
+            /** @enum {string} */
+            action: "create" | "read" | "update" | "delete" | "list" | "import" | "export";
+            owned_only: boolean;
+        };
+        UserVisibleEntityTool: {
+            entity_name: string;
+            entity_label: string;
+            description?: string;
+            actions: components["schemas"]["UserVisibleAction"][];
+            /** @description FieldToolDefinition shape; see contract tool-catalog types. */
+            fields: Record<string, never>[];
+            /**
+             * @description MCP tool names exposed to this user for this entity. Includes
+             *     entity-CRUD tools (list_*, create_*, get_*, update_*, delete_*)
+             *     and, for every field of the entity whose contract declares a
+             *     non-empty transitions[] block and for which the user's roles
+             *     intersect R(entity, field), the dynamic state-machine trio:
+             *       - request_{entity}_{field}_transition
+             *       - resolve_{entity}_{field}_transition_request
+             *       - list_{entity}_{field}_pending_transition_requests
+             *     See ADR-0081 for the generation rules; structured per-trio
+             *     metadata lives in UserToolCatalog.transitions.
+             */
+            tool_names: string[];
+        };
+        TransitionEdge: {
+            from: string;
+            to: string;
+            /**
+             * @description Spec 015 / M4. When true, the trigger UI MUST require a reason
+             *     textarea before dispatch. Omitted when false/absent in YAML.
+             */
+            requires_reason?: boolean;
+        };
+        UserVisibleTransitionTool: {
+            /** @description Entity whose field carries the state machine. */
+            entity_name: string;
+            /** @description Field declaring the transitions[] block. */
+            field_name: string;
+            /** @example request_limit_requests_status_transition */
+            request_tool_name: string;
+            /** @example resolve_limit_requests_status_transition_request */
+            resolve_tool_name: string;
+            /** @example list_limit_requests_status_pending_transition_requests */
+            list_pending_tool_name: string;
+            /**
+             * @description Distinct `to` states declared reachable across all transitions of
+             *     the field, in declaration order. The LLM sees this set at schema
+             *     time; the dispatch service enforces the (from, to) legality per
+             *     record.
+             */
+            target_states: string[];
+            /**
+             * @description Per-edge projection (spec 015 / M4). Parallel to `target_states`
+             *     and carries `requires_reason` so trigger UIs can mark the reason
+             *     textarea required for the matching (from, to) edge. Order mirrors
+             *     YAML declaration; not deduplicated.
+             */
+            transitions: components["schemas"]["TransitionEdge"][];
+            /** @description Optional display label for the field; used by the prompt builder. */
+            field_label?: string;
+            /** @description Optional description of the field; used by the prompt builder. */
+            field_description?: string;
+            /**
+             * @description Forward-compatibility hook for a future introspect capability. V1
+             *     always emits `false`. No enforcement is attached to this field in
+             *     V1.
+             */
+            inspect: boolean;
+        };
+        /**
+         * @description Spec 016 / M5 / ADR-0085 amendment. Per-user projection of a single
+         *     YAML-declared `action` the caller is authorized to dispatch.
+         */
+        UserVisibleActionTool: {
+            /** @description Action name from YAML; unique within tenant. */
+            name: string;
+            entity: string;
+            /** @enum {string} */
+            verb: "create" | "read" | "update" | "delete" | "list";
+            /** @description From YAML `action.description`. Optional. */
+            description?: string;
+            /** @description Dispatcher-recognised intent string — `action.<name>` for native, `external.<ns>.<tool>` for external (ADR-0076). */
+            intent_type: string;
+            /** @enum {string} */
+            provenance: "native" | "external";
+        };
+        /**
+         * @description Spec-042 — per-tenant role declaration. Read-only metadata always
+         *     projected for every caller; editing is gated separately by the
+         *     `roles` contract-section policy (W3: surfaced via `admin_sections`).
+         */
+        UserVisibleRole: {
+            name: string;
+            label?: string;
+            description?: string;
+        };
+        /**
+         * @description Spec-042 — per-tenant flow declaration projected for users with
+         *     `inspect` policy on the flow (open-by-default per ADR-0065).
+         */
+        UserVisibleFlow: {
+            name: string;
+            description?: string;
+        };
+        /**
+         * @description Spec-042 — per-tenant skill declaration projected for users whose
+         *     role set satisfies the skill's YAML `constraints[]`.
+         */
+        UserVisibleSkill: {
+            name: string;
+            label?: string;
+            description?: string;
+        };
+        /**
+         * @description W3 — a contract section name. `UserToolCatalog.admin_sections` is the
+         *     subset the caller's roles can `update` (drives admin mutation pages).
+         * @enum {string}
+         */
+        ContractSectionName: "metadata" | "entities" | "roles" | "skills" | "actions" | "schemas" | "capabilities" | "flows" | "constraints" | "events" | "llm" | "embeddings" | "treatment" | "channels" | "channels/credentials" | "mcp_servers" | "quotas" | "timezone" | "process_model" | "authorization";
+        UserToolCatalog: {
+            tenant_name: string;
+            user_name: string;
+            user_roles: string[];
+            entities: components["schemas"]["UserVisibleEntityTool"][];
+            /**
+             * @description Structured metadata for every state-machine transition trio
+             *     visible to this user. One entry per (entity, field) with
+             *     non-empty transitions[] for which user_roles ∩ R(entity, field)
+             *     ≠ ∅. See ADR-0081.
+             */
+            transitions: components["schemas"]["UserVisibleTransitionTool"][];
+            /**
+             * @description Spec 016 / M5 / ADR-0085 amendment. Per-user projection of
+             *     YAML-declared `actions[]` the caller is authorized to dispatch.
+             *     One entry per action whose `(entity, verb)` resolves to
+             *     `kind: 'action'` under the action-surface-resolver decision
+             *     logic for the caller's capabilities. Hidden/entity-fallback
+             *     decisions are NOT projected. Optional — omitted entirely when
+             *     zero entries.
+             */
+            actions?: components["schemas"]["UserVisibleActionTool"][];
+            /**
+             * @description Spec-042 — declared roles in the tenant contract (read-only
+             *     metadata always emitted, even when empty).
+             */
+            roles: components["schemas"]["UserVisibleRole"][];
+            /**
+             * @description Spec-042 — flows the user can `inspect` (ADR-0065
+             *     open-by-default).
+             */
+            flows: components["schemas"]["UserVisibleFlow"][];
+            /**
+             * @description Spec-042 — skills whose YAML `constraints[]` evaluate true for
+             *     the user.
+             */
+            skills: components["schemas"]["UserVisibleSkill"][];
+            /**
+             * @description W3 (ADR-0102 §3 closure) — contract sections the user can `update`,
+             *     derived from `authorization.spec.{section}` policies. The dashboard
+             *     derives admin mutation pages (roles/skills/flows/authorization+
+             *     policies/state-machines/settings) and the admin-tier pages
+             *     (imports, api-keys) from this. Sorted; may be empty.
+             */
+            admin_sections: components["schemas"]["ContractSectionName"][];
+        };
+        RoleAssignment: {
+            user_name: string;
+            role_name: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * @description Opaque 64-hex digest of a party's address within its channel's address
+         *     namespace (QI-001). NOT an address — the runtime never names a phone
+         *     number, an email or a handle.
+         */
+        ChannelPartyRef: string;
+        /** @description Content digest — metadata-only handle, never the body (R12). */
+        ChannelContentRef: string;
+        /** @description Tenant-declared channel name (the `channels:` contract section). */
+        ChannelName: string;
+        /** @enum {string} */
+        ChannelDeliveryMode: "freeform" | "template" | "deferred";
+        /**
+         * @description Who attests the send outcome — the runtime itself, or the channel
+         *     provider (the transport descriptor declares which is admissible).
+         * @enum {string}
+         */
+        ChannelAttestedBy: "runtime" | "channel_provider";
+        /**
+         * @description Strict by construction: `party_ref` is the ONLY accepted key. The
+         *     strictness IS the QI-003 claim rejection — any role/privilege key
+         *     alongside it fails validation (422 `MINT_CLAIM_REJECTED`) before the
+         *     mint. The channel comes from the credential, never from here.
+         */
+        ChannelMintRequest: {
+            party_ref: components["schemas"]["ChannelPartyRef"];
+        };
+        ChannelPartyToken: {
+            /**
+             * @description Short-TTL anonymous party token (`token_class: party`) bound to
+             *     `(channel, party_ref)`. Carries no role and grants no authority.
+             */
+            token: string;
+            /** Format: date-time */
+            expires_at: string;
+        };
+        ChannelDirectiveTemplateRef: {
+            id: string;
+            version: number;
+        };
+        ChannelDirectiveCorrelation: {
+            session_key: string;
+            turn_seq: number;
+        };
+        /**
+         * @description The claimed directive plus its resolved content. `fetch = claim`, so
+         *     receiving this body means the lease is now held by the caller's `jti`.
+         */
+        ChannelDirectiveContent: {
+            /** Format: uuid */
+            id: string;
+            channel_name: components["schemas"]["ChannelName"];
+            recipient_ref: components["schemas"]["ChannelPartyRef"];
+            content_ref: components["schemas"]["ChannelContentRef"];
+            delivery_mode: components["schemas"]["ChannelDeliveryMode"];
+            template?: components["schemas"]["ChannelDirectiveTemplateRef"];
+            correlation: components["schemas"]["ChannelDirectiveCorrelation"];
+            /** Format: date-time */
+            deadline_at?: string;
+            /**
+             * @description The resolved turn body, returned ONLY here — the directive itself
+             *     (and every audit row) carries `content_ref` and never the content
+             *     (R12 / QI-004). Resolved by the directive's turn correlation as an
+             *     authorized, audited read.
+             */
+            content: unknown;
+        };
+        ChannelSendResult: {
+            /** @enum {string} */
+            status: "accepted" | "failed" | "deferred";
+            /**
+             * @description Provider-supplied opaque id. MUST already be hashed by the adapter
+             *     (FR-E03) — an E.164- or email-shaped value is refused (QI-001).
+             */
+            provider_message_id?: string;
+            attested_by: components["schemas"]["ChannelAttestedBy"];
+        };
+        ChannelSendResultAck: {
+            /**
+             * @description The directive's resulting lifecycle status.
+             * @enum {string}
+             */
+            status: "pending" | "claimed" | "deferred" | "sent" | "failed" | "dead" | "expired";
+            /**
+             * @description The reported send outcome; `null` until a terminal report.
+             * @enum {string|null}
+             */
+            send_status: "accepted" | "failed" | "deferred" | null;
+        };
+        RuntimeSseConversationTurnCreatedPayload: {
+            session_key: string;
+            turn_number: number;
+            role: string;
+            intent_type?: string;
+            flow?: {
+                [key: string]: unknown;
+            };
+        };
+        RuntimeSseConversationTurnCreatedData: {
+            entity: string;
+            record_id: string;
+            timestamp: string;
+            payload: components["schemas"]["RuntimeSseConversationTurnCreatedPayload"];
+        };
+    };
+    responses: {
+        /** @description Standard success envelope */
+        OkEnvelope: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["SuccessEnvelope"];
+            };
+        };
+        /** @description Invalid request */
+        BadRequest: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description Missing or invalid authentication token */
+        Unauthorized: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description Insufficient permissions */
+        Forbidden: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description Resource not found */
+        NotFound: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description Resource state conflict */
+        Conflict: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+        /**
+         * @description ADR-0127 US2 — the verb is governed by ≥1 named action and must be
+         *     dispatched via `POST /runtime/actions/{name}`; the bare records surface
+         *     rejects it. `error.code='action_required'`; `error.candidate_actions[]`
+         *     lists the eligible action names.
+         */
+        ActionRequired: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"] & {
+                    error?: {
+                        candidate_actions?: string[];
+                    };
+                };
+            };
+        };
+        /**
+         * @description ADR-0127 — the write floor blocked the mutation: `error.code` is
+         *     `phase_not_allowed` (action not allowed in the record's current process
+         *     phase) or `precondition_failed` (a declared precondition evaluated false
+         *     against the real record set).
+         */
+        GovernanceUnprocessable: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+        /**
+         * @description ADR-0127 US3 — a `confirm` guard (an entity check or a transition edge)
+         *     paused this write pending human consent; the write is not performed.
+         *     Re-submit the IDENTICAL write with the returned token in the
+         *     `X-Zarel-Confirmation-Token` header before `expires_at`.
+         */
+        ConfirmationRequired: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"] & {
+                    error?: {
+                        confirmation?: {
+                            /**
+                             * @description Every `confirm` guard that fired on this write. One
+                             *     write can fire several at once, and the token below
+                             *     is bound to the WHOLE set — so a client must render
+                             *     every prompt before retrying. Showing one of them
+                             *     would collect consent for conditions the operator
+                             *     never saw.
+                             */
+                            guards: {
+                                /**
+                                 * @description The guard's own name — an entity check's `name`,
+                                 *     or `<field>__<from>__<to>` for a state-machine
+                                 *     edge. Never a governed action name.
+                                 */
+                                name: string;
+                                prompt: string;
+                            }[];
+                            /** @description The `zct1.…` confirmation token to echo in the retry header. */
+                            token?: string;
+                            /** Format: date-time */
+                            expires_at: string;
+                        };
+                    };
+                };
+            };
+        };
+        /** @description Unexpected server error */
+        InternalError: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+        /**
+         * @description The `?locale=` query parameter was supplied with a value not in
+         *     the supported set. The body is the standard `ErrorResponse` envelope,
+         *     extended with the supported set so clients can pick a valid one.
+         */
+        UnsupportedLocaleError: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"] & {
+                    error: {
+                        /**
+                         * @example [
+                         *       "en",
+                         *       "es"
+                         *     ]
+                         */
+                        supported: string[];
+                    };
+                };
+            };
+        };
+    };
+    parameters: {
+        /** @description Canonical natural-key identifier (ADR-0077 P4) */
+        NamePath: string;
+        EntityNamePath: string;
+        /** @description Egress directive id (ADR-0133 §B.4) */
+        ChannelDirectiveIdPath: string;
+        RequestId: string;
+        /**
+         * @description ADR-0127 US3 — the self-confirmation retry token from a prior `409
+         *     confirmation_required` response. Re-submit the IDENTICAL write carrying
+         *     this header to proceed. The token is bound to the exact write
+         *     (tenant/actor/contract-version/action/entity/verb/record/params) and
+         *     expires; it is read only from this header, never the body.
+         */
+        ConfirmationToken: string;
+        /**
+         * @description Locale for semantic content (labels, descriptions) in the response.
+         *
+         *     Resolution order:
+         *       1. This query parameter (if present and supported).
+         *       2. The actor's session-stored preference (JWT claim `preferences.language`).
+         *       3. The canonical locale (`en`).
+         *
+         *     Unsupported values produce a 400 response.
+         */
+        Locale: "en" | "es";
+    };
+    requestBodies: {
+        JsonObject: {
+            content: {
+                "application/json": Record<string, never>;
+            };
+        };
+    };
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    listLlmServices: {
+        parameters: {
+            query: {
+                scope: "runtime" | "contract";
+                /**
+                 * @description Locale for semantic content (labels, descriptions) in the response.
+                 *
+                 *     Resolution order:
+                 *       1. This query parameter (if present and supported).
+                 *       2. The actor's session-stored preference (JWT claim `preferences.language`).
+                 *       3. The canonical locale (`en`).
+                 *
+                 *     Unsupported values produce a 400 response.
+                 */
+                locale?: components["parameters"]["Locale"];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            400: components["responses"]["UnsupportedLocaleError"];
+        };
+    };
+    getLlmService: {
+        parameters: {
+            query: {
+                scope: "runtime" | "contract";
+                /**
+                 * @description Locale for semantic content (labels, descriptions) in the response.
+                 *
+                 *     Resolution order:
+                 *       1. This query parameter (if present and supported).
+                 *       2. The actor's session-stored preference (JWT claim `preferences.language`).
+                 *       3. The canonical locale (`en`).
+                 *
+                 *     Unsupported values produce a 400 response.
+                 */
+                locale?: components["parameters"]["Locale"];
+            };
+            header?: never;
+            path: {
+                name: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            400: components["responses"]["UnsupportedLocaleError"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    listLlmCredentials: {
+        parameters: {
+            query?: {
+                /**
+                 * @description Locale for semantic content (labels, descriptions) in the response.
+                 *
+                 *     Resolution order:
+                 *       1. This query parameter (if present and supported).
+                 *       2. The actor's session-stored preference (JWT claim `preferences.language`).
+                 *       3. The canonical locale (`en`).
+                 *
+                 *     Unsupported values produce a 400 response.
+                 */
+                locale?: components["parameters"]["Locale"];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            400: components["responses"]["UnsupportedLocaleError"];
+        };
+    };
+    getLlmCredential: {
+        parameters: {
+            query?: {
+                /**
+                 * @description Locale for semantic content (labels, descriptions) in the response.
+                 *
+                 *     Resolution order:
+                 *       1. This query parameter (if present and supported).
+                 *       2. The actor's session-stored preference (JWT claim `preferences.language`).
+                 *       3. The canonical locale (`en`).
+                 *
+                 *     Unsupported values produce a 400 response.
+                 */
+                locale?: components["parameters"]["Locale"];
+            };
+            header?: never;
+            path: {
+                service_name: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            400: components["responses"]["UnsupportedLocaleError"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    setLlmCredential: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                service_name: string;
+            };
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["JsonObject"];
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    deleteLlmCredential: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                service_name: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description No Content */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    };
+    listEmbeddingCredentials: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    getEmbeddingCredential: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The DECLARED embedding-service name from `embeddings.services[]`
+                 *     (FR-023) — not the provider. A provider is not an identity: two
+                 *     services may share one, and the credential keys to a declaration that
+                 *     exists. The provider is resolved from that declaration server-side.
+                 */
+                service_name: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    setEmbeddingCredential: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The DECLARED embedding-service name from `embeddings.services[]`
+                 *     (FR-023) — not the provider. A provider is not an identity: two
+                 *     services may share one, and the credential keys to a declaration that
+                 *     exists. The provider is resolved from that declaration server-side.
+                 */
+                service_name: string;
+            };
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["JsonObject"];
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    deleteEmbeddingCredential: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The DECLARED embedding-service name from `embeddings.services[]`
+                 *     (FR-023) — not the provider. A provider is not an identity: two
+                 *     services may share one, and the credential keys to a declaration that
+                 *     exists. The provider is resolved from that declaration server-side.
+                 */
+                service_name: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description No Content */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            404: components["responses"]["NotFound"];
+        };
+    };
+    listRuntimeRecords: {
+        parameters: {
+            query?: {
+                limit?: number;
+                offset?: number;
+                sort_by?: string;
+                sort_dir?: "asc" | "desc";
+            };
+            header?: never;
+            path: {
+                entity_name: components["parameters"]["EntityNamePath"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    createRuntimeRecord: {
+        parameters: {
+            query?: never;
+            header?: {
+                /**
+                 * @description ADR-0127 US3 — the self-confirmation retry token from a prior `409
+                 *     confirmation_required` response. Re-submit the IDENTICAL write carrying
+                 *     this header to proceed. The token is bound to the exact write
+                 *     (tenant/actor/contract-version/action/entity/verb/record/params) and
+                 *     expires; it is read only from this header, never the body.
+                 */
+                "X-Zarel-Confirmation-Token"?: components["parameters"]["ConfirmationToken"];
+            };
+            path: {
+                entity_name: components["parameters"]["EntityNamePath"];
+            };
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["JsonObject"];
+        responses: {
+            201: components["responses"]["OkEnvelope"];
+            400: components["responses"]["ActionRequired"];
+            409: components["responses"]["ConfirmationRequired"];
+            422: components["responses"]["GovernanceUnprocessable"];
+        };
+    };
+    getRuntimeRecord: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                entity_name: components["parameters"]["EntityNamePath"];
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    deleteRuntimeRecord: {
+        parameters: {
+            query?: never;
+            header?: {
+                /**
+                 * @description ADR-0127 US3 — the self-confirmation retry token from a prior `409
+                 *     confirmation_required` response. Re-submit the IDENTICAL write carrying
+                 *     this header to proceed. The token is bound to the exact write
+                 *     (tenant/actor/contract-version/action/entity/verb/record/params) and
+                 *     expires; it is read only from this header, never the body.
+                 */
+                "X-Zarel-Confirmation-Token"?: components["parameters"]["ConfirmationToken"];
+            };
+            path: {
+                entity_name: components["parameters"]["EntityNamePath"];
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            400: components["responses"]["ActionRequired"];
+            409: components["responses"]["ConfirmationRequired"];
+            422: components["responses"]["GovernanceUnprocessable"];
+        };
+    };
+    patchRuntimeRecord: {
+        parameters: {
+            query?: never;
+            header?: {
+                /**
+                 * @description ADR-0127 US3 — the self-confirmation retry token from a prior `409
+                 *     confirmation_required` response. Re-submit the IDENTICAL write carrying
+                 *     this header to proceed. The token is bound to the exact write
+                 *     (tenant/actor/contract-version/action/entity/verb/record/params) and
+                 *     expires; it is read only from this header, never the body.
+                 */
+                "X-Zarel-Confirmation-Token"?: components["parameters"]["ConfirmationToken"];
+            };
+            path: {
+                entity_name: components["parameters"]["EntityNamePath"];
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["JsonObject"];
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            400: components["responses"]["ActionRequired"];
+            409: components["responses"]["ConfirmationRequired"];
+            422: components["responses"]["GovernanceUnprocessable"];
+        };
+    };
+    getRuntimeRecordsCounter: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                entity_name: components["parameters"]["EntityNamePath"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    listStateMachineInstances: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    getStateMachineInstance: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    listStateMachineEvents: {
+        parameters: {
+            query?: {
+                entity_name?: string;
+                instance_id?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    getStateMachineEvent: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    listTransitionRequests: {
+        parameters: {
+            query?: {
+                status?: "pending" | "approved" | "rejected";
+                role?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    createTransitionRequest: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["JsonObject"];
+        responses: {
+            201: components["responses"]["OkEnvelope"];
+        };
+    };
+    getTransitionRequest: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    resolveTransitionRequest: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["JsonObject"];
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    dispatchAction: {
+        parameters: {
+            query?: never;
+            header?: {
+                /**
+                 * @description ADR-0127 US3 — the self-confirmation retry token from a prior `409
+                 *     confirmation_required` response. Re-submit the IDENTICAL write carrying
+                 *     this header to proceed. The token is bound to the exact write
+                 *     (tenant/actor/contract-version/action/entity/verb/record/params) and
+                 *     expires; it is read only from this header, never the body.
+                 */
+                "X-Zarel-Confirmation-Token"?: components["parameters"]["ConfirmationToken"];
+            };
+            path: {
+                /** @description Action name from the tenant contract `actions[]` block. */
+                name: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    /** @description Required for read/update/delete verbs; null/omitted for create/list (entity-level). */
+                    record_id?: number | string | null;
+                    /** @description Forwarded to the underlying entity intent. */
+                    payload?: {
+                        [key: string]: unknown;
+                    };
+                    /** @description V1 wire-format pass-through; server-side dedup deferred. */
+                    idempotency_key?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Dispatch succeeded */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @enum {boolean} */
+                        success: true;
+                        data: {
+                            [key: string]: unknown;
+                        } | null;
+                        /** @description ADR-0085 telemetry tag — action name as resolved. */
+                        resolved_via_action: string;
+                    };
+                };
+            };
+            /** @description Bad request (validation_error / record_id_required / invalid_action_type / action_required / reason_required) */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Caller lacks the underlying (entity, verb) capability — `error.code='action_unauthorized'` */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Action name not found in tenant contract — `error.code='unknown_action'` */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            409: components["responses"]["ConfirmationRequired"];
+            422: components["responses"]["GovernanceUnprocessable"];
+        };
+    };
+    listFlowInstances: {
+        parameters: {
+            query?: {
+                /** @description Only runs of this flow definition. */
+                flow?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    getFlowInstance: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    listFlowEvents: {
+        parameters: {
+            query?: {
+                /** @description Only events belonging to this flow instance. */
+                instance_id?: string;
+                /** @description Only events of this kind. An unrecognised kind is refused `400` rather than silently matching nothing. */
+                event_type?: "FlowStarted" | "FlowStepCompleted" | "FlowStepFailed" | "FlowStepSkipped" | "FlowStepAlreadyCompleted" | "FlowPaused" | "FlowResumed" | "FlowCompleted" | "FlowFailed" | "FlowConstraintViolated" | "FlowConstraintUnverifiable";
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            400: components["responses"]["BadRequest"];
+        };
+    };
+    getFlowEvent: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    listFlowCallbacks: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    getFlowCallback: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    resolveFlowCallback: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["JsonObject"];
+        responses: {
+            /** @description Flat callback-resolution ack (success + optional message). */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        success: boolean;
+                        message?: string;
+                    };
+                };
+            };
+        };
+    };
+    listEventSubscriptions: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    createEventSubscription: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["JsonObject"];
+        responses: {
+            201: components["responses"]["OkEnvelope"];
+        };
+    };
+    getEventSubscription: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                subscription_id: number;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    deactivateEventSubscription: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                subscription_id: number;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    patchEventSubscription: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                subscription_id: number;
+            };
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["JsonObject"];
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    listEventDeliveries: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    getEventDelivery: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    listConversationSessions: {
+        parameters: {
+            query?: {
+                /** @description Declared channel name (tenant `channels:` section, ADR-0133) */
+                channel_name?: string;
+                status?: "active" | "expired" | "cleared";
+                from?: string;
+                to?: string;
+                limit?: number;
+                offset?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    createConversationSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["JsonObject"];
+        responses: {
+            201: components["responses"]["OkEnvelope"];
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    };
+    getConversationSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_key: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    clearConversationSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_key: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    listConversationTurns: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_key: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    getConversationTurn: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_key: string;
+                turn_number: number;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    listConversationActions: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_key: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    getConversationAction: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_key: string;
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    recomputeEntity: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                entity_name: components["parameters"]["EntityNamePath"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    verifyChannelBinding: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: number;
+            };
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["JsonObject"];
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            /** @description Missing the system action — `error.code='verify_channel_binding_required'` */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    listRoleAssignments: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    createRoleAssignment: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["JsonObject"];
+        responses: {
+            201: components["responses"]["OkEnvelope"];
+            /** @description Owner-marked role — `error.code='owner_role_protected'` (ADR-0102 S4) */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Assigned user has no live `users` record — `error.code='assignment_user_not_found'` */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    deleteRoleAssignment: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                user_name: string;
+                role_name: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            /** @description Owner-marked role — `error.code='owner_role_protected'` (ADR-0102 S4) */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    runtimeConversationSend: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["JsonObject"];
+        responses: {
+            /**
+             * @description Cognitive-agent reply — a **flat** body (`success` + `message` +
+             *     optional intent/clarification fields), NOT envelope-wrapped. The SDK
+             *     returns it whole (codegen-unwrap: no-unwrap).
+             */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        success: boolean;
+                        message: string;
+                        intent_type?: string;
+                        intent_id?: string;
+                        data?: unknown;
+                        clarification_needed?: boolean;
+                        options?: string[];
+                        suggestions?: string[];
+                        error?: string;
+                    };
+                };
+            };
+            404: components["responses"]["NotFound"];
+        };
+    };
+    runtimeChannelsMint: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ChannelMintRequest"];
+            };
+        };
+        responses: {
+            /** @description The minted party token — a bare body, NOT envelope-wrapped. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ChannelPartyToken"];
+                };
+            };
+            /**
+             * @description `MINT_CLAIM_REJECTED` — the body carried a role/privilege claim, or
+             *     any key other than `party_ref`. Refused before the mint (QI-003).
+             */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    runtimeChannelsSubscribe: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description text/event-stream */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/event-stream": string;
+                };
+            };
+            /**
+             * @description `STREAM_UNAVAILABLE` — the directive stream is not configured on
+             *     this instance.
+             */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    runtimeChannelsFetch: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Egress directive id (ADR-0133 §B.4) */
+                id: components["parameters"]["ChannelDirectiveIdPath"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /**
+             * @description The claimed directive plus its resolved content — a bare body, NOT
+             *     envelope-wrapped.
+             */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ChannelDirectiveContent"];
+                };
+            };
+            /**
+             * @description The directive belongs to another channel — refused, never readable
+             *     (QI-006).
+             */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            404: components["responses"]["NotFound"];
+            /**
+             * @description A live FOREIGN lease — another holder is mid-delivery. The caller
+             *     must not deliver.
+             */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    runtimeChannelsReport: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Egress directive id (ADR-0133 §B.4) */
+                id: components["parameters"]["ChannelDirectiveIdPath"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ChannelSendResult"];
+            };
+        };
+        responses: {
+            /**
+             * @description The directive's resulting terminal status — a bare body, NOT
+             *     envelope-wrapped.
+             */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ChannelSendResultAck"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            /** @description The directive belongs to another channel — refused (QI-006). */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            404: components["responses"]["NotFound"];
+            /**
+             * @description The lease was lost (claimed by another holder) — the adapter must
+             *     abort rather than assume the send succeeded.
+             */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    runtimeToolsList: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description User-filtered tool catalog */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        success: boolean;
+                        catalog: components["schemas"]["UserToolCatalog"];
+                    };
+                };
+            };
+        };
+    };
+    runtimeEffectiveAuthorizations: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Effective authorizations of the calling actor */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        tenant_name: string;
+                        user_name: string;
+                        user_roles: string[];
+                        admin_sections: string[];
+                        system_actions: string[];
+                        /**
+                         * @description ADR-0102 S5b-a (FR-012): bounds carried by the actor's
+                         *     matched CONDITIONED system grants (e.g. the Cat-2
+                         *     provider allow-lists on `manage_credentials`). Present
+                         *     only when at least one matched grant is bounded.
+                         */
+                        system_action_bounds?: {
+                            [key: string]: Record<string, never>;
+                        };
+                        entity_permissions: {
+                            entity: string;
+                            actions: string[];
+                            /**
+                             * @description The scope the write floor will enforce for each reported action.
+                             *     `full` reaches every row; `owner` reaches only rows the caller
+                             *     owns, so an affordance rendered from an `owner` action must be
+                             *     gated on the row's owner or it will meet a 403.
+                             */
+                            scope_by_action: {
+                                [key: string]: "full" | "owner";
+                            };
+                            /**
+                             * @description The fields each action opens, ON A ROW THE CALLER OWNS — the widest
+                             *     set any single row admits, since ownership is a property of a row
+                             *     and this endpoint is asked about an entity. ABSENT means all
+                             *     fields; it never means none. An EMPTY list means exactly none, and
+                             *     is emitted rather than dropped: a policy may grant the scope while
+                             *     opening no field (`fields: []`), and the write floor then refuses
+                             *     every field. Absence and `[]` are opposite answers and both are
+                             *     reachable. Read together with `scope_by_action`: where an `owner`
+                             *     grant contributed, that part of the list applies only to the
+                             *     caller's own rows.
+                             */
+                            fields_by_action: {
+                                [key: string]: string[] | null;
+                            };
+                        }[];
+                    };
+                };
+            };
+        };
+    };
+    runtimeMcp: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    [key: string]: unknown;
+                };
+            };
+        };
+        responses: {
+            /**
+             * @description MCP JSON-RPC response (single object) or an SSE stream of MCP
+             *     messages — the server selects the content type per request.
+             */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        [key: string]: unknown;
+                    };
+                    "text/event-stream": string;
+                };
+            };
+            /**
+             * @description Method not allowed. GET on the stateless transport returns 405
+             *     (no server-initiated SSE); DELETE is a 200 no-op.
+             */
+            405: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    runtimeToolsMcpList: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    runtimeToolsCall: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["JsonObject"];
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    getHealth: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    getMetrics: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    listApiKeys: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Bare array of masked API-key metadata. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        id: string;
+                        name: string;
+                        key_prefix: string;
+                        scopes?: string[];
+                        created_at?: string;
+                    }[];
+                };
+            };
+        };
+    };
+    createApiKey: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    name: string;
+                    scopes?: string[];
+                };
+            };
+        };
+        responses: {
+            /** @description Created API key (bare body — includes one-time plaintext `key`). */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        id: string;
+                        name: string;
+                        key: string;
+                        scopes?: string[];
+                        created_at?: string;
+                    };
+                };
+            };
+        };
+    };
+    deleteApiKey: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                key_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Flat revoke ack. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        success: boolean;
+                    };
+                };
+            };
+        };
+    };
+    runtimeStateMachineReplay: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["JsonObject"];
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    streamEvents: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description text/event-stream */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/event-stream": string;
+                };
+            };
+        };
+    };
+    getTrace: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                trace_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            /** @description trace_not_found / legacy_trace_not_available */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    queryTraces: {
+        parameters: {
+            query?: {
+                flow?: string;
+                user?: string;
+                from?: string;
+                to?: string;
+                outcome?: "executed" | "refused" | "awaiting_human_decision" | "failed";
+                limit?: number;
+                cursor?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            /** @description invalid_query */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    replayTrace: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                trace_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["JsonObject"];
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            /** @description trace_not_found / legacy_trace_not_available */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description trace_in_flight (no terminal outcome recorded yet) */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    getTraceBundle: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                trace_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description application/gzip bundle */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/gzip": string;
+                };
+            };
+            /** @description trace_not_found / legacy_trace_not_available */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description trace_in_flight (no terminal outcome) */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description bundle_too_large (>200 MB after compression) */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    getAuditEvidenceBundle: {
+        parameters: {
+            query?: {
+                /** @description Inclusive lower `seq` bound (non-negative integer). */
+                from?: number;
+                /** @description Inclusive upper `seq` bound (non-negative integer; must be >= `from`). */
+                to?: number;
+            };
+            header?: never;
+            path: {
+                /** @description The event log whose hash-chain to export. */
+                log: "state_machine" | "flows";
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description application/gzip bundle */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/gzip": string;
+                };
+            };
+            /** @description invalid_range — `from`/`to` not non-negative integers, or `from > to` */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description unknown_log (unsupported `{log}`) / evidence_not_found (unauthorized) */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description payload_too_large — selected range exceeds the per-bundle event cap; narrow via `from`/`to` */
+            413: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    listAuditLog: {
+        parameters: {
+            query?: {
+                /** @description Inclusive lower bound on `created_at` (ISO date-time). */
+                from?: string;
+                /** @description Inclusive upper bound on `created_at` (ISO date-time; must be >= `from`). */
+                to?: string;
+                limit?: number;
+                /** @description Opaque pagination cursor from a prior response's `next_cursor`. */
+                cursor?: string;
+                /** @description `binding_violations` only — filter by entity name. */
+                entity?: string;
+                /** @description `binding_violations` only — filter by field name. */
+                field?: string;
+                /** @description `binding_violations` only — filter by binding mode. */
+                binding_mode?: "bind" | "assert" | "immutable";
+                /** @description `topic_refusals` only — filter by refusal category slug. */
+                category?: string;
+                /** @description `topic_refusals` only — filter by decision reason. */
+                reason?: "matched" | "no_verdict" | "unscored";
+                /** @description `topic_refusals` only — filter by verdict (currently always `hard_refusal`). */
+                verdict?: string;
+            };
+            header?: never;
+            path: {
+                /** @description The audit row-table to list. */
+                log: "binding_violations" | "topic_refusals";
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            /** @description invalid_query (malformed filter/cursor) / invalid_range (`from > to`) */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description audit_log_not_found — unknown `{log}` OR unauthorized (opaque, indistinguishable) */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    getTrustKeysManifest: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    runtimeImportsSnapshot: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["JsonObject"];
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    bulkImportRuntimeRecords: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                entity_name: components["parameters"]["EntityNamePath"];
+            };
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["JsonObject"];
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+        };
+    };
+    listReceipts: {
+        parameters: {
+            query?: {
+                /** @description Filter to one signal; omitted = all three. */
+                signal?: "refusal" | "binding_violation" | "validation_violation";
+                /** @description Filter by conversation/request correlation id. */
+                trace_id?: string;
+                /** @description Inclusive lower bound on `created_at` (ISO date-time). */
+                from?: string;
+                /** @description Inclusive upper bound on `created_at` (ISO date-time; must be >= `from`). */
+                to?: string;
+                limit?: number;
+                /** @description Opaque pagination cursor from a prior response's `next_cursor`. */
+                cursor?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["OkEnvelope"];
+            /** @description invalid_query (unknown signal / malformed cursor / bad limit) / invalid_range (`from > to`) */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+}
+//# sourceMappingURL=runtime.d.ts.map