@modernrelay/orbit-omnigraph 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,540 @@
+import { GraphEdge, GraphNode, BeginIngestOptions, IngestSession, Revisions, GraphDiagnostic, SearchResult, SearchService } from '@modernrelay/orbit-core';
+import { Omnigraph } from '@modernrelay/omnigraph';
+
+/**
+ * Identity codec (spec Appendix B.3 / B.4).
+ *
+ * Omnigraph node ids are unique **per type only** (derived from the `@key`
+ * tuple within each type's table), so unqualified ids are unsound as orbit
+ * `NodeId`s. Every adapter path — nodes, edges, search results, view state,
+ * services — MUST qualify ids through this one collision-proof tuple codec.
+ * `JSON.stringify` of a fixed-arity string tuple is injective over its inputs
+ * (quotes, brackets, commas, and unicode in either component are escaped), so
+ * no `(kind, sourceId)` pair can collide with a different pair.
+ *
+ * Human-readable labels stay separate from identity; there is deliberately no
+ * `namespaceIds:false` escape hatch (B.3).
+ */
+interface DecodedSourceId {
+    /** The namespace component: a node type name or an edge type name. */
+    kind: string;
+    /** The physical Omnigraph id within that type's table. */
+    sourceId: string;
+}
+/**
+ * Encode a `(kind, sourceId)` pair as a collision-proof orbit id.
+ *
+ * - Nodes: `encodeSourceId(NodeType, data.id)`
+ * - Edges: `encodeSourceId(EdgeName, data.id)`; endpoints use
+ *   `encodeSourceId(endpointType, from|to)` (B.3).
+ */
+declare function encodeSourceId(kind: string, sourceId: string): string;
+/**
+ * Decode an id produced by {@link encodeSourceId}.
+ *
+ * Returns `null` for anything that does not conform exactly (non-JSON input,
+ * non-array JSON, wrong arity — including synthetic edge ids, which are
+ * 4-tuples — or non-string elements). Never throws.
+ */
+declare function decodeSourceId(id: string): DecodedSourceId | null;
+/**
+ * Synthetic edge id for **query-derived** subgraphs (spec §5 rule, B.4).
+ *
+ * The GQ grammar has no edge variable, so the query path can never surface
+ * physical edge ids; query-derived edges are identified by
+ * `['synthetic-edge', EdgeName, source, target]` where `source`/`target` are
+ * the already-encoded endpoint node ids.
+ *
+ * Exported for the future query path (B.5 expansion recipe — post-v1).
+ * Caveats (B.4): parallel edges collapse under this scheme, and a dataset
+ * MUST NOT mix synthetic ids with physical `/export` ids for the same edges —
+ * one scheme per dataset, never both. Because a synthetic id is a 4-tuple,
+ * {@link decodeSourceId} rejects it (`null`), keeping the two schemes
+ * mechanically un-confusable.
+ */
+declare function encodeSyntheticEdgeId(edgeName: string, source: string, target: string): string;
+
+/**
+ * `.pg` schema model + tolerant parser (spec Appendix B.3 / B.6).
+ *
+ * The adapter needs three things from the graph schema, all served here:
+ *  1. edge endpoint-type resolution (B.3 — export edge lines carry bare
+ *     `from`/`to` ids without endpoint types),
+ *  2. per-property wire-type knowledge for temporal/blob normalization (B.6),
+ *  3. a stable schema fingerprint for the export revision stamp (B.2).
+ *
+ * The parser is deliberately tolerant: it extracts the declarations it
+ * understands (interfaces, node blocks, edge declarations, properties,
+ * constraints) and preserves anything else — unknown annotations survive as
+ * raw strings, unknown type spellings become `{ kind: 'unknown' }` — so a
+ * newer server grammar degrades gracefully instead of failing the load.
+ *
+ * Browser-safe: no `node:` imports. The fingerprint is a pure FNV-1a 64-bit
+ * hash rather than `node:crypto` sha256 so this module can sit on the
+ * browser entry's critical path.
+ */
+/** Closed scalar set per the `.pg` grammar (docs/user/schema). */
+type PgScalarName = 'String' | 'Blob' | 'Bool' | 'I32' | 'I64' | 'U32' | 'U64' | 'F32' | 'F64' | 'Date' | 'DateTime';
+type PgType = PgScalarName | {
+    kind: 'vector';
+    dim: number;
+} | {
+    kind: 'enum';
+    values: readonly string[];
+} | {
+    kind: 'list';
+    element: PgScalarName;
+} | {
+    kind: 'unknown';
+    raw: string;
+};
+interface PgProperty {
+    name: string;
+    type: PgType;
+    /** `T?` nullability. */
+    optional: boolean;
+    /** Set by inline `@key` or a body-level `@key(...)` naming this property. */
+    key: boolean;
+    /** Set by inline `@unique` or a body-level `@unique(...)` naming this property. */
+    unique: boolean;
+    /** Set by inline `@index` or a body-level `@index(...)` naming this property. */
+    index: boolean;
+    /** Every annotation as written (`'@key'`, `'@embed("body")'`) — unknown ones preserved verbatim. */
+    annotations: readonly string[];
+}
+interface PgInterfaceType {
+    name: string;
+    properties: readonly PgProperty[];
+    /** Body-level constraint declarations preserved verbatim (e.g. `'@unique(a, b)'`). */
+    constraints: readonly string[];
+}
+interface PgNodeType {
+    name: string;
+    /** Interface names from the `implements` clause (already expanded into `properties`). */
+    implements: readonly string[];
+    properties: readonly PgProperty[];
+    constraints: readonly string[];
+}
+interface PgEdgeType {
+    name: string;
+    /** Source (from) node type name. */
+    from: string;
+    /** Destination (to) node type name. */
+    to: string;
+    /** Raw `@card` bounds, e.g. `'1..1'`, `'0..*'`. Absent means the default `0..*`. */
+    card?: string;
+    /** Header annotations as written (including the `@card(...)` one, if any). */
+    annotations: readonly string[];
+    properties: readonly PgProperty[];
+    constraints: readonly string[];
+}
+interface PgSchema {
+    interfaces: readonly PgInterfaceType[];
+    nodes: readonly PgNodeType[];
+    edges: readonly PgEdgeType[];
+}
+/**
+ * Parse `.pg` source into a {@link PgSchema}. Tolerant by design: malformed
+ * or unrecognized declarations are skipped, not fatal; `implements` clauses
+ * are expanded into node properties (node-declared properties win on name
+ * collisions, matching the server's table layout).
+ */
+declare function parsePgSchema(source: string): PgSchema;
+/**
+ * Resolve an edge type's declared endpoint node types (B.3). Export edge
+ * lines carry bare `from`/`to` ids, so endpoint types come from here. Edge
+ * names match exactly first, then case-insensitively (the server matches edge
+ * names case-insensitively). Returns `null` for an unknown edge name.
+ */
+declare function edgeEndpointTypes(schema: PgSchema, edgeName: string): {
+    from: string;
+    to: string;
+} | null;
+/**
+ * Stable fingerprint of `.pg` source for the B.2 revision stamp: FNV-1a
+ * 64-bit over the UTF-8 bytes of the source, as 16 lowercase hex chars.
+ *
+ * Pure and browser-safe (no `node:crypto`). Hashes the source **verbatim**:
+ * any textual change — including comments or whitespace — changes the
+ * fingerprint, which is the conservative choice for drift detection.
+ */
+declare function schemaFingerprint(source: string): string;
+interface BigIntKeyWarning {
+    /** Node or edge type name. */
+    type: string;
+    /** The hazardous property. */
+    property: string;
+}
+/**
+ * B.6 hazard scan: `I64`/`U64` properties used as identity (`@key` or named
+ * `id`). The HTTP path emits native JSON numbers even past ±2^53 — silently
+ * rounded by `JSON.parse`, unrescued by the SDK — so two distinct big-int ids
+ * can collapse after rounding, violating §5. Surface these before loading.
+ */
+declare function bigIntKeyWarnings(schema: PgSchema): BigIntKeyWarning[];
+
+/**
+ * Export-line classification and normalization (spec Appendix B.2 / B.3 / B.6).
+ *
+ * `/export` streams NDJSON — one JSON object per line, `data` passed through
+ * **verbatim** by the SDK. This module turns those lines into orbit
+ * `GraphNode`/`GraphEdge` values:
+ *
+ *  - ids are namespaced through the B.3 codec (`encodeSourceId`),
+ *  - the node/edge KIND is injected as {@link ORBIT_TYPE_KEY} — namespaced so
+ *    a schema's own `type` property passes through as ordinary data (B.6),
+ *  - edge endpoint types are resolved from the `.pg` schema (edge lines carry
+ *    bare `from`/`to` ids — B.3),
+ *  - attr values are normalized to the query-path string forms (B.6) so
+ *    generated types and §16.6 temporal dimensions see one encoding
+ *    regardless of read path:
+ *      * `Date`      — export sends **days since Unix epoch** (number) →
+ *                      `'YYYY-MM-DD'` (UTC)
+ *      * `DateTime`  — export sends **epoch milliseconds** (number) →
+ *                      ISO 8601 (`'YYYY-MM-DDTHH:MM:SS.mmmZ'`)
+ *      * `Blob`      — inline internal blobs arrive as `'base64:<data>'` →
+ *                      `'data:application/octet-stream;base64,<data>'`;
+ *                      external-URI refs pass through verbatim (B.10)
+ *      * everything else — verbatim.
+ *
+ * Non-finite float sentinels (`'NaN'`/`'Infinity'`/`'-Infinity'`) are a
+ * **query-path-only** encoding: a non-finite stored float aborts `/export`
+ * server-side, so export-loaded data never contains the sentinels (B.6).
+ * This module therefore does NOT special-case them.
+ */
+
+/** An edge line names an edge type the `.pg` schema does not declare (B.3). */
+declare class UnknownEdgeTypeError extends Error {
+    readonly name = "UnknownEdgeTypeError";
+    readonly edgeName: string;
+    constructor(edgeName: string);
+}
+/** An export line is structurally unusable (e.g. missing/non-string `data.id`). */
+declare class InvalidExportLineError extends Error {
+    readonly name = "InvalidExportLineError";
+    constructor(message: string);
+}
+interface NodeExportLine {
+    kind: 'node';
+    type: string;
+    data: Record<string, unknown>;
+}
+interface EdgeExportLine {
+    kind: 'edge';
+    edge: string;
+    from: string;
+    to: string;
+    data: Record<string, unknown>;
+}
+type ClassifiedExportLine = NodeExportLine | EdgeExportLine | {
+    kind: 'unknown';
+};
+/**
+ * Classify one parsed export line per the B.2 shapes:
+ *  - node line: `{"type": "<NodeType>", "data": {"id", …props}}`
+ *  - edge line: `{"edge": "<EdgeName>", "from": <src id>, "to": <dst id>, "data": {"id", …props}}`
+ * Anything else is `{ kind: 'unknown' }`.
+ */
+declare function classifyExportLine(line: unknown): ClassifiedExportLine;
+/**
+ * The adapter's node/edge KIND discriminator key (B.3/B.6).
+ *
+ * Namespaced on purpose: the adapter injects this field into someone else's
+ * data, so it takes the awkward key and leaves the generic word `type` to the
+ * schema author, who means something real by it (`Company.type = investor`).
+ * A colon is illegal in `.pg` identifiers, so no schema property can ever
+ * claim this key — the collision class is closed by construction, and a
+ * source-declared `type` now flows through untouched with no preservation
+ * mechanism, no warning, and no schema migration. Same convention as
+ * GraphQL's `__typename` / JSON-LD's `@type`.
+ */
+declare const ORBIT_TYPE_KEY = "orbit:type";
+/**
+ * Normalize a node export line to a `GraphNode`:
+ * `id = encodeSourceId(type, data.id)`, `attrs = { …data, 'orbit:type' }`
+ * with B.6 value normalization driven by the schema's property types. A node
+ * type absent from the schema is tolerated — its attrs pass through verbatim
+ * (identity never needs the schema on the node path).
+ */
+declare function normalizeNode(line: {
+    type: string;
+    data: Record<string, unknown>;
+}, schema: PgSchema): GraphNode;
+/**
+ * Normalize an edge export line to a `GraphEdge`:
+ * `id = encodeSourceId(edge, data.id)`; `source`/`target` namespace the bare
+ * `from`/`to` ids with the endpoint node types resolved from the schema
+ * (B.3). Throws {@link UnknownEdgeTypeError} when the schema does not declare
+ * the edge — endpoint identity cannot be constructed without it.
+ */
+declare function normalizeEdge(line: {
+    edge: string;
+    from: string;
+    to: string;
+    data: Record<string, unknown>;
+}, schema: PgSchema): GraphEdge;
+
+/**
+ * Public types for the v1 export loader (spec Appendix B.1/B.2/B.8/B.10).
+ *
+ * The organizing rule of the v1 adapter (B.10): graphs load via `og.export()`;
+ * queries only ever resolve ids. These types describe that one load path —
+ * its options, its ingestion target seam, and its revision-stamped result.
+ */
+
+/** Cumulative progress, reported after every appended batch (B.2). */
+interface OmnigraphLoadProgress {
+    /** Export lines consumed so far (nodes + edges + skipped unknowns). */
+    lines: number;
+    /** Node lines normalized so far. */
+    nodes: number;
+    /** Edge lines normalized so far. */
+    edges: number;
+    /** Serialized UTF-8 NDJSON bytes consumed so far (including line breaks). */
+    bytes: number;
+}
+/**
+ * B.2 revision-stamp drift policy: what to do when the branch head observed
+ * after the export stream differs from the head observed before it.
+ *
+ * - `'reject'` (default): abort the session and throw — the graph is left
+ *   untouched. The right choice for durable/shareable sessions.
+ * - `'accept-warn'`: buffer the export, then commit under the canonical final
+ *   revision once `headAfter` is known; both heads are recorded in `dataRef`
+ *   and a warning is added when they differ.
+ * - `'retry-once'`: abort, restart the whole load once; a second drift
+ *   rejects.
+ */
+type OmnigraphDriftPolicy = 'reject' | 'accept-warn' | 'retry-once';
+interface OmnigraphSourceOptions {
+    /**
+     * A **preconfigured** SDK client. In the browser this must be a safe
+     * same-origin or public client — this option surface deliberately accepts
+     * no `baseUrl`/`token` pair (B.1): authenticated client construction lives
+     * ONLY in `@modernrelay/orbit-omnigraph/server`
+     * (`createOmnigraphServerClient`), which is excluded from client bundles.
+     */
+    client: Omnigraph;
+    /** Cluster graph id; every call is scoped to it via `client.graph(graphId)`. */
+    graphId: string;
+    /** Branch to export (B.2 — export is branch-only). Default `'main'`. */
+    branch?: string;
+    /**
+     * Partial per-type load (B.10): forwarded as the SDK `ExportInput.typeNames`
+     * field (wire form `type_names`). Omit to export every table.
+     */
+    typeNames?: readonly string[];
+    /** Export lines per `IngestBatch` append. Default 2000. */
+    batchSize?: number;
+    /**
+     * Whole-load byte budget for the atomic replace. Because atomic staging
+     * cannot drain before commit, exceeding this finite cap aborts the load
+     * without publishing a partial graph. Must be a positive safe integer.
+     * Default 64 MiB.
+     */
+    maxPendingBytes?: number;
+    /** B.2 drift policy. Default `'reject'`. */
+    driftPolicy?: OmnigraphDriftPolicy;
+    /** Called after every appended batch with cumulative counts. */
+    onProgress?: (p: OmnigraphLoadProgress) => void;
+}
+/**
+ * B.8 view-state `dataRef` (v1: branch-based). The readable object behind the
+ * canonical `sourceRevision` hash; retained so hosts can display/persist the
+ * exact coordinates a session was loaded from. `headBefore !== headAfter`
+ * only ever appears under `driftPolicy: 'accept-warn'`.
+ */
+interface OmnigraphDataRef {
+    graphId: string;
+    branch: string;
+    /** Branch head commit id captured before the export stream. */
+    headBefore: string;
+    /** Branch head commit id captured after the stream, before commit. */
+    headAfter: string;
+    /** Fingerprint of the `.pg` schema source (see `schemaFingerprint`). */
+    schemaFingerprint: string;
+}
+interface OmnigraphLoadCounts {
+    lines: number;
+    nodes: number;
+    edges: number;
+    /** Serialized UTF-8 NDJSON bytes streamed (including line breaks). */
+    bytes: number;
+}
+interface OmnigraphLoadResult {
+    /**
+     * The committed source coordinate: the canonical hash of `dataRef` (B.2).
+     * Stable across identical replays — a second load of a quiescent branch
+     * commits idempotently (§5: same `{datasetKey, sourceRevision}` publishes
+     * nothing).
+     */
+    sourceRevision: string;
+    dataRef: OmnigraphDataRef;
+    counts: OmnigraphLoadCounts;
+    /** `og.health().version` — the server build the load ran against. */
+    serverVersion: string;
+    /**
+     * Non-fatal observations: SDK/server major.minor mismatch (B.1), accepted
+     * drift (B.2), B.6 big-int identity hazards, skipped unknown lines. Never
+     * hides a retry or accepted-drift decision.
+     */
+    warnings: string[];
+}
+/**
+ * Minimal structural ingestion target (§7.5) — deliberately decoupled from
+ * `GraphInstance`. The loader needs exactly the ingest seam and nothing else,
+ * so any object with these members works: a real `GraphInstance` (which
+ * satisfies this interface structurally), a recorder, or a headless pipeline.
+ */
+interface IngestTarget {
+    beginIngest(opts: BeginIngestOptions): IngestSession;
+    getRevisions(): Revisions;
+    getDiagnostics?(): readonly GraphDiagnostic[];
+}
+
+/**
+ * v1 export loader (spec Appendix B.2 / B.8 / B.10).
+ *
+ * The organizing rule (B.10): graphs load via `og.export()` — one streamed
+ * NDJSON pass, edge lines first (lexicographic table-key order), driven
+ * straight into a `purpose:'replace'` ingest session on the target. Queries
+ * never introduce nodes or edges.
+ *
+ * Revision stamp (B.2): the canonical `sourceRevision` hashes
+ * `{ graphId, branch, headBefore, headAfter, schemaFingerprint }`, but
+ * `headAfter` is only knowable after the stream — while core's
+ * `BeginIngestOptions` requires `sourceRevision` up front for a replace
+ * session. Resolution: under the rejecting/retrying policies the session
+ * begins under the PROVISIONAL revision (the canonical hash with
+ * `headAfter := headBefore`), the stream appends into it, and `headAfter` is
+ * captured BEFORE `commit()`. `accept-warn` is the exception: normalized
+ * batches are buffered until `headAfter` is known, then appended once into a
+ * session opened with the canonical FINAL revision:
+ *
+ *  - equal heads   → provisional === final; commit cleanly. The session only
+ *                    ever commits a revision whose hash is truthful.
+ *  - drifted heads → `driftPolicy` decides: `'reject'` aborts the session
+ *                    (graph untouched) and throws {@link OmnigraphDriftError};
+ *                    `'accept-warn'` commits the buffered export under the
+ *                    final revision, records BOTH heads in `dataRef`, and
+ *                    adds a warning;
+ *                    `'retry-once'` aborts and restarts the whole load once
+ *                    (a second drift rejects).
+ *
+ * This is sound because a replace session is atomic and invisible until
+ * commit (§7.5): nothing is published under a revision the policy did not
+ * explicitly accept.
+ *
+ * Error surface (B.9): SDK typed errors never cross this package's public
+ * surface — they are mapped to plain `Error`s with a stable `omnigraph:`
+ * message prefix.
+ */
+
+/**
+ * B.2 drift under `driftPolicy: 'reject'` (or a second drift under
+ * `'retry-once'`): the branch head moved while the export streamed, the
+ * session was aborted, and the target graph is untouched.
+ */
+declare class OmnigraphDriftError extends Error {
+    readonly name = "OmnigraphDriftError";
+    readonly graphId: string;
+    readonly branch: string;
+    readonly headBefore: string;
+    readonly headAfter: string;
+    constructor(graphId: string, branch: string, headBefore: string, headAfter: string);
+}
+/** The one load path a v1 source exposes (B.10). */
+interface OmnigraphSource {
+    /**
+     * Stream one export of the configured graph/branch into `target` via a
+     * `purpose:'replace'` ingest session. Resolves with the revision-stamped
+     * result; rejects with the session aborted and the target untouched.
+     * `signal` aborts both the HTTP stream and the session.
+     */
+    load(target: IngestTarget, signal?: AbortSignal): Promise<OmnigraphLoadResult>;
+}
+/**
+ * Create a v1 export-backed data source (B.2/B.10). The client must be
+ * preconfigured (B.1): in the browser a safe same-origin or public client —
+ * there is deliberately no `baseUrl`/`token` option here. Authenticated
+ * construction lives only in `@modernrelay/orbit-omnigraph/server`.
+ */
+declare function createOmnigraphSource(options: OmnigraphSourceOptions): OmnigraphSource;
+
+/**
+ * B.7 stored-query `SearchService` (§16.5).
+ *
+ * A stored query using `bm25`/`fuzzy`/`nearest`/`rrf` with
+ * `order { score desc } limit K` returns entity rows plus a score column; this
+ * module wires it as a §16.5 `SearchService` via
+ * `og.queries.invoke(name, { params, branch })`, passing
+ * `RequestContext.signal` through SDK `CallOptions`. Core performs revision
+ * admission — the service only declares `revisionDependencies: ['source']`
+ * (results come from the server-side branch, so they are invalidated by a
+ * source change, never by client-side model/scope drift).
+ *
+ * Identity (B.3): Omnigraph ids are unique per type only, and a query row
+ * carries no type discriminator of its own — so the adapter REQUIRES a
+ * caller-supplied column→node-type mapping (`typeOf`), either a
+ * `{ column: NodeType }` record keyed by the projection columns that hold
+ * bare-variable node structs, or a per-row function. Every returned id is
+ * qualified through `encodeSourceId(nodeType, physicalId)` — the same codec
+ * every other adapter path uses — so results round-trip `decodeSourceId` and
+ * match export-loaded node ids exactly.
+ *
+ * v1 caveat (B.7): search runs server-side over the WHOLE branch, so against
+ * a partial export load it can return ids outside the loaded set. §16.5
+ * classifies those as `'not-loaded'` at activation; constrain the stored
+ * query to the loaded types, or load the full graph, to avoid the mismatch.
+ *
+ * Error surface (B.9): SDK typed errors never cross this package's public
+ * surface — they rethrow as plain `Error`s with the stable `omnigraph:`
+ * prefix. Abort rejections pass through unchanged.
+ */
+
+/** One stored-query result row: projection column → value. Bare-variable
+ * projections (`return { $s }`) hold whole-node structs including `id`. */
+type OmnigraphSearchRow = Record<string, unknown>;
+/**
+ * The required B.3 column→node-type mapping:
+ *
+ * - a record `{ '$s': 'Signal' }` — the FIRST listed column present in a row
+ *   with a node struct supplies the physical id, encoded under the mapped
+ *   type name;
+ * - or a per-row function returning the node type name — the row's first
+ *   node-struct column (row key order) supplies the physical id.
+ */
+type OmnigraphSearchTypeOf = ((row: OmnigraphSearchRow) => string) | Readonly<Record<string, string>>;
+interface OmnigraphSearchServiceOptions<N = Record<string, unknown>> {
+    /** A **preconfigured** SDK client (B.1) — no `baseUrl`/`token` here. */
+    client: Omnigraph;
+    /** Cluster graph id; the invoke is scoped via `client.graph(graphId)`. */
+    graphId: string;
+    /** Branch the stored query reads (B.7). Default `'main'`. */
+    branch?: string;
+    /** Registry name of the stored search query (`POST /queries/{name}`).
+     * Invoking a known name works whether or not it is `mcp.expose`d. */
+    queryName: string;
+    /** Builds the stored query's `params` object from the §16.5 call.
+     * Default: `(q, limit) => ({ q, limit })`. */
+    params?: (q: string, limit: number) => Record<string, unknown>;
+    /** REQUIRED B.3 mapping from row to node type — see
+     * {@link OmnigraphSearchTypeOf}. */
+    typeOf: OmnigraphSearchTypeOf;
+    /** Column whose value becomes `label` (String()-coerced when present).
+     * Default: the first string-valued column in row key order. */
+    labelColumn?: string;
+    /** Full custom row→result escape hatch: overrides the default mapping
+     * (including `typeOf`/`labelColumn`); return `null` to skip a row. The
+     * returned `id` MUST already be B.3-encoded via `encodeSourceId`. */
+    mapRow?: (row: OmnigraphSearchRow) => SearchResult<N> | null;
+}
+/**
+ * Create the B.7 stored-query search service. Plug it into core as
+ * `services.search`; the instance owns `RequestContext` creation,
+ * revision-keyed caching, supersede cancellation, and stale-result rejection
+ * at admission (§16.5).
+ */
+declare function createOmnigraphSearchService<N = Record<string, unknown>>(options: OmnigraphSearchServiceOptions<N>): SearchService<N>;
+
+export { type BigIntKeyWarning, type ClassifiedExportLine, type DecodedSourceId, type EdgeExportLine, type IngestTarget, InvalidExportLineError, type NodeExportLine, ORBIT_TYPE_KEY, type OmnigraphDataRef, OmnigraphDriftError, type OmnigraphDriftPolicy, type OmnigraphLoadCounts, type OmnigraphLoadProgress, type OmnigraphLoadResult, type OmnigraphSearchRow, type OmnigraphSearchServiceOptions, type OmnigraphSearchTypeOf, type OmnigraphSource, type OmnigraphSourceOptions, type PgEdgeType, type PgInterfaceType, type PgNodeType, type PgProperty, type PgScalarName, type PgSchema, type PgType, UnknownEdgeTypeError, bigIntKeyWarnings, classifyExportLine, createOmnigraphSearchService, createOmnigraphSource, decodeSourceId, edgeEndpointTypes, encodeSourceId, encodeSyntheticEdgeId, normalizeEdge, normalizeNode, parsePgSchema, schemaFingerprint };