@littlebigbrain/client 0.7.0 → 0.8.1

package/dist/namespaces.d.ts

@@ -1,19 +1,18 @@
 import type { LbbClient } from "./client.js";
 import type { CallOptions } from "./transport.js";
-import { type EntityAttributeFilterOptions, type ImportLine, type ListResponse, type RdfExportOptions, type RdfImportOptions, type Schemas } from "./types.js";
+import { type EntityAttributeFilterOptions, type ImportLine, type ReadConsistencyOptions, type RdfImportOptions, type Schemas } from "./types.js";
 export interface HybridSearchOptions extends CallOptions {
     topK?: number;
-    source?: string;
     consistency?: string;
+    /** A5 read-your-writes floor (`min_indexed_seq`): the committed sequence a
+     * write returned; under eventual, an uncovered floor yields a retryable
+     * `read_your_writes_pending` 429. */
+    minIndexedSeq?: number;
     lexical?: boolean;
     bm25?: boolean;
     vector?: boolean;
     targets?: string[];
     profile?: string;
-    /** Valid-time cursor (RFC 3339): results reflect facts true at this instant. */
-    asOf?: string;
-    /** Snapshot pin: results reproduce the graph as of this commit sequence. */
-    asOfCommitSeq?: number;
     /** Opt-in impression logging for later relevance feedback. */
     logImpression?: boolean;
 }
@@ -22,7 +21,6 @@ export declare class GraphNamespace {
     readonly facts: FactsNamespace;
     readonly context: ContextNamespace;
     readonly entities: EntityNamespace;
-    readonly indexes: IndexNamespace;
     readonly ontology: OntologyNamespace;
     readonly query: QueryNamespace;
     readonly schema: SchemaNamespace;
@@ -64,8 +62,6 @@ export declare class GraphNamespace {
     }): Promise<Schemas["ManagedEmbeddingPromoteResponse"]>;
     /** Retract edges/entities from the scoped graph. See {@link LbbClient.retract}. */
     retract(body: Schemas["GraphRetractRequest"], opts?: CallOptions): Promise<Schemas["GraphRetractResponse"]>;
-    /** Export this graph's current snapshot as Turtle, N-Triples, TriG, or N-Quads. */
-    exportRdf(opts?: RdfExportOptions): Promise<string>;
 }
 export declare class FactsNamespace {
     private readonly client;
@@ -76,7 +72,6 @@ export declare class FactsNamespace {
         batch?: number;
         strict?: boolean;
         observedAt?: string;
-        index?: boolean;
         idempotencyKey?: string;
     }): Promise<Schemas["GraphImportResponse"]>;
     /**
@@ -96,74 +91,21 @@ export declare class SearchNamespace {
     feedback(body: Schemas["SearchFeedbackRequest"], opts?: CallOptions): Promise<Schemas["SearchFeedbackResponse"]>;
     feedbackExport(opts?: CallOptions): Promise<Schemas["SearchFeedbackExportResponse"]>;
     feedbackSummary(opts?: CallOptions): Promise<Schemas["SearchFeedbackSummaryResponse"]>;
-    fullText(body: Schemas["FullTextSearchRequest"], opts?: CallOptions): Promise<Schemas["FullTextSearchResponse"]>;
-    vector(body: Schemas["EmbeddingSearchRequest"], opts?: CallOptions): Promise<Schemas["EmbeddingSearchResponse"]>;
-}
-export declare class SchemaNamespace {
-    private readonly client;
-    constructor(client: LbbClient);
-    /** Active graph schema bundle: ontology plus activated SHACL shapes. */
-    view(opts?: {
-        audit?: boolean;
-    } & CallOptions): Promise<Schemas["SchemaBundleView"]>;
-    /** Preview a proposed RDF/SHACL schema bundle and audit current data. */
-    preview(body: Schemas["SchemaPreviewRequest"], opts?: CallOptions): Promise<Schemas["SchemaPreviewResponse"]>;
-    /** Activate a previewed SHACL schema bundle for this graph branch. */
-    publish(body: Schemas["SchemaPublishRequest"], opts?: CallOptions): Promise<Schemas["SchemaPublishResponse"]>;
-    /** Audit current data against the active SHACL schema bundle. */
-    audit(opts?: CallOptions): Promise<Schemas["SchemaAuditReport"]>;
-}
-export declare class IndexNamespace {
-    private readonly client;
-    constructor(client: LbbClient);
-    run(opts?: {
-        wait?: boolean;
-        background?: boolean;
-        body?: unknown;
-    } & CallOptions): Promise<unknown>;
-    build(opts?: {
-        background?: boolean;
-    } & CallOptions): Promise<unknown>;
-    delta(opts?: CallOptions): Promise<Schemas["IndexDeltaResponse"]>;
-    submit(body: Partial<Schemas["IndexBuildOptions"]> | undefined, opts: CallOptions & {
-        idempotencyKey: string;
-    }): Promise<Schemas["SearchIndexJobStatusResponse"]>;
-    job(jobId: string, opts?: CallOptions): Promise<Schemas["SearchIndexJobStatusResponse"]>;
-    cancel(jobId: string, opts?: CallOptions): Promise<Schemas["SearchIndexJobStatusResponse"]>;
-    gc(opts?: {
-        keepRuns?: number;
-        dryRun?: boolean;
-    } & CallOptions): Promise<Schemas["IndexGcResponse"]>;
-    submitGc(body: Schemas["IndexGcRequest"] | undefined, opts: CallOptions & {
-        idempotencyKey: string;
-    }): Promise<Schemas["IndexGcJobStatusResponse"]>;
-    gcJob(jobId: string, opts?: CallOptions): Promise<Schemas["IndexGcJobStatusResponse"]>;
-    cancelGc(jobId: string, opts?: CallOptions): Promise<Schemas["IndexGcJobStatusResponse"]>;
+    fullText(body: Schemas["FullTextSearchRequest"], opts?: CallOptions & ReadConsistencyOptions): Promise<Schemas["FullTextSearchResponse"]>;
+    vector(body: Schemas["EmbeddingSearchRequest"], opts?: CallOptions & ReadConsistencyOptions): Promise<Schemas["EmbeddingSearchResponse"]>;
 }
 export declare class EntityNamespace {
     private readonly client;
     constructor(client: LbbClient);
     /**
      * Return the exact type cardinality and a bounded deterministic sample from
-     * the ranged adjacency index. The server returns `index_busy` rather than
-     * falling back to an exhaustive snapshot scan when the index is unavailable.
+     * the ranged adjacency family pinned by the published generation. A missing
+     * family fails closed rather than falling back to an exhaustive scan.
      */
     sample(opts: {
         type: string;
         limit?: number;
     } & CallOptions): Promise<Schemas["EntityTypeSampleResponse"]>;
-    /**
-     * Browse entities as the unified list envelope. Pass `fields` (names or `*`)
-     * to inline each row's typed attributes as native JSON (under `attributes`) —
-     * "list entities and their titles" in one call instead of a list plus N point
-     * lookups — or `ids`
-     * to fetch a specific set. Page with `cursor` from the previous `next_cursor`.
-     */
-    list(opts?: EntityListOptions): Promise<ListResponse<Schemas["EntityExplorerRow"]>>;
-    /** Yield list envelopes while following `next_cursor` until exhaustion. */
-    pages(opts?: EntityListOptions): AsyncGenerator<ListResponse<Schemas["EntityExplorerRow"]>>;
-    /** Yield entities directly while following the server's stable cursor. */
-    iterate(opts?: EntityListOptions): AsyncGenerator<Schemas["EntityExplorerRow"]>;
     get(opts: {
         id?: string;
         type?: string;
@@ -183,23 +125,10 @@ export declare class EntityNamespace {
      */
     filterByAttributes(opts: EntityAttributeFilterOptions): Promise<Schemas["SparqlSelectResponse"]>;
 }
-export interface EntityListOptions extends CallOptions {
-    type?: string;
-    limit?: number;
-    cursor?: string | number;
-    /** @deprecated Legacy alias for `cursor`. */
-    offset?: number;
-    query?: string;
-    /** Property names to inline per row (or `"*"` / `["*"]` for all). */
-    fields?: string | string[];
-    /** Specific entity ids to fetch in one call (bulk lookup). */
-    ids?: string | string[];
-}
-/** Grounding and answer operations over the graph's real vocabulary. */
+/** Grounding operations over one pinned published vocabulary. */
 export declare class ContextNamespace {
     private readonly client;
     constructor(client: LbbClient);
-    ask(body: Schemas["AskRequest"], opts?: CallOptions): Promise<Schemas["AskResponse"]>;
     suggest(body: Schemas["SearchSuggestRequest"], opts?: CallOptions): Promise<Schemas["SearchSuggestResponse"]>;
     resolve(body: Schemas["ResolveTermRequest"], opts?: CallOptions): Promise<Schemas["ResolveTermResponse"]>;
     decode(body: Schemas["DecodeRequest"], opts?: CallOptions): Promise<Schemas["DecodeResponse"]>;
@@ -207,6 +136,15 @@ export declare class ContextNamespace {
         sample?: number;
     } & CallOptions): Promise<Schemas["GroundabilityReport"]>;
 }
+/** Active ontology/SHACL bundle metadata and atomic publication. */
+export declare class SchemaNamespace {
+    private readonly client;
+    constructor(client: LbbClient);
+    /** Read active metadata without running request-time validation. */
+    view(opts?: CallOptions): Promise<Schemas["SchemaBundleView"]>;
+    /** Atomically publish a bundle; conformance is produced asynchronously. */
+    publish(body: Schemas["SchemaPublishRequest"], opts?: CallOptions): Promise<Schemas["SchemaPublishResponse"]>;
+}
 /** Ontology discovery and lifecycle operations. */
 export declare class OntologyNamespace {
     private readonly client;
@@ -214,22 +152,19 @@ export declare class OntologyNamespace {
     view(options?: {
         counts?: boolean;
     } & CallOptions): Promise<Schemas["OntologyView"]>;
-    conformance(opts?: CallOptions): Promise<Schemas["SchemaAuditReport"]>;
+    conformance(opts?: CallOptions & Pick<ReadConsistencyOptions, "consistency">): Promise<Schemas["SchemaAuditReport"]>;
     search(body: Schemas["OntologySearchRequest"], opts?: CallOptions): Promise<Schemas["OntologySearchResponse"]>;
     resolve(body: Schemas["OntologyResolveRequest"], opts?: CallOptions): Promise<Schemas["OntologyResolveResponse"]>;
     define(body: Schemas["OntologyDefineRequest"], opts?: CallOptions): Promise<Schemas["OntologyDefineResponse"]>;
     evolve(body: Schemas["OntologyEvolveRequest"], opts?: CallOptions): Promise<Schemas["OntologyEvolveResponse"]>;
     induce(body: Schemas["OntologyInduceRequest"], opts?: CallOptions): Promise<Schemas["OntologyInduceResponse"]>;
 }
-/** Structured, SPARQL-text, reasoning, and analytical query operations. */
+/** Structured, SPARQL-text, and analytical query operations. */
 export declare class QueryNamespace {
     private readonly client;
     constructor(client: LbbClient);
-    structured(body: Schemas["SparqlSelectRequest"], opts?: CallOptions): Promise<Schemas["SparqlSelectResponse"]>;
-    sparql(body: Schemas["SparqlTextRequest"], opts?: CallOptions): Promise<import("./types.js").SparqlResults>;
-    sparqlRaw(body: Schemas["SparqlTextRequest"], opts?: CallOptions): Promise<Schemas["SparqlTextResponse"]>;
+    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"]>;
     analytics(body: Schemas["AnalyticQueryRequest"], opts?: CallOptions): Promise<Schemas["AnalyticQueryResponse"]>;
-    shacl(body: Schemas["ShaclQueryRequest"], opts?: CallOptions): Promise<Schemas["ShaclQueryResponse"]>;
-    infer(body: Schemas["InferenceRunRequest"], opts?: CallOptions): Promise<Schemas["InferenceRunResponse"]>;
-    premises(body: Schemas["RetrievalPremiseRequest"], opts?: CallOptions): Promise<Schemas["RetrievalPremiseResponse"]>;
 }

package/dist/namespaces.js

@@ -1,4 +1,18 @@
 import { attributeFilter, firstPatternVariable, parseSparqlResults, } from "./types.js";
+/** A5: fold read-consistency options into a request body's `consistency` /
+ * `min_indexed_seq` fields; a per-call value wins over the client default. */
+function withReadConsistency(client, body, opts) {
+    const consistency = opts.consistency ?? client.defaultConsistency;
+    const merged = { ...body };
+    if (consistency !== undefined && merged.consistency === undefined) {
+        merged.consistency = consistency;
+    }
+    if (opts.minIndexedSeq !== undefined &&
+        merged.min_indexed_seq === undefined) {
+        merged.min_indexed_seq = opts.minIndexedSeq;
+    }
+    return merged;
+}
 function transportOptions(options) {
     return {
         idempotencyKey: options.idempotencyKey,
@@ -14,7 +28,6 @@ export class GraphNamespace {
     facts;
     context;
     entities;
-    indexes;
     ontology;
     query;
     schema;
@@ -24,7 +37,6 @@ export class GraphNamespace {
         this.facts = new FactsNamespace(client);
         this.context = client.context;
         this.entities = client.entities;
-        this.indexes = client.indexes;
         this.ontology = client.ontology;
         this.query = client.query;
         this.schema = client.schema;
@@ -116,10 +128,6 @@ export class GraphNamespace {
             body,
         });
     }
-    /** Export this graph's current snapshot as Turtle, N-Triples, TriG, or N-Quads. */
-    exportRdf(opts = {}) {
-        return this.client.exportRdf(opts);
-    }
 }
 export class FactsNamespace {
     client;
@@ -135,7 +143,7 @@ export class FactsNamespace {
     }
     /** Bulk-load a dataset as NDJSON. See {@link LbbClient.import}. */
     import(lines, opts = {}) {
-        const { batch, strict, observedAt, index, ...request } = opts;
+        const { batch, strict, observedAt, ...request } = opts;
         const ndjson = typeof lines === "string"
             ? lines
             : lines.map((line) => JSON.stringify(line)).join("\n");
@@ -144,7 +152,7 @@ export class FactsNamespace {
             idempotencyKey: request.idempotencyKey ?? this.client.idempotencyKey("import"),
             rawBody: ndjson,
             contentType: "application/x-ndjson",
-            query: { batch, strict, observed_at: observedAt, index },
+            query: { batch, strict, observed_at: observedAt },
         });
     }
     /**
@@ -186,10 +194,14 @@ export class SearchNamespace {
     }
     hybrid(input, opts = {}) {
         if (typeof input !== "string") {
+            const search = withReadConsistency(this.client, input.search ?? {}, {
+                consistency: opts.consistency,
+                minIndexedSeq: opts.minIndexedSeq,
+            });
             return this.client.request("POST", "/v1/graph/search", {
                 ...transportOptions(opts),
                 retry: opts.retry ?? true,
-                body: input,
+                body: { ...input, search },
             });
         }
         return this.client.request("GET", "/v1/search", {
@@ -197,15 +209,13 @@ export class SearchNamespace {
             query: {
                 query: input,
                 top_k: opts.topK,
-                source: opts.source,
-                consistency: opts.consistency,
+                consistency: opts.consistency ?? this.client.defaultConsistency,
+                min_indexed_seq: opts.minIndexedSeq,
                 lexical: opts.lexical,
                 bm25: opts.bm25,
                 vector: opts.vector,
                 targets: opts.targets?.join(","),
                 profile: opts.profile,
-                as_of: opts.asOf,
-                as_of_commit_seq: opts.asOfCommitSeq,
                 log_impression: opts.logImpression,
             },
         });
@@ -233,109 +243,14 @@ export class SearchNamespace {
         return this.client.request("POST", "/v1/search/full-text", {
             ...opts,
             retry: opts.retry ?? true,
-            body,
+            body: withReadConsistency(this.client, body, opts),
         });
     }
     vector(body, opts = {}) {
         return this.client.request("POST", "/v1/search/embedding", {
             ...opts,
             retry: opts.retry ?? true,
-            body,
-        });
-    }
-}
-export class SchemaNamespace {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    /** Active graph schema bundle: ontology plus activated SHACL shapes. */
-    view(opts = {}) {
-        const { audit, ...request } = opts;
-        return this.client.request("GET", "/v1/schema", {
-            ...request,
-            query: { audit: audit || undefined },
-        });
-    }
-    /** Preview a proposed RDF/SHACL schema bundle and audit current data. */
-    preview(body, opts = {}) {
-        return this.client.request("POST", "/v1/schema/preview", {
-            ...opts,
-            retry: opts.retry ?? true,
-            body,
-        });
-    }
-    /** Activate a previewed SHACL schema bundle for this graph branch. */
-    publish(body, opts = {}) {
-        return this.client.request("POST", "/v1/schema/publish", { ...opts, body });
-    }
-    /** Audit current data against the active SHACL schema bundle. */
-    audit(opts = {}) {
-        return this.client.request("POST", "/v1/schema/audit", {
-            ...opts,
-            retry: opts.retry ?? true,
-        });
-    }
-}
-export class IndexNamespace {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    run(opts = {}) {
-        const { wait, background: requestedBackground, body, ...request } = opts;
-        const background = requestedBackground ?? (wait === false ? true : undefined);
-        return this.client.request("POST", "/v1/index/run", {
-            ...request,
-            query: { background },
-            body,
-        });
-    }
-    build(opts = {}) {
-        const { background, ...request } = opts;
-        return this.client.request("POST", "/v1/index/build", {
-            ...request,
-            query: { background: background || undefined },
-        });
-    }
-    delta(opts = {}) {
-        return this.client.request("POST", "/v1/index/delta", opts);
-    }
-    submit(body = {}, opts) {
-        return this.client.request("POST", "/v1/index/jobs", { ...opts, body });
-    }
-    job(jobId, opts = {}) {
-        return this.client.request("GET", "/v1/index/jobs", {
-            ...opts,
-            query: { job_id: jobId },
-        });
-    }
-    cancel(jobId, opts = {}) {
-        return this.client.request("DELETE", "/v1/index/jobs", {
-            ...opts,
-            query: { job_id: jobId },
-        });
-    }
-    gc(opts = {}) {
-        const { keepRuns, dryRun, ...request } = opts;
-        return this.client.request("POST", "/v1/index/gc", {
-            ...request,
-            query: { keep_runs: keepRuns, dry_run: dryRun },
-        });
-    }
-    submitGc(body = {}, opts) {
-        return this.client.request("POST", "/v1/index/gc-jobs", { ...opts, body });
-    }
-    gcJob(jobId, opts = {}) {
-        return this.client.request("GET", "/v1/index/gc-jobs", {
-            ...opts,
-            query: { job_id: jobId },
-        });
-    }
-    cancelGc(jobId, opts = {}) {
-        return this.client.request("DELETE", "/v1/index/gc-jobs", {
-            ...opts,
-            query: { job_id: jobId },
+            body: withReadConsistency(this.client, body, opts),
         });
     }
 }
@@ -346,61 +261,12 @@ export class EntityNamespace {
     }
     /**
      * Return the exact type cardinality and a bounded deterministic sample from
-     * the ranged adjacency index. The server returns `index_busy` rather than
-     * falling back to an exhaustive snapshot scan when the index is unavailable.
+     * the ranged adjacency family pinned by the published generation. A missing
+     * family fails closed rather than falling back to an exhaustive scan.
      */
     sample(opts) {
         return this.client.entityTypeSample(opts);
     }
-    /**
-     * Browse entities as the unified list envelope. Pass `fields` (names or `*`)
-     * to inline each row's typed attributes as native JSON (under `attributes`) —
-     * "list entities and their titles" in one call instead of a list plus N point
-     * lookups — or `ids`
-     * to fetch a specific set. Page with `cursor` from the previous `next_cursor`.
-     */
-    list(opts = {}) {
-        const csv = (v) => Array.isArray(v) ? v.join(",") : v;
-        return this.client.request("GET", "/v1/graph/entities", {
-            ...transportOptions(opts),
-            query: {
-                type: opts.type,
-                limit: opts.limit,
-                cursor: opts.cursor,
-                offset: opts.offset,
-                q: opts.query,
-                fields: csv(opts.fields),
-                ids: csv(opts.ids),
-            },
-        });
-    }
-    /** Yield list envelopes while following `next_cursor` until exhaustion. */
-    async *pages(opts = {}) {
-        let cursor = opts.cursor;
-        const seen = new Set();
-        do {
-            const page = await this.list({
-                ...opts,
-                cursor,
-                offset: cursor === undefined ? opts.offset : undefined,
-            });
-            yield page;
-            if (!page.has_more || page.next_cursor === null)
-                return;
-            if (seen.has(page.next_cursor)) {
-                throw new Error(`entity pagination cursor repeated: ${page.next_cursor}`);
-            }
-            seen.add(page.next_cursor);
-            cursor = page.next_cursor;
-        } while (true);
-    }
-    /** Yield entities directly while following the server's stable cursor. */
-    async *iterate(opts = {}) {
-        for await (const page of this.pages(opts)) {
-            for (const entity of page.data)
-                yield entity;
-        }
-    }
     get(opts) {
         return this.client.entityMetadata(opts);
     }
@@ -425,8 +291,6 @@ export class EntityNamespace {
             select: opts.select,
             limit: opts.limit,
             offset: opts.offset,
-            as_of_valid_time: opts.asOfValidTime,
-            as_of_commit_seq: opts.asOfCommitSeq,
             order_by: opts.orderBy,
             reason: opts.reason,
             max_solutions: opts.maxSolutions,
@@ -435,19 +299,12 @@ export class EntityNamespace {
         });
     }
 }
-/** Grounding and answer operations over the graph's real vocabulary. */
+/** Grounding operations over one pinned published vocabulary. */
 export class ContextNamespace {
     client;
     constructor(client) {
         this.client = client;
     }
-    ask(body, opts = {}) {
-        return this.client.request("POST", "/v1/ask", {
-            ...opts,
-            retry: opts.retry ?? true,
-            body,
-        });
-    }
     suggest(body, opts = {}) {
         return this.client.request("POST", "/v1/search/suggest", {
             ...opts,
@@ -477,6 +334,25 @@ export class ContextNamespace {
         });
     }
 }
+/** Active ontology/SHACL bundle metadata and atomic publication. */
+export class SchemaNamespace {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /** Read active metadata without running request-time validation. */
+    view(opts = {}) {
+        return this.client.request("GET", "/v1/schema", opts);
+    }
+    /** Atomically publish a bundle; conformance is produced asynchronously. */
+    publish(body, opts = {}) {
+        return this.client.request("POST", "/v1/schema/publish", {
+            ...opts,
+            idempotencyKey: opts.idempotencyKey ?? this.client.idempotencyKey("schema-publish"),
+            body,
+        });
+    }
+}
 /** Ontology discovery and lifecycle operations. */
 export class OntologyNamespace {
     client;
@@ -491,7 +367,12 @@ export class OntologyNamespace {
         });
     }
     conformance(opts = {}) {
-        return this.client.request("GET", "/v1/ontology/conformance", opts);
+        return this.client.request("GET", "/v1/ontology/conformance", {
+            ...opts,
+            query: {
+                consistency: opts.consistency ?? this.client.defaultConsistency,
+            },
+        });
     }
     search(body, opts = {}) {
         return this.client.request("POST", "/v1/ontology/search", {
@@ -527,7 +408,7 @@ export class OntologyNamespace {
         });
     }
 }
-/** Structured, SPARQL-text, reasoning, and analytical query operations. */
+/** Structured, SPARQL-text, and analytical query operations. */
 export class QueryNamespace {
     client;
     constructor(client) {
@@ -537,11 +418,20 @@ export class QueryNamespace {
         return this.client.request("POST", "/v1/query/sparql", {
             ...opts,
             retry: opts.retry ?? true,
-            body,
+            body: withReadConsistency(this.client, body, opts),
         });
     }
     async sparql(body, opts = {}) {
-        const response = await this.client.request("POST", "/v1/query/sparql-text", { ...opts, retry: opts.retry ?? true, body });
+        // 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,
+            query: {
+                consistency: opts.consistency ?? this.client.defaultConsistency,
+                min_indexed_seq: opts.minIndexedSeq,
+            },
+        });
         return parseSparqlResults(response);
     }
     sparqlRaw(body, opts = {}) {
@@ -549,6 +439,10 @@ export class QueryNamespace {
             ...opts,
             retry: opts.retry ?? true,
             body,
+            query: {
+                consistency: opts.consistency ?? this.client.defaultConsistency,
+                min_indexed_seq: opts.minIndexedSeq,
+            },
         });
     }
     analytics(body, opts = {}) {
@@ -558,25 +452,4 @@ export class QueryNamespace {
             body,
         });
     }
-    shacl(body, opts = {}) {
-        return this.client.request("POST", "/v1/query/shacl", {
-            ...opts,
-            retry: opts.retry ?? true,
-            body,
-        });
-    }
-    infer(body, opts = {}) {
-        return this.client.request("POST", "/v1/inference/run", {
-            ...opts,
-            retry: opts.retry ?? true,
-            body,
-        });
-    }
-    premises(body, opts = {}) {
-        return this.client.request("POST", "/v1/inference/retrieval-premises", {
-            ...opts,
-            retry: opts.retry ?? true,
-            body,
-        });
-    }
 }