@nicia-ai/typegraph 0.20.0 → 0.21.0

package/dist/{types-B3mmOMJV.d.cts → types-CQF88McG.d.cts}

@@ -1,5 +1,170 @@
 import { SQL } from 'drizzle-orm';
-import { N as NodeType, E as EdgeType, j as UniquenessScope, a as Collation, D as DeleteBehavior, C as Cardinality, f as EndpointExistence, T as TemporalMode, S as SqlDialect } from './types-DMzKq0d5.cjs';
+import { z } from 'zod';
+
+/** Brand key for NodeType */
+declare const NODE_TYPE_BRAND: "__nodeType";
+/** Brand key for EdgeType */
+declare const EDGE_TYPE_BRAND: "__edgeType";
+/** Brand symbol for NodeId */
+declare const __nodeId: unique symbol;
+/** Brand symbol for EdgeId */
+declare const __edgeId: unique symbol;
+/**
+ * A node type definition.
+ *
+ * Created via `defineNode()`. Represents a type of node in the graph
+ * with an associated Zod schema for properties.
+ */
+type NodeType<K extends string = string, S extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>> = Readonly<{
+    [NODE_TYPE_BRAND]: true;
+    kind: K;
+    schema: S;
+    description: string | undefined;
+}>;
+/**
+ * Branded node ID type.
+ *
+ * Prevents mixing IDs from different node types at compile time.
+ */
+type NodeId<N extends NodeType> = string & Readonly<{
+    [__nodeId]: N;
+}>;
+/**
+ * Infer the props type from a NodeType.
+ */
+type NodeProps<N extends NodeType> = z.infer<N["schema"]>;
+/**
+ * An edge type definition.
+ *
+ * Created via `defineEdge()`. Represents a type of edge in the graph
+ * with an optional Zod schema for properties.
+ *
+ * Optionally includes `from` and `to` arrays that define the allowed
+ * source and target node types (domain and range constraints).
+ */
+type EdgeType<K extends string = string, S extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>, From extends readonly NodeType[] | undefined = undefined, To extends readonly NodeType[] | undefined = undefined> = Readonly<{
+    [EDGE_TYPE_BRAND]: true;
+    kind: K;
+    schema: S;
+    description: string | undefined;
+    from: From;
+    to: To;
+}>;
+/**
+ * Base edge type for use in constraints - accepts any from/to configuration.
+ */
+type AnyEdgeType = EdgeType<string, z.ZodObject<z.ZodRawShape>, readonly NodeType[] | undefined, readonly NodeType[] | undefined>;
+/**
+ * An edge type that has both from and to constraints defined.
+ * Can be used directly in defineGraph without an EdgeRegistration wrapper.
+ */
+type EdgeTypeWithEndpoints = EdgeType<string, z.ZodObject<z.ZodRawShape>, readonly NodeType[], readonly NodeType[]>;
+/**
+ * Branded edge ID type.
+ *
+ * Prevents mixing IDs from different edge types at compile time.
+ */
+type EdgeId<E extends AnyEdgeType = AnyEdgeType> = string & Readonly<{
+    [__edgeId]: E;
+}>;
+/**
+ * Infer the props type from an EdgeType.
+ */
+type EdgeProps<E extends AnyEdgeType> = z.infer<E["schema"]>;
+/**
+ * Delete behaviors for nodes.
+ */
+type DeleteBehavior = "restrict" | "cascade" | "disconnect";
+/**
+ * Edge cardinality constraints.
+ */
+type Cardinality = "many" | "one" | "unique" | "oneActive";
+/**
+ * Endpoint existence modes for edge validation.
+ */
+type EndpointExistence = "notDeleted" | "currentlyValid" | "ever";
+/**
+ * Temporal query modes.
+ */
+type TemporalMode = "current" | "asOf" | "includeEnded" | "includeTombstones";
+/**
+ * Uniqueness constraint scope.
+ */
+type UniquenessScope = "kind" | "kindWithSubClasses";
+/**
+ * Collation for uniqueness constraints.
+ */
+type Collation = "binary" | "caseInsensitive";
+/**
+ * Uniqueness constraint definition.
+ */
+type UniqueConstraint<S extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>> = Readonly<{
+    name: string;
+    fields: readonly (keyof z.infer<S> & string)[];
+    where?: (props: UniqueConstraintPredicateBuilder<S>) => UniqueConstraintPredicate;
+    scope: UniquenessScope;
+    collation: Collation;
+}>;
+/**
+ * Predicate builder for uniqueness constraint where clause.
+ * Uses -? to make all fields required in the builder, even if optional in the schema.
+ */
+type UniqueConstraintPredicateBuilder<S extends z.ZodObject<z.ZodRawShape>> = Readonly<{
+    [K in keyof z.infer<S>]-?: UniqueConstraintField;
+}>;
+/**
+ * Field operations for uniqueness constraint predicates.
+ */
+type UniqueConstraintField = Readonly<{
+    isNull: () => UniqueConstraintPredicate;
+    isNotNull: () => UniqueConstraintPredicate;
+}>;
+/**
+ * A uniqueness constraint predicate (internal representation).
+ */
+type UniqueConstraintPredicate = Readonly<{
+    __type: "unique_predicate";
+    field: string;
+    op: "isNull" | "isNotNull";
+}>;
+/**
+ * Node registration in a graph definition.
+ */
+type NodeRegistration<N extends NodeType = NodeType> = Readonly<{
+    type: N;
+    unique?: readonly UniqueConstraint<N["schema"]>[];
+    onDelete?: DeleteBehavior;
+}>;
+/**
+ * Edge registration in a graph definition.
+ */
+type EdgeRegistration<E extends AnyEdgeType = AnyEdgeType, FromTypes extends NodeType = NodeType, ToTypes extends NodeType = NodeType> = Readonly<{
+    type: E;
+    from: readonly FromTypes[];
+    to: readonly ToTypes[];
+    cardinality?: Cardinality;
+    endpointExistence?: EndpointExistence;
+}>;
+/**
+ * Default settings for a graph.
+ */
+type GraphDefaults = Readonly<{
+    onNodeDelete?: DeleteBehavior;
+    temporalMode?: TemporalMode;
+}>;
+/**
+ * Checks if a value is a NodeType.
+ */
+declare function isNodeType(value: unknown): value is NodeType;
+/**
+ * Checks if a value is an EdgeType.
+ */
+declare function isEdgeType(value: unknown): value is AnyEdgeType;
+/**
+ * Checks if a value is an EdgeType with both from and to constraints defined.
+ * Such edges can be used directly in defineGraph without an EdgeRegistration wrapper.
+ */
+declare function isEdgeTypeWithEndpoints(value: unknown): value is EdgeTypeWithEndpoints;
 
 /** Brand key for MetaEdge */
 declare const META_EDGE_BRAND: "__metaEdge";
@@ -69,6 +234,8 @@ type SqlTableNames = Readonly<{
     edges: string;
     /** Node embeddings table name (default: "typegraph_node_embeddings") */
     embeddings: string;
+    /** Node fulltext table name (default: "typegraph_node_fulltext") */
+    fulltext: string;
 }>;
 /**
  * SQL schema configuration for query compilation.
@@ -83,6 +250,8 @@ type SqlSchema = Readonly<{
     edgesTable: SQL;
     /** Get a SQL reference to the embeddings table */
     embeddingsTable: SQL;
+    /** Get a SQL reference to the fulltext table */
+    fulltextTable: SQL;
 }>;
 /**
  * Creates a SqlSchema configuration from table names.
@@ -113,6 +282,115 @@ declare function createSqlSchema(names?: Partial<SqlTableNames>): SqlSchema;
  */
 declare const DEFAULT_SQL_SCHEMA: SqlSchema;
 
+/**
+ * Fulltext Strategy — pluggable DDL + SQL generation for a dialect's
+ * fulltext stack. A strategy owns every SQL statement that touches its
+ * backing table: DDL, upsert (single + batch), delete (single + batch),
+ * MATCH condition, rank expression, and snippet expression.
+ *
+ * A dialect picks one as its default; `createPostgresBackend` /
+ * `createSqliteBackend` accept an override for alternate Postgres stacks
+ * (pg_trgm, ParadeDB/pg_search, pgroonga) to swap the entire fulltext
+ * pipeline without forking TypeGraph.
+ */
+
+/**
+ * A pluggable fulltext implementation. Each strategy is expected to be
+ * self-contained: given a table name, a query string, and a parse mode,
+ * it emits every SQL statement the compiler and backend need — DDL,
+ * reads, and writes. No out-of-band conventions across layers.
+ */
+interface FulltextStrategy {
+    /** Human-readable identifier used in error messages and telemetry. */
+    readonly name: string;
+    /**
+     * Parse modes this strategy can translate. Callers validate against
+     * this list before emitting SQL; a mode outside the set means the
+     * strategy rejects the query at compile time.
+     */
+    readonly supportedModes: readonly FulltextQueryMode[];
+    /**
+     * Whether the strategy can emit a per-row highlighted snippet. When
+     * false, `snippetExpression` returns a literal `NULL` so callers can
+     * leave the `snippet` column in place without a branch.
+     */
+    readonly supportsSnippets: boolean;
+    /**
+     * Whether the strategy supports prefix queries (`foo*`). Used to
+     * populate `BackendCapabilities.fulltext.prefixQueries`. A strategy
+     * may support prefix queries via dedicated syntax without advertising
+     * "raw" mode (and vice-versa).
+     */
+    readonly supportsPrefix: boolean;
+    /**
+     * Whether a per-query `language` override is honored. Postgres' tsvector
+     * accepts any installed regconfig at query time; SQLite FTS5's tokenizer
+     * is fixed at table-create time, so the override is silently ignored.
+     * Callers may surface a warning when the user passes `language` to a
+     * strategy that doesn't honor it.
+     */
+    readonly supportsLanguageOverride: boolean;
+    /**
+     * Languages / tokenizer names understood by the strategy. Advisory — a
+     * runtime backend like Postgres may accept other installed regconfigs.
+     * Used to populate `BackendCapabilities.fulltext.languages`.
+     */
+    readonly languages: readonly string[];
+    /**
+     * Emits the WHERE-side MATCH expression.
+     *
+     * @example
+     * tsvector: `"typegraph_node_fulltext"."tsv" @@ websearch_to_tsquery('english', 'cats')`
+     * fts5:     `"typegraph_node_fulltext" MATCH '"cats"'`
+     */
+    matchCondition(tableName: string, query: string, mode: FulltextQueryMode, language?: string): SQL;
+    /**
+     * Emits the relevance expression. Higher values = more relevant. The
+     * compiler orders by this expression DESC, and both builder and
+     * backend-direct paths use the same form so their top-k results agree.
+     */
+    rankExpression(tableName: string, query: string, mode: FulltextQueryMode, language?: string): SQL;
+    /**
+     * Emits a per-row highlighted snippet expression, or `NULL` when
+     * `supportsSnippets` is false. Snippet markup is `<mark>…</mark>` in
+     * both shipped strategies so consumers can apply one stylesheet.
+     */
+    snippetExpression(tableName: string, query: string, mode: FulltextQueryMode, language?: string): SQL;
+    /**
+     * DDL statements to create the backing table and any supporting
+     * indexes. Idempotent (`CREATE ... IF NOT EXISTS`). Called once from
+     * `bootstrapTables()` on a fresh database.
+     */
+    generateDdl(tableName: string): readonly string[];
+    /**
+     * Emits the statements that upsert a single fulltext row. Returns one
+     * or more statements — some backends (SQLite FTS5) cannot emulate
+     * upsert in a single statement and need DELETE + INSERT.
+     */
+    buildUpsert(tableName: string, params: UpsertFulltextParams, timestamp: string): readonly SQL[];
+    /**
+     * Emits the statements that upsert many fulltext rows at once. Input
+     * rows are expected to be de-duplicated last-write-wins by the
+     * strategy if the underlying SQL statement cannot tolerate duplicate
+     * conflict keys. Returns `[]` when `params.rows` is empty.
+     */
+    buildBatchUpsert(tableName: string, params: UpsertFulltextBatchParams, timestamp: string): readonly SQL[];
+    /**
+     * Emits the statements that delete a single fulltext row. Normally a
+     * single PK-scoped DELETE, but strategies that maintain auxiliary
+     * indexes (delete-triggered external stores, ParadeDB-style secondary
+     * structures) may need more.
+     */
+    buildDelete(tableName: string, params: DeleteFulltextParams): readonly SQL[];
+    /**
+     * Emits the statements that delete many fulltext rows at once. Returns
+     * `[]` when `params.nodeIds` is empty.
+     */
+    buildBatchDelete(tableName: string, params: DeleteFulltextBatchParams): readonly SQL[];
+}
+declare const tsvectorStrategy: FulltextStrategy;
+declare const fts5Strategy: FulltextStrategy;
+
 /**
  * Types for serialized schema storage.
  *
@@ -257,6 +535,19 @@ type SerializedSchema = Readonly<{
  */
 type SchemaHash = string;
 
+/**
+ * SQL Dialect Abstraction Layer
+ *
+ * Provides a unified interface for dialect-specific SQL generation.
+ * Implementing a new dialect (MySQL, SQL Server, etc.) requires
+ * implementing this interface.
+ */
+
+/**
+ * Supported SQL dialects.
+ */
+type SqlDialect = "sqlite" | "postgres";
+
 /**
  * Backend interface types for TypeGraph storage.
  *
@@ -285,6 +576,37 @@ type VectorCapabilities = Readonly<{
     /** Maximum dimensions supported */
     maxDimensions: number;
 }>;
+/**
+ * Query modes for fulltext search.
+ *
+ * - "websearch": Google-style syntax (quoted phrases, +required, -excluded).
+ *    Postgres: `websearch_to_tsquery`. SQLite: translated to FTS5 MATCH.
+ * - "phrase": treats the whole query as a phrase.
+ *    Postgres: `phraseto_tsquery`. SQLite: FTS5 `"..."` phrase.
+ * - "plain": splits on whitespace and ANDs terms.
+ *    Postgres: `plainto_tsquery`. SQLite: default FTS5 AND.
+ * - "raw": dialect-native syntax passed through unchanged.
+ */
+type FulltextQueryMode = "websearch" | "phrase" | "plain" | "raw";
+/**
+ * Fulltext search capabilities declared by a backend.
+ */
+type FulltextCapabilities = Readonly<{
+    /** Whether the backend supports fulltext operations */
+    supported: boolean;
+    /**
+     * Language / tokenizer names understood by this backend.
+     * Postgres: installed regconfigs (english, simple, ...).
+     * SQLite FTS5: tokenizer names (unicode61, porter, trigram).
+     */
+    languages: readonly string[];
+    /** Whether phrase queries are supported. */
+    phraseQueries: boolean;
+    /** Whether prefix (`foo*`) queries are supported. */
+    prefixQueries: boolean;
+    /** Whether highlighting / snippets are supported. */
+    highlighting: boolean;
+}>;
 
 /**
  * Backend capabilities that vary by dialect.
@@ -304,6 +626,8 @@ type BackendCapabilities = Readonly<{
     transactions: boolean;
     /** Vector search capabilities (undefined if not configured) */
     vector?: VectorCapabilities | undefined;
+    /** Fulltext search capabilities (undefined if not configured) */
+    fulltext?: FulltextCapabilities | undefined;
 }>;
 /**
  * A row from the typegraph_nodes table.
@@ -524,6 +848,118 @@ type DropVectorIndexParams = Readonly<{
     nodeKind: string;
     fieldPath: string;
 }>;
+/**
+ * Parameters for inserting or updating a fulltext entry.
+ *
+ * One row per node. Callers concatenate the searchable fields into
+ * `content` so a single MATCH query can find terms spread across fields.
+ */
+type UpsertFulltextParams = Readonly<{
+    graphId: string;
+    nodeKind: string;
+    nodeId: string;
+    content: string;
+    language: string;
+}>;
+/**
+ * Parameters for deleting a single fulltext entry.
+ */
+type DeleteFulltextParams = Readonly<{
+    graphId: string;
+    nodeKind: string;
+    nodeId: string;
+}>;
+/**
+ * A single row in a fulltext batch upsert.
+ */
+type FulltextBatchRow = Readonly<{
+    nodeId: string;
+    content: string;
+    language: string;
+}>;
+/**
+ * Parameters for a batched fulltext upsert.
+ *
+ * Homogeneous: one graph, one node kind, many nodes. Duplicate `nodeId`
+ * values within a single batch are deduplicated last-write-wins by the
+ * builders before SQL generation — Postgres `ON CONFLICT` errors on
+ * repeated conflict keys in one statement, and SQLite `DELETE + INSERT`
+ * would create duplicate virtual-table rows otherwise.
+ */
+type UpsertFulltextBatchParams = Readonly<{
+    graphId: string;
+    nodeKind: string;
+    rows: readonly FulltextBatchRow[];
+}>;
+/**
+ * Parameters for a batched fulltext delete.
+ */
+type DeleteFulltextBatchParams = Readonly<{
+    graphId: string;
+    nodeKind: string;
+    nodeIds: readonly string[];
+}>;
+/**
+ * Parameters for fulltext search.
+ */
+type FulltextSearchParams = Readonly<{
+    graphId: string;
+    nodeKind: string;
+    /** The user-supplied query string. */
+    query: string;
+    /** How to parse `query`. Default: "websearch". */
+    mode?: FulltextQueryMode;
+    /**
+     * Language override. Default: per-row language (as stored at insert time).
+     * Postgres: passed as the regconfig to `to_tsquery` / `websearch_to_tsquery`.
+     * SQLite: informational only (FTS5 tokenizer is fixed at table-create time).
+     */
+    language?: string;
+    /** Max rows to return. */
+    limit: number;
+    /** Minimum rank to include (backend-dependent units). */
+    minScore?: number;
+    /** Whether to return a highlighted snippet per match. */
+    includeSnippets?: boolean;
+}>;
+/**
+ * Result from a fulltext search.
+ *
+ * Score semantics differ by backend; prefer `rank` (1-based) when fusing
+ * with another source via RRF.
+ */
+type FulltextSearchResult = Readonly<{
+    nodeId: string;
+    /**
+     * Backend-native relevance score.
+     * Postgres: `ts_rank_cd` (higher is better).
+     * SQLite FTS5: negated `bm25()` (higher is better; FTS5 returns lower-is-better).
+     */
+    score: number;
+    /** 1-based rank within the result set, suitable for RRF. */
+    rank: number;
+    /** Highlighted snippet of the content (if `includeSnippets` was set). */
+    snippet?: string;
+}>;
+/**
+ * Parameters for creating a fulltext index.
+ *
+ * The canonical index (Postgres GIN on `tsv`, SQLite FTS5 virtual table)
+ * is created when the fulltext table itself is created. This is reserved
+ * for advanced per-kind specializations.
+ */
+type CreateFulltextIndexParams = Readonly<{
+    graphId: string;
+    nodeKind: string;
+    language: string;
+}>;
+/**
+ * Parameters for dropping a fulltext index created via createFulltextIndex.
+ */
+type DropFulltextIndexParams = Readonly<{
+    graphId: string;
+    nodeKind: string;
+}>;
 /**
  * Transaction options.
  */
@@ -549,6 +985,14 @@ type GraphBackend = Readonly<{
     capabilities: BackendCapabilities;
     /** Table names used by this backend (for query schema auto-derivation) */
     tableNames?: SqlTableNames | undefined;
+    /**
+     * Optional fulltext strategy override. When present, both the compiler
+     * (for `$fulltext.matches()` in query builder) and backend-direct
+     * search paths use this instead of the dialect's default strategy —
+     * allowing a Postgres backend to ship pg_trgm, ParadeDB, pgroonga etc.
+     * When absent, the dialect's default strategy is used.
+     */
+    fulltextStrategy?: FulltextStrategy | undefined;
     insertNode: (params: InsertNodeParams) => Promise<NodeRow>;
     insertNodeNoReturn?: (params: InsertNodeParams) => Promise<void>;
     insertNodesBatch?: (params: readonly InsertNodeParams[]) => Promise<void>;
@@ -588,6 +1032,21 @@ type GraphBackend = Readonly<{
     vectorSearch?: (params: VectorSearchParams) => Promise<readonly VectorSearchResult[]>;
     createVectorIndex?: (params: CreateVectorIndexParams) => Promise<void>;
     dropVectorIndex?: (params: DropVectorIndexParams) => Promise<void>;
+    upsertFulltext?: (params: UpsertFulltextParams) => Promise<void>;
+    deleteFulltext?: (params: DeleteFulltextParams) => Promise<void>;
+    /**
+     * Batched variant of `upsertFulltext`. Optional — callers fall back to
+     * per-row `upsertFulltext` when unset.
+     */
+    upsertFulltextBatch?: (params: UpsertFulltextBatchParams) => Promise<void>;
+    /**
+     * Batched variant of `deleteFulltext`. Optional — callers fall back to
+     * per-row `deleteFulltext` when unset.
+     */
+    deleteFulltextBatch?: (params: DeleteFulltextBatchParams) => Promise<void>;
+    fulltextSearch?: (params: FulltextSearchParams) => Promise<readonly FulltextSearchResult[]>;
+    createFulltextIndex?: (params: CreateFulltextIndexParams) => Promise<void>;
+    dropFulltextIndex?: (params: DropFulltextIndexParams) => Promise<void>;
     /**
      * Hard-deletes all data for a graph (nodes, edges, uniques, embeddings, schema versions).
      * Intended for import-replacement workflows. No hooks, no per-row logic.
@@ -700,7 +1159,9 @@ type FindEdgesConnectedToParams = Readonly<{
 type FindNodesByKindParams = Readonly<{
     graphId: string;
     kind: string;
+    /** Max rows to return. */
     limit?: number;
+    /** Offset. Present for backward compat; rebuild uses `after` instead. */
     offset?: number;
     /** If true, exclude deleted nodes. Default true. */
     excludeDeleted?: boolean;
@@ -708,6 +1169,18 @@ type FindNodesByKindParams = Readonly<{
     temporalMode?: TemporalMode;
     /** Timestamp for "current" and "asOf" temporal modes. */
     asOf?: string;
+    /**
+     * Stable ordering for keyset pagination. Default: "created_at" (existing
+     * behavior). Rebuild should use "id" for iteration that is stable under
+     * concurrent writes and shared timestamps.
+     */
+    orderBy?: "id" | "created_at";
+    /**
+     * Keyset cursor. Returns rows strictly greater (by `orderBy`) than this
+     * value. When `orderBy: "id"`, compared lexicographically. Mutually
+     * exclusive with `offset` — callers pick one.
+     */
+    after?: string;
 }>;
 /**
  * Parameters for counting nodes by kind.
@@ -759,4 +1232,4 @@ type CountEdgesByKindParams = Readonly<{
     asOf?: string;
 }>;
 
-export { DEFAULT_SQL_SCHEMA as D, type EdgeRow as E, type GraphBackend as G, type InferenceType as I, type JsonSchema as J, type MetaEdge as M, type NodeRow as N, type OntologyRelation as O, type SqlSchema as S, type TransactionBackend as T, type MetaEdgeProperties as a, type SqlTableNames as b, createSqlSchema as c, type SerializedNodeDef as d, type SerializedEdgeDef as e, type SerializedMetaEdge as f, type SerializedOntologyRelation as g, type SerializedClosures as h, isMetaEdge as i, type SerializedSchema as j, type SchemaHash as k, type SerializedOntology as l, type SerializedUniqueConstraint as m, type SchemaVersionRow as n };
+export { type SerializedSchema as $, type AnyEdgeType as A, type BackendCapabilities as B, type Cardinality as C, DEFAULT_SQL_SCHEMA as D, type EdgeType as E, type FulltextBatchRow as F, type GraphBackend as G, isEdgeTypeWithEndpoints as H, type InferenceType as I, isMetaEdge as J, isNodeType as K, tsvectorStrategy as L, type MetaEdge as M, type NodeType as N, type OntologyRelation as O, type EdgeRow as P, type NodeRow as Q, type VectorMetric as R, type SqlDialect as S, type TemporalMode as T, type UniqueConstraint as U, type VectorCapabilities as V, type SerializedNodeDef as W, type SerializedEdgeDef as X, type SerializedMetaEdge as Y, type SerializedOntologyRelation as Z, type SerializedClosures as _, type Collation as a, type SchemaHash as a0, type JsonSchema as a1, type SerializedOntology as a2, type SerializedUniqueConstraint as a3, type SchemaVersionRow as a4, type DeleteBehavior as b, type DeleteFulltextBatchParams as c, type EdgeId as d, type EdgeProps as e, type EdgeRegistration as f, type EdgeTypeWithEndpoints as g, type EndpointExistence as h, type FulltextCapabilities as i, type FulltextQueryMode as j, type FulltextSearchParams as k, type FulltextSearchResult as l, type FulltextStrategy as m, type GraphDefaults as n, type MetaEdgeProperties as o, type NodeId as p, type NodeProps as q, type NodeRegistration as r, type SqlSchema as s, type SqlTableNames as t, type TransactionBackend as u, type UniquenessScope as v, type UpsertFulltextBatchParams as w, createSqlSchema as x, fts5Strategy as y, isEdgeType as z };