@anvailabs/proximadb-client 0.3.0

package/src/generated/schema.ts

@@ -0,0 +1,4271 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+
+export interface paths {
+    "/api/v2/collections": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List collections.
+         * @description List all collections with pagination.
+         *
+         *     ## Query Parameters
+         *
+         *     - `limit`: Maximum number of collections to return (default: 100)
+         *     - `offset`: Offset for pagination (default: 0)
+         *     - `include_stats`: Whether to include collection statistics
+         *
+         *     ## Response
+         *
+         *     Returns [`ListCollectionsV2Response`] with collection list.
+         *
+         *     ## Errors
+         *
+         *     - `500 Internal Server Error`: List operation failed
+         */
+        get: operations["listCollections"];
+        put?: never;
+        /**
+         * Create a collection with optional schema.
+         * @description Create a new collection with optional schema support.
+         *
+         *     ## Request Body
+         *
+         *     See [`CreateCollectionV2Request`] for the expected JSON format.
+         *
+         *     ## Response
+         *
+         *     Returns [`CreateCollectionV2Response`] with collection details.
+         *
+         *     ## Errors
+         *
+         *     - `400 Bad Request`: Invalid request or schema
+         *     - `409 Conflict`: Collection already exists
+         *     - `500 Internal Server Error`: Creation failed
+         */
+        post: operations["createCollection"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/collections/{collection_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get collection details.
+         * @description Get collection details including schema and statistics.
+         *
+         *     ## Path Parameters
+         *
+         *     - `collection_id`: Collection name/ID
+         *
+         *     ## Response
+         *
+         *     Returns [`CollectionV2Response`] with collection details.
+         *
+         *     ## Errors
+         *
+         *     - `404 Not Found`: Collection does not exist
+         *     - `500 Internal Server Error`: Retrieval failed
+         */
+        get: operations["getCollection"];
+        put?: never;
+        post?: never;
+        /**
+         * Delete a collection.
+         * @description Delete a collection by ID/name. This v2 route keeps SDK lifecycle methods on
+         *     the ProximaRecord-era API while delegating to the existing collection control
+         *     plane.
+         */
+        delete: operations["deleteCollection"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/collections/{collection_id}/documents": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Ingest documents for native server-side embedding.
+         * @description Canonical document-ingest surface (ADR-041, spec-driven-primary). Body `{records:[{id,text,metadata}]}`; the server embeds `text` natively under `X-Embed-Source=native` (default) when no per-record `vector` is supplied. `X-Tenant-ID` scopes records to a tenant; `X-Ingest-Mode` carries the billing mode.
+         */
+        post: operations["ingestDocuments"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/collections/{collection_id}/entities": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["upsert_entity_v2"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/collections/{collection_id}/entities/search": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["search_entities_v2"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/collections/{collection_id}/entities/{entity_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["get_entity_v2"];
+        put?: never;
+        post?: never;
+        delete: operations["delete_entity_v2"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/collections/{collection_id}/records/batch": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Insert or upsert ProximaRecord batches.
+         * @description Insert ProximaRecords into a collection with typed field support.
+         *
+         *     ## Request Body
+         *
+         *     See [`InsertRecordsRequest`] for the expected JSON format.
+         *
+         *     ## Response
+         *
+         *     Returns [`InsertRecordsResponse`] with counts and any errors.
+         *
+         *     ## Errors
+         *
+         *     - `400 Bad Request`: Invalid request format or validation error
+         *     - `404 Not Found`: Collection does not exist
+         *     - `500 Internal Server Error`: Storage or processing error
+         */
+        post: operations["insertRecords"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/collections/{collection_id}/records/scan": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Paginated scan of records in a collection.
+         * @description Returns the next page of records (TD-099 acceptance 2 + 3, live).
+         *     Cursor-based pagination: pass the response's `next_cursor` back as
+         *     `cursor` to fetch the next page; a `null` cursor means the scan is
+         *     exhausted. Cursors are minted and validated against the caller-facing
+         *     collection id in the URL path, expire after 24h (HTTP 410), and reject
+         *     cross-collection reuse (HTTP 400).
+         */
+        post: operations["scanRecords"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/collections/{collection_id}/records/{record_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get a record by ID.
+         * @description Get a single record by ID.
+         *
+         *     ## Path Parameters
+         *
+         *     - `collection_id`: Collection name/ID
+         *     - `record_id`: Record ID
+         *
+         *     ## Query Parameters
+         *
+         *     - `include_vector`: Whether to include the vector (default: true)
+         *     - `include_text`: Whether to include TEXT fields (default: false)
+         *
+         *     ## Response
+         *
+         *     Returns [`RecordV2Response`] with record details.
+         *
+         *     ## Errors
+         *
+         *     - `404 Not Found`: Collection or record does not exist
+         *     - `500 Internal Server Error`: Retrieval failed
+         */
+        get: operations["getRecord"];
+        put?: never;
+        post?: never;
+        /**
+         * Delete a record by ID.
+         * @description Delete a single record by writing a tombstone through the rich record path.
+         */
+        delete: operations["deleteRecord"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/collections/{collection_id}/schema": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get collection schema.
+         * @description Retrieve the schema definition for a collection.
+         *
+         *     ## Path Parameters
+         *
+         *     - `collection_id`: Collection name/ID
+         *
+         *     ## Response
+         *
+         *     Returns [`SchemaResponse`] with full schema details.
+         *
+         *     ## Errors
+         *
+         *     - `404 Not Found`: Collection or schema does not exist
+         *     - `500 Internal Server Error`: Retrieval failed
+         */
+        get: operations["getCollectionSchema"];
+        /**
+         * Update collection schema.
+         * @description Update the schema for a collection.
+         *
+         *     ## Path Parameters
+         *
+         *     - `collection_id`: Collection name/ID
+         *
+         *     ## Request Body
+         *
+         *     See [`UpdateSchemaRequest`] for the expected JSON format.
+         *
+         *     ## Response
+         *
+         *     Returns [`UpdateSchemaResponse`] with change details.
+         *
+         *     ## Schema Evolution
+         *
+         *     Schema updates must follow evolution rules to maintain data compatibility.
+         *     See [`UpdateSchemaRequest`] for detailed rules.
+         *
+         *     ## Errors
+         *
+         *     - `400 Bad Request`: Invalid schema or evolution violation
+         *     - `404 Not Found`: Collection does not exist
+         *     - `409 Conflict`: Incompatible schema change
+         *     - `500 Internal Server Error`: Update failed
+         */
+        put: operations["updateCollectionSchema"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/collections/{collection_id}/search": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Search records with vector similarity and typed filters.
+         * @description Search a collection with typed filters.
+         *
+         *     ## Request Body
+         *
+         *     See [`TypedSearchRequest`] for the expected JSON format.
+         *
+         *     ## Response
+         *
+         *     Returns [`TypedSearchResponse`] with ranked results.
+         *
+         *     ## Errors
+         *
+         *     - `400 Bad Request`: Invalid request format or filter error
+         *     - `404 Not Found`: Collection does not exist
+         *     - `500 Internal Server Error`: Search execution error
+         */
+        post: operations["searchRecords"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/graphs/{graph_id}/fusion-search": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** `POST /api/v2/graphs/{graph_id}/fusion-search` — vector seed → graph expand → calibrated fuse-by-oid. */
+        post: operations["fusion_search_v2"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/graphs/{graph_id}/impact-analysis": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * `POST /api/v2/graphs/{graph_id}/impact-analysis` — forward/backward blast radius (TD-131). The
+         *     server-side baseline for the embedded-parity gate; mirrors `GraphOperationsService::impact_analysis`.
+         */
+        post: operations["impact_analysis_v2"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/model-registries": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["listModelRegistries"];
+        put?: never;
+        post: operations["createModelRegistry"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/model-registries/{name}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getModelRegistry"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/model-registries/{name}/mutations": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["applyModelRegistryMutation"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/model-registries/{name}/resolve": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["resolveModelAlias"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Execute AQL or UQL through the shared query facade.
+         * @description The canonical unified query surface: UQL (unified multi-modal), federated SQL
+         *     extensions, and AQL. This is NOT plain SQL-over-REST and is NOT deprecated:
+         *     UQL/AQL are non-SQL languages that pgwire and `/api/v2/sql` cannot serve, so
+         *     this endpoint remains their canonical home. Authenticated programmatic SQL
+         *     is available through both gRPC `ExecuteQuery` and `/api/v2/sql`; neither is a
+         *     replacement for this UQL/federated surface.
+         */
+        post: operations["executeQuery"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/query/explain": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Explain an AQL or UQL query through the shared query facade. */
+        post: operations["explainQuery"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/sql": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Execute one authenticated SQL statement.
+         * @description The required foundation identity is inserted by the root tenant middleware
+         *     after authentication. A router mounted without that middleware fails closed
+         *     at extraction instead of constructing an anonymous authorization carrier.
+         */
+        post: operations["executeSql"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/health": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get server health. */
+        get: operations["getHealth"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/health/live": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Kubernetes liveness probe. */
+        get: operations["getLiveness"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/health/ready": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Kubernetes readiness probe. */
+        get: operations["getReadiness"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/_meta/capabilities": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Negotiate server capabilities.
+         * @description Advertises API version, supported features, limits, and the error- envelope contract so SDKs can adapt instead of hard-coding assumptions.
+         */
+        get: operations["getCapabilities"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/graphs": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List graph collections. */
+        get: operations["listGraphs"];
+        put?: never;
+        /** Create a graph collection. */
+        post: operations["createGraph"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/graphs/{graph_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                graph_id: components["parameters"]["GraphId"];
+            };
+            cookie?: never;
+        };
+        /** Get a graph collection by id. */
+        get: operations["getGraph"];
+        put?: never;
+        post?: never;
+        /** Delete a graph collection. */
+        delete: operations["deleteGraph"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/graphs/{graph_id}/nodes": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                graph_id: components["parameters"]["GraphId"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Create a node in a graph. */
+        post: operations["createNode"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/graphs/{graph_id}/nodes/{node_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                graph_id: components["parameters"]["GraphId"];
+                node_id: components["parameters"]["NodeId"];
+            };
+            cookie?: never;
+        };
+        /** Get a node by id. */
+        get: operations["getNode"];
+        put?: never;
+        post?: never;
+        /** Delete a node by id. */
+        delete: operations["deleteNode"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/graphs/{graph_id}/edges": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                graph_id: components["parameters"]["GraphId"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Create an edge in a graph. */
+        post: operations["createEdge"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/graphs/{graph_id}/nodes/batch": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                graph_id: components["parameters"]["GraphId"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Create multiple nodes in a single call.
+         * @description Batch counterpart to `createNode`. Use this on bulk-ingest paths
+         *     where individual round-trips would dominate latency.
+         */
+        post: operations["batchCreateNodes"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/graphs/{graph_id}/edges/batch": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                graph_id: components["parameters"]["GraphId"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Create multiple edges in a single call.
+         * @description Batch counterpart to `createEdge`.
+         */
+        post: operations["batchCreateEdges"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/graphs/{graph_id}/traverse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                graph_id: components["parameters"]["GraphId"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Traverse a graph from a start node. */
+        post: operations["traverseGraph"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/graphs/{graph_id}/stats": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                graph_id: components["parameters"]["GraphId"];
+            };
+            cookie?: never;
+        };
+        /** Get graph statistics. */
+        get: operations["getGraphStats"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/hybrid/search": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** BM25 + vector hybrid (fusion) search. */
+        post: operations["hybridSearch"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/hybrid/index": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Index documents for BM25 full-text search. */
+        post: operations["hybridIndex"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/document-collections": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List document collections. */
+        get: operations["listDocumentCollections"];
+        put?: never;
+        /** Create a document collection. */
+        post: operations["createDocumentCollection"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/document-collections/{collection}/documents": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                collection: string;
+            };
+            cookie?: never;
+        };
+        /** Query documents. */
+        get: operations["queryDocuments"];
+        put?: never;
+        /** Insert a document. */
+        post: operations["insertDocument"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/observability/namespaces/{namespace}/logs": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                namespace: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Ingest a log entry. */
+        post: operations["ingestLog"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/observability/namespaces/{namespace}/logs/search": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                namespace: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Query logs. */
+        post: operations["queryLogs"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        ApplyModelRegistryMutationRequest: {
+            /**
+             * Format: int64
+             * @description Optimistic concurrency token returned by the previous read or mutation.
+             */
+            expected_revision: number;
+            /** @description Command-shaped mutation; whole-registry replacement is intentionally unsupported. */
+            mutation: components["schemas"]["CatalogModelRegistryMutation"];
+        };
+        /** @description Content-addressed reference to bytes held outside xCatalog. */
+        CatalogArtifactDescriptor: {
+            uri: string;
+            digest: string;
+            /** Format: int64 */
+            size_bytes: number;
+            media_type: string;
+        };
+        /** @description Mutable serving intent that always resolves to an immutable version/digest. */
+        CatalogDeploymentBinding: {
+            name: string;
+            /** Format: int64 */
+            version: number;
+            artifact_digest: string;
+            runtime: string;
+            endpoint: string;
+            /** Format: int64 */
+            updated_at_ms: number;
+        };
+        CatalogDimensionPolicy: "fixed" | "discrete" | {
+            range: components["schemas"]["CatalogDimensionRange"];
+        };
+        CatalogDimensionRange: {
+            /** Format: int32 */
+            minimum: number;
+        };
+        /** @description Exact rendered-input and tokenizer budget consumed by an embedding runtime. */
+        CatalogEmbeddingInputContract: {
+            model_revision: string;
+            tokenizer_id: string;
+            tokenizer_revision: string;
+            tokenizer_fingerprint: string;
+            /** Format: int32 */
+            declared_context_limit: number;
+            /** Format: int32 */
+            effective_context_limit: number;
+            /** Format: int32 */
+            special_token_count: number;
+            document_template: string;
+            query_template: string;
+            document_parameters?: {
+                [key: string]: string;
+            };
+            query_parameters?: {
+                [key: string]: string;
+            };
+        };
+        /**
+         * @description Registered embedding model: immutable versions plus separately mutable or
+         *     append-only lifecycle records.
+         */
+        CatalogEmbeddingModelRegistry: {
+            /** Format: int32 */
+            schema_version: number;
+            /**
+             * Format: int64
+             * @description Optimistic concurrency token for catalog/API mutations. Old rows default
+             *     to zero; every successful command increments it.
+             */
+            revision?: number;
+            name: string;
+            versions?: {
+                [key: string]: components["schemas"]["CatalogEmbeddingModelVersion"];
+            };
+            aliases?: {
+                [key: string]: number;
+            };
+            evidence?: components["schemas"]["CatalogEvaluationEvidence"][];
+            decisions?: components["schemas"]["CatalogModelDecision"][];
+            deployments?: {
+                [key: string]: components["schemas"]["CatalogDeploymentBinding"];
+            };
+            tags?: {
+                [key: string]: string;
+            };
+        };
+        /** @description Immutable executable contract for one registered model version. */
+        CatalogEmbeddingModelVersion: {
+            /** Format: int64 */
+            version: number;
+            provider_model_id: string;
+            artifact: components["schemas"]["CatalogArtifactDescriptor"];
+            input: components["schemas"]["CatalogEmbeddingInputContract"];
+            output: components["schemas"]["CatalogEmbeddingOutputContract"];
+            governance?: components["schemas"]["CatalogModelGovernance"];
+            lineage?: components["schemas"]["CatalogModelLineage"];
+            /** Format: int64 */
+            created_at_ms: number;
+            source_run_id?: string | null;
+        };
+        CatalogEmbeddingOutputContract: {
+            /** Format: int32 */
+            native_dimension: number;
+            dimension_policy: components["schemas"]["CatalogDimensionPolicy"];
+            supported_dimensions: number[];
+            normalized: boolean;
+            pooling: string;
+        };
+        /** @description Append-only evaluation summary. Large row-level results remain external. */
+        CatalogEvaluationEvidence: {
+            evidence_id: string;
+            /** Format: int64 */
+            version: number;
+            dataset_name: string;
+            dataset_digest: string;
+            evaluator: string;
+            metrics: {
+                [key: string]: number;
+            };
+            /** Format: int64 */
+            created_at_ms: number;
+        };
+        /** @description Digest-pinned input consumed by the execution that produced a model. */
+        CatalogLineageInput: {
+            kind: components["schemas"]["CatalogLineageInputKind"];
+            name: string;
+            digest: string;
+        };
+        /** @enum {string} */
+        CatalogLineageInputKind: "dataset" | "feature_set" | "model" | "artifact";
+        /** @enum {string} */
+        CatalogModelAccess: "open" | "gated" | "unreviewed";
+        CatalogModelAliasMutation: {
+            alias: string;
+            /** Format: int64 */
+            version: number;
+        };
+        /** @description Append-only policy/audit decision, intentionally separate from evidence. */
+        CatalogModelDecision: {
+            decision_id: string;
+            /** Format: int64 */
+            version: number;
+            decision: components["schemas"]["CatalogModelDecisionKind"];
+            evidence_ids: string[];
+            principal: string;
+            /** Format: int64 */
+            created_at_ms: number;
+        };
+        /** @enum {string} */
+        CatalogModelDecisionKind: "approved" | "rejected" | "deprecated";
+        /**
+         * @description Supply-chain and runtime policy declared for an immutable model version.
+         *     Approval decisions remain separate append-only audit records.
+         */
+        CatalogModelGovernance: {
+            license_id?: string;
+            access?: components["schemas"]["CatalogModelAccess"];
+            requires_remote_code?: boolean;
+            approved_runtimes?: string[];
+        };
+        /** @description MLMD/OpenLineage-shaped producer execution and its declared inputs. */
+        CatalogModelLineage: {
+            producer_execution_id?: string | null;
+            code_revision?: string | null;
+            inputs?: components["schemas"]["CatalogLineageInput"][];
+        };
+        /**
+         * @description Command-shaped mutations preserve version/evidence/decision immutability at
+         *     the persistence boundary. API adapters lower into these commands instead
+         *     of replacing a whole registry document.
+         */
+        CatalogModelRegistryMutation: {
+            payload: components["schemas"]["CatalogEmbeddingModelVersion"];
+            /** @enum {string} */
+            operation: "register_version";
+        } | {
+            payload: components["schemas"]["CatalogModelAliasMutation"];
+            /** @enum {string} */
+            operation: "set_alias";
+        } | {
+            payload: components["schemas"]["CatalogEvaluationEvidence"];
+            /** @enum {string} */
+            operation: "append_evidence";
+        } | {
+            payload: components["schemas"]["CatalogModelDecision"];
+            /** @enum {string} */
+            operation: "record_decision";
+        } | {
+            payload: components["schemas"]["CatalogDeploymentBinding"];
+            /** @enum {string} */
+            operation: "upsert_deployment";
+        };
+        /** @description Collection statistics for v2 API */
+        CollectionStatsV2: {
+            /**
+             * Format: int64
+             * @description Total number of records, or `null` when the server does not know.
+             *
+             *     `null` is a real answer here, not a gap. The counter is maintained by
+             *     `MetadataStore::update_stats`, which the record write path does not call,
+             *     so a collection that has never had stats written carries none. Reporting
+             *     `0` in that case is a *confident wrong answer* — indistinguishable from a
+             *     genuinely empty collection, and it cost one downstream project a false
+             *     durability bug report before the cause was found (#1527).
+             */
+            record_count?: number | null;
+            /**
+             * Format: int64
+             * @description Total storage size in bytes
+             */
+            storage_size_bytes: number;
+            /**
+             * Format: int32
+             * @description Number of indexed fields
+             */
+            indexed_fields: number;
+            /**
+             * Format: int32
+             * @description Number of TEXT fields with dedicated storage
+             */
+            text_field_count: number;
+        };
+        /** @description Collection details response */
+        CollectionV2Response: {
+            /** @description Collection ID */
+            collection_id: string;
+            /** @description Collection name */
+            name: string;
+            /**
+             * Format: int32
+             * @description Vector dimension
+             */
+            dimension: number;
+            /** @description Storage engine */
+            engine: string;
+            /** @description Distance metric */
+            distance_metric: string;
+            /** @description Whether ProximaRecord is enabled */
+            proxima_record_enabled: boolean;
+            /**
+             * @description Canonical embedding precision label for stored vectors.
+             *
+             *     Stable string matching the proto `EmbeddingPrecision::as_str_name()`
+             *     (e.g. "EMBEDDING_PRECISION_FP16"). `None` when the collection didn't
+             *     set a non-default (Unspecified/Fp32) precision.
+             */
+            canonical_embedding_precision?: string | null;
+            schema?: null | components["schemas"]["SchemaDefinition"];
+            /** @description Collection statistics */
+            stats: components["schemas"]["CollectionStatsV2"];
+            /**
+             * Format: int64
+             * @description Monotonic server-owned content revision for cache revalidation.
+             */
+            content_revision: number;
+            /** @description Opaque validator that also fences server restarts. */
+            content_revision_token: string;
+            /**
+             * @description Per-index config (HNSW/IVF params, is_primary) as persisted at create
+             *     time. Mirrors the gRPC-v2 `GetCollection` `index_specs` (TD-122 parity).
+             */
+            index_specs: components["schemas"]["IndexSpecOutput"][];
+            quantization?: null | components["schemas"]["QuantizationConfigOutput"];
+            /** @description Creation timestamp */
+            created_at: string;
+            /** @description Last update timestamp */
+            updated_at?: string | null;
+        };
+        /** @description Summary of a collection for list operations */
+        CollectionV2Summary: {
+            /** @description Collection ID */
+            collection_id: string;
+            /** @description Collection name */
+            name: string;
+            /**
+             * Format: int32
+             * @description Vector dimension
+             */
+            dimension: number;
+            /** @description Storage engine */
+            engine: string;
+            /** @description Whether ProximaRecord is enabled */
+            proxima_record_enabled: boolean;
+            /**
+             * Format: int64
+             * @description Record count (if include_stats is true)
+             */
+            record_count?: number | null;
+        };
+        /**
+         * @description Request to create a collection with schema support
+         *
+         *     ## Example JSON
+         *
+         *     ```json
+         *     {
+         *         "name": "products",
+         *         "dimension": 768,
+         *         "engine": "sst",
+         *         "schema": {
+         *             "columns": [
+         *                 {"name": "category", "data_type": "text", "indexed": true},
+         *                 {"name": "price", "data_type": "float", "filterable": true},
+         *                 {"name": "description", "data_type": "text", "max_length": 10000}
+         *             ],
+         *             "enforcement": "hybrid",
+         *             "allow_additional_fields": true
+         *         },
+         *         "enable_proxima_record": true
+         *     }
+         *     ```
+         */
+        CreateCollectionV2Request: {
+            /** @description Collection name (required) */
+            name: string;
+            /**
+             * Format: int32
+             * @description Vector dimension (required)
+             */
+            dimension: number;
+            /**
+             * @description Storage engine selection
+             *
+             *     Options: "auto", "sst", "helix", "viper", "swift", "nova", "raptor", "tst"
+             *     Default: "auto" (system selects optimal engine)
+             */
+            engine?: string | null;
+            schema?: null | components["schemas"]["SchemaDefinition"];
+            /**
+             * @description Enable ProximaRecord support for this collection
+             *
+             *     When enabled:
+             *     - Records can use rich props and text_fields
+             *     - Schema validation is applied at insert time
+             *     - TEXT columns are stored in dedicated columnar format
+             *
+             *     Default: false (backward compatible with v1)
+             */
+            enable_proxima_record?: boolean | null;
+            /**
+             * @description Distance metric for vector similarity
+             *
+             *     Options: "cosine", "euclidean", "dot_product"
+             *     Default: "cosine"
+             */
+            distance_metric?: string | null;
+            /**
+             * Format: int64
+             * @description Initial capacity hint for pre-allocation
+             */
+            initial_capacity?: number | null;
+            /**
+             * @description Canonical embedding precision for stored vectors
+             *
+             *     Options: "fp32" (default), "fp16", "bf16", "int8", "uint8".
+             *     Accepts the same string forms as the gRPC / Arrow Flight surfaces
+             *     (e.g. "half", "float16", "EMBEDDING_PRECISION_FP16"). The DDL
+             *     service applies the same normalisation, so SDKs and pgwire
+             *     converge on the same enum discriminant.
+             */
+            canonical_embedding_precision?: string | null;
+            /**
+             * @description Index configurations (e.g. an explicit IVF or HNSW index).
+             *
+             *     Restores v1 parity: the v1 proto create accepted `index_configs`, which
+             *     drive `active_algorithm_for` (e.g. an IVF index → recall-tune dispatches
+             *     to the IVF arm). When omitted, the engine selects a default (HNSW).
+             */
+            index_configs?: components["schemas"]["IndexConfigInput"][] | null;
+            /**
+             * @description Operator metadata tags, e.g. `"recall_target:0.95"`,
+             *     `"target_vector_count:1000"`, `"modalities:text,image"`. Consumed by the
+             *     recall advisor / route-health (`services/collection/recall_target.rs`).
+             */
+            tags?: string[] | null;
+            quantization?: null | components["schemas"]["QuantizationConfigInput"];
+            index_policy?: null | components["schemas"]["IndexPolicyInput"];
+        };
+        /** @description Response for collection creation */
+        CreateCollectionV2Response: {
+            /** @description Collection ID (same as name) */
+            collection_id: string;
+            /** @description Collection name */
+            name: string;
+            /**
+             * Format: int32
+             * @description Vector dimension
+             */
+            dimension: number;
+            /** @description Selected storage engine */
+            engine: string;
+            /** @description Whether ProximaRecord is enabled */
+            proxima_record_enabled: boolean;
+            /** @description Schema ID (if schema was defined) */
+            schema_id?: string | null;
+            /** @description Creation timestamp */
+            created_at: string;
+        };
+        CreateModelRegistryRequest: {
+            /** @description Tenant-local registry name. Must be one traversal-free catalog segment. */
+            name: string;
+        };
+        /** @description Response for deleting a collection through the v2 API. */
+        DeleteCollectionV2Response: {
+            /** @description Whether the delete request was accepted. */
+            success: boolean;
+            /** @description Deleted collection ID. */
+            collection_id: string;
+        };
+        /** @description Response for deleting a single record. */
+        DeleteRecordV2Response: {
+            /** @description Whether the delete tombstone was accepted. */
+            success: boolean;
+            /** @description Deleted record ID. */
+            id: string;
+            /**
+             * Format: int64
+             * @description Processing latency in microseconds.
+             */
+            processing_time_us: number;
+        };
+        EntityDto: {
+            id: string;
+            collection_id: string;
+            flexible_metadata: {
+                [key: string]: unknown;
+            };
+        };
+        EntityEmbeddingInput: {
+            model_id: string;
+            modality?: string | null;
+            vector: number[];
+            /** Format: int32 */
+            dimension?: number;
+        };
+        EntityProvenanceInput: {
+            source_id?: string;
+            chunk_id?: string;
+            /** Format: int32 */
+            chunk_position?: number;
+            extraction_method?: string;
+            metadata?: {
+                [key: string]: string;
+            };
+        };
+        EntityRelationInput: {
+            source_entity_id: string;
+            target_entity_id: string;
+            relation_type: string;
+            /** Format: float */
+            weight?: number;
+            properties?: {
+                [key: string]: string;
+            };
+        };
+        EntitySearchResult: {
+            entity: components["schemas"]["EntityDto"];
+            /** Format: float */
+            score: number;
+        };
+        /** @description Inner body of [`ErrorResponse`]. */
+        ErrorBody: {
+            /**
+             * @description Stable machine-readable error code (snake_case).
+             * @example collection_not_found
+             */
+            type: string;
+            message: string;
+            /**
+             * Format: int32
+             * @description HTTP status code.
+             */
+            code: number;
+            /** @description Correlation id (matches the X-Request-ID header). */
+            request_id?: string | null;
+            /** @description Optional structured context (e.g. migration hints). */
+            details?: Record<string, never> | null;
+        };
+        /**
+         * @description Canonical ProximaDB error envelope (`{ error: { type, message, code } }`).
+         *
+         *     `request_id` (also returned in the `X-Request-ID` response header) is present
+         *     whenever the request passed through the request-id middleware; quote it in
+         *     bug reports.
+         */
+        ErrorResponse: {
+            error: components["schemas"]["ErrorBody"];
+        };
+        ExplainQueryRequest: {
+            language: components["schemas"]["QueryLanguage"];
+            query: string;
+            collection?: string | null;
+        };
+        FusionHit: {
+            oid: string;
+            /** Format: float */
+            score: number;
+            source_count: number;
+            /**
+             * @description Graph node label(s) of the reached node. Exposed so cross-modal-joint
+             *     consumers can correlate a fused hit by its graph label without a separate
+             *     node lookup (#485). The expansion already reaches the node, so this is
+             *     near-free to fill. Additive + back-compat (empty until populated).
+             */
+            labels?: string[];
+        };
+        FusionSearchRequest: {
+            /** @description Vector collection to seed from (its records co-indexed with this graph by `oid`). */
+            vector_collection: string;
+            /** @description Query embedding for the ANN seed. */
+            query_vector: number[];
+            limit?: number;
+            /**
+             * Format: int32
+             * @description k-hop expansion depth (bounded; default 1 — the validated sweet spot).
+             */
+            max_depth?: number;
+            edge_types?: string[];
+            /** @description How many of the top vector seeds to expand from (bounded expansion). */
+            max_seeds?: number;
+            /** Format: float */
+            vector_weight?: number | null;
+            /** Format: float */
+            graph_weight?: number | null;
+            /** @description Use the rank-based RRF fallback instead of PIT-calibrated linear. */
+            rrf?: boolean;
+            /**
+             * Format: float
+             * @description Consensus boost added to any `oid` present in ≥2 sources.
+             */
+            consensus_beta?: number | null;
+            /** @description Graph contribution grain: `"nodes"` (default), `"edges"`, or `"both"`. */
+            grain?: string | null;
+            /**
+             * Format: float
+             * @description Cost-routing policy inputs (TD-141): drop negligible modalities (weight fraction) and budget each.
+             *     When absent, fusion is unbounded.
+             */
+            min_weight_fraction?: number | null;
+            total_budget?: number | null;
+            /**
+             * @description Optional BM25/full-text query (TD-138). When present (and non-empty), fusion also searches the
+             *     collection's document index and merges BM25 hits into the result by shared `oid` — tri-modal
+             *     (vector + graph + document) fusion. Absent ⇒ vector+graph only (unchanged).
+             */
+            text_query?: string | null;
+            /**
+             * @description Collection whose document index to BM25-search. Defaults to `vector_collection` (documents
+             *     co-indexed with the vectors share the record `oid`, so they merge by `oid`).
+             */
+            document_collection?: string | null;
+            /**
+             * Format: float
+             * @description Document modality weight (mirrors `vector_weight` / `graph_weight`). Defaults to 1.0.
+             */
+            document_weight?: number | null;
+        };
+        FusionSearchResponse: {
+            results: components["schemas"]["FusionHit"][];
+            stats: components["schemas"]["FusionStatsDto"];
+        };
+        FusionStatsDto: {
+            sources_fused: number;
+            sources_skipped: number;
+            candidates_in: number;
+            items_out: number;
+        };
+        /** @description REST input for HNSW index params (mirrors proto `HnswConfig`). */
+        HnswConfigInput: {
+            /** Format: int32 */
+            m?: number | null;
+            /** Format: int32 */
+            ef_construction?: number | null;
+            /** Format: int32 */
+            ef_search?: number | null;
+        };
+        /** @description REST output for HNSW params (mirrors gRPC `V2HnswConfig`). */
+        HnswConfigOutput: {
+            /** Format: int32 */
+            m?: number | null;
+            /** Format: int32 */
+            ef_construction?: number | null;
+            /** Format: int32 */
+            ef_search?: number | null;
+        };
+        ImpactAnalysisRequest: {
+            /** @description Start symbol node id. */
+            node_id: string;
+            /** @description `"forward"` (default — what X impacts) or `"backward"` (what impacts X). */
+            direction?: string | null;
+            edge_types?: string[];
+            /** Format: int32 */
+            max_depth?: number;
+            limit?: number;
+        };
+        ImpactAnalysisResponse: {
+            /** @description Reached node ids (canonical `oid` = `graph/{graph_id}/node/{id}`). */
+            node_ids: string[];
+            edge_count: number;
+            /** Format: int32 */
+            max_depth_reached: number;
+        };
+        /** @description REST input for a single index config (mirrors proto `IndexConfig`). */
+        IndexConfigInput: {
+            /** @description Optional index name (defaults to `index_<n>`). */
+            index_name?: string | null;
+            /** @description Algorithm: "hnsw", "ivf", "pq", "flat", "annoy", "lsh". */
+            algorithm: string;
+            /** @description Free-form algorithm parameters. */
+            parameters?: {
+                [key: string]: string;
+            };
+            hnsw_config?: null | components["schemas"]["HnswConfigInput"];
+            ivf_config?: null | components["schemas"]["IvfConfigInput"];
+            /** @description Mark this index as the collection's primary ANN index (gRPC-v2 parity). */
+            is_primary?: boolean | null;
+        };
+        /**
+         * @description REST input for the per-collection index routing policy (mirrors proto
+         *     `IndexPolicy`; ADR-028).
+         */
+        IndexPolicyInput: {
+            /**
+             * @description Routing mode: "auto" (default) | "exact" | "ivf" | "hnsw" | "helix".
+             *     "auto"/omitted ⇒ cost-derived. "exact" ⇒ always brute-force (no index).
+             *     The engine modes force the collection onto that engine/route.
+             */
+            mode?: string | null;
+            /**
+             * @description Cold-start index warming: "auto" (default) | "eager" | "lazy" | "never".
+             *     Index/auto modes only — rejected when `mode = "exact"`.
+             */
+            rehydrate?: string | null;
+            /**
+             * Format: int64
+             * @description Exact-scan byte budget override (bytes). 0/omitted ⇒ cost-model default
+             *     for the storage class.
+             */
+            byte_budget?: number | null;
+            /**
+             * Format: int32
+             * @description nprobe override for index modes. 0/omitted ⇒ cost-derived. Rejected when
+             *     `mode = "exact"`.
+             */
+            nprobe?: number | null;
+        };
+        /** @description REST output for a single index config (mirrors gRPC `V2IndexSpec`). */
+        IndexSpecOutput: {
+            /** @description Algorithm: "hnsw" | "ivf" | "pq" | "flat" | "annoy" | "lsh". */
+            algorithm: string;
+            hnsw?: null | components["schemas"]["HnswConfigOutput"];
+            ivf?: null | components["schemas"]["IvfConfigOutput"];
+            /** @description Whether this is the collection's primary ANN index. */
+            is_primary: boolean;
+        };
+        /** @description A single record submitted for native embedding + indexing. */
+        IngestDocument: {
+            id: string;
+            /**
+             * @description Raw text content. Required when `X-Embed-Source: native` (default);
+             *     optional when the client also supplied a vector.
+             */
+            text?: string | null;
+            /**
+             * @description Optional client-provided vector. When present, the server skips
+             *     embedding for this record. Use case: SDK that already embedded
+             *     locally (legacy path).
+             */
+            vector?: number[] | null;
+            /** @description Arbitrary metadata fields. Stored as ProximaRecord props. */
+            metadata?: {
+                [key: string]: unknown;
+            };
+        };
+        IngestDocumentsRequest: {
+            records: components["schemas"]["IngestDocument"][];
+        };
+        IngestDocumentsResponse: {
+            mode: string;
+            records: components["schemas"]["IngestedRecord"][];
+            /** Format: int64 */
+            retry_after_ms?: number | null;
+        };
+        IngestedRecord: {
+            id: string;
+            /** Format: int32 */
+            dim: number;
+        };
+        /** @description Error details for a failed record insertion */
+        InsertError: {
+            /** @description Index of the record in the request */
+            index: number;
+            /** @description Record ID (if provided) */
+            id?: string | null;
+            /** @description Error message */
+            error: string;
+        };
+        /**
+         * @description Request to insert ProximaRecords
+         *
+         *     ## Example JSON
+         *
+         *     ```json
+         *     {
+         *         "records": [
+         *             {
+         *                 "id": "doc_1",
+         *                 "vector": [0.1, 0.2, 0.3],
+         *                 "props": {
+         *                     "category": "electronics",
+         *                     "price": 299.99,
+         *                     "in_stock": true
+         *                 },
+         *                 "text_fields": [
+         *                     {
+         *                         "name": "description",
+         *                         "content": "A detailed product description...",
+         *                         "storage_hint": "adaptive"
+         *                     }
+         *                 ],
+         *                 "source": "catalog_import"
+         *             }
+         *         ],
+         *         "validate_schema": true
+         *     }
+         *     ```
+         *     Not supported in v0.2: optimistic versioning, conditional-write predicates,
+         *     update-by-filter, delete-by-filter, and patch / partial-record update. The
+         *     live contract is exposed via `WriteContractHealth` on the route-health
+         *     diagnostic endpoint (`GET /api/v2/_diagnostics/collections/{id}/route-health`);
+         *     see also `docs/SUPPORTED_SURFACE.adoc` "Not Supported in v0.2".
+         */
+        InsertRecordsRequest: {
+            /** @description Records to insert */
+            records: components["schemas"]["ProximaRecordInput"][];
+            /** @description Whether to validate against collection schema (default: true) */
+            validate_schema?: boolean | null;
+            /**
+             * @description Whether existing records with the same ID should be replaced.
+             *
+             *     The current durable record write path is idempotent/upsert-oriented; this
+             *     field is accepted so SDKs can expose explicit upsert intent without
+             *     leaving the OpenAPI contract.
+             */
+            upsert?: boolean | null;
+        };
+        /** @description Response for insert operation */
+        InsertRecordsResponse: {
+            /** @description Number of successfully inserted records */
+            inserted_count: number;
+            /** @description Number of failed records */
+            failed_count: number;
+            /** @description Detailed errors for failed records */
+            errors: components["schemas"]["InsertError"][];
+            /** @description IDs of successfully inserted records */
+            inserted_ids: string[];
+        };
+        /** @description REST input for IVF index params (mirrors proto `IvfConfig`). */
+        IvfConfigInput: {
+            /** Format: int32 */
+            n_lists?: number | null;
+            /** Format: int32 */
+            n_probe?: number | null;
+        };
+        /** @description REST output for IVF params (mirrors gRPC `V2IvfConfig`). */
+        IvfConfigOutput: {
+            /** Format: int32 */
+            n_lists?: number | null;
+            /** Format: int32 */
+            n_probe?: number | null;
+        };
+        /** @description Response for listing collections */
+        ListCollectionsV2Response: {
+            /** @description List of collections */
+            collections: components["schemas"]["CollectionV2Summary"][];
+            /**
+             * Format: int64
+             * @description Total count of collections
+             */
+            total: number;
+            /**
+             * Format: int32
+             * @description Limit used in this request
+             */
+            limit: number;
+            /**
+             * Format: int32
+             * @description Offset used in this request
+             */
+            offset: number;
+            /** @description Whether there are more results */
+            has_more: boolean;
+        };
+        ListModelRegistriesResponse: {
+            registries: components["schemas"]["ModelRegistryRecordResponse"][];
+        };
+        /**
+         * @description REST uses a decimal string for stable catalog IDs so JavaScript clients do
+         *     not lose precision. gRPC exposes the same value as `uint64`.
+         */
+        ModelRegistryRecordResponse: {
+            tenant_id: string;
+            asset_id: string;
+            registry: components["schemas"]["CatalogEmbeddingModelRegistry"];
+        };
+        /**
+         * @description TD-064: predicate-aware recall shortfall (REST wire shape).
+         *
+         *     Mirrors `observability::search_plan_trace::PredicateShortfall` as an
+         *     explicit REST/OpenAPI schema so the field is typed and documented on the
+         *     wire without forcing the observability type (or the slim `IndexQueryResult`
+         *     DTO) to derive `ToSchema`.
+         */
+        PredicateShortfallWire: {
+            /**
+             * Format: int32
+             * @description The `top_k` value the caller asked for.
+             */
+            requested_k: number;
+            /**
+             * Format: int32
+             * @description Results actually returned after predicate filtering + merge.
+             */
+            returned_k: number;
+            /**
+             * Format: int32
+             * @description Candidate pool size considered before the predicate (oversample budget).
+             */
+            oversample_pool: number;
+            /**
+             * @description ADR-011 mode that produced the shortfall (`post_filter`, `inline`, or
+             *     `pre_filter`).
+             */
+            ann_filtering_mode: string;
+        };
+        /**
+         * @description Input format for ProximaRecord (JSON-friendly)
+         *
+         *     This is the JSON-serializable input format for ProximaRecord.
+         *     It uses serde_json::Value for typed fields to support dynamic typing
+         *     at the API boundary, with validation happening during conversion.
+         */
+        ProximaRecordInput: {
+            /** @description Record ID (optional, will be auto-generated if not provided) */
+            id?: string | null;
+            /** @description Vector embedding (required) */
+            vector: number[];
+            /** @description Canonical rich property map. */
+            props?: {
+                [key: string]: unknown;
+            } | null;
+            /** @description Dedicated TEXT fields with storage hints */
+            text_fields?: components["schemas"]["TextFieldInput"][] | null;
+        };
+        /**
+         * @description REST input for quantization config (mirrors proto `QuantizationConfig`;
+         *     gRPC-v2 parity with `V2QuantizationConfig`).
+         */
+        QuantizationConfigInput: {
+            /** @description Enable quantization for this collection. */
+            enabled?: boolean | null;
+            /** @description Strategy: "smart_defaults" (default) | "minimal" | "aggressive" | "custom_levels". */
+            strategy?: string | null;
+        };
+        /** @description REST output for quantization config (mirrors gRPC `V2QuantizationConfig`). */
+        QuantizationConfigOutput: {
+            enabled: boolean;
+            /** @description Strategy label, e.g. "smart_defaults" | "minimal" | "aggressive". */
+            strategy: string;
+        };
+        /** @enum {string} */
+        QueryLanguage: "uql" | "aql" | "federated";
+        QueryRequest: {
+            language: components["schemas"]["QueryLanguage"];
+            query: string;
+            parameters?: Record<string, never>[] | null;
+            collection?: string | null;
+            /** Format: int32 */
+            limit?: number | null;
+        };
+        /**
+         * @description Query facade result. Implementations return records, total_count, metrics,
+         *     plan, or diagnostics depending on language and endpoint, so the body is a
+         *     free-form JSON object.
+         */
+        QueryResponse: Record<string, never>;
+        /** @description Response for getting a single record */
+        RecordV2Response: {
+            /** @description Record ID */
+            id: string;
+            /** @description Vector embedding (if requested) */
+            vector?: number[] | null;
+            /** @description Rich properties from the record */
+            props: {
+                [key: string]: unknown;
+            };
+            /** @description TEXT fields (if include_text is true) */
+            text_fields?: components["schemas"]["TextFieldOutput"][] | null;
+            /**
+             * Format: int64
+             * @description Record version
+             */
+            version?: number | null;
+            /**
+             * Format: int64
+             * @description Record timestamp
+             */
+            timestamp?: number | null;
+        };
+        ResolveModelAliasRequest: {
+            alias: string;
+            /** Format: int32 */
+            dimension: number;
+            /** @description Runtime implementation that will execute the immutable contract. */
+            runtime?: string | null;
+            /** @description Require the latest append-only decision to approve the selected version. */
+            require_approved?: boolean;
+        };
+        ResolvedEmbeddingModelResponse: {
+            asset_id: string;
+            registry_name: string;
+            /** Format: int64 */
+            registry_revision: number;
+            contract_sha256: string;
+            model: components["schemas"]["CatalogEmbeddingModelVersion"];
+        };
+        ResolvedModelBindingResponse: {
+            model: string;
+            /** Format: int32 */
+            dimension: number;
+            model_asset_id: string;
+            /** Format: int64 */
+            model_version: number;
+            contract_sha256: string;
+            snapshot: components["schemas"]["ResolvedEmbeddingModelResponse"];
+        };
+        /** @description Column definition for schema */
+        RestColumnDefinition: {
+            /** @description Column name */
+            name: string;
+            /**
+             * @description Data type
+             *
+             *     Supported types:
+             *     - "text": Variable-length UTF-8 text
+             *     - "text_large": Large text with sidecar storage
+             *     - "integer": 64-bit signed integer
+             *     - "float": 64-bit floating point
+             *     - "decimal": 128-bit decimal (precision, scale)
+             *     - "boolean": True/false
+             *     - "timestamp": Microseconds since epoch
+             *     - "timestamp_tz": Timestamp with timezone
+             *     - "date": Days since epoch
+             *     - "time": Microseconds since midnight
+             *     - "uuid": RFC 4122 UUID
+             *     - "binary": Raw bytes
+             *     - "json": Validated JSON
+             *     - "array_text", "array_integer", "array_float", "array_boolean"
+             *     - "map_string_string", "map_string_any"
+             *     - "geo_point": Latitude/longitude point
+             *     - "vector": Fixed-dimension vector (specify dimension)
+             */
+            data_type: string;
+            /**
+             * @description Whether null values are allowed
+             *
+             *     Default: true
+             */
+            nullable?: boolean | null;
+            /**
+             * @description Create secondary index for this column
+             *
+             *     Improves query performance for equality/range filters.
+             *     Default: false
+             */
+            indexed?: boolean | null;
+            /**
+             * @description Enable filtering on this column
+             *
+             *     When true, the column can be used in WHERE clauses.
+             *     Default: true for indexed columns, false otherwise
+             */
+            filterable?: boolean | null;
+            /**
+             * Format: int32
+             * @description Maximum length for TEXT/BINARY columns
+             *
+             *     Default: no limit
+             */
+            max_length?: number | null;
+            /**
+             * Format: int32
+             * @description Precision for DECIMAL type (1-38)
+             */
+            precision?: number | null;
+            /**
+             * Format: int32
+             * @description Scale for DECIMAL type (0-precision)
+             */
+            scale?: number | null;
+            /**
+             * Format: int32
+             * @description Dimension for VECTOR type
+             */
+            vector_dimension?: number | null;
+        };
+        /**
+         * @description Body of `POST /records/scan`. Mirrors the OpenAPI `ScanRecordsRequest`
+         *     schema; all fields optional so an empty `{}` returns the first page.
+         */
+        ScanRecordsRequest: {
+            /**
+             * @description Opaque continuation token returned as `next_cursor` from a
+             *     prior page. Omit / null to start from the beginning.
+             */
+            cursor?: string | null;
+            /**
+             * Format: int32
+             * @description Max records to return in this page. Server enforces upper bound.
+             */
+            limit?: number | null;
+            /**
+             * @description Metadata filter applied (before the limit) to the scanned page.
+             *     Accepts either the typed list form `[{field,op,value}]` (mirrors
+             *     `searchRecords.filters`) or a simple equality map `{field: value}`.
+             */
+            filter?: unknown;
+            include_vector?: boolean | null;
+            include_text?: boolean | null;
+        };
+        /**
+         * @description Response shape for `scanRecords`. Empty `records` + null
+         *     `next_cursor` signals end-of-scan. Each record matches the OpenAPI
+         *     `RecordResponse` schema (same shape used by `getRecord`).
+         */
+        ScanRecordsResponse: {
+            records: components["schemas"]["RecordV2Response"][];
+            /** Format: int64 */
+            content_revision: number;
+            content_revision_token: string;
+            next_cursor?: string | null;
+            /** Format: int64 */
+            scanned_count?: number | null;
+        };
+        /** @description Description of a schema change */
+        SchemaChange: {
+            /** @description Type of change */
+            change_type: string;
+            /** @description Affected column (if applicable) */
+            column?: string | null;
+            /** @description Description of the change */
+            description: string;
+        };
+        /**
+         * @description Schema definition for a collection
+         *
+         *     Defines the typed columns and enforcement rules for ProximaRecord support.
+         */
+        SchemaDefinition: {
+            /** @description Column definitions */
+            columns: components["schemas"]["RestColumnDefinition"][];
+            /**
+             * @description Schema enforcement mode
+             *
+             *     - "strict": All columns must match schema exactly
+             *     - "flexible": Schema on read, no validation at insert
+             *     - "hybrid": Core columns enforced, additional fields allowed (default)
+             */
+            enforcement?: string | null;
+            /**
+             * @description Allow additional fields not defined in schema
+             *
+             *     Only applies in "hybrid" mode.
+             *     Default: true
+             */
+            allow_additional_fields?: boolean | null;
+        };
+        /** @description Schema response with metadata */
+        SchemaResponse: {
+            /** @description Schema ID (UUID) */
+            schema_id: string;
+            /** @description Schema version (semantic versioning) */
+            schema_version: string;
+            /** @description Collection this schema belongs to */
+            collection_id: string;
+            /** @description Schema definition */
+            schema: components["schemas"]["SchemaDefinition"];
+            /** @description Creation timestamp */
+            created_at: string;
+            /** @description Last update timestamp */
+            updated_at?: string | null;
+            /** @description Parent schema ID (for evolution tracking) */
+            parent_schema_id?: string | null;
+        };
+        SearchEntitiesRequest: {
+            /** @description Query embedding for vector similarity search. Omit for metadata-only search. */
+            query_vector?: number[];
+            /** @description Equality metadata filters as a `{field: value}` JSON object. */
+            filters?: {
+                [key: string]: unknown;
+            };
+            /** Format: int32 */
+            top_k?: number;
+        };
+        SearchEntitiesResponse: {
+            results: components["schemas"]["EntitySearchResult"][];
+            /** Format: int32 */
+            total: number;
+        };
+        /**
+         * @description One SQL statement executed through the shared SQL authority.
+         *
+         *     Parameter binding is intentionally not advertised yet: the relational
+         *     execution port currently has no typed binding contract. Callers must not be
+         *     offered a field that an adapter would silently ignore or interpolate.
+         */
+        SqlRequest: {
+            query: string;
+            /** @description Optional collection context used by vector/graph SQL extensions. */
+            collection?: string | null;
+            /**
+             * Format: int64
+             * @description Per-request deadline. Defaults to 30 seconds and is capped at 5 minutes.
+             */
+            timeout_ms?: number | null;
+        };
+        /**
+         * @description Stable JSON envelope for SQL reads and writes.
+         *
+         *     For reads, `rows_returned` is the row count. For DDL/DML, the shared SQL
+         *     authority reports the affected count in `rows_returned` and `rows` is empty.
+         */
+        SqlResponse: {
+            rows: Record<string, never>[];
+            columns: string[];
+            column_types: string[];
+            /** Format: int64 */
+            rows_returned: number;
+            /** Format: int64 */
+            rows_scanned: number;
+            /** Format: int64 */
+            execution_time_ms: number;
+            request_id: string;
+        };
+        /**
+         * @description Input format for TEXT fields
+         *
+         *     TEXT fields are stored in dedicated columns with optional chunking
+         *     for large content. The storage hint helps optimize storage strategy.
+         */
+        TextFieldInput: {
+            /** @description Field name */
+            name: string;
+            /** @description Text content */
+            content: string;
+            /**
+             * @description Storage strategy hint
+             *
+             *     - "inline": Store inline in main column (<4KB)
+             *     - "chunked": Split into chunks with embeddings (4KB-1MB)
+             *     - "sidecar": Store in separate sidecar file (>1MB)
+             *     - "adaptive": Auto-select based on content size (default)
+             */
+            storage_hint?: string | null;
+        };
+        /** @description Output format for TEXT fields */
+        TextFieldOutput: {
+            /** @description Field name */
+            name: string;
+            /** @description Text content (may be truncated for large content) */
+            content: string;
+            /**
+             * Format: int32
+             * @description Number of chunks (for chunked storage)
+             */
+            chunk_count?: number | null;
+            /** @description Whether content was truncated */
+            truncated: boolean;
+        };
+        /**
+         * @description A typed filter for search operations
+         *
+         *     Supports various comparison operators with type-safe values.
+         */
+        TypedFilter: {
+            /** @description Field name to filter on */
+            field: string;
+            /**
+             * @description Comparison operator
+             *
+             *     Supported operators:
+             *     - "eq": Equals
+             *     - "neq": Not equals
+             *     - "gt": Greater than
+             *     - "gte": Greater than or equal
+             *     - "lt": Less than
+             *     - "lte": Less than or equal
+             *     - "contains": String/array contains
+             *     - "between": Value is between two bounds (requires value_upper)
+             *     - "in": Value is in a list
+             *     - "starts_with": String starts with prefix
+             *     - "ends_with": String ends with suffix
+             */
+            op: string;
+            /** @description Filter value (type depends on field type) */
+            value: unknown;
+            /** @description Upper bound for "between" operator */
+            value_upper?: unknown;
+        };
+        /**
+         * @description Search request with typed filters
+         *
+         *     ## Example JSON
+         *
+         *     ```json
+         *     {
+         *         "vector": [0.1, 0.2, 0.3],
+         *         "top_k": 10,
+         *         "filters": [
+         *             {"field": "category", "op": "eq", "value": "electronics"},
+         *             {"field": "price", "op": "lt", "value": 500},
+         *             {"field": "in_stock", "op": "eq", "value": true}
+         *         ],
+         *         "include_text": true
+         *     }
+         *     ```
+         */
+        TypedSearchRequest: {
+            /** @description Query vector */
+            vector: number[];
+            /** @description Number of results to return */
+            top_k: number;
+            /** @description Typed filters with operator support */
+            filters?: components["schemas"]["TypedFilter"][] | null;
+            /**
+             * @description Whether to include TEXT fields in results (default: false)
+             *
+             *     TEXT fields can be large, so they are excluded by default.
+             *     Set to true to include them in the response.
+             */
+            include_text?: boolean | null;
+            /**
+             * @description Whether to include the vector in results (default: false)
+             *
+             *     Vector data can be large, so it is excluded by default.
+             */
+            include_vector?: boolean | null;
+            /**
+             * @description Return the SearchPlanTrace + a human-readable route explain
+             *     in the response (LLD §1 contract). Defaults to `false` so
+             *     non-debug requests don't pay the JSON serialization cost of
+             *     the ~30-field trace envelope.
+             */
+            debug?: boolean | null;
+        };
+        /** @description Search response with typed results */
+        TypedSearchResponse: {
+            /** @description Search results */
+            results: components["schemas"]["TypedSearchResult"][];
+            /**
+             * Format: int64
+             * @description Total number of matching documents (before top_k limit)
+             */
+            total_matches?: number | null;
+            /**
+             * Format: int64
+             * @description Search latency in milliseconds
+             */
+            latency_ms: number;
+            /** @description Request ID for tracing */
+            request_id: string;
+            predicate_shortfall?: null | components["schemas"]["PredicateShortfallWire"];
+            /**
+             * @description SearchPlanTrace (LLD §10) — the per-query telemetry envelope that
+             *     upstream gateways consume for metering and planner-v2 training.
+             *     Phase 0 emits a stub trace populated from request_id + latency; later
+             *     phases fill in the per-stage counters. Only emitted when the request
+             *     sets `debug=true` (LLD §1 contract).
+             */
+            search_plan_trace?: unknown;
+            /**
+             * @description Human-readable explain summary derived from the SearchPlanTrace.
+             *     Only emitted when the request sets `debug=true` — gives an on-call
+             *     operator a one-glance view of the plan, cache result, and any
+             *     actionable hints (high scan fraction, repair triggered, ...).
+             */
+            explain?: unknown;
+        };
+        /** @description Search result with typed fields */
+        TypedSearchResult: {
+            /** @description Record ID */
+            id: string;
+            /**
+             * Format: float
+             * @description Similarity score (0.0 - 1.0 for cosine, distance for L2)
+             */
+            score: number;
+            /** @description Vector embedding (if requested) */
+            vector?: number[] | null;
+            /** @description Rich properties from the record */
+            props: {
+                [key: string]: unknown;
+            };
+            /** @description TEXT fields (if include_text is true) */
+            text_fields?: components["schemas"]["TextFieldOutput"][] | null;
+        };
+        /**
+         * @description Request to update schema
+         *
+         *     ## Schema Evolution Rules
+         *
+         *     1. **Adding Columns**: New columns must be nullable or have defaults
+         *     2. **Type Changes**: Not allowed (except compatible widening like int32->int64)
+         *     3. **Removing Columns**: Not allowed (use deprecation instead)
+         *     4. **Enforcement Mode**: Can be changed, but strict->flexible may lose validation
+         *
+         *     ## Example JSON
+         *
+         *     ```json
+         *     {
+         *         "columns": [
+         *             {"name": "category", "data_type": "text", "indexed": true},
+         *             {"name": "price", "data_type": "float", "filterable": true},
+         *             {"name": "tags", "data_type": "array_text", "nullable": true}
+         *         ],
+         *         "enforcement": "hybrid",
+         *         "allow_additional_fields": true
+         *     }
+         *     ```
+         */
+        UpdateSchemaRequest: components["schemas"]["SchemaDefinition"] & {
+            /**
+             * @description Force update even if validation warnings exist
+             *
+             *     Use with caution - may cause data compatibility issues.
+             */
+            force?: boolean | null;
+        };
+        /** @description Schema update response */
+        UpdateSchemaResponse: {
+            /** @description Updated schema ID */
+            schema_id: string;
+            /** @description New schema version */
+            schema_version: string;
+            /** @description Previous schema ID (for rollback) */
+            previous_schema_id: string;
+            /** @description List of applied changes */
+            changes: components["schemas"]["SchemaChange"][];
+            /** @description Warnings about the update */
+            warnings: string[];
+            /** @description Update timestamp */
+            updated_at: string;
+        };
+        UpsertEntityRequest: {
+            /** @description Empty ⇒ the server generates a UUID. */
+            id?: string;
+            flexible_metadata?: {
+                [key: string]: unknown;
+            };
+            embeddings?: components["schemas"]["EntityEmbeddingInput"][];
+            provenance?: null | components["schemas"]["EntityProvenanceInput"];
+            relations?: components["schemas"]["EntityRelationInput"][];
+        };
+        UpsertEntityResponse: {
+            success: boolean;
+            entity_id: string;
+            message: string;
+        };
+        HealthResponse: {
+            status?: string;
+            version?: string;
+            uptime_seconds?: number;
+        } & {
+            [key: string]: unknown;
+        };
+        ProbeResponse: {
+            status: string;
+        };
+        CapabilitiesResponse: {
+            api_version?: string;
+            surface?: string;
+            features?: string[];
+            limits?: {
+                [key: string]: unknown;
+            };
+            error_envelope?: {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        };
+        CreateGraphRequest: {
+            /** @description Unique identifier for the new graph collection. */
+            graph_id: string;
+            /** @description Optional human-readable name (defaults to graph_id). */
+            name?: string | null;
+            description?: string | null;
+        };
+        /**
+         * @description Server returns a `GraphResponse<T>` envelope around graph
+         *     collection metadata. The fields below are the common subset
+         *     SDKs rely on; extra server-side fields are passed through.
+         */
+        GraphCollectionResponse: {
+            graph_id?: string;
+            name?: string | null;
+            description?: string | null;
+            node_count?: number | null;
+            edge_count?: number | null;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * @description Server returns a `GraphResponse<Vec<...>>` envelope with `data`
+         *     containing the graph collections.
+         */
+        ListGraphsResponse: {
+            data?: components["schemas"]["GraphCollectionResponse"][];
+            success?: boolean;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * @description 204 No Content on success with an empty `GraphResponse` envelope;
+         *     404 Not Found with an error envelope when the graph is missing.
+         */
+        DeleteGraphResponse: {
+            success?: boolean;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * @description Node payload nested inside `CreateNodeRequest.node`. Matches
+         *     `RestNodeInput` in proximadb-api's graph handler.
+         */
+        NodeInput: {
+            id: string;
+            labels?: string[];
+            properties?: {
+                [key: string]: unknown;
+            };
+            embedding?: components["schemas"]["EmbeddingInput"];
+        };
+        EmbeddingInput: {
+            vector: number[];
+            model_id?: string | null;
+            modality?: string | null;
+        };
+        /** @description Wrapped envelope: server expects `{"node": NodeInput}`. */
+        CreateNodeRequest: {
+            node: components["schemas"]["NodeInput"];
+        };
+        NodeResponse: {
+            id: string;
+            labels?: string[] | null;
+            properties?: {
+                [key: string]: unknown;
+            } | null;
+        } & {
+            [key: string]: unknown;
+        };
+        DeleteNodeResponse: {
+            success?: boolean;
+            id?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * @description Edge payload nested inside `CreateEdgeRequest.edge`. Matches
+         *     `RestEdgeInput` in proximadb-api's graph handler.
+         */
+        EdgeInput: {
+            id: string;
+            from_node_id: string;
+            to_node_id: string;
+            edge_type: string;
+            properties?: {
+                [key: string]: unknown;
+            };
+            /** Format: double */
+            weight?: number | null;
+        };
+        /** @description Wrapped envelope: server expects `{"edge": EdgeInput}`. */
+        CreateEdgeRequest: {
+            edge: components["schemas"]["EdgeInput"];
+        };
+        EdgeResponse: {
+            id: string;
+            from_node_id?: string;
+            to_node_id?: string;
+            edge_type?: string | null;
+            properties?: {
+                [key: string]: unknown;
+            } | null;
+            /** Format: double */
+            weight?: number | null;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * @description Flat shape (no wrapper). Matches `RestTraversalRequest` in
+         *     proximadb-api.
+         */
+        TraverseRequest: {
+            start_node_id: string;
+            /** @default 3 */
+            max_depth: number;
+            edge_types?: string[];
+            node_labels?: string[];
+            /** @description bfs | dfs | shortest_path */
+            algorithm?: string | null;
+            limit?: number | null;
+        };
+        TraverseResponse: {
+            nodes?: components["schemas"]["NodeResponse"][];
+            edges?: components["schemas"]["EdgeResponse"][];
+            paths?: string[][];
+        } & {
+            [key: string]: unknown;
+        };
+        GraphStatsResponse: {
+            node_count?: number;
+            edge_count?: number;
+            /** Format: double */
+            density?: number | null;
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description Body for `POST /api/v2/graphs/{id}/nodes/batch`. */
+        BatchCreateNodesRequest: {
+            nodes: components["schemas"]["NodeInput"][];
+        };
+        /** @description Server returns a `GraphResponse<BatchResults<Node>>` envelope. */
+        BatchNodesResponse: {
+            success?: boolean;
+            data?: {
+                results?: components["schemas"]["NodeResponse"][];
+                count?: number;
+            } & {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description Body for `POST /api/v2/graphs/{id}/edges/batch`. */
+        BatchCreateEdgesRequest: {
+            edges: components["schemas"]["EdgeInput"][];
+        };
+        /** @description Server returns a `GraphResponse<BatchResults<Edge>>` envelope. */
+        BatchEdgesResponse: {
+            success?: boolean;
+            data?: {
+                results?: components["schemas"]["EdgeResponse"][];
+                count?: number;
+            } & {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        };
+    };
+    responses: {
+        /** @description Invalid request. */
+        BadRequest: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description Resource not found. */
+        NotFound: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description Authentication required or insufficient permissions. */
+        Unauthorized: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+    };
+    parameters: {
+        GraphId: string;
+        NodeId: string;
+    };
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    listCollections: {
+        parameters: {
+            query?: {
+                /** @description Maximum number of collections to return (default: 100) */
+                limit?: number;
+                /** @description Offset for pagination (default: 0) */
+                offset?: number;
+                /** @description Whether to include statistics */
+                include_stats?: boolean;
+            };
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Collection page. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListCollectionsV2Response"];
+                };
+            };
+        };
+    };
+    createCollection: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateCollectionV2Request"];
+            };
+        };
+        responses: {
+            /** @description Collection created. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CreateCollectionV2Response"];
+                };
+            };
+            /** @description Invalid request. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    getCollection: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                /** @description Collection name/ID. */
+                collection_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Collection details. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CollectionV2Response"];
+                };
+            };
+            /** @description Resource not found. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    deleteCollection: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                /** @description Collection name/ID. */
+                collection_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Collection deleted. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["DeleteCollectionV2Response"];
+                };
+            };
+            /** @description Resource not found. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    ingestDocuments: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                /** @description Target collection name/ID. */
+                collection_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["IngestDocumentsRequest"];
+            };
+        };
+        responses: {
+            /** @description Ingested. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["IngestDocumentsResponse"];
+                };
+            };
+            /** @description Invalid request. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Collection not found. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    upsert_entity_v2: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                /** @description Collection backing the entities */
+                collection_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpsertEntityRequest"];
+            };
+        };
+        responses: {
+            /** @description Entity upserted */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UpsertEntityResponse"];
+                };
+            };
+            /** @description Invalid request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Upsert failed */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    search_entities_v2: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                /** @description Collection backing the entities */
+                collection_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SearchEntitiesRequest"];
+            };
+        };
+        responses: {
+            /** @description Search results */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SearchEntitiesResponse"];
+                };
+            };
+            /** @description Invalid request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Search failed */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    get_entity_v2: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                /** @description Collection backing the entities */
+                collection_id: string;
+                /** @description Entity ID */
+                entity_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Entity found */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["EntityDto"];
+                };
+            };
+            /** @description Entity not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Fetch failed */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    delete_entity_v2: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                /** @description Collection backing the entities */
+                collection_id: string;
+                /** @description Entity ID */
+                entity_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Entity deleted */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UpsertEntityResponse"];
+                };
+            };
+            /** @description Entity not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Delete failed */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    insertRecords: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                /** @description Collection name/ID. */
+                collection_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["InsertRecordsRequest"];
+            };
+        };
+        responses: {
+            /** @description Batch write result. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["InsertRecordsResponse"];
+                };
+            };
+            /** @description Invalid request. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    scanRecords: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                /** @description Collection name/ID. */
+                collection_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ScanRecordsRequest"];
+            };
+        };
+        responses: {
+            /** @description Page of records + optional next cursor. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ScanRecordsResponse"];
+                };
+            };
+            /** @description Invalid request (including a cursor minted for a different collection). */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Resource not found. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Collection changed during the scan; restart pagination. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Cursor expired (older than 24h); restart the scan. */
+            410: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    getRecord: {
+        parameters: {
+            query?: {
+                /** @description Whether to include the vector in the response */
+                include_vector?: boolean;
+                /** @description Whether to include TEXT fields in the response */
+                include_text?: boolean;
+            };
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                /** @description Collection name/ID. */
+                collection_id: string;
+                /** @description Record ID. */
+                record_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Record. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["RecordV2Response"];
+                };
+            };
+            /** @description Resource not found. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    deleteRecord: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                /** @description Collection name/ID. */
+                collection_id: string;
+                /** @description Record ID. */
+                record_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Delete accepted. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["DeleteRecordV2Response"];
+                };
+            };
+        };
+    };
+    getCollectionSchema: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                /** @description Collection name/ID. */
+                collection_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Collection schema. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SchemaResponse"];
+                };
+            };
+            /** @description Resource not found. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    updateCollectionSchema: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                /** @description Collection name/ID. */
+                collection_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateSchemaRequest"];
+            };
+        };
+        responses: {
+            /** @description Schema updated. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UpdateSchemaResponse"];
+                };
+            };
+            /** @description Invalid request. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    searchRecords: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                /** @description Collection name/ID. */
+                collection_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["TypedSearchRequest"];
+            };
+        };
+        responses: {
+            /** @description Search results. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TypedSearchResponse"];
+                };
+            };
+            /** @description Invalid request. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    fusion_search_v2: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                /** @description Graph ID for traversal expansion */
+                graph_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["FusionSearchRequest"];
+            };
+        };
+        responses: {
+            /** @description Fusion results with calibrated scores */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FusionSearchResponse"];
+                };
+            };
+            /** @description Invalid request (empty query_vector, etc.) */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Fusion execution failed */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    impact_analysis_v2: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                /** @description Graph ID */
+                graph_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ImpactAnalysisRequest"];
+            };
+        };
+        responses: {
+            /** @description Impacted node ids */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ImpactAnalysisResponse"];
+                };
+            };
+            /** @description Missing graph_id/node_id */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Impact analysis failed */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    listModelRegistries: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Tenant-scoped registries in deterministic name order. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListModelRegistriesResponse"];
+                };
+            };
+        };
+    };
+    createModelRegistry: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateModelRegistryRequest"];
+            };
+        };
+        responses: {
+            /** @description Created model registry. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ModelRegistryRecordResponse"];
+                };
+            };
+            /** @description Invalid registry name. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Registry already exists. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    getModelRegistry: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                /** @description Tenant-local registry name. */
+                name: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Model registry. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ModelRegistryRecordResponse"];
+                };
+            };
+            /** @description Registry not found. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    applyModelRegistryMutation: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                /** @description Tenant-local registry name. */
+                name: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ApplyModelRegistryMutationRequest"];
+            };
+        };
+        responses: {
+            /** @description Updated registry. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ModelRegistryRecordResponse"];
+                };
+            };
+            /** @description Invalid lifecycle command. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Registry not found. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Revision conflict. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    resolveModelAlias: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                /** @description Tenant-local registry name. */
+                name: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ResolveModelAliasRequest"];
+            };
+        };
+        responses: {
+            /** @description Immutable version and digest binding. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ResolvedModelBindingResponse"];
+                };
+            };
+            /** @description Alias, dimension, runtime, or approval policy rejected. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Registry not found. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    executeQuery: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["QueryRequest"];
+            };
+        };
+        responses: {
+            /** @description Query result. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["QueryResponse"];
+                };
+            };
+            /** @description Invalid request. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    explainQuery: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ExplainQueryRequest"];
+            };
+        };
+        responses: {
+            /** @description Query plan and lowering details. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["QueryResponse"];
+                };
+            };
+            /** @description Invalid request. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    executeSql: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SqlRequest"];
+            };
+        };
+        responses: {
+            /** @description SQL result or write count. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SqlResponse"];
+                };
+            };
+            /** @description Invalid SQL request. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Query deadline exceeded. */
+            408: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Write lock conflict. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description SQL execution failure. */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    getHealth: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Health status. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HealthResponse"];
+                };
+            };
+        };
+    };
+    getLiveness: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Process is alive. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ProbeResponse"];
+                };
+            };
+        };
+    };
+    getReadiness: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Server is ready. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ProbeResponse"];
+                };
+            };
+        };
+    };
+    getCapabilities: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Capability document. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CapabilitiesResponse"];
+                };
+            };
+        };
+    };
+    listGraphs: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Graph collection listing. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListGraphsResponse"];
+                };
+            };
+        };
+    };
+    createGraph: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateGraphRequest"];
+            };
+        };
+        responses: {
+            /** @description Graph collection metadata. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GraphCollectionResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+        };
+    };
+    getGraph: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                graph_id: components["parameters"]["GraphId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Graph collection metadata. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GraphCollectionResponse"];
+                };
+            };
+            404: components["responses"]["NotFound"];
+        };
+    };
+    deleteGraph: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                graph_id: components["parameters"]["GraphId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Deletion acknowledged. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["DeleteGraphResponse"];
+                };
+            };
+            404: components["responses"]["NotFound"];
+        };
+    };
+    createNode: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                graph_id: components["parameters"]["GraphId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateNodeRequest"];
+            };
+        };
+        responses: {
+            /** @description Created node. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["NodeResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    getNode: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                graph_id: components["parameters"]["GraphId"];
+                node_id: components["parameters"]["NodeId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Node payload. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["NodeResponse"];
+                };
+            };
+            404: components["responses"]["NotFound"];
+        };
+    };
+    deleteNode: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                graph_id: components["parameters"]["GraphId"];
+                node_id: components["parameters"]["NodeId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Deletion acknowledged. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["DeleteNodeResponse"];
+                };
+            };
+            404: components["responses"]["NotFound"];
+        };
+    };
+    createEdge: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                graph_id: components["parameters"]["GraphId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateEdgeRequest"];
+            };
+        };
+        responses: {
+            /** @description Created edge. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["EdgeResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    batchCreateNodes: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                graph_id: components["parameters"]["GraphId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["BatchCreateNodesRequest"];
+            };
+        };
+        responses: {
+            /** @description Batch result. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BatchNodesResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    batchCreateEdges: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                graph_id: components["parameters"]["GraphId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["BatchCreateEdgesRequest"];
+            };
+        };
+        responses: {
+            /** @description Batch result. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BatchEdgesResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    traverseGraph: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                graph_id: components["parameters"]["GraphId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["TraverseRequest"];
+            };
+        };
+        responses: {
+            /** @description Traversal result. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TraverseResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+        };
+    };
+    getGraphStats: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                graph_id: components["parameters"]["GraphId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Graph statistics. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GraphStatsResponse"];
+                };
+            };
+        };
+    };
+    hybridSearch: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    collection: string;
+                    vector?: number[];
+                    text_query?: string;
+                    top_k?: number;
+                    fusion_strategy?: string;
+                } & {
+                    [key: string]: unknown;
+                };
+            };
+        };
+        responses: {
+            /** @description Fused results. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+        };
+    };
+    hybridIndex: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    [key: string]: unknown;
+                };
+            };
+        };
+        responses: {
+            /** @description Index result. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+        };
+    };
+    listDocumentCollections: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Collections. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+        };
+    };
+    createDocumentCollection: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    [key: string]: unknown;
+                };
+            };
+        };
+        responses: {
+            /** @description Created. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+        };
+    };
+    queryDocuments: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                collection: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Documents. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+        };
+    };
+    insertDocument: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                collection: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    [key: string]: unknown;
+                };
+            };
+        };
+        responses: {
+            /** @description Inserted. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+            404: components["responses"]["NotFound"];
+        };
+    };
+    ingestLog: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                namespace: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    [key: string]: unknown;
+                };
+            };
+        };
+        responses: {
+            /** @description Ingested. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+        };
+    };
+    queryLogs: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Optional explicit tenant selector. Applied only when there is no authenticated tenant context — a JWT tenant claim takes precedence, and a header that disagrees with the authenticated tenant is rejected. Absent ⇒ the default tenant. Tenant isolation is structural on the server; this header only selects the tenant. */
+                "X-Tenant-ID"?: string;
+            };
+            path: {
+                namespace: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    [key: string]: unknown;
+                };
+            };
+        };
+        responses: {
+            /** @description Matching logs. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+        };
+    };
+}