@littlebigbrain/client 0.12.0 → 0.13.1

package/dist/schema.d.ts

@@ -232,7 +232,7 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        /** Entity detail */
+        /** Native entity attributes and relationships from the branch-owned RDF view; unavailable provenance sections are explicitly listed */
         get: operations["get_v1_graph_entity"];
         put?: never;
         post?: never;
@@ -381,6 +381,23 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/graph/publication-status": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Automatic publication lifecycle and exact read watermarks */
+        get: operations["get_v1_graph_publication_status"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/graph/read-snapshot": {
         parameters: {
             query?: never;
@@ -432,6 +449,23 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/graph/schema-summary": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Compact observed RDF schema attached to the immutable F3 base */
+        get: operations["get_v1_graph_schema_summary"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/graph/summary": {
         parameters: {
             query?: never;
@@ -798,7 +832,7 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        /** Read the durable ontology-conformance report referenced by the published snapshot, including its validation watermark and ontology/shapes provenance */
+        /** Read the immutable branch-owned ontology-conformance sidecar selected by the F3 checksum and schema identity */
         get: operations["get_v1_ontology_conformance"];
         put?: never;
         post?: never;
@@ -817,7 +851,7 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** Import a custom ontology and create the scoped graph head with it; fails if the graph already exists */
+        /** Define or additively evolve a graph ontology, or preview the exact result without mutation */
         post: operations["post_v1_ontology_define"];
         delete?: never;
         options?: never;
@@ -1107,7 +1141,7 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** Atomically activate a SHACL shapes bundle and enqueue durable conformance validation */
+        /** Atomically activate a SHACL shapes bundle, or preview compatibility without writes or validation jobs */
         post: operations["post_v1_schema_publish"];
         delete?: never;
         options?: never;
@@ -1325,8 +1359,25 @@ export interface components {
             /** @description Whether the relation is transitive (default false). */
             transitive?: boolean;
         };
+        /**
+         * @description Add direct parent classes to an existing entity type. All named classes
+         *     must already exist, or be declared earlier in the same request with
+         *     `add_entity_type`. Existing links are skipped, so the op is idempotent.
+         *     Removing a parent is not additive and requires an explicit migration.
+         */
+        AddSuperTypesOp: {
+            /** @description Entity type whose direct parents should grow. */
+            entity_type: string;
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            op: "add_super_types";
+            /** @description Direct parent entity-type names to add. */
+            super_types: string[];
+        };
         /** @description Governed proposal operation restricted to additive ontology changes. */
-        AdditiveOntologyEvolveOp: components["schemas"]["WidenRelationOp"] | components["schemas"]["AddEntityTypeOp"] | components["schemas"]["AddRelationOp"] | components["schemas"]["AddPropertyOp"];
+        AdditiveOntologyEvolveOp: components["schemas"]["WidenRelationOp"] | components["schemas"]["AddEntityTypeOp"] | components["schemas"]["AddSuperTypesOp"] | components["schemas"]["AddRelationOp"];
         /** @description Additive-only ontology proposal helper for structured-output systems. */
         AdditiveOntologyEvolveRequest: {
             ops: components["schemas"]["AdditiveOntologyEvolveOp"][];
@@ -1922,12 +1973,9 @@ export interface components {
         };
         EntityDetailResponse: {
             /**
-             * @description The entity's typed scalar properties as native JSON — the flat read-back
-             *     of what a commit's `entity_properties` wrote, so round-trip verification
-             *     is a one-hop lookup. A numeric property reads back as a JSON number, a
-             *     bool as a bool, a datetime as an RFC3339 string; empty when the entity
-             *     carries no scalar attributes. The `/entities` list returns the same
-             *     `attributes` shape under `?fields=`.
+             * @description The entity's RDF-projected properties as typed JSON: numbers, booleans,
+             *     RFC3339 datetime strings, strings and sets. Nulls, bytes, vectors,
+             *     non-finite numbers and empty sets have no RDF projection and are omitted.
              */
             attributes?: {
                 [key: string]: unknown;
@@ -1939,8 +1987,14 @@ export interface components {
             metadata: components["schemas"]["EntityMetadataResponse"];
             observations: components["schemas"]["ObservationRow"][];
             outgoing: components["schemas"]["GraphEdgeRow"][];
+            rdf_relations?: null | components["schemas"]["EntityRdfRelations"];
             snapshot: components["schemas"]["SnapshotView"];
             truncation?: null | components["schemas"]["EntityDetailTruncation"];
+            /**
+             * @description Legacy sections unavailable in this read model. An empty listed section
+             *     means unavailable, not that the entity has no history or relationships.
+             */
+            unavailable_sections?: string[];
         };
         /**
          * @description Which of an entity read's degree-proportional collections were cut, and by
@@ -2147,6 +2201,12 @@ export interface components {
             remove_fields?: string[];
             type: string;
         };
+        EntityRdfRelations: {
+            incoming: components["schemas"]["RdfEntityRelation"][];
+            incoming_truncation?: null | components["schemas"]["TruncatedCollection"];
+            outgoing: components["schemas"]["RdfEntityRelation"][];
+            outgoing_truncation?: null | components["schemas"]["TruncatedCollection"];
+        };
         EntitySelector: {
             entity_id?: null | components["schemas"]["EntityId"];
             entity_type?: string | null;
@@ -3243,7 +3303,7 @@ export interface components {
             valid_time: components["schemas"]["ValidTime"];
         };
         /** @enum {string} */
-        HistoryObjectKind: "wal" | "segment" | "pending";
+        HistoryObjectKind: "wal" | "segment" | "unavailable" | "pending";
         HybridMultiSearchExplain: {
             fused_candidates: number;
             rrf_k: string;
@@ -3758,6 +3818,12 @@ export interface components {
          *     difference is refused with a typed error naming the route that applies it.
          */
         OntologyDefineRequest: {
+            /**
+             * @description Preview the exact definition without creating a graph, writing an
+             *     ontology object, or changing the graph head. Equivalent to the
+             *     `?dry_run=true` query parameter; either signal enables preview mode.
+             */
+            dry_run?: boolean;
             /** @description Import format hint. `auto` (the default) sniffs the content. */
             format?: string | null;
             /**
@@ -3773,29 +3839,28 @@ export interface components {
         };
         OntologyDefineResponse: {
             /**
-             * @description True when this call wrote a new ontology version, either by creating the
-             *     graph or by applying an additive difference. False when the proposed
-             *     ontology already matched the active one, which is what makes re-running
-             *     the same bootstrap request a no-op.
+             * @description True when this call wrote a new ontology version, or when a dry run
+             *     predicts that it would. False when the proposed ontology already matched
+             *     the active one, which is what makes re-running the same bootstrap request
+             *     a no-op.
              *
-             *     This tracks what was written, so it never reports `false` for a call
-             *     that changed the ontology: a widened relation domain or range and a new
-             *     property field both set it, even though neither appears in the
-             *     class-and-relation schema diff.
+             *     A widened relation domain or range and a new property field both set it,
+             *     even though neither appears in the class-and-relation schema diff.
              */
             changed?: boolean;
             /**
-             * @description The additive changes this call applied to an existing graph's ontology.
-             *     Empty when the graph was created and when nothing changed.
+             * @description The additive changes this call applied, or would apply during a dry run,
+             *     to an existing graph's ontology. Empty on create and no-op.
              */
             changes?: components["schemas"]["SchemaDiffEntry"][];
+            /** @description True when this response is a preview and no durable state changed. */
+            dry_run?: boolean;
             entity_types: components["schemas"]["OntologyTermView"][];
             format: string;
             graph: components["schemas"]["GraphKey"];
             /**
-             * @description True when this call created the graph head. False when the graph already
-             *     existed, whether the ontology then changed or not. This is the `created`
-             *     signal for the define route.
+             * @description True when this call created the graph head, or when a dry run predicts
+             *     that the real definition would create it.
              */
             graph_created: boolean;
             merged_default: boolean;
@@ -3840,6 +3905,8 @@ export interface components {
         OntologyDraftStatus: "draft" | "validated" | "promoted" | "rejected";
         /** @description The full definition of one entity type (class) in the active ontology. */
         OntologyEntityTypeView: {
+            /** @description Canonical query IRI minted by Little Big Brain for this class identity. */
+            iri?: string;
             name: string;
             properties: components["schemas"]["OntologyPropertyView"][];
             /** Format: int64 */
@@ -3848,6 +3915,17 @@ export interface components {
             resolvable: boolean;
             /** Format: int64 */
             since_version: number;
+            /**
+             * @description Frozen class identity used by commits and the RDF projection. This is
+             *     unique even when imported vocabularies reuse the same local name.
+             */
+            stable_id?: string;
+            /**
+             * @description Direct parent classes (`rdfs:subClassOf`), named by their frozen
+             *     `stable_id`s. Clients can build the full class lattice without a SPARQL
+             *     scan or a second ontology lookup.
+             */
+            super_types?: string[];
         };
         OntologyEvidenceSample: {
             /** @description Stable connector/source reference; sample content is never used as identity. */
@@ -3866,7 +3944,7 @@ export interface components {
          *     the supported "ontology evolution" path; identity-breaking changes (removals,
          *     narrowing) still require an explicit expand→migrate→contract plan.
          */
-        OntologyEvolveOp: components["schemas"]["WidenRelationOp"] | components["schemas"]["AddEntityTypeOp"] | components["schemas"]["AddRelationOp"] | components["schemas"]["AddPropertyOp"] | components["schemas"]["SetPropertyConstraintOp"] | components["schemas"]["RenameEntityTypeOp"] | components["schemas"]["RenameRelationOp"] | components["schemas"]["SetRelationInverseOp"] | components["schemas"]["SetRelationCardinalityOp"] | components["schemas"]["NarrowRelationOp"] | components["schemas"]["RemoveEntityTypeOp"] | components["schemas"]["RemoveRelationOp"];
+        OntologyEvolveOp: components["schemas"]["WidenRelationOp"] | components["schemas"]["AddEntityTypeOp"] | components["schemas"]["AddSuperTypesOp"] | components["schemas"]["AddRelationOp"] | components["schemas"]["AddPropertyOp"] | components["schemas"]["SetPropertyConstraintOp"] | components["schemas"]["RenameEntityTypeOp"] | components["schemas"]["RenameRelationOp"] | components["schemas"]["SetRelationInverseOp"] | components["schemas"]["SetRelationCardinalityOp"] | components["schemas"]["NarrowRelationOp"] | components["schemas"]["RemoveEntityTypeOp"] | components["schemas"]["RemoveRelationOp"];
         /**
          * @description Apply a list of additive ontology changes in order, writing a new ontology
          *     version when anything actually changes. Ops are applied against the
@@ -4344,6 +4422,42 @@ export interface components {
             /** @description Members of an `i64_set` field; canonicalized like `keyword_set`. */
             i64_set: number[];
         };
+        PublicationRetryGuidance: {
+            eventual_read_available: boolean;
+            message: string;
+            /** Format: int64 */
+            retry_after_ms: number;
+        };
+        /**
+         * @description Server-managed publication lifecycle for one graph epoch.
+         * @enum {string}
+         */
+        PublicationState: "current" | "queued" | "compacting" | "building" | "publishing" | "blocked";
+        /**
+         * @description One bounded status document for automatic exact-generation publication.
+         *     It is available before the first generation publishes, unlike
+         *     [`PublishedReadStatusResponse`], so SDKs can wait without probing SPARQL.
+         */
+        PublicationStatusResponse: {
+            current_stage?: string | null;
+            /** Format: int64 */
+            epoch: number;
+            /** Format: int64 */
+            head_generation: number;
+            head_seq: components["schemas"]["CommitSeq"];
+            /** Format: int64 */
+            lag_commits: number;
+            /** Format: int64 */
+            last_progress_at_micros: number;
+            /** Format: int64 */
+            published_generation?: number | null;
+            published_seq: components["schemas"]["CommitSeq"];
+            retry: components["schemas"]["PublicationRetryGuidance"];
+            state: components["schemas"]["PublicationState"];
+            /** Format: int64 */
+            target_head_generation: number;
+            target_seq: components["schemas"]["CommitSeq"];
+        };
         /**
          * @description Whether an import's deterministic published-generation job was newly
          *     queued or coalesced with equivalent pending work.
@@ -4467,6 +4581,56 @@ export interface components {
              */
             rerank_raw_bytes_fetched?: number;
         };
+        RdfEntityRelation: {
+            entity: components["schemas"]["EntityView"];
+            relation: components["schemas"]["RelationView"];
+        };
+        /**
+         * @description The RDF node kind of a bounded observed-schema statement object.
+         * @enum {string}
+         */
+        RdfSchemaObjectKind: "iri" | "blank_node" | "literal";
+        /** @description One OWL/RDFS vocabulary or annotation statement retained for schema UIs. */
+        RdfSchemaStatement: {
+            object: string;
+            object_kind: components["schemas"]["RdfSchemaObjectKind"];
+            predicate: string;
+            subject: string;
+        };
+        /**
+         * @description Compact, immutable observed-schema artifact attached to one exact F3 base.
+         *
+         *     This is the overview/read-model surface for Explorer and Ontology. It is
+         *     produced by maintenance while publishing F3 and is therefore cheap to read:
+         *     no request-time graph scan or base-plus-delta assembly is required.
+         */
+        RdfSchemaSummaryResponse: {
+            /**
+             * @description Per-predicate totals of literal-valued statements, the data-property
+             *     sibling of `resource_predicate_counts`. `None` when the stored summary
+             *     artifact predates this field; the next full summary rebuild fills it.
+             */
+            literal_predicate_counts?: components["schemas"]["RdfSchemaTermCount"][] | null;
+            /** Format: int64 */
+            ontology_version: number;
+            resource_predicate_counts: components["schemas"]["RdfSchemaTermCount"][];
+            snapshot: components["schemas"]["SnapshotView"];
+            statements: components["schemas"]["RdfSchemaStatement"][];
+            truncated: boolean;
+            type_counts: components["schemas"]["RdfSchemaTermCount"][];
+        };
+        /**
+         * @description One exact RDF term count in the compact observed-schema summary.
+         *
+         *     `term` is the complete IRI rather than a display-local name. This keeps
+         *     foreign vocabularies unambiguous; clients may choose their own prefix or
+         *     local-name presentation.
+         */
+        RdfSchemaTermCount: {
+            /** Format: int64 */
+            count: number;
+            term: string;
+        };
         /**
          * @description A page-region provenance anchor on a fact's evidence (region provenance
          *     §4.1/§6.4(b) BYO import): where the evidence appears in the source
@@ -4739,6 +4903,11 @@ export interface components {
         };
         SchemaAuditResult: {
             component: string;
+            /**
+             * @description Nested results explaining a composite violation (`sh:detail`), e.g.
+             *     which constraint inside a `sh:node` shape the value node failed.
+             */
+            details?: components["schemas"]["SchemaAuditResult"][];
             focus_node: string;
             message?: string | null;
             result_path?: string | null;
@@ -4786,6 +4955,8 @@ export interface components {
         /** @enum {string} */
         SchemaChangeKind: "additive" | "restrictive" | "identity_breaking";
         SchemaClassView: {
+            /** @description Canonical query IRI minted by Little Big Brain for this class identity. */
+            iri?: string;
             name: string;
             property_count: number;
             /** Format: int64 */
@@ -4793,6 +4964,8 @@ export interface components {
             /** Format: int64 */
             since_version: number;
             stable_id: string;
+            /** @description Direct parent classes (`rdfs:subClassOf`), named by `stable_id`. */
+            super_types?: string[];
         };
         /** @enum {string} */
         SchemaCompatibilityVerdict: "compatible" | "restrictive" | "migration_required";
@@ -4819,6 +4992,7 @@ export interface components {
             ontology_version: number;
             /** Format: int64 */
             shapes_version?: number | null;
+            write_enforcement?: null | components["schemas"]["SchemaWriteEnforcement"];
         };
         SchemaRelationView: {
             dst_types: string[];
@@ -4830,6 +5004,12 @@ export interface components {
             src_types: string[];
             stable_id: string;
         };
+        SchemaShapeWriteEnforcement: {
+            blockers?: components["schemas"]["SchemaWriteEnforcementBlocker"][];
+            /** @description An active root shape: one that selects focus nodes. */
+            shape: string;
+            write_enforceable: boolean;
+        };
         SchemaSource: {
             /**
              * @description Format hint for this source. Ontology sources use the ontology importer
@@ -4841,6 +5021,36 @@ export interface components {
             /** @description RDF or ontology document text. */
             source: string;
         };
+        /** @description How the published shape set is enforced on this branch. */
+        SchemaWriteEnforcement: {
+            shapes: components["schemas"]["SchemaShapeWriteEnforcement"][];
+            timing: components["schemas"]["SchemaWriteEnforcementTiming"];
+            /**
+             * @description True when no root shape has a blocker. An RDF-native branch accepts
+             *     `reject` mode only for such a shape set.
+             */
+            write_enforceable: boolean;
+        };
+        /**
+         * @description A constraint with no bounded affected set: the engine cannot tell which
+         *     focus nodes a write changes its verdict for.
+         */
+        SchemaWriteEnforcementBlocker: {
+            /**
+             * @description The SHACL parameter: `sh:sparql`, or the shape reference that closes a
+             *     cycle (`sh:node`, `sh:property`, `sh:or`, ...).
+             */
+            constraint: string;
+            /** @description `sparql_constraint` or `recursive_shape`. */
+            reason: string;
+            /** @description The shape that carries the constraint. */
+            shape: string;
+        };
+        /**
+         * @description When the engine checks the published shapes against a write.
+         * @enum {string}
+         */
+        SchemaWriteEnforcementTiming: "write_time" | "write_time_full_scan" | "after_publication";
         /**
          * @description One scored retrieval candidate on the wire: which entity matched and its raw
          *     (pre-calibration) score from whatever channel produced it. The entity is
@@ -5767,11 +5977,13 @@ export interface components {
          */
         SparqlCompareOp: "eq" | "ne" | "lt" | "le" | "gt" | "ge";
         /**
-         * @description RDFS entailment regime applied when projecting the graph for a conformant
-         *     SPARQL query. Controls whether a class term matches subtype instances.
+         * @description Entailment regime applied to a conformant SPARQL query. The regime is
+         *     evaluated at query time as a closure-driven pattern rewrite over the
+         *     dataset's asserted schema triples; the published dataset itself stays
+         *     asserted-only.
          * @enum {string}
          */
-        SparqlEntailment: "subclass" | "none";
+        SparqlEntailment: "owl" | "rdfs" | "subclass" | "none";
         /**
          * @description A FILTER over a solution: a comparison, or a boolean composition of filters.
          *     A comparison whose operands are unbound, incomparable, or a type mismatch is
@@ -5906,6 +6118,7 @@ export interface components {
              *     the query into grouped/aggregated mode.
              */
             aggregates?: components["schemas"]["SparqlAggregate"][];
+            as_of_commit_seq?: null | components["schemas"]["CommitSeq"];
             /**
              * @description `ASK` form: return only `boolean` (whether the pattern has any solution).
              *     Projection, DISTINCT, and limit/offset are ignored.
@@ -5967,11 +6180,10 @@ export interface components {
             /** @description WHERE: the conjunctive basic graph pattern (shares the analytic engine). */
             patterns: components["schemas"]["AnalyticTriplePattern"][];
             /**
-             * @description Reason over the graph's stored inference rules so a pattern matches
-             *     asserted **and** derived edges in one shot. Off by default
-             *     (asserted-only). Public serving requires a compatible reasoned
-             *     projection in the pinned published generation and fails closed when it
-             *     is absent; it never forces an overlay reduce.
+             * @description Not available on the published SPARQL surface: a branch's stored
+             *     inference rules already run at publish time, folding derived facts into
+             *     the asserted dataset every query reads. Requesting `reason: true`
+             *     returns a typed, non-retryable error.
              */
             reason?: boolean;
             /**
@@ -6032,10 +6244,13 @@ export interface components {
          *     RDF graph, not a results table).
          */
         SparqlTextRequest: {
+            as_of_commit_seq?: null | components["schemas"]["CommitSeq"];
             /**
-             * @description RDFS entailment regime. `None` (default) reads the asserted published
-             *     projection. `Subclass` requires a compatible reasoned projection and
-             *     fails closed while one is unavailable.
+             * @description Entailment regime. `None` (default) matches asserted triples only.
+             *     `Rdfs` applies the practical RDFS core at query time, `Subclass` the
+             *     class-only subset, and `Owl` the OWL profile on top of `Rdfs`. All
+             *     derive the closure from the pinned generation's asserted schema
+             *     triples.
              */
             entailment?: components["schemas"]["SparqlEntailment"];
             /**
@@ -6048,12 +6263,10 @@ export interface components {
             /** @description The SPARQL query text (SELECT or ASK). */
             query: string;
             /**
-             * @description Reason over the branch's stored inference rules: project the rule-derived
-             *     facts into the dataset the conformant engine runs over, so a query reasons
-             *     over asserted **and** derived edges. Off by default; a no-op when the branch
-             *     has no stored rules. Combine with `entailment: subclass` for full
-             *     reasoning—rule-derived facts plus `rdfs:subClassOf` type closure—once
-             *     maintenance publishes a compatible reasoned projection.
+             * @description Not available on the published SPARQL surface: a branch's stored
+             *     inference rules already run at publish time, folding derived facts into
+             *     the asserted dataset every query reads. Requesting `reason: true`
+             *     returns a typed, non-retryable error.
              */
             reason?: boolean;
         };
@@ -8616,6 +8829,14 @@ export interface operations {
                 type?: string;
                 /** @description Entity canonical name for name-addressed lookup */
                 name?: string;
+                /** @description External entity key; takes precedence over name */
+                key?: string;
+                /** @description strong or eventual (default); strong includes the exact durable delta suffix */
+                consistency?: string;
+                /** @description Retained commit sequence; valid-time as_of is unsupported */
+                as_of_commit_seq?: string;
+                /** @description Maximum RDF relationships per direction (default 1000, ceiling 10000) */
+                edges?: string;
             };
             header?: {
                 /** @description API contract version to pin. Use `2026-07-23` for this beta-breaking shape. */
@@ -10068,7 +10289,7 @@ export interface operations {
                 blank_node_scope?: string;
                 /** @description Entity type name for imported RDF resources (default Resource) */
                 resource_type?: string;
-                /** @description Set false to defer the published-generation enqueue; send build=false on every chunk except the last of a chunked bulk stream. Default true. */
+                /** @description Set false on intermediate chunks to defer eager publication. Each request still atomically commits a compacted truth segment and exact per-commit F3 delta; graph reconstruction, SHACL, and complete F3 construction run off-path. The server advances one coalesced safety fence when the deferred delta tail reaches 8 entries or 32 MiB, so a large stream cannot wedge itself. Omit build=false on the final chunk to advance the final fence. Default true. */
                 build?: string;
             };
             header?: {
@@ -10337,6 +10558,142 @@ export interface operations {
             };
         };
     };
+    get_v1_graph_publication_status: {
+        parameters: {
+            query?: {
+                /** @description Graph name (default `main`) */
+                graph?: string;
+                /** @description Branch name (default `main`) */
+                branch?: string;
+            };
+            header?: {
+                /** @description API contract version to pin. Use `2026-07-23` for this beta-breaking shape. */
+                "Lbb-Version"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicationStatusResponse"];
+                };
+            };
+            /** @description Bad request */
+            400: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Forbidden */
+            403: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Not found */
+            404: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Conflict */
+            409: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Rate limit exceeded */
+            429: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Service unavailable */
+            503: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+        };
+    };
     get_v1_graph_read_snapshot: {
         parameters: {
             query?: {
@@ -10761,6 +11118,142 @@ export interface operations {
             };
         };
     };
+    get_v1_graph_schema_summary: {
+        parameters: {
+            query?: {
+                /** @description Graph name (default `main`) */
+                graph?: string;
+                /** @description Branch name (default `main`) */
+                branch?: string;
+            };
+            header?: {
+                /** @description API contract version to pin. Use `2026-07-23` for this beta-breaking shape. */
+                "Lbb-Version"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["RdfSchemaSummaryResponse"];
+                };
+            };
+            /** @description Bad request */
+            400: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Forbidden */
+            403: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Not found */
+            404: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Conflict */
+            409: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Rate limit exceeded */
+            429: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Service unavailable */
+            503: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+        };
+    };
     get_v1_graph_summary: {
         parameters: {
             query?: {
@@ -13988,7 +14481,7 @@ export interface operations {
                 graph?: string;
                 /** @description Branch name (default `main`) */
                 branch?: string;
-                /** @description eventual (default) serves the referenced durable report; strong requires validation at current head with current ontology/shapes */
+                /** @description eventual (default) serves the selected base sidecar; strong requires an exact-head sidecar with current ontology/shapes */
                 consistency?: string;
                 /** @description Maximum returned result rows; result_count remains exact */
                 limit?: string;
@@ -14128,6 +14621,8 @@ export interface operations {
                 graph?: string;
                 /** @description Branch name (default `main`) */
                 branch?: string;
+                /** @description Validate and return the exact predicted definition without creating a graph, writing an ontology object, or changing the graph head */
+                dry_run?: string;
             };
             header?: {
                 /** @description API contract version to pin. Use `2026-07-23` for this beta-breaking shape. */
@@ -16672,6 +17167,8 @@ export interface operations {
                 graph?: string;
                 /** @description Branch name (default `main`) */
                 branch?: string;
+                /** @description Parse and check compatibility without activation; returns activated=false and predicted schema versions. Does not run whole-graph conformance */
+                dry_run?: string;
             };
             header?: {
                 /** @description API contract version to pin. Use `2026-07-23` for this beta-breaking shape. */