@littlebigbrain/client 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,764 @@
+import type { components } from "./schema.js";
+/** Request/response types, generated from the committed OpenAPI spec. */
+export type Schemas = components["schemas"];
+/**
+ * The unified list-response envelope returned by every collection read
+ * (`/v1/graph/entities`, `/v1/graph/edges`, `/v1/graph/observations`): the rows
+ * in `data`, plus `next_cursor` (echo back as `cursor` for the next page) and
+ * the pre-page `total_count`. Walk pages with {@link LbbClient.listAll}.
+ */
+export interface ListResponse<T> {
+    object: "list";
+    data: T[];
+    has_more: boolean;
+    next_cursor: string | null;
+    snapshot: Schemas["SnapshotView"];
+    total_count: number;
+}
+/**
+ * A flat `{ field: value }` property map. Values are coerced to each field's
+ * declared type server-side, so a string like `"2026-06-26"` lands in a
+ * `date_time` field and `"52"` in an `i64` field. The verbose
+ * `Schemas["PropertyInput"][]` form is also accepted.
+ */
+export type FlatProperties = Record<string, string | number | boolean>;
+/** A single entity-properties record for commit/import, with flat or verbose properties. */
+export type EntityPropertiesLine = {
+    type: string;
+    name: string;
+    /** Optional stable external key; identity becomes `(type, key)`. */
+    key?: string;
+    properties: FlatProperties | Schemas["PropertyInput"][];
+};
+/** One bulk-import line: a triplet, or an entity-properties record. */
+export type ImportLine = Schemas["TripletInput"] | EntityPropertiesLine;
+export type AttributeFilterOp = "eq" | "ne" | "lt" | "le" | "gt" | "ge";
+export type AttributeFilterValue = string | number | boolean | {
+    dateTime: string;
+} | {
+    entity: Schemas["EntitySelector"];
+};
+export interface AttributeFilter {
+    /** Query variable whose typed property should be compared. Defaults to the first bound pattern variable. */
+    var?: string;
+    /** Ontology property field name, e.g. `status`, `score`, or `committed_at`. */
+    field: string;
+    /** Comparison operator. Defaults to `eq`. */
+    op?: AttributeFilterOp;
+    value: AttributeFilterValue;
+}
+export interface EntityAttributeFilterOptions {
+    /** Relation patterns that bind the entity variable(s) before attribute filters run. */
+    patterns: Schemas["AnalyticTriplePattern"][];
+    /** One or more typed-property comparisons. */
+    where: AttributeFilter | AttributeFilter[];
+    /** Additional raw structured-SPARQL filters to AND with `where`. */
+    filters?: Schemas["SparqlFilter"][];
+    select?: string[];
+    limit?: number;
+    offset?: number;
+    asOfValidTime?: string;
+    asOfCommitSeq?: number;
+    orderBy?: Schemas["SparqlOrderBy"][];
+    reason?: boolean;
+    maxSolutions?: number;
+    maxObjectReads?: number;
+    maxFetchedBytes?: number;
+}
+/**
+ * Minimal structural shape of `fetch`, so the client depends on neither the DOM
+ * lib nor a specific runtime. Native `fetch` (Node 18+, browsers, workers)
+ * satisfies it; tests can pass a fake.
+ */
+export type FetchLike = (input: string, init?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    headers?: {
+        get(name: string): string | null;
+    };
+    text(): Promise<string>;
+}>;
+/** One term in a SPARQL result binding (the standard results-JSON term object). */
+export interface SparqlTerm {
+    type: "uri" | "literal" | "bnode" | "typed-literal";
+    value: string;
+    datatype?: string;
+    "xml:lang"?: string;
+}
+/** The standard SPARQL 1.1 Query Results JSON document. */
+export interface SparqlResultsJson {
+    head: {
+        vars?: string[];
+        link?: string[];
+    };
+    results?: {
+        bindings: Record<string, SparqlTerm>[];
+    };
+    boolean?: boolean;
+}
+/** Parsed SPARQL results: the head vars, the ASK boolean (or null), the raw
+ * typed bindings, and the bindings flattened to `{ variable: lexicalValue }`. */
+export interface SparqlResults {
+    vars: string[];
+    boolean: boolean | null;
+    bindings: Record<string, SparqlTerm>[];
+    rows: Record<string, string>[];
+}
+/**
+ * Parse a {@link Schemas.SparqlTextResponse} (whose `results` field carries the
+ * SPARQL Results document as a JSON *string*) into typed bindings plus flat
+ * `{ variable: lexicalValue }` rows — the form most callers want, so they never
+ * have to `JSON.parse` and zip `head.vars` with binding values by hand.
+ */
+export declare function parseSparqlResults(response: Schemas["SparqlTextResponse"]): SparqlResults;
+export interface LbbClientOptions {
+    /** Base URL of the Little Big Brain server, e.g. `https://db.eu.littlebigbrain.com`. */
+    baseUrl: string;
+    /** Stack API key (`lbb_sk_test_…` / `lbb_sk_live_…`) or single-mode token. */
+    apiKey?: string;
+    /** Graph name (sent as `?graph=`; server default is `main`). */
+    graph?: string;
+    /** Branch name (sent as `?branch=`; server default is `main`). */
+    branch?: string;
+    /**
+     * Stack slug (sent as `?stack=`). Needed only with a session-token `apiKey`
+     * (`lbb_ses_…`), which authorizes an account rather than a single stack; a
+     * stack API key (`lbb_sk_test_…` / `lbb_sk_live_…`) already fixes the stack and ignores this.
+     */
+    stack?: string;
+    /** Override the fetch implementation (defaults to the global `fetch`). */
+    fetch?: FetchLike;
+    /** API version header sent on every request. Defaults to the beta reset contract. */
+    apiVersion?: string;
+    /** Retry count for 429/5xx responses and network failures. Defaults to 2. */
+    maxRetries?: number;
+    /** Base delay between retries. Defaults to 100ms. Tests can set 0. */
+    retryDelayMs?: number;
+}
+export interface LbbStackView {
+    stack_id: string;
+    owner_id?: string;
+    name: string;
+    slug: string;
+    tenant_id: string;
+    default_graph: string;
+    default_branch: string;
+    created_at_micros: number;
+    api_key_hint: string;
+    api_key_rotated_at_micros: number;
+}
+export interface LbbAdminStackCreateRequest {
+    owner_id: string;
+    name: string;
+    slug?: string;
+}
+export interface LbbAdminStackResponse {
+    ok: true;
+    stack: LbbStackView;
+    api_key?: string;
+    active_api_key_count?: number;
+}
+export type LbbStackActivityWindow = "1h" | "4h" | "12h" | "24h";
+export interface LbbStackActivityResponse {
+    ok: true;
+    stack: {
+        slug: string;
+        name?: string;
+    };
+    window: {
+        range: LbbStackActivityWindow;
+        from_micros: number;
+        to_micros: number;
+        bucket_seconds: number;
+        freshness_seconds: number;
+    };
+    totals: {
+        requests: number;
+        errors: number;
+        p50_latency_ms: number;
+        p95_latency_ms: number;
+        p99_latency_ms: number;
+        storage_read_ops: number;
+        storage_read_bytes: number;
+        storage_write_ops: number;
+        storage_write_bytes: number;
+        index_read_ops: number;
+        index_read_bytes: number;
+    };
+    details: {
+        total_bucket_count: number;
+        active_bucket_count: number;
+        error_rate: number;
+        storage_total_ops: number;
+        storage_total_bytes: number;
+        non_index_storage_read_ops: number;
+        non_index_storage_read_bytes: number;
+        index_read_share: number;
+        first_activity_bucket_start_micros?: number;
+        last_activity_bucket_start_micros?: number;
+    };
+    series: Array<{
+        bucket_start_micros: number;
+        requests: number;
+        errors: number;
+        p50_latency_ms: number;
+        p95_latency_ms: number;
+        p99_latency_ms: number;
+        storage_read_ops: number;
+        storage_read_bytes: number;
+        storage_write_ops: number;
+        storage_write_bytes: number;
+        index_read_ops: number;
+        index_read_bytes: number;
+    }>;
+    routes: Array<{
+        family: string;
+        requests: number;
+        errors: number;
+        error_rate: number;
+        request_share: number;
+        p50_latency_ms: number;
+        p95_latency_ms: number;
+        p99_latency_ms: number;
+    }>;
+    storage: Array<{
+        family: string;
+        read_ops: number;
+        read_bytes: number;
+        write_ops: number;
+        write_bytes: number;
+        total_ops: number;
+        total_bytes: number;
+        op_share: number;
+        byte_share: number;
+    }>;
+    partial: boolean;
+}
+export interface LbbAdminSessionResponse {
+    ok: true;
+    /** A `lbb_ses_…` session token scoped to the account. */
+    token: string;
+    expires_at_micros: number;
+}
+export interface LbbAdminStackDeleteResponse {
+    ok: true;
+    deleted_stack: LbbStackView;
+    tenant_prefix: string;
+    objects_deleted: number;
+    bytes_deleted: number;
+}
+export interface LbbErrorPayload {
+    type?: string;
+    code?: string;
+    message?: string;
+    param?: string | null;
+    request_id?: string | null;
+    doc_url?: string | null;
+}
+export interface RawLbbResponse<T> {
+    data: T;
+    status: number;
+    requestId?: string;
+    version?: string;
+    headers?: {
+        get(name: string): string | null;
+    };
+}
+export interface RequestOptions {
+    query?: Query;
+    body?: unknown;
+    /** Pre-serialized request body (e.g. NDJSON). Takes precedence over `body`. */
+    rawBody?: string;
+    /** Overrides the default `application/json` content type (used with `rawBody`). */
+    contentType?: string;
+    idempotencyKey?: string;
+}
+/** Thrown when the server responds with a non-2xx status. */
+export declare class LbbError extends Error {
+    readonly status: number;
+    readonly body: string;
+    readonly error?: LbbErrorPayload | undefined;
+    readonly type?: string;
+    readonly code?: string;
+    readonly param?: string | null;
+    readonly requestId?: string | null;
+    readonly docUrl?: string | null;
+    constructor(status: number, body: string, error?: LbbErrorPayload | undefined);
+}
+type QueryValue = string | number | boolean | undefined;
+type Query = Record<string, QueryValue>;
+/**
+ * A typed HTTP client for a Little Big Brain graph server. One instance is scoped to a
+ * single graph/branch; construct another for a different scope. All methods
+ * return the parsed JSON response and throw {@link LbbError} on failure.
+ */
+export declare class LbbClient {
+    private readonly baseUrl;
+    private readonly apiKey?;
+    private readonly graphName?;
+    private readonly branchName?;
+    private readonly stack?;
+    private readonly fetchImpl;
+    private readonly apiVersion;
+    private readonly maxRetries;
+    private readonly retryDelayMs;
+    readonly search: SearchNamespace;
+    readonly indexes: IndexNamespace;
+    readonly entities: EntityNamespace;
+    readonly schema: SchemaNamespace;
+    constructor(options: LbbClientOptions);
+    graph(name: string, opts?: {
+        branch?: string;
+        stack?: string;
+    }): GraphNamespace;
+    /**
+     * A new client for a different graph/branch on the same server and credential.
+     * Each instance is scoped to one graph/branch, so use this to target another
+     * scope (e.g. creating a fresh graph) without mutating the current client.
+     */
+    withScope(scope: {
+        graph?: string;
+        branch?: string;
+        stack?: string;
+    }): LbbClient;
+    private buildUrl;
+    rawRequest<T>(method: string, path: string, opts?: RequestOptions): Promise<RawLbbResponse<T>>;
+    request<T>(method: string, path: string, opts?: RequestOptions): Promise<T>;
+    private mutationKey;
+    idempotencyKey(prefix?: string): string;
+    /** Commit triplets and optional entity embeddings. Prefer `client.graph("main").facts.create(...)`. */
+    commit(body: Schemas["TripletCommitFile"], opts?: {
+        idempotencyKey?: string;
+    }): Promise<Schemas["GraphCommitResponse"]>;
+    /**
+     * Validate-only preflight: run the same ontology/schema validation a real
+     * commit would and report the would-be effect (`op_count`, `written_properties`,
+     * `schema_validation`) without writing. A rejected request fails exactly as a
+     * real commit would, so this is a safe check before mutating. No idempotency
+     * key needed — nothing is persisted.
+     */
+    commitDryRun(body: Schemas["TripletCommitFile"]): Promise<Schemas["GraphCommitDryRunResponse"]>;
+    /**
+     * Bulk-ingest a dataset as NDJSON. Each line is either a triplet or an
+     * `{type,name,properties}` entity-properties record; lines are batched into
+     * bounded internal commits server-side, so a whole dataset loads in one
+     * streamed request without a single oversized commit. Pass `lines` as an array
+     * (serialized to NDJSON here) or a pre-built NDJSON string.
+     */
+    import(lines: ImportLine[] | string, opts?: {
+        batch?: number;
+        strict?: boolean;
+        observedAt?: string;
+        idempotencyKey?: string;
+    }): Promise<Schemas["GraphImportResponse"]>;
+    /**
+     * Bulk-ingest N-Triples without client-side conversion. Resource-object
+     * triples become keyed Resource edges; literal-object triples become text
+     * properties on the subject Resource.
+     */
+    importRdf(ntriples: string, opts?: {
+        batch?: number;
+        strict?: boolean;
+        observedAt?: string;
+        resourceType?: string;
+        edgeIdempotency?: "append" | "skip_unchanged";
+        idempotencyKey?: string;
+    }): Promise<Schemas["GraphRdfImportResponse"]>;
+    /**
+     * Retract specific edges and/or every edge touching given entities. Appends
+     * superseding retract events rather than deleting — history stays visible in an
+     * `as_of` read before the retraction, but the edges drop out of current state.
+     * The surgical alternative to {@link deleteGraph}.
+     */
+    retract(body: Schemas["GraphRetractRequest"], opts?: {
+        idempotencyKey?: string;
+    }): Promise<Schemas["GraphRetractResponse"]>;
+    /** Create the scoped graph/branch. Construct the client with the desired graph/branch first. */
+    createGraph(): Promise<Schemas["CreateGraphResponse"]>;
+    /** Fork the scoped branch from an existing branch in the same graph. */
+    createBranch(body: Schemas["GraphBranchCreateRequest"]): Promise<Schemas["GraphBranchCreateResponse"]>;
+    /**
+     * Delete every object under the scoped graph/branch — a destructive reset.
+     * `confirm` must equal the scoped graph id; the next commit re-initializes the
+     * graph. Branch-scoped: sibling branches are untouched.
+     */
+    deleteGraph(opts: {
+        confirm: string;
+    }): Promise<unknown>;
+    /** Full semantic hybrid search from a request body (`POST /v1/graph/search`). */
+    graphSearch(body: Schemas["SemanticGraphSearchRequest"]): Promise<Schemas["SemanticGraphSearchResponse"]>;
+    /** Reciprocal-rank-fusion across sub-queries. */
+    multiSearch(body: Schemas["HybridMultiSearchRequest"]): Promise<Schemas["HybridMultiSearchResponse"]>;
+    /**
+     * Append relevance labels for a set of search results — how Little Big Brain
+     * gathers customer-specific qrels. Grade results (3 ideal/good, 1 partial,
+     * 0 bad), referencing the search response's `search_id` so labels tie back to
+     * that ranking. Stored apart from customer facts and exported via
+     * {@link searchFeedbackExport} as training/eval data for embedding fine-tuning.
+     */
+    searchFeedback(body: Schemas["SearchFeedbackRequest"], opts?: {
+        idempotencyKey?: string;
+    }): Promise<Schemas["SearchFeedbackResponse"]>;
+    /** Export the stored relevance labels as qrels-style rows for training. */
+    searchFeedbackExport(): Promise<Schemas["SearchFeedbackExportResponse"]>;
+    /** BM25 search. */
+    fullTextSearch(body: Schemas["FullTextSearchRequest"]): Promise<Schemas["FullTextSearchResponse"]>;
+    /** ANN/vector search. */
+    embeddingSearch(body: Schemas["EmbeddingSearchRequest"]): Promise<Schemas["EmbeddingSearchResponse"]>;
+    /** Bounded k-hop graph traversal. */
+    traverse(body: Schemas["TraverseRequest"]): Promise<Schemas["TraverseResponse"]>;
+    /** Resolve a query to seed entities, then return bounded paths. */
+    semanticTraverse(body: Schemas["SemanticTraverseRequest"]): Promise<Schemas["SemanticTraverseResponse"]>;
+    /** Ranked incoming/outgoing neighborhood for a graph entity. */
+    entityNeighborhood(opts: {
+        id?: string;
+        type?: string;
+        name?: string;
+        relations?: string[];
+        asOf?: string;
+    }): Promise<Schemas["EntityNeighborhoodResponse"]>;
+    /** 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"]>;
+    /**
+     * Entity detail: metadata, attributes, current state, edge history, and
+     * observations. Pass `asOf` / `asOfCommitSeq` to reproduce the node as of a
+     * past instant / commit (the state, edges, and history are pinned to it).
+     */
+    entityDetail(opts: {
+        id?: string;
+        type?: string;
+        name?: string;
+        asOf?: string;
+        asOfCommitSeq?: number;
+    }): Promise<Schemas["EntityDetailResponse"]>;
+    /**
+     * Paged edge listing. Scope to one node with `id` (or `type`+`name`) and a
+     * `direction` (`out`/`in`/`both`) to walk **every** edge of a high-degree node
+     * — `entityDetail` returns the full set but is awkward to page; this carries
+     * `offset`/`limit` and reports `total_count`. Optional `relation`/`q` filters
+     * and an `asOf`/`asOfCommitSeq` snapshot pin. Each row carries `valid_time`, so
+     * the page is enough to reconstruct a per-edge timeline.
+     */
+    graphEdges(opts?: {
+        id?: string;
+        type?: string;
+        name?: string;
+        direction?: "out" | "in" | "both";
+        relation?: string;
+        q?: string;
+        limit?: number;
+        /** Opaque cursor from a previous page's `next_cursor`. */
+        cursor?: string | number;
+        /** @deprecated Legacy alias for `cursor` (still accepted by the server). */
+        offset?: number;
+        asOf?: string;
+        asOfCommitSeq?: number;
+    }): Promise<ListResponse<Schemas["GraphEdgeRow"]>>;
+    /**
+     * Page through every row of a list endpoint, following `next_cursor` until
+     * exhausted. Pass a fetcher that takes a cursor and returns a
+     * {@link ListResponse}:
+     * ```ts
+     * for await (const e of client.listAll((cursor) =>
+     *   client.entities.list({ cursor, fields: "title" }))) { … }
+     * ```
+     */
+    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"]>;
+    /** SHACL-style shape/pattern query. */
+    shacl(body: Schemas["ShaclQueryRequest"]): Promise<Schemas["ShaclQueryResponse"]>;
+    /**
+     * SPARQL-subset SELECT/ASK/aggregate query (FILTER, HAVING, ORDER BY, ASK,
+     * COUNT/SUM/AVG/MIN/MAX). GROUP BY is not limited to entity identity:
+     * `group_by` keys on a variable's entity, and `group_keys` adds typed scalar
+     * keys — a `property` value, or a `date_bucket` calendar truncation
+     * (`year`/`month`/`week`/`day`/`hour`) of a datetime property — so a
+     * per-category breakdown or a time series is one server-side query. Scalar
+     * keys come back per group in `groups[].value_keys[<as>]`, entity keys in
+     * `groups[].keys`.
+     */
+    sparql(body: Schemas["SparqlSelectRequest"]): Promise<Schemas["SparqlSelectResponse"]>;
+    /** SPARQL 1.1 query from text (SELECT/ASK) over the live graph; `results` is SPARQL 1.1 Query Results JSON. */
+    sparqlText(body: Schemas["SparqlTextRequest"]): 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).
+     */
+    sparqlRows(body: Schemas["SparqlTextRequest"]): Promise<SparqlResults>;
+    /**
+     * Basic-graph-pattern query with group-graph-pattern combinators
+     * (UNION / OPTIONAL / MINUS / EXISTS / NOT EXISTS) folded over the base
+     * patterns. The complement to {@link sparql}: this route carries the
+     * combinators (but not FILTER/aggregation), so use it when a query needs an
+     * optional/union/negated leg rather than a grouped aggregate.
+     */
+    analytics(body: Schemas["AnalyticQueryRequest"]): Promise<Schemas["AnalyticQueryResponse"]>;
+    /**
+     * Run inference rules (SHACL-AF `sh:TripleRule` shape) to a bounded fixpoint
+     * and return the derived edges as a **preview** — derived facts are never
+     * written to the asserted graph. Each rule is a BGP `body`/`where` plus a
+     * `head` triple template instantiated per binding.
+     */
+    infer(body: Schemas["InferenceRunRequest"]): Promise<Schemas["InferenceRunResponse"]>;
+    /**
+     * Define (replace) the versioned rule set stored on the scoped graph branch.
+     * The stored set is what SHACL `include_derived` and `infer` use when a
+     * request carries no inline rules. Returns the new `rules_version`.
+     */
+    defineRules(body: Schemas["RuleSetDefineRequest"]): Promise<Schemas["RuleSetDefineResponse"]>;
+    /** The rule set stored on the scoped graph branch (version + rules). */
+    graphRules(): Promise<Schemas["RuleSet"]>;
+    /**
+     * Stage G — derive edges from calibrated retrieval matches (preview): each
+     * candidate scored `P >= threshold` becomes a derived edge `(anchor, relation,
+     * matched)` with a typed `Retrieval` provenance leaf. Pass either explicit
+     * `candidates` or a `query` the server runs as BM25 entity retrieval.
+     */
+    retrievalPremises(body: Schemas["RetrievalPremiseRequest"]): Promise<Schemas["RetrievalPremiseResponse"]>;
+    /**
+     * The active ontology (entity types and relations) for the scoped graph.
+     * Pass `{ counts: true }` to include a per-relation current-edge count
+     * (`OntologyRelationView.edge_count`) so a caller can see which declared
+     * relations are actually populated — at the cost of a snapshot load.
+     */
+    ontologyView(opts?: {
+        counts?: boolean;
+    }): Promise<Schemas["OntologyView"]>;
+    /**
+     * Audit the current snapshot against the ontology's *implied* constraints —
+     * capped `cardinality` derived as `sh:maxCount` — returning a SHACL-shaped
+     * report. Whole-snapshot and never blocks a write. Unlike
+     * {@link SchemaNamespace.audit}, this needs no published shape bundle: the
+     * shapes come from the ontology itself. See the `decoration_status` catalog on
+     * {@link ontologyView} for which decorations are enforced.
+     */
+    ontologyConformance(): Promise<Schemas["SchemaAuditReport"]>;
+    /** Discover ontology concepts, terms, and relations. */
+    ontologySearch(body: Schemas["OntologySearchRequest"]): Promise<Schemas["OntologySearchResponse"]>;
+    /** Resolve mentions to concepts/entities. */
+    ontologyResolve(body: Schemas["OntologyResolveRequest"]): Promise<Schemas["OntologyResolveResponse"]>;
+    /** Define the active ontology before the scoped graph's first commit. */
+    ontologyDefine(body: Schemas["OntologyDefineRequest"]): Promise<Schemas["OntologyDefineResponse"]>;
+    /**
+     * Additively evolve the active ontology of an existing graph: widen relation
+     * domains/ranges and declare new entity types (all by name), bumping the
+     * ontology version. Additive-only — every existing record stays valid, so no
+     * migration is needed — and a request that changes nothing is a no-op.
+     */
+    evolveOntology(body: Schemas["OntologyEvolveRequest"]): Promise<Schemas["OntologyEvolveResponse"]>;
+    /**
+     * Build default ANN + BM25 indexes. With `{ background: true }` the build
+     * runs detached on the server and the call returns immediately — use it for
+     * large corpora whose synchronous build would exceed a fronting gateway's
+     * timeout (a 504), then poll `metadata()` for completion.
+     */
+    indexBuild(opts?: {
+        background?: boolean;
+    }): Promise<unknown>;
+    /**
+     * Build BM25, ANN/vector, and adjacency index families. With
+     * `{ background: true }` the build runs detached on the server and the call
+     * returns immediately — use it for large corpora whose synchronous build would
+     * exceed a fronting gateway's timeout, then poll `metadata()` for completion.
+     */
+    indexRun(opts?: {
+        background?: boolean;
+    }): Promise<unknown>;
+    /** Append a BM25 delta segment for the unindexed WAL tail. */
+    indexDelta(): Promise<Schemas["IndexDeltaResponse"]>;
+    /** Preview or delete superseded persisted index runs. */
+    indexGc(opts?: {
+        keepRuns?: number;
+        dryRun?: boolean;
+    }): Promise<Schemas["IndexGcResponse"]>;
+    /** Fold the WAL tail into snapshot segments. */
+    compact(opts?: {
+        minTailCommits?: number;
+        maxSegments?: number;
+    }): Promise<Schemas["WalCompactResponse"]>;
+    /** Server, graph, and persisted-index status. */
+    status(): Promise<unknown>;
+    /** Graph footprint, WAL tail, and index coverage. */
+    metadata(): Promise<Schemas["GraphMetadataResponse"]>;
+    /** Graph counts and type/relation buckets. */
+    summary(): Promise<Schemas["GraphSummaryResponse"]>;
+    /** List the graphs (and branches) under the scoped tenant. */
+    listGraphs(): Promise<Schemas["GraphListResponse"]>;
+    /** Create a database stack and return its one-time stack API key. */
+    adminCreateStack(body: LbbAdminStackCreateRequest): Promise<LbbAdminStackResponse>;
+    /** Inspect a database stack without returning secret key material. */
+    adminStack(slug: string): Promise<LbbAdminStackResponse>;
+    /** Rotate a database stack key and return the new one-time API key. */
+    adminRotateStackKey(slug: string): Promise<LbbAdminStackResponse>;
+    /** Delete a database stack after confirming the slug. */
+    adminDeleteStack(slug: string): Promise<LbbAdminStackDeleteResponse>;
+    /**
+     * Mint a short-lived `lbb_ses_…` session token for an account. A trusted
+     * co-located service uses it (with `?stack=<slug>`) to call the data plane on
+     * the account's behalf without handling the stack's mode-bearing stack key.
+     */
+    adminMintSession(accountId: string): Promise<LbbAdminSessionResponse>;
+    /** Customer-visible activity for one database stack. */
+    adminStackActivity(slug: string, window?: LbbStackActivityWindow): Promise<LbbStackActivityResponse>;
+    /** Activity for the stack selected by the bearer stack key or session. */
+    stackActivity(window?: LbbStackActivityWindow): Promise<LbbStackActivityResponse>;
+}
+export declare class GraphNamespace {
+    private readonly client;
+    readonly facts: FactsNamespace;
+    constructor(client: LbbClient);
+    branch(name: string): GraphNamespace;
+    create(): Promise<Schemas["CreateGraphResponse"]>;
+    delete(opts: {
+        confirm: string;
+    }): Promise<unknown>;
+    /** Retract edges/entities from the scoped graph. See {@link LbbClient.retract}. */
+    retract(body: Schemas["GraphRetractRequest"], opts?: {
+        idempotencyKey?: string;
+    }): Promise<Schemas["GraphRetractResponse"]>;
+}
+export declare class FactsNamespace {
+    private readonly client;
+    constructor(client: LbbClient);
+    create(body: Schemas["TripletCommitFile"], opts?: {
+        idempotencyKey?: string;
+    }): Promise<Schemas["GraphCommitResponse"]>;
+    /** Bulk-load a dataset as NDJSON. See {@link LbbClient.import}. */
+    import(lines: ImportLine[] | string, opts?: {
+        batch?: number;
+        strict?: boolean;
+        observedAt?: string;
+        idempotencyKey?: string;
+    }): Promise<Schemas["GraphImportResponse"]>;
+    /**
+     * Bulk-load N-Triples through the native RDF import endpoint.
+     *
+     * Statements are committed through the fixed RDF_TRIPLE relation; source RDF
+     * predicates and literal term details are preserved as edge metadata.
+     */
+    importRdf(ntriples: string, opts?: {
+        batch?: number;
+        strict?: boolean;
+        observedAt?: string;
+        resourceType?: string;
+        edgeIdempotency?: "append" | "skip_unchanged";
+        idempotencyKey?: string;
+    }): Promise<Schemas["GraphRdfImportResponse"]>;
+}
+export declare class SearchNamespace {
+    private readonly client;
+    constructor(client: LbbClient);
+    hybrid(query: string, opts?: {
+        topK?: number;
+        source?: string;
+        consistency?: string;
+        lexical?: boolean;
+        bm25?: boolean;
+        vector?: boolean;
+        targets?: string[];
+        profile?: string;
+        /** Opt-in impression logging (L1): durably record this search's full
+         * ranking context, keyed by `search_id`, so a later feedback label on it
+         * carries the ranking it was judged against. Off by default. */
+        logImpression?: boolean;
+    }): Promise<Schemas["SemanticGraphSearchResponse"]>;
+    hybrid(body: Schemas["SemanticGraphSearchRequest"]): Promise<Schemas["SemanticGraphSearchResponse"]>;
+    multi(body: Schemas["HybridMultiSearchRequest"]): Promise<Schemas["HybridMultiSearchResponse"]>;
+    feedback(body: Schemas["SearchFeedbackRequest"], opts?: {
+        idempotencyKey?: string;
+    }): Promise<Schemas["SearchFeedbackResponse"]>;
+    feedbackExport(): Promise<Schemas["SearchFeedbackExportResponse"]>;
+    fullText(body: Schemas["FullTextSearchRequest"]): Promise<Schemas["FullTextSearchResponse"]>;
+    vector(body: Schemas["EmbeddingSearchRequest"]): 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;
+    }): Promise<Schemas["SchemaBundleView"]>;
+    /** Preview a proposed RDF/SHACL schema bundle and audit current data. */
+    preview(body: Schemas["SchemaPreviewRequest"]): Promise<Schemas["SchemaPreviewResponse"]>;
+    /** Activate a previewed SHACL schema bundle for this graph branch. */
+    publish(body: Schemas["SchemaPublishRequest"]): Promise<Schemas["SchemaPublishResponse"]>;
+    /** Audit current data against the active SHACL schema bundle. */
+    audit(): Promise<Schemas["SchemaAuditReport"]>;
+}
+export declare class IndexNamespace {
+    private readonly client;
+    constructor(client: LbbClient);
+    run(opts?: {
+        wait?: boolean;
+        background?: boolean;
+        body?: unknown;
+    }): Promise<unknown>;
+    build(): Promise<unknown>;
+    delta(): Promise<Schemas["IndexDeltaResponse"]>;
+    gc(opts?: {
+        keepRuns?: number;
+        dryRun?: boolean;
+    }): Promise<Schemas["IndexGcResponse"]>;
+}
+export declare class EntityNamespace {
+    private readonly client;
+    constructor(client: LbbClient);
+    /**
+     * 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?: {
+        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[];
+    }): Promise<ListResponse<Schemas["EntityExplorerRow"]>>;
+    get(opts: {
+        id?: string;
+        type?: string;
+        name?: string;
+        asOf?: string;
+    }): Promise<Schemas["EntityMetadataResponse"]>;
+    detail(opts: {
+        id?: string;
+        type?: string;
+        name?: string;
+    }): Promise<Schemas["EntityDetailResponse"]>;
+    /**
+     * Filter entities already bound by relation patterns using typed attributes,
+     * without writing RDF property IRIs by hand. This is a convenience wrapper over
+     * the structured SPARQL route: relation `patterns` bind variables, and `where`
+     * compares ontology property fields on those bound variables.
+     */
+    filterByAttributes(opts: EntityAttributeFilterOptions): Promise<Schemas["SparqlSelectResponse"]>;
+}
+export {};