@nicia-ai/typegraph 0.24.1 → 0.25.0

package/dist/{store-U3i2tUch.d.ts → store-BAGuOHDh.d.cts}

@@ -1,8 +1,9 @@
-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-Qk2l3IkQ.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-nIhmttD-.js';
 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, 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-C8S37w1A.js';
+import { m as SqlDialect, ac as SqlSchema, F as FulltextStrategy, aq as ValueType, ar as PredicateExpression, as as VectorMetricType, X as FulltextQueryMode, Q as QueryAst, J as JsonPointer, C as FieldRef, a7 as ParameterRef, G as GraphBackend, ae as TransactionBackend, a0 as JsonPointerInput, af as TraversalExpansion, at as Traversal, au as NodePredicate, av as ProjectedField, a6 as OrderSpec, aw as GroupBySpec, _ as HybridFusionOptions, ax as RecursiveCyclePolicy, ay as TraversalDirection$1, az as EdgeRow, aA as NodeRow, A as AggregateExpr, aB as SelectiveField, aC as ComposableQuery, aD as SetOperationType, aE as SetOperation, ab as SortDirection, j as JsonSchema, aF as VectorMetric } from './types--0EslBx5.cjs';
+import { K as KindRegistry, G as GraphDef, t as EdgeKinds, w as NodeKinds, s as AllNodeTypes, c as SchemaManagerOptions, d as SchemaValidationResult } from './manager-BpjBW1JK.cjs';
+import { A as AnyEdgeType, N as NodeType, T as TemporalMode, d as EdgeType, E as EdgeRegistration, i as EdgeId, m as NodeId, b as NodeRegistration, K as KindEntity, f as Cardinality, g as EndpointExistence, e as KindAnnotations, U as UniquenessScope, C as Collation, G as GraphExtension } from './extension-types-D07e_NTw.cjs';
 import { SQL } from 'drizzle-orm';
+import { b as MaterializeIndexesOptions, M as MaterializeIndexesResult } from './materialize-indexes-BB9N5uQl.cjs';
 
 /**
  * Embedding type for vector search.
@@ -31,12 +32,73 @@ type EmbeddingValue = readonly number[] & {
  * and extract dimension information.
  */
 declare const EMBEDDING_DIMENSIONS_KEY: "_embeddingDimensions";
+/**
+ * Symbol key for storing the embedding's preferred index configuration
+ * on the schema. The schema introspector reads this when auto-deriving
+ * `VectorIndexDeclaration` entries at `defineGraph()` time.
+ */
+declare const EMBEDDING_INDEX_KEY: "_embeddingIndex";
+/**
+ * Distance metric used for vector similarity. Pinned at the embedding
+ * brand because changing the metric usually means generating different
+ * model output (e.g. cosine-normalized vs. raw inner-product), and the
+ * stored index needs the same metric to score correctly.
+ *
+ * - `cosine`: cosine similarity. The default — works for most
+ *   sentence-transformer / OpenAI-style embeddings that are already
+ *   length-normalized.
+ * - `l2`: Euclidean distance. Use when your model outputs vectors
+ *   trained for L2 (e.g. some image embedding models).
+ * - `inner_product`: dot-product distance. Use when your model outputs
+ *   pre-normalized vectors AND you want to skip the cosine
+ *   normalization step at query time.
+ */
+type EmbeddingMetric = "cosine" | "l2" | "inner_product";
+/**
+ * Vector index implementation. `hnsw` is the default and what pgvector
+ * recommends for most workloads. `ivfflat` is the alternative for
+ * larger datasets where memory is the bottleneck. `none` disables
+ * automatic index creation for this embedding (the operator can still
+ * call `backend.createVectorIndex` manually).
+ */
+type EmbeddingIndexType = "hnsw" | "ivfflat" | "none";
+/**
+ * Per-embedding configuration for the auto-derived
+ * `VectorIndexDeclaration`. All fields are optional with sensible
+ * defaults (`cosine` / `hnsw` / pgvector defaults: `m=16`,
+ * `ef_construction=64`). Override only when your model or dataset has
+ * a known reason to.
+ */
+type EmbeddingIndexOptions = Readonly<{
+    /** Distance metric. Default `"cosine"`. */
+    metric?: EmbeddingMetric;
+    /** Vector index implementation. Default `"hnsw"`. */
+    indexType?: EmbeddingIndexType;
+    /** HNSW `m` parameter — max connections per layer. Default `16`. */
+    m?: number;
+    /** HNSW `ef_construction` parameter — build-time search depth. Default `64`. */
+    efConstruction?: number;
+    /** IVFFlat `lists` parameter — number of inverted-list partitions. */
+    lists?: number;
+}>;
+/**
+ * Resolved embedding index configuration with all defaults applied.
+ * What gets attached to the brand and read by the auto-derivation pass.
+ */
+type ResolvedEmbeddingIndex = Readonly<{
+    metric: EmbeddingMetric;
+    indexType: EmbeddingIndexType;
+    m: number;
+    efConstruction: number;
+    lists: number | undefined;
+}>;
 /**
  * A Zod schema for vector embeddings with attached dimension metadata.
  * Uses the branded EmbeddingValue type for type-level distinction.
  */
 type EmbeddingSchema<D extends number = number> = z.ZodType<EmbeddingValue> & Readonly<{
     [EMBEDDING_DIMENSIONS_KEY]: D;
+    [EMBEDDING_INDEX_KEY]: ResolvedEmbeddingIndex;
 }>;
 /**
  * Creates a Zod schema for vector embeddings.
@@ -74,7 +136,7 @@ type EmbeddingSchema<D extends number = number> = z.ZodType<EmbeddingValue> & Re
  * });
  * ```
  */
-declare function embedding<D extends number>(dimensions: D): EmbeddingSchema<D>;
+declare function embedding<D extends number>(dimensions: D, options?: EmbeddingIndexOptions): EmbeddingSchema<D>;
 /**
  * Checks if a value is an embedding schema.
  */
@@ -367,6 +429,93 @@ declare function inSubquery(field: FieldRef, subquery: QueryAst): Predicate;
  */
 declare function notInSubquery(field: FieldRef, subquery: QueryAst): Predicate;
 
+/**
+ * Dynamic query builder types.
+ *
+ * Backs `fromDynamic` / `traverseDynamic` / `optionalTraverseDynamic`
+ * / `toDynamic` — the string-keyed sibling methods on `QueryBuilder`
+ * and `TraversalBuilder` that admit runtime-declared kinds. Same SQL
+ * compiler under the hood; only the alias-level surface types differ.
+ *
+ * Aliases declared via the dynamic methods carry `DynamicNodeType` /
+ * `DynamicEdgeType` brands. `NodeAccessor<N>` / `EdgeAccessor<E>` /
+ * `SelectableNode<N>` / `SelectableEdge<E>` branch on those brands so a
+ * single query can mix typed and dynamic aliases — a typed alias keeps
+ * `StringFieldAccessor`, etc., while a dynamic alias gets
+ * `DynamicNodeAccessor` with a `.field(name)` discriminator.
+ */
+
+declare const DYNAMIC_NODE_BRAND: unique symbol;
+declare const DYNAMIC_EDGE_BRAND: unique symbol;
+type DynamicNodeType = NodeType & Readonly<{
+    [DYNAMIC_NODE_BRAND]: true;
+}>;
+type DynamicEdgeType = AnyEdgeType & Readonly<{
+    [DYNAMIC_EDGE_BRAND]: true;
+}>;
+type IsDynamicNodeType<N> = N extends Readonly<{
+    [DYNAMIC_NODE_BRAND]: true;
+}> ? true : false;
+type IsDynamicEdgeType<E> = E extends Readonly<{
+    [DYNAMIC_EDGE_BRAND]: true;
+}> ? true : false;
+/**
+ * Type-discriminated field builder for runtime-typed properties.
+ *
+ * `BaseFieldAccessor` methods (`eq`, `isNull`, etc.) are available
+ * directly. Type-specific methods (`gte`, `contains`, `similarTo`, …)
+ * sit behind a discriminator method that asserts the field's type:
+ *
+ * ```ts
+ * (n) => n.field("year").number().gte(2020)
+ * ```
+ *
+ * The discriminator validates against the registered Zod schema at
+ * query-build time and throws `TypeError` on mismatch — the user can't
+ * accidentally call `.between(...)` on a string field. The discriminator
+ * is a type assertion *and* a runtime check.
+ */
+type DynamicFieldBuilder = BaseFieldAccessor & Readonly<{
+    string: () => StringFieldAccessor;
+    number: () => NumberFieldAccessor;
+    date: () => DateFieldAccessor;
+    array: () => ArrayFieldAccessor<unknown>;
+    object: () => ObjectFieldAccessor<Readonly<Record<string, unknown>>>;
+    embedding: () => EmbeddingFieldAccessor;
+}>;
+/**
+ * Predicate accessor for a runtime-kind alias.
+ *
+ * System fields keep their narrow types. Schema properties are reached
+ * through `.field(name)` — `.field()` validates the property exists on
+ * the registered Zod schema and throws if it doesn't.
+ */
+type DynamicNodeAccessor = Readonly<{
+    id: StringFieldAccessor;
+    kind: StringFieldAccessor;
+    $fulltext: FulltextAccessor;
+    field: (name: string) => DynamicFieldBuilder;
+}>;
+type DynamicEdgeAccessor = Readonly<{
+    id: StringFieldAccessor;
+    kind: StringFieldAccessor;
+    fromId: StringFieldAccessor;
+    toId: StringFieldAccessor;
+    field: (name: string) => DynamicFieldBuilder;
+}>;
+type DynamicSelectableNode = Readonly<{
+    id: string;
+    kind: string;
+    meta: SelectableNodeMeta;
+}> & Readonly<Record<string, unknown>>;
+type DynamicSelectableEdge = Readonly<{
+    id: string;
+    kind: string;
+    fromId: string;
+    toId: string;
+    meta: SelectableEdgeMeta;
+}> & Readonly<Record<string, unknown>>;
+
 /**
  * Shared type definitions for the query builder.
  *
@@ -555,8 +704,12 @@ type ObjectFieldAccessor<T> = BaseFieldAccessor & Readonly<{
  *   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.
+ *
+ * For aliases declared via `fromDynamic` / `toDynamic`, `N` carries the
+ * dynamic brand and this resolves to `DynamicNodeAccessor` — schema
+ * properties go through a `.field(name)` discriminator.
  */
-type NodeAccessor<N extends NodeType> = Readonly<{
+type NodeAccessor<N extends NodeType> = IsDynamicNodeType<N> extends true ? DynamicNodeAccessor : Readonly<{
     id: StringFieldAccessor;
     kind: StringFieldAccessor;
     $fulltext: FulltextAccessor;
@@ -573,8 +726,11 @@ type EdgePropsAccessor<E extends AnyEdgeType> = Readonly<{
  * Properties are available at the top level for ergonomic access:
  * - `e.role` instead of `e.props.role`
  * - System fields: `e.id`, `e.kind`, `e.fromId`, `e.toId`
+ *
+ * Dynamic-mode counterpart: see `NodeAccessor` for the brand-detection
+ * pattern.
  */
-type EdgeAccessor<E extends AnyEdgeType> = Readonly<{
+type EdgeAccessor<E extends AnyEdgeType> = IsDynamicEdgeType<E> extends true ? DynamicEdgeAccessor : Readonly<{
     id: StringFieldAccessor;
     kind: StringFieldAccessor;
     fromId: StringFieldAccessor;
@@ -597,8 +753,12 @@ type SelectableNodeMeta = Readonly<{
  * Properties from the schema are spread at the top level for ergonomic access:
  * - `node.name` instead of `node.props.name`
  * - System metadata is under `node.meta.*`
+ *
+ * For aliases declared via `fromDynamic` / `toDynamic` this resolves to
+ * `DynamicSelectableNode` — same wire shape, schema properties typed
+ * `unknown` for narrowing at the call site.
  */
-type SelectableNode<N extends NodeType> = Readonly<{
+type SelectableNode<N extends NodeType> = IsDynamicNodeType<N> extends true ? DynamicSelectableNode : Readonly<{
     id: string;
     kind: N["kind"];
     meta: SelectableNodeMeta;
@@ -619,8 +779,10 @@ type SelectableEdgeMeta = Readonly<{
  * Properties from the schema are spread at the top level for ergonomic access:
  * - `edge.role` instead of `edge.props.role`
  * - System metadata is under `edge.meta.*`
+ *
+ * Dynamic-mode counterpart: see `SelectableNode`.
  */
-type SelectableEdge<E extends AnyEdgeType = EdgeType> = Readonly<{
+type SelectableEdge<E extends AnyEdgeType = EdgeType> = IsDynamicEdgeType<E> extends true ? DynamicSelectableEdge : Readonly<{
     id: string;
     kind: E["kind"];
     fromId: string;
@@ -727,6 +889,14 @@ type QueryBuilderState = Readonly<{
     groupBy: GroupBySpec | undefined;
     having: PredicateExpression | undefined;
     fusion: HybridFusionOptions | undefined;
+    /**
+     * Aliases declared via `fromDynamic` / `toDynamic`. The accessor
+     * factories check membership to decide between typed and dynamic
+     * predicate surfaces.
+     */
+    dynamicNodeAliases: ReadonlySet<string>;
+    /** Edge aliases declared via `traverseDynamic` / `optionalTraverseDynamic`. */
+    dynamicEdgeAliases: ReadonlySet<string>;
 }>;
 /**
  * Options for creating a query builder.
@@ -891,7 +1061,7 @@ type OperationHookContext = HookContext & Readonly<{
     /** Operation type */
     operation: "create" | "update" | "delete";
     /** Entity type */
-    entity: "node" | "edge";
+    entity: KindEntity;
     /** Kind of node or edge */
     kind: string;
     /** Entity ID */
@@ -952,6 +1122,35 @@ type StoreOptions = Readonly<{
         traversalExpansion?: TraversalExpansion;
     }>;
 }>;
+/**
+ * A mutable handle to the current `Store`, used by `store.evolve(...)`
+ * so long-lived consumers can dereference through the ref and pick up
+ * the new store after each evolve call. `current` is overwritten by
+ * `evolve()` atomically with the schema commit when the ref is passed
+ * via `evolve(extension, { ref })`.
+ *
+ * **Mid-request semantics.** `ref.current` flips on the *next* call
+ * after evolve, not mid-handler. Dereference once at request entry and
+ * reuse the captured `Store` for the duration:
+ *
+ * ```ts
+ * async function handleRequest(): Promise<void> {
+ *   const store = ref.current; // capture once
+ *   const tag = await store.nodes.Tag?.create({ label: "..." });
+ *   // ...further work on the same `store`...
+ * }
+ * ```
+ *
+ * Pure dereferenceable handle — no event/subscription machinery. If
+ * consumers need eventing, they wrap the ref themselves.
+ *
+ * Generic over the held value (typically `Store<G>`) so the store
+ * module can refer to it without importing the `Store` class into
+ * `types.ts`.
+ */
+interface StoreRef<T> {
+    current: T;
+}
 /**
  * Behavior when a get-or-create operation matches an existing record.
  */
@@ -1662,6 +1861,33 @@ type SubgraphResult<G extends GraphDef, NK extends NodeKinds<G> = NodeKinds<G>,
     reverseAdjacency: ReadonlyMap<string, ReadonlyMap<EK, readonly SubgraphEdgeResult<G, EK, P>[]>>;
 }>;
 
+/**
+ * Data-cleanup phase for `store.removeKinds()`.
+ *
+ * The removeKinds verb commits the new schema atomically (millisecond
+ * budget); the data deletion happens here, scoped per-deployment via
+ * the `typegraph_kind_removals` status table. Splitting the verbs
+ * mirrors how `materializeIndexes` complements `evolve`: schema
+ * commits are atomic and fast, data work is bounded by row count and
+ * deferrable / parallelizable.
+ */
+
+type MaterializeRemovalsOptions = Readonly<{
+    /** Restrict to specific kind names. */
+    kinds?: readonly string[];
+    /** Halt on first failure. Default: false (best-effort). */
+    stopOnError?: boolean;
+}>;
+type MaterializeRemovalsEntry = Readonly<{
+    kind: string;
+    entity: KindEntity;
+    status: "removed" | "failed";
+    error?: Error;
+}>;
+type MaterializeRemovalsResult = Readonly<{
+    results: readonly MaterializeRemovalsEntry[];
+}>;
+
 /**
  * ExecutableAggregateQuery - A query with aggregate functions that can be executed.
  */
@@ -1990,6 +2216,15 @@ declare class ExecutableQuery<G extends GraphDef, Aliases extends AliasMap, Edge
  * TraversalBuilder - Intermediate builder for edge traversals.
  */
 
+/**
+ * Resolves the edge type for an edge alias based on its kind type parameter.
+ *
+ * For `traverse(...)`, `EK` is a literal like `"authoredBy"` and the
+ * type comes from the typed graph. For `traverseDynamic(...)`, `EK` is
+ * widened to `string` — `string extends EK` distinguishes that case and
+ * resolves to `DynamicEdgeType`, so the conditional accessor types fire.
+ */
+type EdgeTypeForKey<G extends GraphDef, EK> = string extends EK ? DynamicEdgeType : EK extends keyof G["edges"] & string ? G["edges"][EK]["type"] : DynamicEdgeType;
 /**
  * State for variable-length traversal configuration.
  */
@@ -2028,7 +2263,7 @@ declare class TraversalBuilder<G extends GraphDef, Aliases extends AliasMap, Edg
      * @param alias - The edge alias to filter on (must be the current edge alias)
      * @param predicateFunction - A function that builds predicates using the edge accessor
      */
-    whereEdge(alias: EA, predicateFunction: (edge: EdgeAccessor<G["edges"][EK]["type"]>) => Predicate): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, Dir, Optional, DC, PC, RecAliases>;
+    whereEdge(alias: EA, predicateFunction: (edge: EdgeAccessor<EdgeTypeForKey<G, EK>>) => Predicate): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, Dir, Optional, DC, PC, RecAliases>;
     /**
      * Specifies the target node kind.
      *
@@ -2045,6 +2280,13 @@ declare class TraversalBuilder<G extends GraphDef, Aliases extends AliasMap, Edg
     to<K extends ValidEdgeTargets<G, EK, Dir>, A extends string>(kind: K, alias: UniqueAlias<A, Aliases>, options: {
         includeSubClasses: true;
     }): QueryBuilder<G, Aliases & Record<A, NodeAlias<NodeType, Optional>>, EdgeAliases & Record<EA, EdgeAlias<G["edges"][EK]["type"], Optional>>, RecAliases & BuildRecursiveAliases<DC, PC, A>>;
+    /**
+     * String-keyed sibling of `to` for runtime-declared target kinds.
+     * Throws `KindNotFoundError` if the kind is not registered.
+     */
+    toDynamic<A extends string>(kind: string, alias: UniqueAlias<A, Aliases>, options?: {
+        includeSubClasses?: boolean;
+    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<DynamicNodeType, Optional>>, EdgeAliases & Record<EA, EdgeAlias<EdgeTypeForKey<G, EK>, Optional>>, RecAliases & BuildRecursiveAliases<DC, PC, A>>;
 }
 
 /**
@@ -2074,6 +2316,14 @@ declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = {}, Ed
     from<K extends keyof G["nodes"] & string, A extends string>(kind: K, alias: UniqueAlias<A, Aliases>, options: {
         includeSubClasses: true;
     }): QueryBuilder<G, Aliases & Record<A, NodeAlias>, EdgeAliases, RecursiveAliases>;
+    /**
+     * String-keyed sibling of `from` for runtime-declared kinds. Throws
+     * `KindNotFoundError` if the kind is not registered. Predicates use
+     * the `n.field("name").number().gte(...)` discriminator.
+     */
+    fromDynamic<A extends string>(kind: string, alias: UniqueAlias<A, Aliases>, options?: {
+        includeSubClasses?: boolean;
+    }): QueryBuilder<G, Aliases & Record<A, NodeAlias<DynamicNodeType>>, EdgeAliases, RecursiveAliases>;
     /**
      * Adds a WHERE clause for a node.
      */
@@ -2114,6 +2364,15 @@ declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = {}, Ed
         expand?: TraversalExpansion;
         from?: keyof Aliases & string;
     }): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, "in", false, false, false, RecursiveAliases>;
+    /**
+     * String-keyed sibling of `traverse` for runtime-declared edge kinds.
+     * Throws `KindNotFoundError` if the edge kind is not registered.
+     */
+    traverseDynamic<EA extends string>(edgeKind: string, edgeAlias: EA, options?: {
+        direction?: TraversalDirection$1;
+        expand?: TraversalExpansion;
+        from?: keyof Aliases & string;
+    }): TraversalBuilder<G, Aliases, EdgeAliases & Record<EA, EdgeAlias<DynamicEdgeType>>, string, EA, TraversalDirection$1, false, false, false, RecursiveAliases>;
     /**
      * Optionally traverses an edge to another node (LEFT JOIN semantics).
      * If no matching edge/node exists, the result will include null values.
@@ -2135,6 +2394,17 @@ declare class QueryBuilder<G extends GraphDef, Aliases extends AliasMap = {}, Ed
         expand?: TraversalExpansion;
         from?: keyof Aliases & string;
     }): TraversalBuilder<G, Aliases, EdgeAliases, EK, EA, "in", true, false, false, RecursiveAliases>;
+    /**
+     * String-keyed sibling of `optionalTraverse` for runtime-declared edge
+     * kinds. LEFT JOIN semantics — non-matching rows produce a null edge
+     * alias instead of dropping. Throws `KindNotFoundError` if the edge
+     * kind is not registered.
+     */
+    optionalTraverseDynamic<EA extends string>(edgeKind: string, edgeAlias: EA, options?: {
+        direction?: TraversalDirection$1;
+        expand?: TraversalExpansion;
+        from?: keyof Aliases & string;
+    }): TraversalBuilder<G, Aliases, EdgeAliases & Record<EA, EdgeAlias<DynamicEdgeType, true>>, string, EA, TraversalDirection$1, true, false, false, RecursiveAliases>;
     /**
      * Selects fields to return.
      */
@@ -2432,6 +2702,81 @@ type GraphAlgorithms<G extends GraphDef> = Readonly<{
     degree: (node: NodeIdentifier, options?: DegreeOptions<G>) => Promise<number>;
 }>;
 
+/**
+ * `store.introspect()` — unified read of the merged schema.
+ *
+ * Returns a coherent snapshot of "what does my schema look like right
+ * now" suitable for schema-management UIs, codegen, and IDE plugins.
+ * The previous surface was fragmented across `registry.hasNodeType`,
+ * `store.deprecatedKinds`, and direct graph poking; `introspect()`
+ * unifies them with explicit `origin` markers distinguishing
+ * compile-time from runtime declarations.
+ *
+ * Pure read — no I/O. Built from the in-memory `GraphDef` and the
+ * persisted-but-already-merged `extension`. `schemaVersion` /
+ * `schemaHash` are populated when the loader cached them at
+ * construction time and `undefined` otherwise; consumers needing a
+ * fresh read should call `backend.getActiveSchema(graphId)` directly.
+ */
+
+type SchemaIntrospection = Readonly<{
+    graphId: string;
+    /** Active schema version on the backend, when known to the caller. */
+    schemaVersion: number | undefined;
+    /** Hash of the active schema document, when known to the caller. */
+    schemaHash: string | undefined;
+    kinds: readonly KindIntrospection[];
+    edges: readonly EdgeIntrospection[];
+    ontology: readonly OntologyIntrospection[];
+    deprecatedKinds: ReadonlySet<string>;
+    /**
+     * The persisted graph extension, or `undefined` when the store has
+     * no extensions. Round-trips: passing this value to
+     * `defineGraphExtension` and `evolve` against an empty graph yields
+     * a graph with the same extension kinds.
+     */
+    extension: GraphExtension | undefined;
+}>;
+type KindIntrospection = Readonly<{
+    name: string;
+    origin: "compile-time" | "runtime";
+    description: string | undefined;
+    annotations: KindAnnotations | undefined;
+    deprecated: boolean;
+    /**
+     * JSON-Schema view of the kind's properties. For extension kinds the
+     * lower-level `ExtensionPropertyType` shape (with first-class
+     * `searchable` / `embedding` modifiers) is reachable via
+     * `introspection.extension.nodes[name].properties`.
+     */
+    properties: JsonSchema;
+    unique: readonly UniqueIntrospection[];
+}>;
+type EdgeIntrospection = Readonly<{
+    name: string;
+    origin: "compile-time" | "runtime";
+    description: string | undefined;
+    from: readonly string[];
+    to: readonly string[];
+    cardinality: Cardinality;
+    endpointExistence: EndpointExistence;
+    properties: JsonSchema;
+    annotations: KindAnnotations | undefined;
+    deprecated: boolean;
+}>;
+type OntologyIntrospection = Readonly<{
+    metaEdge: string;
+    from: string;
+    to: string;
+    origin: "compile-time" | "runtime";
+}>;
+type UniqueIntrospection = Readonly<{
+    name: string;
+    fields: readonly string[];
+    scope: UniquenessScope;
+    collation: Collation;
+}>;
+
 type RebuildFulltextOptions = Readonly<{
     /** Page size. Must be a positive integer. Default: 500. */
     pageSize?: number;
@@ -2540,6 +2885,23 @@ type HybridVectorOptions = Readonly<{
     /** Minimum similarity to include (units depend on metric). */
     minScore?: number;
 }>;
+/**
+ * Options for the standalone `store.search.vector` path. Mirrors the
+ * vector half of `HybridSearchOptions` but flattens it because the
+ * standalone path doesn't fuse against fulltext.
+ */
+type VectorSearchOptions = Readonly<{
+    /** Field path of the embedding column on the node kind. */
+    fieldPath: string;
+    /** Query embedding to compare against. */
+    queryEmbedding: readonly number[];
+    /** Max results. Required. */
+    limit: number;
+    /** Distance metric. Default: "cosine". */
+    metric?: VectorMetric;
+    /** 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. */
@@ -2560,17 +2922,27 @@ type HybridSearchOptions = Readonly<{
 /**
  * StoreSearch — store.search facade.
  *
- * Groups fulltext, hybrid, and maintenance operations under one
+ * Groups fulltext, vector, 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.
+ * traversal. The methods delegate to their respective execution
+ * modules; this class exists to shape the surface and to gate kind
+ * names through the registry — the kind argument is `string` so
+ * graph-extension kinds (added via `store.evolve()`) work without a
+ * type cast, with a runtime guard rejecting misspellings at the call
+ * site.
  */
 
 /**
- * Narrows `Node` to the concrete typed node for a given kind in the graph.
+ * Resolves the hit's `node` type. Compile-time kinds keep their
+ * narrowed `Node<N>`; kinds outside `G` (added via graph extension through
+ * `store.evolve()`, or string variables the type system can't see)
+ * widen to the base `Node` so callers don't need a cast.
+ *
+ * This is the same shape as `getNodeCollection` — the dynamic form
+ * works for any registered kind, and the type narrows when (and only
+ * when) the literal is statically known.
  */
-type NodeOfKind<G extends GraphDef, K extends NodeKinds<G>> = G["nodes"][K] extends NodeRegistration<infer N extends NodeType> ? Node<N> : Node;
+type ResolveNode<G extends GraphDef, K extends string> = K extends NodeKinds<G> ? G["nodes"][K] extends NodeRegistration<infer N extends NodeType> ? Node<N> : Node : Node;
 type StoreSearchContext = Readonly<{
     graphId: string;
     backend: GraphBackend;
@@ -2588,6 +2960,14 @@ type StoreSearchContext = Readonly<{
  *   includeSnippets: true,
  * });
  *
+ * // Vector only — for extension kinds with embedding() modifiers,
+ * // the auto-derived index serves this query.
+ * const nearest = await store.search.vector("Document", {
+ *   fieldPath: "embedding",
+ *   queryEmbedding: vec,
+ *   limit: 10,
+ * });
+ *
  * // Hybrid: vector + fulltext, fused with RRF
  * const ranked = await store.search.hybrid("Document", {
  *   limit: 10,
@@ -2598,6 +2978,10 @@ type StoreSearchContext = Readonly<{
  * // Rebuild after backfill / schema change
  * const stats = await store.search.rebuildFulltext();
  * ```
+ *
+ * Extension kinds added via `store.evolve(...)` work with all four
+ * methods without a type cast — the kind argument is `string` and a
+ * registry check rejects misspellings at the call site.
  */
 declare class StoreSearch<G extends GraphDef> {
     #private;
@@ -2611,7 +2995,19 @@ declare class StoreSearch<G extends GraphDef> {
      * 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>>[]>;
+    fulltext<K extends string>(nodeKind: K, options: FulltextSearchOptions): Promise<readonly FulltextSearchHit<ResolveNode<G, K>>[]>;
+    /**
+     * Runs a vector similarity search against nodes of the given kind.
+     *
+     * Requires a field on the node schema declared with `embedding()`,
+     * either at compile time or via a graph extension (the auto-derived
+     * `VectorIndexDeclaration` flows through `materializeIndexes()` on
+     * the same path either way).
+     *
+     * Pure vector — no fulltext leg, no fusion. For combined
+     * vector+fulltext ranking, use `hybrid`.
+     */
+    vector<K extends string>(nodeKind: K, options: VectorSearchOptions): Promise<readonly VectorSearchHit<ResolveNode<G, K>>[]>;
     /**
      * Runs a vector + fulltext hybrid search and fuses the results with
      * Reciprocal Rank Fusion.
@@ -2621,7 +3017,7 @@ declare class StoreSearch<G extends GraphDef> {
      * 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>>[]>;
+    hybrid<K extends string>(nodeKind: K, options: HybridSearchOptions): Promise<readonly HybridSearchHit<ResolveNode<G, K>>[]>;
     /**
      * Rebuilds the fulltext index from existing node data.
      *
@@ -2640,7 +3036,7 @@ declare class StoreSearch<G extends GraphDef> {
      * 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>;
+    rebuildFulltext<K extends string>(nodeKind?: K, options?: RebuildFulltextOptions): Promise<RebuildFulltextResult>;
 }
 
 /**
@@ -2654,6 +3050,10 @@ declare class StoreSearch<G extends GraphDef> {
  * - Transaction handling
  */
 
+type StoreSchemaMetadata = Readonly<{
+    schemaVersion: number | undefined;
+    schemaHash: string | undefined;
+}>;
 /**
  * The Store provides typed access to a TypeGraph database.
  *
@@ -2689,7 +3089,7 @@ declare class StoreSearch<G extends GraphDef> {
  */
 declare class Store<G extends GraphDef> {
     #private;
-    constructor(graph: G, backend: GraphBackend, options?: StoreOptions);
+    constructor(graph: G, backend: GraphBackend, options?: StoreOptions, schemaMetadata?: StoreSchemaMetadata);
     /** The graph definition */
     get graph(): G;
     /** The graph ID */
@@ -2758,17 +3158,74 @@ declare class Store<G extends GraphDef> {
      *
      * Use this for runtime string-keyed access when the kind is not known at
      * compile time (e.g., iterating all kinds, resolving from edge metadata,
-     * dynamic admin UIs).
+     * dynamic admin UIs). For the post-evolve "I just added this kind, give
+     * me the collection" pattern, prefer `getNodeCollectionOrThrow` — it
+     * throws `KindNotFoundError` instead of forcing a null-check.
      */
     getNodeCollection(kind: string): DynamicNodeCollection | undefined;
+    /**
+     * Returns the node collection for the given kind. Throws
+     * `KindNotFoundError` when the kind is not registered.
+     *
+     * The dominant graph-extension-kind access pattern: `await store.evolve(...)`
+     * returns a new store, the caller immediately operates on the new
+     * kind, and the null-check the optional variant requires is busywork.
+     */
+    getNodeCollectionOrThrow(kind: string): DynamicNodeCollection;
     /**
      * Returns the edge collection for the given kind, or undefined if the kind
      * is not registered in this graph.
      *
      * Use this for runtime string-keyed access when the kind is not known at
-     * compile time.
+     * compile time. For post-evolve access, prefer `getEdgeCollectionOrThrow`.
      */
     getEdgeCollection(kind: string): DynamicEdgeCollection | undefined;
+    /**
+     * Returns the edge collection for the given kind. Throws
+     * `KindNotFoundError` when the kind is not registered.
+     */
+    getEdgeCollectionOrThrow(kind: string): DynamicEdgeCollection;
+    /**
+     * Returns the Zod props schema for the given node kind, or `undefined`
+     * if the kind is not registered. Identity-preserving: returns the
+     * exact instance used by `.create()` / `.update()`, so a `parse()`
+     * surfaces the same underlying Zod issues that `ValidationError`
+     * wraps (operation-level checks like uniqueness and endpoints stay
+     * in `collection.create`).
+     */
+    getNodePropsSchema(kind: string): z.ZodObject<z.ZodRawShape> | undefined;
+    /**
+     * Returns the Zod props schema for the given node kind. Throws
+     * `KindNotFoundError` when the kind is not registered.
+     */
+    getNodePropsSchemaOrThrow(kind: string): z.ZodObject<z.ZodRawShape>;
+    /**
+     * Returns the Zod props schema for the given edge kind, or `undefined`
+     * if the kind is not registered. Symmetric with `getNodePropsSchema`.
+     */
+    getEdgePropsSchema(kind: string): z.ZodObject<z.ZodRawShape> | undefined;
+    /**
+     * Returns the Zod props schema for the given edge kind. Throws
+     * `KindNotFoundError` when the kind is not registered.
+     */
+    getEdgePropsSchemaOrThrow(kind: string): z.ZodObject<z.ZodRawShape>;
+    /**
+     * Returns a unified read of the merged schema — every compile-time
+     * and graph-extension kind, every edge, every ontology relation,
+     * with explicit `origin: "compile-time" | "runtime"` markers — plus
+     * the persisted `extension` for round-tripping.
+     *
+     * Pure synchronous read built from the in-memory graph and the
+     * already-merged graph-extension document. `schemaVersion` and `schemaHash`
+     * are populated when the loader cached them at construction or after
+     * `evolve` returns; consumers needing a fresh read should call
+     * `backend.getActiveSchema(graphId)`.
+     *
+     * The return shape is the canonical schema-introspection surface:
+     * the prior standalone `store.deprecatedKinds` accessor is replaced
+     * by `introspect().deprecatedKinds`.
+     */
+    introspect(): SchemaIntrospection;
     /**
      * Creates a query builder for this store.
      *
@@ -2952,6 +3409,185 @@ declare class Store<G extends GraphDef> {
      * ```
      */
     refreshStatistics(): Promise<void>;
+    /**
+     * Evolves the graph at runtime by merging a graph extension into the
+     * current schema, atomically committing a new schema version, and
+     * returning a fresh `Store` constructed against the merged graph.
+     *
+     * The `Store` is immutable — its registry, collections, and operation
+     * contexts close over the graph at construction time — so callers
+     * must use the returned store (or pass a `ref` to be re-pointed) for
+     * any work involving the new kinds.
+     *
+     * **Cost for purely additive extensions is proportional to schema
+     * document size, not row count.** The commit is a single CAS write.
+     * Tightening changes against existing graph-extension-declared kinds run
+     * row-count probes for those affected kinds so populated kinds can
+     * be rejected without a backfill.
+     *
+     * **Concurrent evolve recovery.** On `StaleVersionError`, refetch the
+     * current active schema (or dereference your `StoreRef`),
+     * reconstruct your `Store`, and re-call `evolve(extension)` against
+     * the new store. Re-validation may now surface deterministic errors
+     * (e.g., another caller just added a kind that collides with yours,
+     * or redeclared one of yours with a different shape). Don't loop
+     * blindly — surface the error.
+     *
+     * @param extension - Graph extension produced by
+     *   `defineGraphExtension(...)`.
+     * @param options.ref - Optional handle whose `current` is overwritten
+     *   atomically with the schema commit. Long-lived consumers
+     *   (request handlers, background workers) that dereference through
+     *   the ref see the new kinds on the *next* call.
+     *
+     * @throws {GraphExtensionValidationError} when the extension is
+     *   structurally invalid.
+     * @throws {KindCollisionError} when an extension kind shadows a
+     *   compile-time kind (code `KIND_COLLISION`).
+     * @throws {IncompatibleChangeError} when a redeclared kind narrows
+     *   in a way the existing rows can't satisfy
+     *   (code `INCOMPATIBLE_CHANGE`).
+     * @throws {GraphExtensionUnresolvedEndpointError} when an edge
+     *   endpoint references a kind that exists in neither the extension
+     *   nor the host graph
+     *   (code `GRAPH_EXTENSION_UNRESOLVED_ENDPOINT`).
+     * @throws {StaleVersionError} when another writer has advanced the
+     *   schema since this store was constructed; recovery as above.
+     * @throws {SchemaContentConflictError} when a row already exists at
+     *   the target version with a different content hash.
+     */
+    evolve(extension: GraphExtension, options?: Readonly<{
+        ref?: StoreRef<Store<G>>;
+        /**
+         * When set, automatically run `materializeIndexes()` on the new
+         * Store after the schema commit succeeds. Pass `{}` for default
+         * behavior (all declared indexes, best-effort) or a populated
+         * options object for finer control. Omit to defer materialization
+         * to a later `materializeIndexes()` call.
+         *
+         * The schema-version write is NOT rolled back if materialization
+         * produces failed entries — failure surfaces as
+         * `EagerMaterializationError` thrown AFTER the new Store is
+         * constructed and `ref.current` is updated, so the caller can
+         * recover via the ref handle.
+         */
+        eager?: MaterializeIndexesOptions;
+    }>): Promise<Store<G>>;
+    /**
+     * Marks the named node and edge kinds as soft-deprecated. Surfaces in
+     * `store.introspect().deprecatedKinds` for introspection (codegen,
+     * UI tooling, lints) but does not gate reads, writes, or queries —
+     * deprecation is a signal, not a removal.
+     *
+     * Atomically commits a new schema version through the same primitive
+     * `evolve()` uses, so concurrent deprecate/evolve calls produce
+     * `StaleVersionError | SchemaContentConflictError` race losers that
+     * the caller refetches and retries. Idempotent: re-deprecating a
+     * kind that's already marked is a no-op (no version bump).
+     *
+     * @param names - Node or edge kind names to mark as deprecated.
+     * @param options.ref - Optional handle to be re-pointed atomically
+     *   with the schema commit, mirroring `evolve()`.
+     *
+     * @throws {ConfigurationError} on `DEPRECATE_BEFORE_INITIALIZE` (no
+     *   schema yet) or `DEPRECATE_UNKNOWN_KIND` (name not on the graph).
+     * @throws {StaleVersionError} when another writer has advanced the
+     *   schema since this store was constructed; refetch and retry per
+     *   the same recipe `evolve()` documents.
+     * @throws {SchemaContentConflictError} when a row already exists at
+     *   the target version with a different content hash.
+     */
+    deprecateKinds(names: readonly string[], options?: Readonly<{
+        ref?: StoreRef<Store<G>>;
+    }>): Promise<Store<G>>;
+    /**
+     * Reverses `deprecateKinds(...)` for the named kinds. Same race +
+     * idempotency semantics: removing a name that isn't currently
+     * deprecated is a no-op for that name (the call as a whole is a
+     * no-op only if every name was already absent).
+     *
+     * @param names - Node or edge kind names to remove from the
+     *   deprecated set.
+     * @param options.ref - Optional handle to be re-pointed atomically
+     *   with the schema commit.
+     *
+     * @throws {ConfigurationError} on `DEPRECATE_BEFORE_INITIALIZE`.
+     * @throws {StaleVersionError} on a CAS race with another writer.
+     * @throws {SchemaContentConflictError} on a same-version content
+     *   conflict.
+     */
+    undeprecateKinds(names: readonly string[], options?: Readonly<{
+        ref?: StoreRef<Store<G>>;
+    }>): Promise<Store<G>>;
+    /**
+     * Runs `CREATE INDEX` DDL for the indexes declared on this graph and
+     * records per-deployment status in `typegraph_index_materializations`.
+     * The status table is per-database (two replicas of the same
+     * `schema_doc` are still two different databases for DDL purposes),
+     * so the same call against two replicas materializes independently.
+     *
+     * Idempotent. Re-running the verb against an already-materialized
+     * index is a no-op (`status: "alreadyMaterialized"`). Postgres uses
+     * `CREATE INDEX CONCURRENTLY` so live tables never take an
+     * `AccessExclusiveLock`. SQLite is single-writer regardless.
+     *
+     * Best-effort by default: a failed index records `status: "failed"`
+     * with the error and the loop continues. Pass `{ stopOnError: true }`
+     * to halt on the first failure.
+     *
+     * @param options.kinds - Restrict to indexes whose `kind` is in this
+     *   set. Throws `ConfigurationError` (`code:
+     *   "MATERIALIZE_UNKNOWN_KIND"`) if any name doesn't match a known
+     *   compile-time or extension kind.
+     * @param options.stopOnError - Halt on first failure. Default false.
+     *
+     * @throws {ConfigurationError} `MATERIALIZE_BACKEND_UNSUPPORTED` if
+     *   the backend lacks `executeDdl`, `getIndexMaterialization`, or
+     *   `recordIndexMaterialization`; `MATERIALIZE_UNKNOWN_KIND` for an
+     *   unknown kind name; `MATERIALIZE_BEFORE_INITIALIZE` if the store
+     *   has no schema yet.
+     */
+    materializeIndexes(options?: MaterializeIndexesOptions): Promise<MaterializeIndexesResult>;
+    /**
+     * Removes extension kinds from the schema with cascading edge and
+     * ontology cleanup. Two-phase by design:
+     *
+     *   1. **Schema commit (this method).** Validates the removal,
+     *      rebuilds the persisted extension without the named kinds
+     *      (and without extension edges that lose their last endpoint),
+     *      CAS-commits the new schema version, and queues
+     *      per-deployment data-cleanup status. Millisecond budget.
+     *   2. **Data cleanup (`materializeRemovals`).** Deletes the orphan
+     *      rows from the nodes/edges tables. Bounded by row count.
+     *
+     * Pass `{ eager: {} }` to run the data-cleanup pass inline with
+     * default options, or `{ eager: { ... } }` to scope it; otherwise
+     * call `materializeRemovals()` later.
+     *
+     * Idempotent: removing a name that doesn't exist is a no-op (no
+     * version bump). Removing an extension kind referenced by a compile-
+     * time edge or ontology relation throws `KindHasReferentsError`.
+     * Removing a compile-time kind throws `RemoveCompileTimeKindError` —
+     * compile-time kinds are removed by recompiling and redeploying.
+     *
+     * @throws {RemoveCompileTimeKindError} when `names` includes a
+     *   compile-time kind.
+     * @throws {KindHasReferentsError} when an extension kind being
+     *   removed is referenced by a compile-time declaration.
+     * @throws {StaleVersionError} on a CAS race with another writer.
+     * @throws {SchemaContentConflictError} on a same-version content
+     *   conflict.
+     */
+    removeKinds(names: readonly string[], options?: Readonly<{
+        ref?: StoreRef<Store<G>>;
+        eager?: MaterializeRemovalsOptions;
+    }>): Promise<Store<G>>;
+    /**
+     * Runs the data-cleanup phase for any kinds removed via
+     * `removeKinds()` whose data has not yet been deleted on this
+     * deployment. Safe to call repeatedly; idempotent.
+     */
+    materializeRemovals(options?: MaterializeRemovalsOptions): Promise<MaterializeRemovalsResult>;
     /**
      * Closes the store and releases underlying resources.
      *
@@ -3023,4 +3659,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 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 };
+export { type MaterializeRemovalsOptions as $, type AliasMap as A, type BaseTraversalOptions as B, type CreateQueryBuilderOptions as C, DEFAULT_SEARCHABLE_LANGUAGE as D, type EdgeAliasMap as E, type EmbeddingSchema as F, type EmbeddingValue as G, ExecutableAggregateQuery as H, ExecutableQuery as I, type FieldAccessor as J, type FulltextSearchHit as K, type FulltextSearchOptions as L, type GetOrCreateAction as M, type GraphAlgorithms as N, type GraphEdgeCollections as O, type GraphNodeCollections as P, QueryBuilder as Q, type HookContext as R, Store as S, TraversalBuilder as T, type HybridFulltextOptions as U, type HybridSearchHit as V, type HybridSearchOptions as W, type HybridVectorOptions as X, type IfExistsMode as Y, type KindIntrospection as Z, type MaterializeRemovalsEntry as _, type AggregateResult as a, getSearchableMetadata as a$, type MaterializeRemovalsResult as a0, type NeighborsOptions as a1, type Node as a2, type NodeAccessor as a3, type NodeAlias as a4, type NodeCollection as a5, type NodeGetOrCreateByConstraintOptions as a6, type NodeGetOrCreateByConstraintResult as a7, type NodeIdentifier as a8, type NodeRef as a9, type StoreProjection as aA, type StoreRef as aB, StoreSearch as aC, type StreamOptions as aD, type SubgraphEdgeResult as aE, type SubgraphNodeResult as aF, type SubgraphOptions as aG, type SubgraphResult as aH, type SubsetEdge as aI, type SubsetNode as aJ, type TemporalAlgorithmOptions as aK, type TransactionContext as aL, type TraversalDirection as aM, type TypedEdgeCollection as aN, UnionableQuery as aO, type UniqueIntrospection as aP, type UpdateEdgeInput as aQ, type UpdateNodeInput as aR, type VectorSearchHit as aS, type VectorSearchOptions as aT, createStore as aU, createStoreWithSchema as aV, defineSubgraphProject as aW, embedding as aX, exists as aY, fieldRef as aZ, getEmbeddingDimensions as a_, type OntologyIntrospection as aa, type OperationHookContext as ab, type PaginateOptions as ac, type PaginatedResult as ad, type PathNode as ae, type Predicate as af, PreparedQuery as ag, type PropsAccessor as ah, type QueryHookContext as ai, type QueryOptions as aj, type ReachableNode as ak, type ReachableOptions as al, type RebuildFulltextOptions as am, type RebuildFulltextResult as an, type RecursiveTraversalOptions as ao, type SchemaIntrospection as ap, type SearchableMetadata as aq, type SearchableOptions as ar, type SearchableSchema as as, type SelectContext as at, type SelectableEdge as au, type SelectableNode as av, type ShortestPathOptions as aw, type ShortestPathResult as ax, type StoreHooks as ay, type StoreOptions as az, type AlgorithmCyclePolicy as b, inSubquery as b0, isEmbeddingSchema as b1, isParameterRef as b2, isSearchableSchema as b3, notExists as b4, notInSubquery as b5, param as b6, searchable as b7, 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 DynamicEdgeAccessor as k, type DynamicEdgeCollection as l, type DynamicEdgeType as m, type DynamicFieldBuilder as n, type DynamicNodeAccessor as o, type DynamicNodeCollection as p, type DynamicNodeType as q, type DynamicSelectableEdge as r, type DynamicSelectableNode as s, type Edge as t, type EdgeAccessor as u, type EdgeCollection as v, type EdgeFindByEndpointsOptions as w, type EdgeGetOrCreateByEndpointsOptions as x, type EdgeGetOrCreateByEndpointsResult as y, type EdgeIntrospection as z };