@nicia-ai/typegraph 0.20.0 → 0.22.0

package/dist/{store-BMrRi_mY.d.ts → store-2QW2SIRk.d.cts}

@@ -1,8 +1,7 @@
-import { S as SqlSchema, G as GraphBackend, T as TransactionBackend, E as EdgeRow, N as NodeRow } from './types-ThB4cFLp.js';
-import { K as KindRegistry, G as GraphDef, E as EdgeKinds, N as NodeKinds, a as AllNodeTypes, S as SchemaManagerOptions, d as SchemaValidationResult } from './manager-Chhrq1vl.js';
-import { S as SqlDialect, N as NodeType, A as AnyEdgeType, T as TemporalMode, E as EdgeType, d as EdgeRegistration, b as EdgeId, g as NodeId, i as NodeRegistration } from './types-DMzKq0d5.js';
+import { S as SqlDialect, s as SqlSchema, m as FulltextStrategy, j as FulltextQueryMode, N as NodeType, G as GraphBackend, u as TransactionBackend, A as AnyEdgeType, T as TemporalMode, E as EdgeType, f as EdgeRegistration, d as EdgeId, p as NodeId, P as EdgeRow, Q as NodeRow, r as NodeRegistration, R as VectorMetric } from './types-CQF88McG.cjs';
+import { K as KindRegistry, G as GraphDef, E as EdgeKinds, N as NodeKinds, a as AllNodeTypes, S as SchemaManagerOptions, d as SchemaValidationResult } from './manager-BPK-2PUI.cjs';
 import { z } from 'zod';
-import { V as ValueType, i as PredicateExpression, k as VectorMetricType, Q as QueryAst, J as JsonPointer, F as FieldRef, P as ParameterRef, c as JsonPointerInput, T as TraversalExpansion, l as Traversal, N as NodePredicate, m as ProjectedField, O as OrderSpec, G as GroupBySpec, o as RecursiveCyclePolicy, q as TraversalDirection$1, A as AggregateExpr, r as SelectiveField, s as ComposableQuery, t as SetOperationType, u as SetOperation, S as SortDirection } from './ast-COMyNeMn.js';
+import { V as ValueType, i as PredicateExpression, k as VectorMetricType, Q as QueryAst, J as JsonPointer, F as FieldRef, P as ParameterRef, c as JsonPointerInput, T as TraversalExpansion, l as Traversal, N as NodePredicate, m as ProjectedField, O as OrderSpec, G as GroupBySpec, H as HybridFusionOptions, o as RecursiveCyclePolicy, q as TraversalDirection$1, A as AggregateExpr, r as SelectiveField, s as ComposableQuery, t as SetOperationType, u as SetOperation, S as SortDirection } from './ast-DogwbBqA.cjs';
 import { SQL } from 'drizzle-orm';
 
 /**
@@ -86,6 +85,75 @@ declare function isEmbeddingSchema(value: unknown): value is EmbeddingSchema;
  */
 declare function getEmbeddingDimensions(schema: z.ZodType): number | undefined;
 
+/**
+ * Searchable string type for fulltext search.
+ *
+ * `searchable()` attaches `SearchableMetadata` to a plain Zod string so
+ * the schema introspector and fulltext-sync layer can keep the fulltext
+ * index in sync with node data.
+ *
+ * The metadata is preserved by Zod's `.meta()` across refinements
+ * (`.min(1)`, `.trim()`, `.regex(...)`) and wrapper types (`.optional()`,
+ * `.nullable()`, `.default(...)`, pipes) — `getSearchableMetadata()` walks
+ * these variants so runtime indexing works whether or not a user chains
+ * additional modifiers.
+ *
+ * `$fulltext` is exposed on every `NodeAccessor` at the type level; a
+ * runtime guard throws a clear error if you call `.matches()` on an
+ * alias whose node kind has no `searchable()` fields. This is simpler
+ * and more predictable than a type-level brand that silently disappears
+ * behind `.min(1)`.
+ *
+ * @example
+ * ```typescript
+ * const Document = defineNode("Document", {
+ *   schema: z.object({
+ *     title: searchable({ language: "english" }),
+ *     body: searchable().min(1),
+ *     authorId: z.string(),
+ *   }),
+ * });
+ * ```
+ */
+
+declare const SEARCHABLE_FIELD_KEY: "_searchableField";
+declare const DEFAULT_SEARCHABLE_LANGUAGE: "english";
+/**
+ * Searchable field metadata attached to a Zod schema.
+ */
+type SearchableMetadata = Readonly<{
+    /**
+     * Language for stemming / tokenization.
+     * Postgres: passed to `to_tsvector(regconfig, ...)`.
+     * SQLite FTS5: tokenizer is fixed at table-create time, so the
+     * language is recorded but not applied per-row.
+     */
+    language: string;
+}>;
+/**
+ * Branded Zod string schema. The `SEARCHABLE_FIELD_KEY` marker is
+ * attached both as a direct property (fast runtime check) and via Zod's
+ * `.meta()` (so it survives `.min()`, `.trim()`, etc.).
+ */
+type SearchableSchema = z.ZodString & Readonly<{
+    [SEARCHABLE_FIELD_KEY]: SearchableMetadata;
+}>;
+type SearchableOptions = Readonly<{
+    language?: string;
+}>;
+/**
+ * Creates a Zod string schema tagged as fulltext-searchable.
+ *
+ * The returned schema passes runtime validation unchanged — the tag only
+ * affects how TypeGraph treats the field for indexing and search. Pair
+ * with `.optional()` / `.nullable()` / `.min()` / `.trim()` exactly like
+ * any other Zod string; `getSearchableMetadata()` finds the metadata
+ * through all of them.
+ */
+declare function searchable(options?: SearchableOptions): SearchableSchema;
+declare function isSearchableSchema(value: unknown): value is SearchableSchema;
+declare function getSearchableMetadata(schema: z.ZodType): SearchableMetadata | undefined;
+
 /**
  * Query Compiler Module
  *
@@ -101,6 +169,14 @@ type CompileQueryOptions = Readonly<{
     dialect?: SqlDialect | undefined;
     /** SQL schema configuration for table names. Defaults to standard names. */
     schema?: SqlSchema | undefined;
+    /**
+     * Fulltext strategy override. When set, overrides the dialect's
+     * default fulltext strategy for `$fulltext.matches()` compilation.
+     * Callers typically read this from `backend.fulltextStrategy` so a
+     * backend-declared strategy (e.g. ParadeDB) wins over the dialect
+     * default (tsvector).
+     */
+    fulltextStrategy?: FulltextStrategy | undefined;
 }>;
 
 type FieldTypeInfo = Readonly<{
@@ -111,14 +187,29 @@ type FieldTypeInfo = Readonly<{
     recordValueType?: FieldTypeInfo | undefined;
     /** For embedding types: the number of dimensions */
     dimensions?: number | undefined;
+    /** For fulltext-searchable string types: field-level metadata */
+    searchable?: SearchableMetadata | undefined;
 }>;
 type SchemaIntrospector = Readonly<{
     getFieldTypeInfo: (kindName: string, fieldName: string) => FieldTypeInfo | undefined;
     getSharedFieldTypeInfo: (kindNames: readonly string[], fieldName: string) => FieldTypeInfo | undefined;
     getEdgeFieldTypeInfo: (edgeKindName: string, fieldName: string) => FieldTypeInfo | undefined;
     getSharedEdgeFieldTypeInfo: (edgeKindNames: readonly string[], fieldName: string) => FieldTypeInfo | undefined;
+    /**
+     * True iff every kind in `kindNames` has at least one `searchable()`
+     * field. For polymorphic aliases, `$fulltext` is available only when
+     * every resolved kind has searchable content — otherwise `.matches()`
+     * would silently miss some kinds.
+     */
+    hasSearchableField: (kindNames: readonly string[]) => boolean;
 }>;
 
+/**
+ * Predicate builders for TypeGraph queries.
+ *
+ * Provides a fluent API for building type-safe predicates.
+ */
+
 /**
  * A chainable predicate that can be combined with AND/OR.
  */
@@ -151,6 +242,34 @@ declare function param(name: string): ParameterRef;
  * Type guard for ParameterRef values.
  */
 declare function isParameterRef(value: unknown): value is ParameterRef;
+/**
+ * Options for the `$fulltext.matches()` predicate.
+ *
+ * Note the term glossary used throughout TypeGraph search:
+ * - **`k`** (the positional argument on `.matches(query, k)`) is the
+ *   per-predicate top-k cap applied inside the fulltext CTE.
+ * - **`limit`** (on store-level `search.fulltext` / `search.hybrid` and
+ *   on the query builder) is the final result count returned to the
+ *   caller after any fusion.
+ */
+type MatchesOptions = Readonly<{
+    /**
+     * Parse mode for the query string. Default: "websearch".
+     *
+     * - "websearch": Google-style syntax (quoted phrases, `-excluded`, `OR`).
+     *   Postgres: `websearch_to_tsquery`. SQLite: translated to FTS5 MATCH.
+     * - "phrase": treats the whole query as a phrase.
+     * - "plain": splits on whitespace and ANDs terms.
+     * - "raw": dialect-native syntax passed through unchanged.
+     */
+    mode?: FulltextQueryMode;
+    /**
+     * Language override. Default: per-row language as stored at insert time.
+     */
+    language?: string;
+    /** Minimum relevance score to include. */
+    minScore?: number;
+}>;
 /**
  * Options for the similarTo method.
  */
@@ -174,6 +293,17 @@ type FieldRefOptions = Readonly<{
     elementType?: ValueType | undefined;
 }>;
 declare function fieldRef(alias: string, path: readonly string[], options?: FieldRefOptions): FieldRef;
+/**
+ * Node-level fulltext accessor. Always present on the `NodeAccessor`
+ * type — a runtime check throws a clear error if the node kind has no
+ * `searchable()` fields. `k` is the top-k cap applied inside the
+ * fulltext CTE; defaults to `DEFAULT_FULLTEXT_MATCH_K`. Use a larger
+ * value when feeding the result into RRF (`.fuseWith()` /
+ * `store.search.hybrid()`).
+ */
+type FulltextAccessor = Readonly<{
+    matches: (query: string, k?: number, options?: MatchesOptions) => Predicate;
+}>;
 /**
  * Creates an EXISTS subquery predicate.
  * Returns true if the subquery returns at least one row.
@@ -421,10 +551,15 @@ type ObjectFieldAccessor<T> = BaseFieldAccessor & Readonly<{
  * Properties are available at the top level for ergonomic access:
  * - `n.name` instead of `n.props.name`
  * - System fields: `n.id`, `n.kind`
+ * - Fulltext: `n.$fulltext.matches(...)` — throws at query build time if
+ *   the node kind has no `searchable()` fields. Exposed at the type
+ *   level on every accessor so refinements like
+ *   `searchable().min(1)` do not make it disappear.
  */
 type NodeAccessor<N extends NodeType> = Readonly<{
     id: StringFieldAccessor;
     kind: StringFieldAccessor;
+    $fulltext: FulltextAccessor;
 }> & PropsAccessor<N>;
 /**
  * Creates typed field accessors for an edge kind's properties.
@@ -591,6 +726,7 @@ type QueryBuilderState = Readonly<{
     asOf: string | undefined;
     groupBy: GroupBySpec | undefined;
     having: PredicateExpression | undefined;
+    fusion: HybridFusionOptions | undefined;
 }>;
 /**
  * Options for creating a query builder.
@@ -2052,6 +2188,30 @@ declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = {}, Ed
      * @param predicate - A predicate expression to filter groups
      */
     having(predicate: PredicateExpression): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases>;
+    /**
+     * Sets fusion parameters for hybrid (vector + fulltext) queries.
+     *
+     * Applies only when the query contains both a `.similarTo()` and a
+     * `.$fulltext.matches()` predicate. Without this call, the default is
+     * RRF with k=60 and equal weights. A mismatch between `.fuseWith()`
+     * configuration and the predicates on the query is caught during
+     * compilation, not here.
+     *
+     * @example
+     * ```typescript
+     * store.query()
+     *   .from("Document", "d")
+     *   .whereNode("d", d =>
+     *     d.$fulltext.matches("renewable energy", 50)
+     *       .and(d.embedding.similarTo(vec, 50))
+     *       .and(d.tenantId.eq(tenant))
+     *   )
+     *   .fuseWith({ k: 60, weights: { fulltext: 1.5 } })
+     *   .limit(10)
+     *   .execute();
+     * ```
+     */
+    fuseWith(options: HybridFusionOptions): QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases>;
     /**
      * Applies a query fragment to transform this builder.
      *
@@ -2272,6 +2432,217 @@ type GraphAlgorithms<G extends GraphDef> = Readonly<{
     degree: (node: NodeIdentifier, options?: DegreeOptions<G>) => Promise<number>;
 }>;
 
+type RebuildFulltextOptions = Readonly<{
+    /** Page size. Must be a positive integer. Default: 500. */
+    pageSize?: number;
+    /**
+     * Maximum number of skipped node IDs to include in the `skippedIds`
+     * array. Default: 10,000. Set higher to collect the full list when
+     * investigating systemic corruption; set lower when `processed` is
+     * all you care about. The `skipped` total is always accurate.
+     */
+    maxSkippedIds?: number;
+}>;
+type RebuildFulltextResult = Readonly<{
+    /** Node kinds that were rebuilt (those with at least one searchable field). */
+    kinds: readonly string[];
+    /** Total nodes scanned. */
+    processed: number;
+    /** Fulltext upsert operations executed. */
+    upserted: number;
+    /** Fulltext delete operations executed (soft-deleted or all-empty nodes). */
+    cleared: number;
+    /**
+     * Nodes skipped due to corrupt or non-object `props` (not counted in
+     * upserted/cleared).
+     */
+    skipped: number;
+    /**
+     * IDs of skipped nodes, capped at 10,000 entries so pathological
+     * corruption doesn't turn rebuild into an OOM. See `skippedTruncated`
+     * to tell whether the cap was hit. Empty when `skipped === 0`.
+     */
+    skippedIds: readonly string[];
+    /** True when `skipped > skippedIds.length` (the cap was reached). */
+    skippedTruncated: boolean;
+}>;
+
+/**
+ * Store-level search helpers.
+ *
+ * `fulltextSearch` is a thin typed wrapper over `backend.fulltextSearch`.
+ * `hybridSearch` runs a vector and a fulltext query in parallel and
+ * fuses the two ranked lists with Reciprocal Rank Fusion. RRF is
+ * rank-based, so it papers over score-scale differences between
+ * pgvector/sqlite-vec (distance-derived) and tsvector/FTS5 (BM25-style).
+ */
+
+/**
+ * A fulltext search hit. `N` defaults to the generic `Node`; the
+ * `store.search.fulltext<K>(kind)` facade narrows it to the concrete
+ * typed node for that kind so callers get `hit.node.title` without a cast.
+ */
+type FulltextSearchHit<N = Node> = Readonly<{
+    node: N;
+    /** Backend-native relevance score; higher is better. */
+    score: number;
+    /** 1-based rank within the result set. */
+    rank: number;
+    /** Highlighted snippet (only present when `includeSnippets: true`). */
+    snippet?: string;
+}>;
+type VectorSearchHit<N = Node> = Readonly<{
+    node: N;
+    score: number;
+    rank: number;
+}>;
+/**
+ * A hybrid search hit. Both sub-results (`vector`, `fulltext`) carry the
+ * same narrowed node type as the top-level `node` for ergonomic access.
+ */
+type HybridSearchHit<N = Node> = Readonly<{
+    node: N;
+    /** Fused RRF score (higher is better). */
+    score: number;
+    /** 1-based rank in the fused list. */
+    rank: number;
+    /** Sub-result from the vector half, if it ranked this node. */
+    vector?: VectorSearchHit<N>;
+    /** Sub-result from the fulltext half, if it ranked this node. */
+    fulltext?: FulltextSearchHit<N>;
+}>;
+type FulltextSearchOptions = Readonly<{
+    /** The user-supplied query string. */
+    query: string;
+    /** Max results. Required. */
+    limit: number;
+    /** Query parser mode. Default: "websearch". */
+    mode?: FulltextQueryMode;
+    /**
+     * Language override for query parsing. Default: per-row language as
+     * stored at insert time.
+     */
+    language?: string;
+    /** Minimum relevance score to include in results. */
+    minScore?: number;
+    /** Return a highlighted snippet alongside each hit. */
+    includeSnippets?: boolean;
+}>;
+type HybridVectorOptions = Readonly<{
+    /** Field path of the embedding column on the node kind. */
+    fieldPath: string;
+    /** Query embedding to compare against. */
+    queryEmbedding: readonly number[];
+    /** Distance metric. Default: "cosine". */
+    metric?: VectorMetric;
+    /** How many candidates to retrieve from the vector side. Default: 4 * limit. */
+    k?: number;
+    /** Minimum similarity to include (units depend on metric). */
+    minScore?: number;
+}>;
+type HybridFulltextOptions = Readonly<{
+    query: string;
+    /** How many candidates to retrieve from the fulltext side. Default: 4 * limit. */
+    k?: number;
+    mode?: FulltextQueryMode;
+    language?: string;
+    minScore?: number;
+    includeSnippets?: boolean;
+}>;
+type HybridSearchOptions = Readonly<{
+    vector: HybridVectorOptions;
+    fulltext: HybridFulltextOptions;
+    fusion?: HybridFusionOptions;
+    /** Final number of fused results to return. Required. */
+    limit: number;
+}>;
+
+/**
+ * StoreSearch — store.search facade.
+ *
+ * Groups fulltext, hybrid, and maintenance operations under one
+ * namespace so the top-level Store API stays focused on CRUD + graph
+ * traversal. The three methods delegate to their respective execution
+ * modules; this class exists purely to shape the surface, not to add
+ * behavior.
+ */
+
+/**
+ * Narrows `Node` to the concrete typed node for a given kind in the graph.
+ */
+type NodeOfKind<G extends GraphDef, K extends NodeKinds<G>> = G["nodes"][K] extends NodeRegistration<infer N extends NodeType> ? Node<N> : Node;
+type StoreSearchContext = Readonly<{
+    graphId: string;
+    backend: GraphBackend;
+    registry: KindRegistry;
+}>;
+/**
+ * Search-related operations exposed via `store.search`.
+ *
+ * @example
+ * ```typescript
+ * // Fulltext only
+ * const hits = await store.search.fulltext("Document", {
+ *   query: "climate change",
+ *   limit: 10,
+ *   includeSnippets: true,
+ * });
+ *
+ * // Hybrid: vector + fulltext, fused with RRF
+ * const ranked = await store.search.hybrid("Document", {
+ *   limit: 10,
+ *   vector: { fieldPath: "embedding", queryEmbedding: vec },
+ *   fulltext: { query: "climate change" },
+ * });
+ *
+ * // Rebuild after backfill / schema change
+ * const stats = await store.search.rebuildFulltext();
+ * ```
+ */
+declare class StoreSearch<G extends GraphDef> {
+    #private;
+    constructor(context: StoreSearchContext);
+    /**
+     * Runs a fulltext search against nodes of the given kind.
+     *
+     * Requires fields on the node schema declared with `searchable()`.
+     * The search hits the backend's fulltext index (tsvector + GIN on
+     * Postgres, FTS5 on SQLite — or whatever strategy the backend is
+     * configured with) and resolves the matching node IDs back to typed
+     * `Node` objects.
+     */
+    fulltext<K extends NodeKinds<G>>(nodeKind: K, options: FulltextSearchOptions): Promise<readonly FulltextSearchHit<NodeOfKind<G, K>>[]>;
+    /**
+     * Runs a vector + fulltext hybrid search and fuses the results with
+     * Reciprocal Rank Fusion.
+     *
+     * RRF is rank-based, so it composes well across heterogeneous score
+     * scales (cosine similarity vs ts_rank_cd vs FTS5 BM25). Default
+     * over-fetch is 4× `limit` from each source — tune via `vector.k` /
+     * `fulltext.k` for higher-recall corpora.
+     */
+    hybrid<K extends NodeKinds<G>>(nodeKind: K, options: HybridSearchOptions): Promise<readonly HybridSearchHit<NodeOfKind<G, K>>[]>;
+    /**
+     * Rebuilds the fulltext index from existing node data.
+     *
+     * Use when:
+     * - A node kind gained a `searchable()` field after data was already
+     *   written and existing rows were never indexed.
+     * - The fulltext table was dropped / truncated.
+     * - `language` was changed on a `searchable()` field.
+     *
+     * Iterates nodes with keyset pagination (stable under shared
+     * timestamps and light concurrent writes), transacts per page, skips
+     * kinds with no searchable fields, and cleans up stale rows for
+     * soft-deleted nodes. Corrupt or non-object `props` are counted in
+     * `skipped` with their node IDs surfaced via `skippedIds` so operators
+     * can investigate. Concurrent hard-deletes between page fetches can
+     * be missed by a single pass — run during a maintenance window for
+     * full consistency.
+     */
+    rebuildFulltext<K extends NodeKinds<G>>(nodeKind?: K, options?: RebuildFulltextOptions): Promise<RebuildFulltextResult>;
+}
+
 /**
  * Main Store implementation for TypeGraph.
  *
@@ -2411,6 +2782,34 @@ declare class Store<G extends GraphDef> {
      * ```
      */
     query(): QueryBuilder<G>;
+    /**
+     * Search-related operations (fulltext, hybrid, and rebuild).
+     *
+     * All search methods live under this facade to keep the top-level
+     * Store API focused on CRUD + graph traversal. The facade is
+     * lazy-initialized and cached for the lifetime of the store.
+     *
+     * @example
+     * ```typescript
+     * // Fulltext
+     * const hits = await store.search.fulltext("Document", {
+     *   query: "climate warming",
+     *   limit: 10,
+     *   includeSnippets: true,
+     * });
+     *
+     * // Hybrid (vector + fulltext fused with RRF)
+     * const ranked = await store.search.hybrid("Document", {
+     *   limit: 10,
+     *   vector: { fieldPath: "embedding", queryEmbedding: vec },
+     *   fulltext: { query: "climate warming" },
+     * });
+     *
+     * // Rebuild index after schema change
+     * const stats = await store.search.rebuildFulltext();
+     * ```
+     */
+    get search(): StoreSearch<G>;
     /**
      * Executes multiple queries over a single connection with snapshot consistency.
      *
@@ -2574,4 +2973,4 @@ declare function createStore<G extends GraphDef>(graph: G, backend: GraphBackend
  */
 declare function createStoreWithSchema<G extends GraphDef>(graph: G, backend: GraphBackend, options?: StoreOptions & SchemaManagerOptions): Promise<[Store<G>, SchemaValidationResult]>;
 
-export { type ReachableNode as $, type AliasMap as A, type BaseTraversalOptions as B, type CreateQueryBuilderOptions as C, type DegreeOptions as D, type EdgeAliasMap as E, type FieldAccessor as F, type GetOrCreateAction as G, type HookContext as H, type IfExistsMode as I, type NodeAlias as J, type NodeCollection as K, type NodeGetOrCreateByConstraintOptions as L, type NodeGetOrCreateByConstraintResult as M, type NeighborsOptions as N, type NodeIdentifier as O, type NodeRef as P, QueryBuilder as Q, type OperationHookContext as R, type PaginateOptions as S, TraversalBuilder as T, type PaginatedResult as U, type PathNode as V, type Predicate as W, PreparedQuery as X, type PropsAccessor as Y, type QueryHookContext as Z, type QueryOptions as _, type AggregateResult as a, type ReachableOptions as a0, type RecursiveTraversalOptions as a1, type SelectContext as a2, type SelectableEdge as a3, type SelectableNode as a4, type ShortestPathOptions as a5, type ShortestPathResult as a6, Store as a7, type StoreHooks as a8, type StoreOptions as a9, notInSubquery as aA, param as aB, type StoreProjection as aa, type StreamOptions as ab, type SubgraphEdgeResult as ac, type SubgraphNodeResult as ad, type SubgraphOptions as ae, type SubgraphResult as af, type SubsetEdge as ag, type SubsetNode as ah, type TemporalAlgorithmOptions as ai, type TransactionContext as aj, type TraversalDirection as ak, type TypedEdgeCollection as al, UnionableQuery as am, type UpdateEdgeInput as an, type UpdateNodeInput as ao, createStore as ap, createStoreWithSchema as aq, defineSubgraphProject as ar, embedding as as, exists as at, fieldRef as au, getEmbeddingDimensions as av, inSubquery as aw, isEmbeddingSchema as ax, isParameterRef as ay, notExists as az, type AlgorithmCyclePolicy as b, type AnyEdge as c, type AnyNode as d, type BatchResults as e, type BatchableQuery as f, type ConstraintNames as g, type CreateEdgeInput as h, type CreateNodeInput as i, type DynamicEdgeCollection as j, type DynamicNodeCollection as k, type Edge as l, type EdgeAccessor as m, type EdgeCollection as n, type EdgeFindByEndpointsOptions as o, type EdgeGetOrCreateByEndpointsOptions as p, type EdgeGetOrCreateByEndpointsResult as q, type EmbeddingSchema as r, type EmbeddingValue as s, ExecutableAggregateQuery as t, ExecutableQuery as u, type GraphAlgorithms as v, type GraphEdgeCollections as w, type GraphNodeCollections as x, type Node as y, type NodeAccessor as z };
+export { type PaginatedResult as $, type AliasMap as A, type BaseTraversalOptions as B, type CreateQueryBuilderOptions as C, DEFAULT_SEARCHABLE_LANGUAGE as D, type EdgeAliasMap as E, type FieldAccessor as F, type GetOrCreateAction as G, type GraphNodeCollections as H, type HookContext as I, type HybridFulltextOptions as J, type HybridSearchHit as K, type HybridSearchOptions as L, type HybridVectorOptions as M, type IfExistsMode as N, type NeighborsOptions as O, type Node as P, QueryBuilder as Q, type NodeAccessor as R, type NodeAlias as S, TraversalBuilder as T, type NodeCollection as U, type NodeGetOrCreateByConstraintOptions as V, type NodeGetOrCreateByConstraintResult as W, type NodeIdentifier as X, type NodeRef as Y, type OperationHookContext as Z, type PaginateOptions as _, type AggregateResult as a, type PathNode as a0, type Predicate as a1, PreparedQuery as a2, type PropsAccessor as a3, type QueryHookContext as a4, type QueryOptions as a5, type ReachableNode as a6, type ReachableOptions as a7, type RebuildFulltextOptions as a8, type RebuildFulltextResult as a9, type UpdateEdgeInput as aA, type UpdateNodeInput as aB, type VectorSearchHit as aC, createStore as aD, createStoreWithSchema as aE, defineSubgraphProject as aF, embedding as aG, exists as aH, fieldRef as aI, getEmbeddingDimensions as aJ, getSearchableMetadata as aK, inSubquery as aL, isEmbeddingSchema as aM, isParameterRef as aN, isSearchableSchema as aO, notExists as aP, notInSubquery as aQ, param as aR, searchable as aS, type RecursiveTraversalOptions as aa, type SearchableMetadata as ab, type SearchableOptions as ac, type SearchableSchema as ad, type SelectContext as ae, type SelectableEdge as af, type SelectableNode as ag, type ShortestPathOptions as ah, type ShortestPathResult as ai, Store as aj, type StoreHooks as ak, type StoreOptions as al, type StoreProjection as am, StoreSearch as an, type StreamOptions as ao, type SubgraphEdgeResult as ap, type SubgraphNodeResult as aq, type SubgraphOptions as ar, type SubgraphResult as as, type SubsetEdge as at, type SubsetNode as au, type TemporalAlgorithmOptions as av, type TransactionContext as aw, type TraversalDirection as ax, type TypedEdgeCollection as ay, UnionableQuery as az, type AlgorithmCyclePolicy as b, type AnyEdge as c, type AnyNode as d, type BatchResults as e, type BatchableQuery as f, type ConstraintNames as g, type CreateEdgeInput as h, type CreateNodeInput as i, type DegreeOptions as j, type DynamicEdgeCollection as k, type DynamicNodeCollection as l, type Edge as m, type EdgeAccessor as n, type EdgeCollection as o, type EdgeFindByEndpointsOptions as p, type EdgeGetOrCreateByEndpointsOptions as q, type EdgeGetOrCreateByEndpointsResult as r, type EmbeddingSchema as s, type EmbeddingValue as t, ExecutableAggregateQuery as u, ExecutableQuery as v, type FulltextSearchHit as w, type FulltextSearchOptions as x, type GraphAlgorithms as y, type GraphEdgeCollections as z };