@littlebigbrain/client 0.14.0 → 0.16.0

package/dist/client.d.ts

@@ -1,5 +1,6 @@
+import { WorkflowNamespace } from "./workflows.js";
 import type { DurableImportSource, ImportLine, LbbClientOptions, ListResponse, RawLbbResponse, ReadConsistencyOptions, RdfImportDocument, RdfImportManyResult, RdfImportOptions, Schemas, SearchConsistency, SparqlResults } from "./types.js";
-import { type CallOptions, type RequestOptions } from "./transport.js";
+import { type RequestOptions } from "./transport.js";
 import { EntityNamespace, GraphNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace, EvalsNamespace, EmbeddingsNamespace } from "./namespaces.js";
 export { parseSparqlResults } from "./types.js";
 export type { AttributeFilter, AttributeFilterOp, AttributeFilterValue, EntityAttributeFilterOptions, EntityPropertiesLine, DurableImportLine, DurableImportSource, FetchLike, FlatProperties, ImportLine, LbbClientOptions, LbbRequestEvent, LbbResponseEvent, LbbRetryEvent, LbbErrorPayload, ListResponse, RawLbbResponse, ReadConsistencyOptions, RdfImportDocument, RdfImportManyResult, RdfImportOptions, Schemas, SearchConsistency, SparqlResults, SparqlResultsJson, SparqlTerm, CommitRequest, CommitResponse, Entity, EntitySelector, GraphMetadata, GraphSummary, SchemaView, Snapshot, } from "./types.js";
@@ -35,6 +36,7 @@ export declare class LbbClient {
     readonly query: QueryNamespace;
     readonly evals: EvalsNamespace;
     readonly embeddings: EmbeddingsNamespace;
+    readonly workflows: WorkflowNamespace;
     constructor(options: LbbClientOptions);
     graph(name: string, opts?: {
         stack?: string;
@@ -290,34 +292,6 @@ export declare class LbbClient {
     }): Promise<Schemas["SearchFeedbackResponse"]>;
     /** Export the stored relevance labels as qrels-style rows for training. */
     searchFeedbackExport(): Promise<Schemas["SearchFeedbackExportResponse"]>;
-    /**
-     * Ranked incoming/outgoing neighborhood for a graph entity.
-     *
-     * `edges` caps the edges returned per direction (default 1000, maximum
-     * 10000). When a cap cuts a direction the response carries a `truncation`
-     * block; an uncut response omits it entirely.
-     */
-    entityNeighborhood(opts: {
-        id?: string;
-        type?: string;
-        name?: string;
-        relations?: string[];
-        asOf?: string;
-        edges?: number;
-    }): Promise<Schemas["EntityNeighborhoodResponse"]>;
-    /** Exact type cardinality plus a bounded deterministic sample from Base. */
-    entityTypeSample(opts: {
-        type: string;
-        limit?: number;
-    } & CallOptions): Promise<Schemas["EntityTypeSampleResponse"]>;
-    /** Stored entity object-ref status and index-coverage metadata (no
-     * attributes — read those from `entityDetail`'s top-level `attributes`). */
-    entityMetadata(opts: {
-        id?: string;
-        type?: string;
-        name?: string;
-        asOf?: string;
-    }): Promise<Schemas["EntityMetadataResponse"]>;
     /**
      * Read projected attributes and current relationships from one RDF snapshot.
      * Inspect `unavailable_sections` before interpreting legacy provenance arrays.
@@ -341,14 +315,6 @@ export declare class LbbClient {
      * The caller supplies a bounded collection endpoint and its cursor.
      */
     listAll<T>(fetchPage: (cursor?: string) => Promise<ListResponse<T>>): AsyncGenerator<T, void, unknown>;
-    /** Current state of an entity's relations, optionally as-of a timestamp. */
-    currentState(body: Schemas["CurrentStateRequest"]): Promise<Schemas["CurrentStateResponse"]>;
-    /** Full edge-event history for a relationship. */
-    history(body: Schemas["RelationshipHistoryRequest"]): Promise<Schemas["RelationshipHistoryResponse"]>;
-    /** Ordered state-transition log for an entity's relation, with dwell time. */
-    transitions(body: Schemas["EntityTransitionsRequest"]): Promise<Schemas["EntityTransitionsResponse"]>;
-    /** Lineage and evidence for a single edge. */
-    why(body: Schemas["WhyRequest"]): Promise<Schemas["WhyResponse"]>;
     /**
      * SPARQL-subset SELECT/ASK/aggregate query (FILTER, HAVING, ORDER BY, ASK,
      * COUNT/SUM/AVG/MIN/MAX). GROUP BY is not limited to entity identity:
@@ -360,14 +326,27 @@ export declare class LbbClient {
      * `groups[].keys`.
      */
     sparql(body: Schemas["SparqlSelectRequest"], opts?: ReadConsistencyOptions): Promise<Schemas["SparqlSelectResponse"]>;
-    /** SPARQL 1.1 query from text (SELECT/ASK) over the live graph; `results` is SPARQL 1.1 Query Results JSON. The text dialect carries `consistency`/`min_indexed_seq` on the URL; a floor with no explicit consistency implies a strong base-plus-delta read. */
+    /**
+     * SPARQL 1.1 query from text (SELECT/ASK) over the live graph; `results` is
+     * SPARQL 1.1 Query Results JSON. The text dialect carries
+     * `consistency`/`min_indexed_seq` on the URL; a floor with no explicit
+     * consistency implies a strong base-plus-delta read. `as_of_commit_seq` in
+     * the body reads the retained published generation of that exact commit.
+     *
+     * The query is read-only, so a retryable `429` (for example
+     * `read_your_writes_pending` while publication catches up to the floor) is
+     * retried within the retry budget. A `5xx` is not retried: a query that
+     * timed out would run again.
+     */
     sparqlText(body: Schemas["SparqlTextRequest"], opts?: ReadConsistencyOptions): Promise<Schemas["SparqlTextResponse"]>;
     /**
      * Run a SPARQL 1.1 text query and return parsed results — the ergonomic
      * complement to {@link sparqlText} (which hands back the raw results string).
-     * Returns `{ vars, boolean, bindings, rows }` via {@link parseSparqlResults}:
-     * `rows` is the bindings flattened to `{ variable: lexicalValue }`, `boolean`
-     * is the ASK answer (or `null` for a SELECT).
+     * Returns `{ vars, boolean, bindings, rows, snapshot }` via
+     * {@link parseSparqlResults}: `rows` is the bindings flattened to
+     * `{ variable: lexicalValue }`, `boolean` is the ASK answer (or `null` for a
+     * SELECT), and `snapshot.served_at_seq` is the commit an eventual or pinned
+     * read answered from (`snapshot` is `null` for a plain strong read).
      */
     sparqlRows(body: Schemas["SparqlTextRequest"], opts?: ReadConsistencyOptions): Promise<SparqlResults>;
     /**
@@ -410,8 +389,6 @@ export declare class LbbClient {
      * migration is needed — and a request that changes nothing is a no-op.
      */
     evolveOntology(body: Schemas["OntologyEvolveRequest"]): Promise<Schemas["OntologyEvolveResponse"]>;
-    /** Suggest ontology additions from the current graph without mutating it. */
-    induceOntology(body: Schemas["OntologyInduceRequest"]): Promise<Schemas["OntologyInduceResponse"]>;
     /** Fold the WAL tail into snapshot segments. */
     compact(opts?: {
         minTailCommits?: number;
@@ -425,9 +402,23 @@ export declare class LbbClient {
     }): Promise<Schemas["GraphMetadataResponse"]>;
     /** Automatic publication lifecycle, available before the first generation exists. */
     publicationStatus(): Promise<Schemas["PublicationStatusResponse"]>;
+    /** Background work on the graph: publication, compaction, query
+     * statistics, validation, embeddings, and imports, exports, forks and
+     * index upgrades. One call reads at most 30 objects, so a status view can
+     * poll it every few seconds. Needs the server capability
+     * `graph_activity_v1`. */
+    activity(): Promise<Schemas["GraphActivityResponse"]>;
     /** The managed models the platform uses per role (embedding, judge,
      * rewriter): the operator's catalog, or the compiled defaults. */
     managedModels(): Promise<Schemas["ManagedModelsResponse"]>;
+    /** What each managed model did for the stack in one month (`yyyy-mm`,
+     * UTC; the current month by default): totals, by day and by graph per
+     * feature (`index`, `search`, `fit`, `judge`, `training`) and model, the
+     * months with activity, and the model each feature uses now. A stack
+     * read: the graph scope is not used. */
+    modelActivity(opts?: {
+        month?: string;
+    }): Promise<Schemas["ModelActivityResponse"]>;
     /** Wait until background reconciliation folds `targetSeq` into the RDF base. */
     waitForPublished(targetSeq: number, opts?: {
         timeoutMs?: number;
@@ -435,6 +426,18 @@ export declare class LbbClient {
     }): Promise<Schemas["PublicationStatusResponse"]>;
     /** Graph counts and type/relation buckets. Carries `consistency`/`min_indexed_seq` on the URL. */
     summary(opts?: ReadConsistencyOptions): Promise<Schemas["GraphSummaryResponse"]>;
+    /**
+     * The SPARQL planner's statistics for the published generation latest reads
+     * use: per-predicate triple and distinct counts (by triple count, paged by
+     * `cursor`/`limit`, 200 by default and 500 at most), key-histogram,
+     * pair-count and trigram sidecars, and value-order index coverage. Read from
+     * the generation's manifest and sidecar metadata; nothing scans the graph.
+     * A graph with no published generation answers `served_at_seq: null`.
+     */
+    plannerStats(opts?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<Schemas["PlannerStatsResponse"]>;
     /** Pinned published read root and its query/conformance lag against one coherent head. */
     readSnapshot(): Promise<Schemas["PublishedReadStatusResponse"]>;
     /**

package/dist/client.js

@@ -1,5 +1,6 @@
-import { parseSparqlResults } from "./types.js";
-import { bodyMarksTerminal, errorCodeFromBody, fullJitterBackoffMs, parseLbbError, parseResponseJson, retryAllowed, retryableStatus, retryDelayMs, sleep, } from "./transport.js";
+import { WorkflowNamespace } from "./workflows.js";
+import { parseSparqlResults, profileBody } from "./types.js";
+import { bodyMarksTerminal, errorCodeFromBody, fullJitterBackoffMs, parseLbbError, parseResponseJson, retriesNetworkFailure, retriesStatus, retryAllowed, retryableStatus, retryDelayMs, sleep, } from "./transport.js";
 import { LbbCapabilityError } from "./transport.js";
 import { EntityNamespace, GraphNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace, EvalsNamespace, EmbeddingsNamespace, } from "./namespaces.js";
 export { parseSparqlResults } from "./types.js";
@@ -111,6 +112,7 @@ export class LbbClient {
     query;
     evals;
     embeddings;
+    workflows;
     constructor(options) {
         const baseUrl = options.baseUrl?.trim();
         if (!baseUrl) {
@@ -154,6 +156,7 @@ export class LbbClient {
         this.query = new QueryNamespace(this);
         this.evals = new EvalsNamespace(this);
         this.embeddings = new EmbeddingsNamespace(this);
+        this.workflows = new WorkflowNamespace(this);
     }
     graph(name, opts = {}) {
         return new GraphNamespace(this.withScope({
@@ -237,7 +240,7 @@ export class LbbClient {
         if (opts.idempotencyKey !== undefined)
             headers["idempotency-key"] = opts.idempotencyKey;
         Object.assign(headers, opts.headers ?? {});
-        const canRetry = opts.retry ?? retryAllowed(method, opts.idempotencyKey);
+        const retry = opts.retry ?? retryAllowed(method, opts.idempotencyKey);
         const body = opts.rawBody !== undefined
             ? opts.rawBody
             : opts.body !== undefined
@@ -302,7 +305,9 @@ export class LbbClient {
                         cause: error,
                     }), { name: "TimeoutError" })
                     : error;
-                if (!callerAborted && canRetry && attempt < maxRetries) {
+                if (!callerAborted &&
+                    retriesNetworkFailure(retry) &&
+                    attempt < maxRetries) {
                     const delayMs = fullJitterBackoffMs(this.retryDelayMs, attempt);
                     if (Date.now() + delayMs <= deadline) {
                         this.onRetry?.({
@@ -329,7 +334,7 @@ export class LbbClient {
                 attempt === maxRetries) {
                 break;
             }
-            if (!canRetry) {
+            if (!retriesStatus(retry, response.status)) {
                 break;
             }
             // Honor the server's typed body verdict: a terminal error
@@ -804,45 +809,6 @@ export class LbbClient {
     searchFeedbackExport() {
         return this.request("GET", "/v1/search/feedback/export");
     }
-    /**
-     * Ranked incoming/outgoing neighborhood for a graph entity.
-     *
-     * `edges` caps the edges returned per direction (default 1000, maximum
-     * 10000). When a cap cuts a direction the response carries a `truncation`
-     * block; an uncut response omits it entirely.
-     */
-    entityNeighborhood(opts) {
-        return this.request("GET", "/v1/graph/entity/neighborhood", {
-            query: {
-                id: opts.id,
-                type: opts.type,
-                name: opts.name,
-                relations: opts.relations?.join(","),
-                as_of: opts.asOf,
-                edges: opts.edges,
-            },
-        });
-    }
-    /** Exact type cardinality plus a bounded deterministic sample from Base. */
-    entityTypeSample(opts) {
-        const { type, limit, ...request } = opts;
-        return this.request("GET", "/v1/graph/entities/sample", {
-            ...request,
-            query: { type, limit },
-        });
-    }
-    /** Stored entity object-ref status and index-coverage metadata (no
-     * attributes — read those from `entityDetail`'s top-level `attributes`). */
-    entityMetadata(opts) {
-        return this.request("GET", "/v1/graph/entity/metadata", {
-            query: {
-                id: opts.id,
-                type: opts.type,
-                name: opts.name,
-                as_of: opts.asOf,
-            },
-        });
-    }
     /**
      * Read projected attributes and current relationships from one RDF snapshot.
      * Inspect `unavailable_sections` before interpreting legacy provenance arrays.
@@ -879,23 +845,7 @@ export class LbbClient {
             cursor = page.next_cursor;
         }
     }
-    // --- temporal / lineage / shapes ---
-    /** Current state of an entity's relations, optionally as-of a timestamp. */
-    currentState(body) {
-        return this.request("POST", "/v1/query/state", { body });
-    }
-    /** Full edge-event history for a relationship. */
-    history(body) {
-        return this.request("POST", "/v1/query/history", { body });
-    }
-    /** Ordered state-transition log for an entity's relation, with dwell time. */
-    transitions(body) {
-        return this.request("POST", "/v1/query/transitions", { body });
-    }
-    /** Lineage and evidence for a single edge. */
-    why(body) {
-        return this.request("POST", "/v1/query/why", { body });
-    }
+    // --- query ---
     /**
      * SPARQL-subset SELECT/ASK/aggregate query (FILTER, HAVING, ORDER BY, ASK,
      * COUNT/SUM/AVG/MIN/MAX). GROUP BY is not limited to entity identity:
@@ -908,22 +858,36 @@ export class LbbClient {
      */
     sparql(body, opts) {
         return this.request("POST", "/v1/query/sparql", {
-            body: this.mergeReadConsistency(body, opts),
+            body: profileBody(this.mergeReadConsistency(body, opts)),
         });
     }
-    /** SPARQL 1.1 query from text (SELECT/ASK) over the live graph; `results` is SPARQL 1.1 Query Results JSON. The text dialect carries `consistency`/`min_indexed_seq` on the URL; a floor with no explicit consistency implies a strong base-plus-delta read. */
+    /**
+     * SPARQL 1.1 query from text (SELECT/ASK) over the live graph; `results` is
+     * SPARQL 1.1 Query Results JSON. The text dialect carries
+     * `consistency`/`min_indexed_seq` on the URL; a floor with no explicit
+     * consistency implies a strong base-plus-delta read. `as_of_commit_seq` in
+     * the body reads the retained published generation of that exact commit.
+     *
+     * The query is read-only, so a retryable `429` (for example
+     * `read_your_writes_pending` while publication catches up to the floor) is
+     * retried within the retry budget. A `5xx` is not retried: a query that
+     * timed out would run again.
+     */
     sparqlText(body, opts) {
         return this.request("POST", "/v1/query/sparql-text", {
-            body,
+            body: profileBody(body),
             query: this.readConsistencyQuery(opts),
+            retry: "rate_limited",
         });
     }
     /**
      * Run a SPARQL 1.1 text query and return parsed results — the ergonomic
      * complement to {@link sparqlText} (which hands back the raw results string).
-     * Returns `{ vars, boolean, bindings, rows }` via {@link parseSparqlResults}:
-     * `rows` is the bindings flattened to `{ variable: lexicalValue }`, `boolean`
-     * is the ASK answer (or `null` for a SELECT).
+     * Returns `{ vars, boolean, bindings, rows, snapshot }` via
+     * {@link parseSparqlResults}: `rows` is the bindings flattened to
+     * `{ variable: lexicalValue }`, `boolean` is the ASK answer (or `null` for a
+     * SELECT), and `snapshot.served_at_seq` is the commit an eventual or pinned
+     * read answered from (`snapshot` is `null` for a plain strong read).
      */
     async sparqlRows(body, opts) {
         return parseSparqlResults(await this.sparqlText(body, opts));
@@ -983,10 +947,6 @@ export class LbbClient {
     evolveOntology(body) {
         return this.request("POST", "/v1/ontology/evolve", { body });
     }
-    /** Suggest ontology additions from the current graph without mutating it. */
-    induceOntology(body) {
-        return this.request("POST", "/v1/ontology/induce", { body, retry: true });
-    }
     /** Fold the WAL tail into snapshot segments. */
     compact(opts = {}) {
         return this.request("POST", "/v1/graph/compact", {
@@ -1013,11 +973,29 @@ export class LbbClient {
     publicationStatus() {
         return this.request("GET", "/v1/graph/publication-status");
     }
+    /** Background work on the graph: publication, compaction, query
+     * statistics, validation, embeddings, and imports, exports, forks and
+     * index upgrades. One call reads at most 30 objects, so a status view can
+     * poll it every few seconds. Needs the server capability
+     * `graph_activity_v1`. */
+    activity() {
+        return this.request("GET", "/v1/graph/activity");
+    }
     /** The managed models the platform uses per role (embedding, judge,
      * rewriter): the operator's catalog, or the compiled defaults. */
     managedModels() {
         return this.request("GET", "/v1/managed-models");
     }
+    /** What each managed model did for the stack in one month (`yyyy-mm`,
+     * UTC; the current month by default): totals, by day and by graph per
+     * feature (`index`, `search`, `fit`, `judge`, `training`) and model, the
+     * months with activity, and the model each feature uses now. A stack
+     * read: the graph scope is not used. */
+    modelActivity(opts = {}) {
+        return this.request("GET", "/v1/models/activity", {
+            query: { month: opts.month },
+        });
+    }
     /** Wait until background reconciliation folds `targetSeq` into the RDF base. */
     async waitForPublished(targetSeq, opts = {}) {
         if (!Number.isSafeInteger(targetSeq) || targetSeq < 0) {
@@ -1054,6 +1032,19 @@ export class LbbClient {
             query: this.readConsistencyQuery(opts),
         });
     }
+    /**
+     * The SPARQL planner's statistics for the published generation latest reads
+     * use: per-predicate triple and distinct counts (by triple count, paged by
+     * `cursor`/`limit`, 200 by default and 500 at most), key-histogram,
+     * pair-count and trigram sidecars, and value-order index coverage. Read from
+     * the generation's manifest and sidecar metadata; nothing scans the graph.
+     * A graph with no published generation answers `served_at_seq: null`.
+     */
+    plannerStats(opts = {}) {
+        return this.request("GET", "/v1/graph/planner-stats", {
+            query: { cursor: opts.cursor, limit: opts.limit },
+        });
+    }
     /** Pinned published read root and its query/conformance lag against one coherent head. */
     readSnapshot() {
         return this.request("GET", "/v1/graph/read-snapshot");

package/dist/index.d.ts

@@ -1,3 +1,5 @@
 export { LbbCapabilityError, LbbClient, LbbError, parseSparqlResults, } from "./client.js";
 export type { DurableImportLine, DurableImportSource, LbbClientOptions, CallOptions, RequestOptions, LbbRequestEvent, LbbResponseEvent, FetchLike, ReadConsistencyOptions, SearchConsistency, Schemas, SparqlResults, SparqlResultsJson, SparqlTerm, CommitRequest, CommitResponse, Entity, EntitySelector, GraphMetadata, GraphSummary, SchemaView, Snapshot, } from "./client.js";
 export type { components, paths, operations } from "./schema.js";
+export { workflow, WorkflowWorker, WorkflowHandle, WorkflowNamespace, WorkflowError, } from "./workflows.js";
+export type { WorkflowContext, WorkflowStepOptions, WorkflowStepContext, WorkflowSignalResult, WorkflowDefinition, WorkflowResult, } from "./workflows.js";

package/dist/index.js

@@ -1 +1,2 @@
 export { LbbCapabilityError, LbbClient, LbbError, parseSparqlResults, } from "./client.js";
+export { workflow, WorkflowWorker, WorkflowHandle, WorkflowNamespace, WorkflowError, } from "./workflows.js";

package/dist/namespaces.d.ts

@@ -1,6 +1,12 @@
+import type { WorkflowNamespace } from "./workflows.js";
 import type { LbbClient } from "./client.js";
 import type { CallOptions } from "./transport.js";
 import { type EntityAttributeFilterOptions, type ImportLine, type ReadConsistencyOptions, type RdfImportDocument, type RdfImportManyResult, type RdfImportOptions, type Schemas } from "./types.js";
+/** Ask the server to return its measurements for one query. */
+export interface ProfileOption {
+    /** Same as `profile: true` in the request body. */
+    profile?: boolean;
+}
 export declare class GraphNamespace {
     private readonly client;
     readonly facts: FactsNamespace;
@@ -11,9 +17,20 @@ export declare class GraphNamespace {
     readonly search: SearchNamespace;
     readonly evals: EvalsNamespace;
     readonly embeddings: EmbeddingsNamespace;
+    readonly workflows: WorkflowNamespace;
     constructor(client: LbbClient);
     /** Publication lifecycle for this graph, including pre-first-publish state. */
     publicationStatus(): Promise<Schemas["PublicationStatusResponse"]>;
+    /** Background work on this graph. See {@link LbbClient.activity}. */
+    activity(): Promise<Schemas["GraphActivityResponse"]>;
+    /**
+     * The SPARQL planner's statistics for the published generation latest reads
+     * use. See {@link LbbClient.plannerStats}.
+     */
+    plannerStats(opts?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<Schemas["PlannerStatsResponse"]>;
     /** Wait until this graph has an exact generation covering `targetSeq`. */
     waitForPublished(targetSeq: number, opts?: {
         timeoutMs?: number;
@@ -61,20 +78,6 @@ export declare class SearchNamespace {
 export declare class EntityNamespace {
     private readonly client;
     constructor(client: LbbClient);
-    /**
-     * Return the exact type cardinality and a bounded deterministic sample from
-     * the Base family pinned by the published generation.
-     */
-    sample(opts: {
-        type: string;
-        limit?: number;
-    } & CallOptions): Promise<Schemas["EntityTypeSampleResponse"]>;
-    get(opts: {
-        id?: string;
-        type?: string;
-        name?: string;
-        asOf?: string;
-    }): Promise<Schemas["EntityMetadataResponse"]>;
     detail(opts: Parameters<LbbClient["entityDetail"]>[0]): Promise<Schemas["EntityDetailResponse"]>;
     /**
      * Filter entities already bound by relation patterns using typed attributes,
@@ -177,14 +180,67 @@ export declare class SchemaNamespace {
         dryRun?: boolean;
     }): Promise<Schemas["SchemaPublishResponse"]>;
 }
+/** Filters for {@link OntologySuggestionsNamespace.list}. */
+export interface OntologySuggestionListOptions extends CallOptions {
+    status?: Schemas["OntologyChangeSuggestionStatus"];
+    originKind?: Schemas["SuggestionOriginKind"];
+    /** Producer id, for example an integration connection id. */
+    originId?: string;
+    /** Class, property or relation name. */
+    anchor?: string;
+    key?: string;
+    /** Default 100, maximum 500. */
+    limit?: number;
+}
+/**
+ * Ontology change suggestions: durable proposals from integrations,
+ * agents and people. People accept or dismiss them; accepting
+ * applies the change to the current ontology.
+ */
+export declare class OntologySuggestionsNamespace {
+    private readonly client;
+    constructor(client: LbbClient);
+    /** Newest update first, with counts per status over the whole graph. */
+    list(options?: OntologySuggestionListOptions): Promise<Schemas["OntologyChangeSuggestionList"]>;
+    /** One suggestion with its evidence, impact and discussion. */
+    get(suggestionId: string, opts?: CallOptions): Promise<Schemas["OntologyChangeSuggestion"]>;
+    /**
+     * File a suggestion, or update the one with the same `key`. The server
+     * dry-runs the change and never changes the ontology here, so a retry is
+     * safe.
+     */
+    create(body: Schemas["OntologyChangeSuggestionCreateRequest"], opts?: CallOptions): Promise<Schemas["OntologyChangeSuggestion"]>;
+    /** Dry-run the change against the current ontology and store the impact. */
+    validate(suggestionId: string, opts?: CallOptions): Promise<Schemas["OntologyChangeSuggestion"]>;
+    /**
+     * Apply the change to the current ontology. Pass `change` to accept an
+     * edited change. Accepting twice returns the accepted suggestion.
+     */
+    accept(suggestionId: string, body?: Schemas["OntologyChangeSuggestionAcceptRequest"], opts?: CallOptions): Promise<Schemas["OntologyChangeSuggestion"]>;
+    /** Decline with a reason. The ontology does not change. */
+    dismiss(suggestionId: string, body: Schemas["OntologyChangeSuggestionDecisionRequest"], opts?: CallOptions): Promise<Schemas["OntologyChangeSuggestion"]>;
+    /** Withdraw as the producer, for example when the source field is gone. */
+    supersede(suggestionId: string, body: Schemas["OntologyChangeSuggestionDecisionRequest"], opts?: CallOptions): Promise<Schemas["OntologyChangeSuggestion"]>;
+    /** Add a comment to the discussion. */
+    comment(suggestionId: string, body: Schemas["OntologyChangeSuggestionCommentRequest"], opts?: CallOptions): Promise<Schemas["OntologyChangeSuggestion"]>;
+}
 /** Ontology discovery and lifecycle operations. */
 export declare class OntologyNamespace {
     private readonly client;
+    /** Reviewable change suggestions from every producer. */
+    readonly suggestions: OntologySuggestionsNamespace;
     constructor(client: LbbClient);
     view(options?: {
         counts?: boolean;
     } & CallOptions): Promise<Schemas["OntologyView"]>;
-    conformance(opts?: CallOptions & Pick<ReadConsistencyOptions, "consistency">): Promise<Schemas["SchemaAuditReport"]>;
+    /**
+     * Read the published SHACL conformance report. `limit` bounds the returned
+     * `results` (server default 200, maximum 2,000); `result_count` and
+     * `conforms` stay exact, and `truncated` says the window is partial.
+     */
+    conformance(opts?: CallOptions & Pick<ReadConsistencyOptions, "consistency"> & {
+        limit?: number;
+    }): Promise<Schemas["SchemaAuditReport"]>;
     search(body: Schemas["OntologySearchRequest"], opts?: CallOptions): Promise<Schemas["OntologySearchResponse"]>;
     resolve(body: Schemas["OntologyResolveRequest"], opts?: CallOptions): Promise<Schemas["OntologyResolveResponse"]>;
     /**
@@ -195,13 +251,18 @@ export declare class OntologyNamespace {
     evolve(body: Schemas["OntologyEvolveRequest"], opts?: CallOptions & {
         dryRun?: boolean;
     }): Promise<Schemas["OntologyEvolveResponse"]>;
-    induce(body: Schemas["OntologyInduceRequest"], opts?: CallOptions): Promise<Schemas["OntologyInduceResponse"]>;
 }
 /** Structured and SPARQL-text query operations. */
 export declare class QueryNamespace {
     private readonly client;
     constructor(client: LbbClient);
     structured(body: Schemas["SparqlSelectRequest"], opts?: CallOptions & ReadConsistencyOptions): Promise<Schemas["SparqlSelectResponse"]>;
-    sparql(body: Schemas["SparqlTextRequest"], opts?: CallOptions & ReadConsistencyOptions): Promise<import("./types.js").SparqlResults>;
-    sparqlRaw(body: Schemas["SparqlTextRequest"], opts?: CallOptions & ReadConsistencyOptions): Promise<Schemas["SparqlTextResponse"]>;
+    /**
+     * Run a SPARQL text query and parse its rows. `profile: true` (in `opts` or
+     * the body) returns the server's measurements in `profile`; a profiled
+     * request never uses the result cache.
+     */
+    sparql(body: Schemas["SparqlTextRequest"], opts?: CallOptions & ReadConsistencyOptions & ProfileOption): Promise<import("./types.js").SparqlResults>;
+    /** As {@link sparql}, returning the raw response with its `results` string. */
+    sparqlRaw(body: Schemas["SparqlTextRequest"], opts?: CallOptions & ReadConsistencyOptions & ProfileOption): Promise<Schemas["SparqlTextResponse"]>;
 }