@littlebigbrain/client 0.15.0 → 0.16.0

package/dist/client.d.ts

@@ -1,3 +1,4 @@
+import { WorkflowNamespace } from "./workflows.js";
 import type { DurableImportSource, ImportLine, LbbClientOptions, ListResponse, RawLbbResponse, ReadConsistencyOptions, RdfImportDocument, RdfImportManyResult, RdfImportOptions, Schemas, SearchConsistency, SparqlResults } from "./types.js";
 import { type RequestOptions } from "./transport.js";
 import { EntityNamespace, GraphNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace, EvalsNamespace, EmbeddingsNamespace } from "./namespaces.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;
@@ -387,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;
@@ -402,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;
@@ -412,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,4 +1,5 @@
-import { parseSparqlResults } from "./types.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";
@@ -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({
@@ -855,7 +858,7 @@ export class LbbClient {
      */
     sparql(body, opts) {
         return this.request("POST", "/v1/query/sparql", {
-            body: this.mergeReadConsistency(body, opts),
+            body: profileBody(this.mergeReadConsistency(body, opts)),
         });
     }
     /**
@@ -872,7 +875,7 @@ export class LbbClient {
      */
     sparqlText(body, opts) {
         return this.request("POST", "/v1/query/sparql-text", {
-            body,
+            body: profileBody(body),
             query: this.readConsistencyQuery(opts),
             retry: "rate_limited",
         });
@@ -944,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", {
@@ -974,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) {
@@ -1015,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;
@@ -163,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"]>;
     /**
@@ -181,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"]>;
 }

package/dist/namespaces.js

@@ -1,4 +1,4 @@
-import { attributeFilter, firstPatternVariable, parseSparqlResults, } from "./types.js";
+import { attributeFilter, firstPatternVariable, parseSparqlResults, profileBody, } from "./types.js";
 // SPARQL is the query language. Search by meaning is `embeddings.search`
 // (`POST /v1/search`); the older search, embedding, decode, groundability,
 // and analytics operations were removed with their routes.
@@ -16,6 +16,9 @@ function withReadConsistency(client, body, opts) {
     }
     return merged;
 }
+function withProfile(body, opts) {
+    return profileBody(body, opts.profile);
+}
 export class GraphNamespace {
     client;
     facts;
@@ -26,6 +29,7 @@ export class GraphNamespace {
     search;
     evals;
     embeddings;
+    workflows;
     constructor(client) {
         this.client = client;
         this.facts = new FactsNamespace(client);
@@ -36,11 +40,23 @@ export class GraphNamespace {
         this.search = client.search;
         this.evals = client.evals;
         this.embeddings = client.embeddings;
+        this.workflows = client.workflows;
     }
     /** Publication lifecycle for this graph, including pre-first-publish state. */
     publicationStatus() {
         return this.client.publicationStatus();
     }
+    /** Background work on this graph. See {@link LbbClient.activity}. */
+    activity() {
+        return this.client.activity();
+    }
+    /**
+     * The SPARQL planner's statistics for the published generation latest reads
+     * use. See {@link LbbClient.plannerStats}.
+     */
+    plannerStats(opts = {}) {
+        return this.client.plannerStats(opts);
+    }
     /** Wait until this graph has an exact generation covering `targetSeq`. */
     waitForPublished(targetSeq, opts = {}) {
         return this.client.waitForPublished(targetSeq, opts);
@@ -371,11 +387,105 @@ export class SchemaNamespace {
         });
     }
 }
+/**
+ * Ontology change suggestions: durable proposals from integrations,
+ * agents and people. People accept or dismiss them; accepting
+ * applies the change to the current ontology.
+ */
+export class OntologySuggestionsNamespace {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /** Newest update first, with counts per status over the whole graph. */
+    list(options = {}) {
+        const { status, originKind, originId, anchor, key, limit, ...opts } = options;
+        return this.client.request("GET", "/v1/ontology/suggestions", {
+            ...opts,
+            query: {
+                status,
+                origin_kind: originKind,
+                origin_id: originId,
+                anchor,
+                key,
+                limit,
+            },
+        });
+    }
+    /** One suggestion with its evidence, impact and discussion. */
+    get(suggestionId, opts = {}) {
+        return this.client.request("GET", "/v1/ontology/suggestions/detail", {
+            ...opts,
+            query: { suggestion_id: suggestionId },
+        });
+    }
+    /**
+     * 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, opts = {}) {
+        return this.client.request("POST", "/v1/ontology/suggestions", {
+            ...opts,
+            retry: opts.retry ?? true,
+            body,
+        });
+    }
+    /** Dry-run the change against the current ontology and store the impact. */
+    validate(suggestionId, opts = {}) {
+        return this.client.request("POST", "/v1/ontology/suggestions/validate", {
+            ...opts,
+            retry: opts.retry ?? true,
+            query: { suggestion_id: suggestionId },
+        });
+    }
+    /**
+     * Apply the change to the current ontology. Pass `change` to accept an
+     * edited change. Accepting twice returns the accepted suggestion.
+     */
+    accept(suggestionId, body = {}, opts = {}) {
+        return this.client.request("POST", "/v1/ontology/suggestions/accept", {
+            ...opts,
+            retry: opts.retry ?? true,
+            query: { suggestion_id: suggestionId },
+            body,
+        });
+    }
+    /** Decline with a reason. The ontology does not change. */
+    dismiss(suggestionId, body, opts = {}) {
+        return this.client.request("POST", "/v1/ontology/suggestions/dismiss", {
+            ...opts,
+            retry: opts.retry ?? true,
+            query: { suggestion_id: suggestionId },
+            body,
+        });
+    }
+    /** Withdraw as the producer, for example when the source field is gone. */
+    supersede(suggestionId, body, opts = {}) {
+        return this.client.request("POST", "/v1/ontology/suggestions/supersede", {
+            ...opts,
+            retry: opts.retry ?? true,
+            query: { suggestion_id: suggestionId },
+            body,
+        });
+    }
+    /** Add a comment to the discussion. */
+    comment(suggestionId, body, opts = {}) {
+        return this.client.request("POST", "/v1/ontology/suggestions/comment", {
+            ...opts,
+            query: { suggestion_id: suggestionId },
+            body,
+        });
+    }
+}
 /** Ontology discovery and lifecycle operations. */
 export class OntologyNamespace {
     client;
+    /** Reviewable change suggestions from every producer. */
+    suggestions;
     constructor(client) {
         this.client = client;
+        this.suggestions = new OntologySuggestionsNamespace(client);
     }
     view(options = {}) {
         const { counts, ...request } = options;
@@ -384,11 +494,18 @@ export class OntologyNamespace {
             query: counts ? { counts: true } : undefined,
         });
     }
+    /**
+     * 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 = {}) {
+        const { limit, ...rest } = opts;
         return this.client.request("GET", "/v1/ontology/conformance", {
-            ...opts,
+            ...rest,
             query: {
                 consistency: opts.consistency ?? this.client.defaultConsistency,
+                ...(limit !== undefined ? { limit } : {}),
             },
         });
     }
@@ -423,13 +540,6 @@ export class OntologyNamespace {
             body,
         });
     }
-    induce(body, opts = {}) {
-        return this.client.request("POST", "/v1/ontology/induce", {
-            ...opts,
-            retry: opts.retry ?? true,
-            body,
-        });
-    }
 }
 /** Structured and SPARQL-text query operations. */
 export class QueryNamespace {
@@ -441,15 +551,20 @@ export class QueryNamespace {
         return this.client.request("POST", "/v1/query/sparql", {
             ...opts,
             retry: opts.retry ?? true,
-            body: withReadConsistency(this.client, body, opts),
+            body: profileBody(withReadConsistency(this.client, body, opts)),
         });
     }
+    /**
+     * 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.
+     */
     async sparql(body, opts = {}) {
         // The text dialect carries consistency/floor on the URL, not the body.
         const response = await this.client.request("POST", "/v1/query/sparql-text", {
             ...opts,
             retry: opts.retry ?? true,
-            body,
+            body: withProfile(body, opts),
             query: {
                 consistency: opts.consistency ?? this.client.defaultConsistency,
                 min_indexed_seq: opts.minIndexedSeq,
@@ -457,11 +572,12 @@ export class QueryNamespace {
         });
         return parseSparqlResults(response);
     }
+    /** As {@link sparql}, returning the raw response with its `results` string. */
     sparqlRaw(body, opts = {}) {
         return this.client.request("POST", "/v1/query/sparql-text", {
             ...opts,
             retry: opts.retry ?? true,
-            body,
+            body: withProfile(body, opts),
             query: {
                 consistency: opts.consistency ?? this.client.defaultConsistency,
                 min_indexed_seq: opts.minIndexedSeq,