pgbeam 0.4.9 → 0.4.11

package/dist/operations.mjs

@@ -1,4 +1,4 @@
-export { o as operationsByPath, a as operationsByTag } from './operations-map.gen-dojer3ji.js';
+export { o as operationsByPath, a as operationsByTag } from './operations-map.gen-nws17nv5.js';
 
 /**
  * Generated by generate-sdk-ts-maps.ts from backend/openapi/bundles/public.yaml — do not edit manually.
@@ -14,7 +14,15 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
         "path": "/v1/account/export",
         "summary": "Export account data",
         "description": "Returns all personal data associated with the authenticated user in a structured JSON format. Supports GDPR data portability and CCPA right to know. Audit logs are limited to the most recent 1000 entries.",
-        "parameters": [],
+        "parameters": [
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
+            }
+        ],
         "requestBodyType": "",
         "requestBodyRequired": false,
         "responseType": "{ audit_logs: ({ action: string; created_at: string; id: string; ip_address?: string; resource_id?: string; resource_type?: string })[]; consents: ({ accepted_at: string; document_type: string; document_version: string; id: string; ip_address?: string })[]; databases: ({ created_at: string; host: string; id: string; name: string; port: number; project_id: string; role: string; ssl_mode: string })[]; email_preferences: { marketing_emails?: boolean; usage_limit_alerts?: boolean }; exported_at: string; organizations: ({ created_at: string; id: string; name: string; role: string; slug: string })[]; projects: ({ created_at: string; description: string; id: string; name: string; org_id: string; status: string })[]; sessions: ({ created_at: string; expires_at: string; id: string; ip_address?: string; user_agent?: string })[]; user: { created_at: string; email: string; email_verified: boolean; id: string; image?: string; name: string; updated_at: string } }",
@@ -47,6 +55,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": false,
                 "type": "string",
                 "description": "Opaque token for cursor-based pagination."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -67,6 +82,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique project identifier (prefixed, e.g. prj_xxx)."
+            },
+            {
+                "name": "Idempotency-Key",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Client-generated key that makes a retry of this request safe. The first request carrying a given key executes normally and its response (status, content type and body) is stored for 24 hours; a later request with the same key returns that stored response without running the operation again, so a retry after a lost or timed-out response cannot create a second resource.\n\nReusing a key with a different request body returns `409 Conflict`: a key is a promise about one specific request, so a changed body is a client bug rather than a retry. Keys are scoped to the calling organization (or to the user, for account-scoped tokens), so one tenant can never read another's stored response.\n\nA `5xx`, `408` or `429` is never stored, because those describe a request that produced no settled answer and the next attempt with the same key must run for real. A `4xx` is stored: it is the server's settled answer about this exact request.\n\nUse a fresh UUID per logical operation. The PgBeam SDKs generate one per call and reuse it across their own automatic retries."
             }
         ],
         "requestBodyType": "{ expires_at?: string; name: string; policy_profile_id: string; principal_type?: \"agent\" | \"human\" }",
@@ -94,6 +116,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique agent credential identifier (prefixed, e.g. agt_xxx)."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -106,7 +135,7 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
         "method": "PATCH",
         "path": "/v1/projects/{project_id}/agents/{agent_id}",
         "summary": "Enable or disable an agent credential",
-        "description": "Toggles the kill-switch. Disabling drops live connections within seconds.",
+        "description": "Toggles the kill-switch between active and disabled. Disabling drops live connections within seconds. Revocation is terminal and cannot be undone here: a revoked credential answers 409, because revoking does not change its secrets, so putting it back to active would make the revoked password and MCP token work again. Issue a new credential instead.",
         "parameters": [
             {
                 "name": "project_id",
@@ -121,6 +150,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique agent credential identifier (prefixed, e.g. agt_xxx)."
+            },
+            {
+                "name": "If-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the write is based on, taken from the `ETag` of the read that produced the values being sent. The write proceeds only if it still matches the current representation; otherwise it is refused with `412 Precondition Failed` and nothing is changed.\n\nThis is what makes a read-modify-write safe. Without it the last writer wins and a concurrent edit is silently discarded, which is the failure an agent is most likely to cause and least likely to notice. The `412` response carries the current `ETag`, so a caller can re-read, re-apply its change and retry.\n\nOmitting the header keeps the old unconditional behaviour. `*` matches any current representation, which asserts only that the resource exists."
             }
         ],
         "requestBodyType": "{ status: \"active\" | \"disabled\" }",
@@ -175,6 +211,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique agent credential identifier (prefixed, e.g. agt_xxx)."
+            },
+            {
+                "name": "Idempotency-Key",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Client-generated key that makes a retry of this request safe. The first request carrying a given key executes normally and its response (status, content type and body) is stored for 24 hours; a later request with the same key returns that stored response without running the operation again, so a retry after a lost or timed-out response cannot create a second resource.\n\nReusing a key with a different request body returns `409 Conflict`: a key is a promise about one specific request, so a changed body is a client bug rather than a retry. Keys are scoped to the calling organization (or to the user, for account-scoped tokens), so one tenant can never read another's stored response.\n\nA `5xx`, `408` or `429` is never stored, because those describe a request that produced no settled answer and the next attempt with the same key must run for real. A `4xx` is stored: it is the server's settled answer about this exact request.\n\nUse a fresh UUID per logical operation. The PgBeam SDKs generate one per call and reuse it across their own automatic retries."
             }
         ],
         "requestBodyType": "",
@@ -243,6 +286,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": false,
                 "type": "string",
                 "description": "Opaque token for cursor-based pagination."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -311,6 +361,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": false,
                 "type": "string",
                 "description": "Opaque token for cursor-based pagination."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -441,6 +498,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": false,
                 "type": "number",
                 "description": "Maximum number of items to return (1-100, default 20)."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -544,6 +608,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": false,
                 "type": "string",
                 "description": "Return entries strictly older than this timestamp (cursor / upper bound)."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -578,6 +649,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": false,
                 "type": "string",
                 "description": "Return entries strictly older than this timestamp (cursor / upper bound)."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -585,13 +663,41 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
         "responseType": "{ anchor_status?: string; anchor_verified_from_seq?: number; anchor_verified_through_seq?: number; chain_end_seq?: number; chain_start_seq?: number; failure_reason?: string; first_broken_seq?: number; keyed_count: number; link_status?: string; link_verified_from_seq?: number; ok: boolean; unchained_count: number; verified_at: string; verified_count: number }",
         "responseStatus": "200"
     },
+    "executeBatch": {
+        "operationId": "executeBatch",
+        "method": "POST",
+        "path": "/v1/projects/{project_id}/batch",
+        "summary": "Apply many project operations in one request",
+        "description": "Applies up to 100 project-scoped operations in a single request, so an agent acting on many resources does not have to loop one call at a time. The loops this exists for are the ones the single-resource endpoints leave an operator running by hand: revoking or disabling every agent credential during an incident, triaging a burst of anomaly alerts, and importing the column descriptions for a whole schema.\n\nThe operation set is closed. A batch is not a tunnel for arbitrary requests; each kind it can perform is named in the contract, carries its own permission, and is authorized independently against the caller's scope before any of them runs, so a batch can never act outside the scope the caller already had. Every operation targets the project in the path, and an id belonging to another project is reported exactly as a nonexistent one is, so this cannot be used to probe for resources the caller cannot see.\n\n`mode` is required and decides what a failure means. `atomic` runs the whole batch in one transaction: the first runtime failure rolls it back, the response is 409, and every operation that did not itself fail is reported `not_applied`. `independent` applies each operation on its own and answers 200 with a per-operation status, so a caller can retry exactly the failures. Structural problems (an unknown operation kind, a missing field, a duplicate target) are all found before any work happens and are answered with a single 400.\n\nA batch costs the rate limiter one unit per operation, not one per HTTP request, so it is exactly as expensive as the loop it replaces and cannot be used to sidestep the quota. When the remaining quota cannot cover the whole batch the response is 429 and nothing runs, which is a better answer than a loop that discovers the same thing halfway through. A batch refused this way still costs the one unit any request costs, so an oversized batch is not a free way to probe the quota.",
+        "parameters": [
+            {
+                "name": "project_id",
+                "in": "path",
+                "required": true,
+                "type": "string",
+                "description": "Unique project identifier (prefixed, e.g. prj_xxx)."
+            }
+        ],
+        "requestBodyType": "{ mode: \"atomic\" | \"independent\"; operations: ({ agent_id?: string; agent_status?: \"active\" | \"disabled\"; annotation?: { column_name?: string; description: string; schema_name?: string; table_name: string }; anomaly_id?: string; anomaly_status?: \"acknowledged\" | \"resolved\"; id: string; op: \"revoke_agent_credential\" | \"set_agent_credential_status\" | \"update_anomaly_alert\" | \"put_schema_annotation\" })[] }",
+        "requestBodyRequired": true,
+        "responseType": "{ applied: boolean; mode: \"atomic\" | \"independent\"; results: ({ error?: { code: \"invalid_input\" | \"not_found\" | \"conflict\" | \"internal\"; message: string }; id: string; op: string; status: \"succeeded\" | \"failed\" | \"not_applied\" })[]; summary: { failed: number; not_applied: number; requested: number; succeeded: number } }",
+        "responseStatus": "200"
+    },
     "listPlans": {
         "operationId": "listPlans",
         "method": "GET",
         "path": "/v1/plans",
         "summary": "List available plans",
         "description": "Returns all available plan tiers with their limits and pricing.",
-        "parameters": [],
+        "parameters": [
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
+            }
+        ],
         "requestBodyType": "",
         "requestBodyRequired": false,
         "responseType": "{ plans: ({ annual_price?: number; description?: string; label: string; limits: { audit_retention_days: number; bytes_per_month: number; included_seats: number; max_agent_credentials: number; max_connections: number; max_databases: number; max_projects: number; max_query_shapes: number; queries_per_day: number; queries_per_second: number; sandbox_idle_seconds: number; sandbox_max_branches: number; sandbox_max_upstream_bytes: number; sandbox_ttl_seconds: number }; monthly_price: number; name: string; overage_text?: string; trial_days?: number })[] }",
@@ -610,6 +716,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique organization identifier."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -630,6 +743,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique organization identifier."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -711,6 +831,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": false,
                 "type": "string",
                 "description": "Opaque token for cursor-based pagination."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -779,6 +906,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": false,
                 "type": "string",
                 "description": "Opaque token for cursor-based pagination."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -847,6 +981,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": false,
                 "type": "string",
                 "description": "Opaque token for cursor-based pagination."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -867,6 +1008,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique project identifier (prefixed, e.g. prj_xxx)."
+            },
+            {
+                "name": "Idempotency-Key",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Client-generated key that makes a retry of this request safe. The first request carrying a given key executes normally and its response (status, content type and body) is stored for 24 hours; a later request with the same key returns that stored response without running the operation again, so a retry after a lost or timed-out response cannot create a second resource.\n\nReusing a key with a different request body returns `409 Conflict`: a key is a promise about one specific request, so a changed body is a client bug rather than a retry. Keys are scoped to the calling organization (or to the user, for account-scoped tokens), so one tenant can never read another's stored response.\n\nA `5xx`, `408` or `429` is never stored, because those describe a request that produced no settled answer and the next attempt with the same key must run for real. A `4xx` is stored: it is the server's settled answer about this exact request.\n\nUse a fresh UUID per logical operation. The PgBeam SDKs generate one per call and reuse it across their own automatic retries."
             }
         ],
         "requestBodyType": "{ auto_read_routing?: boolean; cache_config?: { enabled: boolean; max_entries: number; swr_seconds: number; ttl_seconds: number }; host: string; name: string; password: string; pool_config?: { max_active?: number; min_pool_size: number; pool_mode: \"session\" | \"transaction\" | \"statement\"; pool_size: number }; pool_region?: string; port: number; query_timeout_ms?: number; role?: \"primary\" | \"replica\"; ssl_mode?: \"disable\" | \"allow\" | \"prefer\" | \"require\" | \"verify-ca\" | \"verify-full\"; username: string }",
@@ -894,6 +1042,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique database identifier (prefixed, e.g. db_xxx)."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -921,6 +1076,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique database identifier (prefixed, e.g. db_xxx)."
+            },
+            {
+                "name": "If-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the write is based on, taken from the `ETag` of the read that produced the values being sent. The write proceeds only if it still matches the current representation; otherwise it is refused with `412 Precondition Failed` and nothing is changed.\n\nThis is what makes a read-modify-write safe. Without it the last writer wins and a concurrent edit is silently discarded, which is the failure an agent is most likely to cause and least likely to notice. The `412` response carries the current `ETag`, so a caller can re-read, re-apply its change and retry.\n\nOmitting the header keeps the old unconditional behaviour. `*` matches any current representation, which asserts only that the resource exists."
             }
         ],
         "requestBodyType": "{ auto_read_routing?: boolean; cache_config?: { enabled: boolean; max_entries: number; swr_seconds: number; ttl_seconds: number }; host?: string; name?: string; password?: string; pool_config?: { max_active?: number; min_pool_size: number; pool_mode: \"session\" | \"transaction\" | \"statement\"; pool_size: number }; pool_region?: string; port?: number; query_timeout_ms?: number; role?: \"primary\" | \"replica\"; ssl_mode?: \"disable\" | \"allow\" | \"prefer\" | \"require\" | \"verify-ca\" | \"verify-full\"; username?: string }",
@@ -1029,6 +1191,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique database identifier (prefixed, e.g. db_xxx)."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -1036,6 +1205,50 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
         "responseType": "{ error?: string; relations: ({ columns: ({ data_type: string; is_binary: boolean; name: string })[]; kind: \"table\" | \"view\" | \"materialized_view\" | \"other\"; name: string; schema: string })[]; scanned_columns: number; scanned_relations: number; truncated?: boolean }",
         "responseStatus": "200"
     },
+    "getDemo": {
+        "operationId": "getDemo",
+        "method": "GET",
+        "path": "/v1/demo",
+        "summary": "Describe the demo sandbox",
+        "description": "Returns everything an unauthenticated caller needs before asking for a demo credential: whether the demo is up, how much of the global ceiling is left, what each tier costs, the dataset schema with the treatment the demo policy applies to every column, and the walkthrough of statements that demonstrate each guardrail. Requires no account and no key.",
+        "parameters": [],
+        "requestBodyType": "",
+        "requestBodyRequired": false,
+        "responseType": "{ available: boolean; dataset: { schema: string; tables: ({ columns: ({ name: string; treatment: \"visible\" | \"redacted\" | \"hashed\" | \"nulled\"; type: string })[]; description: string; name: string; reachable: boolean })[] }; live_sessions: number; max_live_sessions: number; max_sessions_per_hour_per_client: number; retry_after_seconds?: number; tiers: ({ max_rows: number; name: \"free\" | \"extended\"; price_usd_cents: number; purchasable: boolean; query_budget: number; resource?: string; ttl_seconds: number })[]; unavailable_reason?: string; upgrade: { description: string; docs_url: string; policy_endpoint: string; signup_url: string }; walkthrough: ({ expect: \"allow\" | \"masked\" | \"blocked\"; expect_columns?: ({ name: string; treatment: \"visible\" | \"redacted\" | \"hashed\" | \"nulled\"; type: string })[]; expect_rule?: string; sql: string; step: number; title: string; why: string })[] }",
+        "responseStatus": "200"
+    },
+    "createDemoCredential": {
+        "operationId": "createDemoCredential",
+        "method": "POST",
+        "path": "/v1/demo/credentials",
+        "summary": "Issue a demo credential",
+        "description": "Issues a scoped, read-only, short-lived PostgreSQL credential plus a hosted MCP token against PgBeam's own demo database, with no account and no key. The credential is governed by the same wire-protocol policy engine every customer credential runs through, so a SELECT of a PII column comes back masked, a statement naming the table left off the allowlist is blocked, and a write is refused, all with machine-readable reasons. The connection string and MCP token are shown once. The response also carries the policy document that governed the demo, so a caller who then opens an account can create the same policy on its own database verbatim.\nRefusals are distinct on purpose. 429 means this client has asked for too many credentials in the last hour and should wait. 503 with a Retry-After header means the global ceiling on concurrent demo credentials is full, so backing off individually will not help; the header says when the oldest session expires. 503 also covers a deployment with no demo database configured.",
+        "parameters": [],
+        "requestBodyType": "{ label?: string; payment_proof?: string; tier?: \"free\" | \"extended\" }",
+        "requestBodyRequired": false,
+        "responseType": "{ connection_string: string; dataset: { schema: string; tables: ({ columns: ({ name: string; treatment: \"visible\" | \"redacted\" | \"hashed\" | \"nulled\"; type: string })[]; description: string; name: string; reachable: boolean })[] }; expires_at: string; mcp_token: string; mcp_url: string; policy_template: { access_mode?: \"read_only\" | \"read_write\"; approval_auto_max_rows?: number; approval_mode?: \"off\" | \"writes\" | \"ddl\" | \"all\"; approval_timeout_seconds?: number; budget_queries_per_day?: number; budget_queries_per_hour?: number; egress_bytes_per_day?: number; masking_rules?: ({ column: string; kind: \"redact\" | \"null\" | \"hash\"; table: string })[]; max_affected_rows?: number; max_rows?: number; migration_safety?: \"off\" | \"warn\" | \"block\"; name: string; row_filters?: ({ predicate: string; table: string })[]; statement_rules?: { allow?: string[]; deny?: string[] }; statement_timeout_ms?: number; table_allowlist?: string[]; table_denylist?: string[]; write_mode?: \"normal\" | \"rollback\" | \"sandbox\" }; query_budget: number; session_id: string; tier: string; ttl_seconds: number; upgrade: { description: string; docs_url: string; policy_endpoint: string; signup_url: string }; walkthrough: ({ expect: \"allow\" | \"masked\" | \"blocked\"; expect_columns?: ({ name: string; treatment: \"visible\" | \"redacted\" | \"hashed\" | \"nulled\"; type: string })[]; expect_rule?: string; sql: string; step: number; title: string; why: string })[] }",
+        "responseStatus": "201"
+    },
+    "releaseDemoCredential": {
+        "operationId": "releaseDemoCredential",
+        "method": "POST",
+        "path": "/v1/demo/credentials/{session_id}/release",
+        "summary": "Release a demo credential",
+        "description": "Revokes a demo credential before its TTL runs out and returns its slot to the global ceiling. Callers that finish early should do this so the next evaluating agent is not turned away by a session nobody is using. The MCP token issued with the credential proves the caller holds it. Releasing an already-expired or already-released session succeeds with released=false.",
+        "parameters": [
+            {
+                "name": "session_id",
+                "in": "path",
+                "required": true,
+                "type": "string",
+                "description": "The demo session to release, as returned when it was issued."
+            }
+        ],
+        "requestBodyType": "{ mcp_token: string }",
+        "requestBodyRequired": true,
+        "responseType": "{ live_sessions: number; released: boolean; session_id: string }",
+        "responseStatus": "200"
+    },
     "listCustomDomains": {
         "operationId": "listCustomDomains",
         "method": "GET",
@@ -1063,6 +1276,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": false,
                 "type": "string",
                 "description": "Opaque token for cursor-based pagination."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -1083,6 +1303,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique project identifier (prefixed, e.g. prj_xxx)."
+            },
+            {
+                "name": "Idempotency-Key",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Client-generated key that makes a retry of this request safe. The first request carrying a given key executes normally and its response (status, content type and body) is stored for 24 hours; a later request with the same key returns that stored response without running the operation again, so a retry after a lost or timed-out response cannot create a second resource.\n\nReusing a key with a different request body returns `409 Conflict`: a key is a promise about one specific request, so a changed body is a client bug rather than a retry. Keys are scoped to the calling organization (or to the user, for account-scoped tokens), so one tenant can never read another's stored response.\n\nA `5xx`, `408` or `429` is never stored, because those describe a request that produced no settled answer and the next attempt with the same key must run for real. A `4xx` is stored: it is the server's settled answer about this exact request.\n\nUse a fresh UUID per logical operation. The PgBeam SDKs generate one per call and reuse it across their own automatic retries."
             }
         ],
         "requestBodyType": "{ domain: string }",
@@ -1150,7 +1377,15 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
         "path": "/v1/health",
         "summary": "Health check",
         "description": "Returns the health status of the API server.",
-        "parameters": [],
+        "parameters": [
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
+            }
+        ],
         "requestBodyType": "",
         "requestBodyRequired": false,
         "responseType": "{ image_sha: string; status: \"ok\" | \"degraded\"; timestamp?: string; version: string }",
@@ -1183,6 +1418,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": false,
                 "type": "string",
                 "description": "Opaque token for cursor-based pagination."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -1203,6 +1445,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique project identifier (prefixed, e.g. prj_xxx)."
+            },
+            {
+                "name": "Idempotency-Key",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Client-generated key that makes a retry of this request safe. The first request carrying a given key executes normally and its response (status, content type and body) is stored for 24 hours; a later request with the same key returns that stored response without running the operation again, so a retry after a lost or timed-out response cannot create a second resource.\n\nReusing a key with a different request body returns `409 Conflict`: a key is a promise about one specific request, so a changed body is a client bug rather than a retry. Keys are scoped to the calling organization (or to the user, for account-scoped tokens), so one tenant can never read another's stored response.\n\nA `5xx`, `408` or `429` is never stored, because those describe a request that produced no settled answer and the next attempt with the same key must run for real. A `4xx` is stored: it is the server's settled answer about this exact request.\n\nUse a fresh UUID per logical operation. The PgBeam SDKs generate one per call and reuse it across their own automatic retries."
             }
         ],
         "requestBodyType": "{ action: \"audit_only\" | \"kill\"; relation_name: string; schema_name?: string }",
@@ -1230,6 +1479,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique honeytoken identifier (prefixed, e.g. hnt_xxx)."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -1257,6 +1513,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique honeytoken identifier (prefixed, e.g. hnt_xxx)."
+            },
+            {
+                "name": "If-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the write is based on, taken from the `ETag` of the read that produced the values being sent. The write proceeds only if it still matches the current representation; otherwise it is refused with `412 Precondition Failed` and nothing is changed.\n\nThis is what makes a read-modify-write safe. Without it the last writer wins and a concurrent edit is silently discarded, which is the failure an agent is most likely to cause and least likely to notice. The `412` response carries the current `ETag`, so a caller can re-read, re-apply its change and retry.\n\nOmitting the header keeps the old unconditional behaviour. `*` matches any current representation, which asserts only that the resource exists."
             }
         ],
         "requestBodyType": "{ action: \"audit_only\" | \"kill\"; relation_name: string; schema_name?: string }",
@@ -1318,6 +1581,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": false,
                 "type": "number",
                 "description": "Maximum number of top queries to return (1-100)."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -1325,6 +1595,196 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
         "responseType": "{ cache: { hit_rate: number; total_hits: number; total_misses: number }; latency: { avg_ms: number; p99_ms: number }; queries: ({ avg_latency_ms: number; p99_latency_ms: number; query_hash: string; query_pattern: string; total_cache_hits: number; total_cache_misses: number; total_count: number })[] }",
         "responseStatus": "200"
     },
+    "listOrgMembers": {
+        "operationId": "listOrgMembers",
+        "method": "GET",
+        "path": "/v1/organizations/{org_id}/members",
+        "summary": "List organization members",
+        "description": "Lists the people who belong to the organization, and their roles.",
+        "parameters": [
+            {
+                "name": "org_id",
+                "in": "path",
+                "required": true,
+                "type": "string",
+                "description": "Unique organization identifier."
+            },
+            {
+                "name": "page_size",
+                "in": "query",
+                "required": false,
+                "type": "number",
+                "description": "Maximum number of items to return (1-100, default 20)."
+            },
+            {
+                "name": "page_token",
+                "in": "query",
+                "required": false,
+                "type": "string",
+                "description": "Opaque token for cursor-based pagination."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
+            }
+        ],
+        "requestBodyType": "",
+        "requestBodyRequired": false,
+        "responseType": "{ members: ({ created_at: string; email: string; id: string; image?: string; name: string; role: \"owner\" | \"admin\" | \"member\" | \"security_admin\" | \"billing_admin\" | \"auditor\" | \"policy-author\" | \"approver\"; user_id: string })[]; next_page_token?: string }",
+        "responseStatus": "200"
+    },
+    "updateOrgMemberRole": {
+        "operationId": "updateOrgMemberRole",
+        "method": "PATCH",
+        "path": "/v1/organizations/{org_id}/members/{member_id}",
+        "summary": "Change a member's role",
+        "description": "Changes what a member is allowed to do. An organization must keep at least one owner, so the last owner cannot be demoted, and `owner` cannot be assigned here: ownership transfer is a separate, higher-privilege flow.",
+        "parameters": [
+            {
+                "name": "org_id",
+                "in": "path",
+                "required": true,
+                "type": "string",
+                "description": "Unique organization identifier."
+            },
+            {
+                "name": "member_id",
+                "in": "path",
+                "required": true,
+                "type": "string",
+                "description": "Unique organization membership identifier. Unlike the resources PgBeam mints itself, memberships carry no type prefix: the id is opaque and is assigned when the membership row is created. Read it from `listOrgMembers` rather than constructing it."
+            }
+        ],
+        "requestBodyType": "{ role: \"admin\" | \"member\" | \"security_admin\" | \"billing_admin\" | \"auditor\" | \"policy-author\" | \"approver\" }",
+        "requestBodyRequired": true,
+        "responseType": "{ created_at: string; email: string; id: string; image?: string; name: string; role: \"owner\" | \"admin\" | \"member\" | \"security_admin\" | \"billing_admin\" | \"auditor\" | \"policy-author\" | \"approver\"; user_id: string }",
+        "responseStatus": "200"
+    },
+    "removeOrgMember": {
+        "operationId": "removeOrgMember",
+        "method": "DELETE",
+        "path": "/v1/organizations/{org_id}/members/{member_id}",
+        "summary": "Remove a member",
+        "description": "Removes someone from the organization. An organization must keep at least one owner, so the last remaining owner cannot be removed and cannot be demoted either: transfer ownership first.",
+        "parameters": [
+            {
+                "name": "org_id",
+                "in": "path",
+                "required": true,
+                "type": "string",
+                "description": "Unique organization identifier."
+            },
+            {
+                "name": "member_id",
+                "in": "path",
+                "required": true,
+                "type": "string",
+                "description": "Unique organization membership identifier. Unlike the resources PgBeam mints itself, memberships carry no type prefix: the id is opaque and is assigned when the membership row is created. Read it from `listOrgMembers` rather than constructing it."
+            }
+        ],
+        "requestBodyType": "",
+        "requestBodyRequired": false,
+        "responseType": "",
+        "responseStatus": "204"
+    },
+    "listOrgInvitations": {
+        "operationId": "listOrgInvitations",
+        "method": "GET",
+        "path": "/v1/organizations/{org_id}/invitations",
+        "summary": "List invitations",
+        "description": "Lists invitations to join the organization and where each has got to.",
+        "parameters": [
+            {
+                "name": "org_id",
+                "in": "path",
+                "required": true,
+                "type": "string",
+                "description": "Unique organization identifier."
+            },
+            {
+                "name": "status",
+                "in": "query",
+                "required": false,
+                "type": "\"pending\" | \"accepted\" | \"rejected\" | \"canceled\"",
+                "description": "Filter to a single status. Omit to list every invitation."
+            },
+            {
+                "name": "page_size",
+                "in": "query",
+                "required": false,
+                "type": "number",
+                "description": "Maximum number of items to return (1-100, default 20)."
+            },
+            {
+                "name": "page_token",
+                "in": "query",
+                "required": false,
+                "type": "string",
+                "description": "Opaque token for cursor-based pagination."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
+            }
+        ],
+        "requestBodyType": "",
+        "requestBodyRequired": false,
+        "responseType": "{ invitations: ({ created_at: string; email: string; expires_at: string; id: string; role: \"owner\" | \"admin\" | \"member\" | \"security_admin\" | \"billing_admin\" | \"auditor\" | \"policy-author\" | \"approver\"; status: \"pending\" | \"accepted\" | \"rejected\" | \"canceled\" })[]; next_page_token?: string }",
+        "responseStatus": "200"
+    },
+    "createOrgInvitation": {
+        "operationId": "createOrgInvitation",
+        "method": "POST",
+        "path": "/v1/organizations/{org_id}/invitations",
+        "summary": "Invite someone to the organization",
+        "description": "Creates an invitation and emails it. Inviting an address that already has a pending invitation returns a conflict rather than a second invitation. `owner` cannot be invited: ownership transfer is a separate, higher-privilege flow.",
+        "parameters": [
+            {
+                "name": "org_id",
+                "in": "path",
+                "required": true,
+                "type": "string",
+                "description": "Unique organization identifier."
+            }
+        ],
+        "requestBodyType": "{ email: string; role?: \"admin\" | \"member\" | \"security_admin\" | \"billing_admin\" | \"auditor\" | \"policy-author\" | \"approver\" }",
+        "requestBodyRequired": true,
+        "responseType": "{ created_at: string; email: string; expires_at: string; id: string; role: \"owner\" | \"admin\" | \"member\" | \"security_admin\" | \"billing_admin\" | \"auditor\" | \"policy-author\" | \"approver\"; status: \"pending\" | \"accepted\" | \"rejected\" | \"canceled\" }",
+        "responseStatus": "201"
+    },
+    "revokeOrgInvitation": {
+        "operationId": "revokeOrgInvitation",
+        "method": "DELETE",
+        "path": "/v1/organizations/{org_id}/invitations/{invitation_id}",
+        "summary": "Revoke an invitation",
+        "description": "Cancels a pending invitation so it can no longer be accepted.",
+        "parameters": [
+            {
+                "name": "org_id",
+                "in": "path",
+                "required": true,
+                "type": "string",
+                "description": "Unique organization identifier."
+            },
+            {
+                "name": "invitation_id",
+                "in": "path",
+                "required": true,
+                "type": "string",
+                "description": "Unique organization invitation identifier. Opaque, with no type prefix. Invitations created through this API are 32 lowercase hex characters; invitations created in the dashboard carry an id of a different shape, so treat it as opaque and read it from `listOrgInvitations`."
+            }
+        ],
+        "requestBodyType": "",
+        "requestBodyRequired": false,
+        "responseType": "",
+        "responseStatus": "204"
+    },
     "lintMigration": {
         "operationId": "lintMigration",
         "method": "POST",
@@ -1358,6 +1818,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique organization identifier."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -1391,7 +1858,15 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
         "path": "/v1/organizations",
         "summary": "List organizations",
         "description": "Lists the organizations visible to the caller's credential. An organization-scoped API key (pbo_) returns exactly the organization it belongs to. A user credential (account-scoped API key or dashboard session token) returns the organizations the user is a member of, including the caller's role in each.",
-        "parameters": [],
+        "parameters": [
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
+            }
+        ],
         "requestBodyType": "",
         "requestBodyRequired": false,
         "responseType": "{ organizations: ({ id: string; name: string; role?: string; slug: string })[] }",
@@ -1424,6 +1899,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": false,
                 "type": "string",
                 "description": "Opaque token for cursor-based pagination."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -1444,6 +1926,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique project identifier (prefixed, e.g. prj_xxx)."
+            },
+            {
+                "name": "Idempotency-Key",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Client-generated key that makes a retry of this request safe. The first request carrying a given key executes normally and its response (status, content type and body) is stored for 24 hours; a later request with the same key returns that stored response without running the operation again, so a retry after a lost or timed-out response cannot create a second resource.\n\nReusing a key with a different request body returns `409 Conflict`: a key is a promise about one specific request, so a changed body is a client bug rather than a retry. Keys are scoped to the calling organization (or to the user, for account-scoped tokens), so one tenant can never read another's stored response.\n\nA `5xx`, `408` or `429` is never stored, because those describe a request that produced no settled answer and the next attempt with the same key must run for real. A `4xx` is stored: it is the server's settled answer about this exact request.\n\nUse a fresh UUID per logical operation. The PgBeam SDKs generate one per call and reuse it across their own automatic retries."
             }
         ],
         "requestBodyType": "{ access_mode?: \"read_only\" | \"read_write\"; approval_auto_max_rows?: number; approval_mode?: \"off\" | \"writes\" | \"ddl\" | \"all\"; approval_timeout_seconds?: number; budget_queries_per_day?: number; budget_queries_per_hour?: number; egress_bytes_per_day?: number; masking_rules?: ({ column: string; kind: \"redact\" | \"null\" | \"hash\"; table: string })[]; max_affected_rows?: number; max_rows?: number; migration_safety?: \"off\" | \"warn\" | \"block\"; name: string; row_filters?: ({ predicate: string; table: string })[]; statement_rules?: { allow?: string[]; deny?: string[] }; statement_timeout_ms?: number; table_allowlist?: string[]; table_denylist?: string[]; write_mode?: \"normal\" | \"rollback\" | \"sandbox\" }",
@@ -1471,6 +1960,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique policy profile identifier (prefixed, e.g. pol_xxx)."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -1498,6 +1994,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique policy profile identifier (prefixed, e.g. pol_xxx)."
+            },
+            {
+                "name": "If-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the write is based on, taken from the `ETag` of the read that produced the values being sent. The write proceeds only if it still matches the current representation; otherwise it is refused with `412 Precondition Failed` and nothing is changed.\n\nThis is what makes a read-modify-write safe. Without it the last writer wins and a concurrent edit is silently discarded, which is the failure an agent is most likely to cause and least likely to notice. The `412` response carries the current `ETag`, so a caller can re-read, re-apply its change and retry.\n\nOmitting the header keeps the old unconditional behaviour. `*` matches any current representation, which asserts only that the resource exists."
             }
         ],
         "requestBodyType": "{ access_mode?: \"read_only\" | \"read_write\"; approval_auto_max_rows?: number; approval_mode?: \"off\" | \"writes\" | \"ddl\" | \"all\"; approval_timeout_seconds?: number; budget_queries_per_day?: number; budget_queries_per_hour?: number; egress_bytes_per_day?: number; masking_rules?: ({ column: string; kind: \"redact\" | \"null\" | \"hash\"; table: string })[]; max_affected_rows?: number; max_rows?: number; migration_safety?: \"off\" | \"warn\" | \"block\"; name: string; row_filters?: ({ predicate: string; table: string })[]; statement_rules?: { allow?: string[]; deny?: string[] }; statement_timeout_ms?: number; table_allowlist?: string[]; table_denylist?: string[]; write_mode?: \"normal\" | \"rollback\" | \"sandbox\" }",
@@ -1606,6 +2109,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": false,
                 "type": "\"name\" | \"created_at\" | \"active_connections\"",
                 "description": "Sort field for projects list."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -1619,7 +2129,15 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
         "path": "/v1/projects",
         "summary": "Create a project",
         "description": "Creates a new project within the specified organization.",
-        "parameters": [],
+        "parameters": [
+            {
+                "name": "Idempotency-Key",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Client-generated key that makes a retry of this request safe. The first request carrying a given key executes normally and its response (status, content type and body) is stored for 24 hours; a later request with the same key returns that stored response without running the operation again, so a retry after a lost or timed-out response cannot create a second resource.\n\nReusing a key with a different request body returns `409 Conflict`: a key is a promise about one specific request, so a changed body is a client bug rather than a retry. Keys are scoped to the calling organization (or to the user, for account-scoped tokens), so one tenant can never read another's stored response.\n\nA `5xx`, `408` or `429` is never stored, because those describe a request that produced no settled answer and the next attempt with the same key must run for real. A `4xx` is stored: it is the server's settled answer about this exact request.\n\nUse a fresh UUID per logical operation. The PgBeam SDKs generate one per call and reuse it across their own automatic retries."
+            }
+        ],
         "requestBodyType": "{ cloud?: \"aws\" | \"azure\" | \"gcp\"; database: { auto_read_routing?: boolean; cache_config?: { enabled: boolean; max_entries: number; swr_seconds: number; ttl_seconds: number }; host: string; name: string; password: string; pool_config?: { max_active?: number; min_pool_size: number; pool_mode: \"session\" | \"transaction\" | \"statement\"; pool_size: number }; pool_region?: string; port: number; query_timeout_ms?: number; role?: \"primary\" | \"replica\"; ssl_mode?: \"disable\" | \"allow\" | \"prefer\" | \"require\" | \"verify-ca\" | \"verify-full\"; username: string }; description?: string; name: string; org_id: string; self_hosted?: boolean; tags?: string[] }",
         "requestBodyRequired": true,
         "responseType": "{ database?: { auto_read_routing?: boolean; cache_config: { enabled: boolean; max_entries: number; swr_seconds: number; ttl_seconds: number }; connection_string?: string; created_at: string; host: string; id: string; name: string; pool_config: { max_active?: number; min_pool_size: number; pool_mode: \"session\" | \"transaction\" | \"statement\"; pool_size: number }; pool_region?: string; port: number; project_id: string; query_timeout_ms?: number; role?: \"primary\" | \"replica\"; ssl_mode: \"disable\" | \"allow\" | \"prefer\" | \"require\" | \"verify-ca\" | \"verify-full\"; updated_at: string; username: string }; project: { active_connections?: number; agents_disabled?: boolean; allowed_cidrs?: ({ cidr: string; label?: string })[]; burst_size?: number; cloud?: \"aws\" | \"azure\" | \"gcp\"; created_at: string; database_count?: number; default_policy_profile_id?: string; description?: string; id: string; max_connections?: number; name: string; org_id: string; proxy_host?: string; queries_per_second?: number; residency?: \"any\" | \"us\" | \"eu\"; self_hosted?: boolean; status: \"active\" | \"suspended\" | \"deleted\"; tags?: string[]; updated_at: string } }",
@@ -1638,6 +2156,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique project identifier (prefixed, e.g. prj_xxx)."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -1658,6 +2183,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique project identifier (prefixed, e.g. prj_xxx)."
+            },
+            {
+                "name": "If-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the write is based on, taken from the `ETag` of the read that produced the values being sent. The write proceeds only if it still matches the current representation; otherwise it is refused with `412 Precondition Failed` and nothing is changed.\n\nThis is what makes a read-modify-write safe. Without it the last writer wins and a concurrent edit is silently discarded, which is the failure an agent is most likely to cause and least likely to notice. The `412` response carries the current `ETag`, so a caller can re-read, re-apply its change and retry.\n\nOmitting the header keeps the old unconditional behaviour. `*` matches any current representation, which asserts only that the resource exists."
             }
         ],
         "requestBodyType": "{ agents_disabled?: boolean; allowed_cidrs?: ({ cidr: string; label?: string })[]; default_policy_profile_id?: string; description?: string; name?: string; residency?: \"any\" | \"us\" | \"eu\"; status?: \"active\" | \"suspended\" | \"deleted\"; tags?: string[] }",
@@ -1712,6 +2244,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": false,
                 "type": "string",
                 "description": "Filter metrics by region code."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -1725,7 +2264,15 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
         "path": "/v1/regions",
         "summary": "List available regions",
         "description": "Returns all active data plane regions.",
-        "parameters": [],
+        "parameters": [
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
+            }
+        ],
         "requestBodyType": "",
         "requestBodyRequired": false,
         "responseType": "{ regions: ({ available: boolean; continent?: string; country?: string; id: string; name: string; provider: \"aws\" | \"azure\" | \"gcp\"; status: \"active\" | \"draining\" | \"inactive\" })[] }",
@@ -1744,6 +2291,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique database identifier (prefixed, e.g. db_xxx)."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -1764,6 +2318,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique database identifier (prefixed, e.g. db_xxx)."
+            },
+            {
+                "name": "Idempotency-Key",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Client-generated key that makes a retry of this request safe. The first request carrying a given key executes normally and its response (status, content type and body) is stored for 24 hours; a later request with the same key returns that stored response without running the operation again, so a retry after a lost or timed-out response cannot create a second resource.\n\nReusing a key with a different request body returns `409 Conflict`: a key is a promise about one specific request, so a changed body is a client bug rather than a retry. Keys are scoped to the calling organization (or to the user, for account-scoped tokens), so one tenant can never read another's stored response.\n\nA `5xx`, `408` or `429` is never stored, because those describe a request that produced no settled answer and the next attempt with the same key must run for real. A `4xx` is stored: it is the server's settled answer about this exact request.\n\nUse a fresh UUID per logical operation. The PgBeam SDKs generate one per call and reuse it across their own automatic retries."
             }
         ],
         "requestBodyType": "{ host: string; port: number; ssl_mode?: \"disable\" | \"allow\" | \"prefer\" | \"require\" | \"verify-ca\" | \"verify-full\" }",
@@ -1825,6 +2386,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": false,
                 "type": "string",
                 "description": "Opaque token for cursor-based pagination."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -1906,6 +2474,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique organization identifier."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -1926,6 +2501,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique organization identifier."
+            },
+            {
+                "name": "Idempotency-Key",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Client-generated key that makes a retry of this request safe. The first request carrying a given key executes normally and its response (status, content type and body) is stored for 24 hours; a later request with the same key returns that stored response without running the operation again, so a retry after a lost or timed-out response cannot create a second resource.\n\nReusing a key with a different request body returns `409 Conflict`: a key is a promise about one specific request, so a changed body is a client bug rather than a retry. Keys are scoped to the calling organization (or to the user, for account-scoped tokens), so one tenant can never read another's stored response.\n\nA `5xx`, `408` or `429` is never stored, because those describe a request that produced no settled answer and the next attempt with the same key must run for real. A `4xx` is stored: it is the server's settled answer about this exact request.\n\nUse a fresh UUID per logical operation. The PgBeam SDKs generate one per call and reuse it across their own automatic retries."
             }
         ],
         "requestBodyType": "{ description?: string; expires_at?: string; region_label?: string }",
@@ -1980,6 +2562,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique enrollment identifier."
+            },
+            {
+                "name": "Idempotency-Key",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Client-generated key that makes a retry of this request safe. The first request carrying a given key executes normally and its response (status, content type and body) is stored for 24 hours; a later request with the same key returns that stored response without running the operation again, so a retry after a lost or timed-out response cannot create a second resource.\n\nReusing a key with a different request body returns `409 Conflict`: a key is a promise about one specific request, so a changed body is a client bug rather than a retry. Keys are scoped to the calling organization (or to the user, for account-scoped tokens), so one tenant can never read another's stored response.\n\nA `5xx`, `408` or `429` is never stored, because those describe a request that produced no settled answer and the next attempt with the same key must run for real. A `4xx` is stored: it is the server's settled answer about this exact request.\n\nUse a fresh UUID per logical operation. The PgBeam SDKs generate one per call and reuse it across their own automatic retries."
             }
         ],
         "requestBodyType": "",
@@ -2028,6 +2617,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": false,
                 "type": "number",
                 "description": "Page number (1-based, default 1)."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -2048,6 +2644,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique organization identifier."
+            },
+            {
+                "name": "Idempotency-Key",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Client-generated key that makes a retry of this request safe. The first request carrying a given key executes normally and its response (status, content type and body) is stored for 24 hours; a later request with the same key returns that stored response without running the operation again, so a retry after a lost or timed-out response cannot create a second resource.\n\nReusing a key with a different request body returns `409 Conflict`: a key is a promise about one specific request, so a changed body is a client bug rather than a retry. Keys are scoped to the calling organization (or to the user, for account-scoped tokens), so one tenant can never read another's stored response.\n\nA `5xx`, `408` or `429` is never stored, because those describe a request that produced no settled answer and the next attempt with the same key must run for real. A `4xx` is stored: it is the server's settled answer about this exact request.\n\nUse a fresh UUID per logical operation. The PgBeam SDKs generate one per call and reuse it across their own automatic retries."
             }
         ],
         "requestBodyType": "{ body: string; org_id: string; severity?: number; title: string }",
@@ -2075,6 +2678,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique support case identifier (prefixed, e.g. sc_xxx)."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -2129,6 +2739,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique support case identifier (prefixed, e.g. sc_xxx)."
+            },
+            {
+                "name": "Idempotency-Key",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Client-generated key that makes a retry of this request safe. The first request carrying a given key executes normally and its response (status, content type and body) is stored for 24 hours; a later request with the same key returns that stored response without running the operation again, so a retry after a lost or timed-out response cannot create a second resource.\n\nReusing a key with a different request body returns `409 Conflict`: a key is a promise about one specific request, so a changed body is a client bug rather than a retry. Keys are scoped to the calling organization (or to the user, for account-scoped tokens), so one tenant can never read another's stored response.\n\nA `5xx`, `408` or `429` is never stored, because those describe a request that produced no settled answer and the next attempt with the same key must run for real. A `4xx` is stored: it is the server's settled answer about this exact request.\n\nUse a fresh UUID per logical operation. The PgBeam SDKs generate one per call and reuse it across their own automatic retries."
             }
         ],
         "requestBodyType": "{ body: string }",
@@ -2175,6 +2792,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "End date (inclusive, YYYY-MM-DD)."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -2209,6 +2833,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "End date (inclusive, YYYY-MM-DD)."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -2243,6 +2874,13 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": false,
                 "type": "string",
                 "description": "Return entries strictly older than this timestamp (cursor / upper bound)."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
@@ -2277,11 +2915,18 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": false,
                 "type": "string",
                 "description": "Opaque token for cursor-based pagination."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
         "requestBodyRequired": false,
-        "responseType": "{ next_page_token?: string; webhooks: ({ created_at: string; description?: string; enabled: boolean; event_types?: string[]; format: \"json\" | \"splunk_hec\" | \"datadog\" | \"elastic\"; id: string; project_id: string; updated_at: string; url: string })[] }",
+        "responseType": "{ next_page_token?: string; webhooks: ({ created_at: string; description?: string; enabled: boolean; event_types?: (\"query_blocked\" | \"budget_exhausted\" | \"kill_switch\" | \"masked\" | \"migration_flagged\" | \"approval_requested\" | \"anomaly_alert\" | \"canary_tripped\" | \"audit_checkpoint\" | \"webhook.test\")[]; format: \"json\" | \"splunk_hec\" | \"datadog\" | \"elastic\"; id: string; project_id: string; updated_at: string; url: string })[] }",
         "responseStatus": "200"
     },
     "createWebhookEndpoint": {
@@ -2297,11 +2942,18 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique project identifier (prefixed, e.g. prj_xxx)."
+            },
+            {
+                "name": "Idempotency-Key",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Client-generated key that makes a retry of this request safe. The first request carrying a given key executes normally and its response (status, content type and body) is stored for 24 hours; a later request with the same key returns that stored response without running the operation again, so a retry after a lost or timed-out response cannot create a second resource.\n\nReusing a key with a different request body returns `409 Conflict`: a key is a promise about one specific request, so a changed body is a client bug rather than a retry. Keys are scoped to the calling organization (or to the user, for account-scoped tokens), so one tenant can never read another's stored response.\n\nA `5xx`, `408` or `429` is never stored, because those describe a request that produced no settled answer and the next attempt with the same key must run for real. A `4xx` is stored: it is the server's settled answer about this exact request.\n\nUse a fresh UUID per logical operation. The PgBeam SDKs generate one per call and reuse it across their own automatic retries."
             }
         ],
-        "requestBodyType": "{ description?: string; enabled?: boolean; event_types?: string[]; format?: \"json\" | \"splunk_hec\" | \"datadog\" | \"elastic\"; secret?: string; url: string }",
+        "requestBodyType": "{ description?: string; enabled?: boolean; event_types?: (\"query_blocked\" | \"budget_exhausted\" | \"kill_switch\" | \"masked\" | \"migration_flagged\" | \"approval_requested\" | \"anomaly_alert\" | \"canary_tripped\" | \"audit_checkpoint\" | \"webhook.test\")[]; format?: \"json\" | \"splunk_hec\" | \"datadog\" | \"elastic\"; secret?: string; url: string }",
         "requestBodyRequired": true,
-        "responseType": "{ created_at: string; description?: string; enabled: boolean; event_types?: string[]; format: \"json\" | \"splunk_hec\" | \"datadog\" | \"elastic\"; id: string; project_id: string; updated_at: string; url: string }",
+        "responseType": "{ created_at: string; description?: string; enabled: boolean; event_types?: (\"query_blocked\" | \"budget_exhausted\" | \"kill_switch\" | \"masked\" | \"migration_flagged\" | \"approval_requested\" | \"anomaly_alert\" | \"canary_tripped\" | \"audit_checkpoint\" | \"webhook.test\")[]; format: \"json\" | \"splunk_hec\" | \"datadog\" | \"elastic\"; id: string; project_id: string; updated_at: string; url: string }",
         "responseStatus": "201"
     },
     "getWebhookEndpoint": {
@@ -2324,11 +2976,18 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique webhook endpoint identifier (prefixed, e.g. whk_xxx)."
+            },
+            {
+                "name": "If-None-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the client already holds, taken from the `ETag` of an earlier response. When it still matches the current representation the server answers `304 Not Modified` with no body, so a poll that finds nothing changed costs a round trip rather than a transfer.\n\nA comma-separated list is accepted, and `*` matches any current representation."
             }
         ],
         "requestBodyType": "",
         "requestBodyRequired": false,
-        "responseType": "{ created_at: string; description?: string; enabled: boolean; event_types?: string[]; format: \"json\" | \"splunk_hec\" | \"datadog\" | \"elastic\"; id: string; project_id: string; updated_at: string; url: string }",
+        "responseType": "{ created_at: string; description?: string; enabled: boolean; event_types?: (\"query_blocked\" | \"budget_exhausted\" | \"kill_switch\" | \"masked\" | \"migration_flagged\" | \"approval_requested\" | \"anomaly_alert\" | \"canary_tripped\" | \"audit_checkpoint\" | \"webhook.test\")[]; format: \"json\" | \"splunk_hec\" | \"datadog\" | \"elastic\"; id: string; project_id: string; updated_at: string; url: string }",
         "responseStatus": "200"
     },
     "updateWebhookEndpoint": {
@@ -2351,11 +3010,18 @@ export { o as operationsByPath, a as operationsByTag } from './operations-map.ge
                 "required": true,
                 "type": "string",
                 "description": "Unique webhook endpoint identifier (prefixed, e.g. whk_xxx)."
+            },
+            {
+                "name": "If-Match",
+                "in": "header",
+                "required": false,
+                "type": "string",
+                "description": "Entity tag the write is based on, taken from the `ETag` of the read that produced the values being sent. The write proceeds only if it still matches the current representation; otherwise it is refused with `412 Precondition Failed` and nothing is changed.\n\nThis is what makes a read-modify-write safe. Without it the last writer wins and a concurrent edit is silently discarded, which is the failure an agent is most likely to cause and least likely to notice. The `412` response carries the current `ETag`, so a caller can re-read, re-apply its change and retry.\n\nOmitting the header keeps the old unconditional behaviour. `*` matches any current representation, which asserts only that the resource exists."
             }
         ],
-        "requestBodyType": "{ description?: string; enabled?: boolean; event_types?: string[]; format?: \"json\" | \"splunk_hec\" | \"datadog\" | \"elastic\"; secret?: string; url: string }",
+        "requestBodyType": "{ description?: string; enabled?: boolean; event_types?: (\"query_blocked\" | \"budget_exhausted\" | \"kill_switch\" | \"masked\" | \"migration_flagged\" | \"approval_requested\" | \"anomaly_alert\" | \"canary_tripped\" | \"audit_checkpoint\" | \"webhook.test\")[]; format?: \"json\" | \"splunk_hec\" | \"datadog\" | \"elastic\"; secret?: string; url: string }",
         "requestBodyRequired": true,
-        "responseType": "{ created_at: string; description?: string; enabled: boolean; event_types?: string[]; format: \"json\" | \"splunk_hec\" | \"datadog\" | \"elastic\"; id: string; project_id: string; updated_at: string; url: string }",
+        "responseType": "{ created_at: string; description?: string; enabled: boolean; event_types?: (\"query_blocked\" | \"budget_exhausted\" | \"kill_switch\" | \"masked\" | \"migration_flagged\" | \"approval_requested\" | \"anomaly_alert\" | \"canary_tripped\" | \"audit_checkpoint\" | \"webhook.test\")[]; format: \"json\" | \"splunk_hec\" | \"datadog\" | \"elastic\"; id: string; project_id: string; updated_at: string; url: string }",
         "responseStatus": "200"
     },
     "deleteWebhookEndpoint": {