@nicia-ai/typegraph 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nicia AI, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,47 @@
+# @nicia-ai/typegraph
+
+Type-driven embedded knowledge graph for TypeScript.
+
+- Docs: [typegraph.dev](https://typegraph.dev)
+- Repo: [github.com/nicia-ai/typegraph](https://github.com/nicia-ai/typegraph)
+
+## Installation
+
+```bash
+npm install @nicia-ai/typegraph zod drizzle-orm better-sqlite3
+```
+
+## Quick Start
+
+```ts
+import { z } from "zod";
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+
+import { createStore, defineEdge, defineGraph, defineNode } from "@nicia-ai/typegraph";
+import { createSqliteBackend, getSqliteMigrationSQL } from "@nicia-ai/typegraph/sqlite";
+
+const Person = defineNode("Person", { schema: z.object({ name: z.string() }) });
+const knows = defineEdge("knows");
+
+const graph = defineGraph({
+  id: "social",
+  nodes: { Person: { type: Person } },
+  edges: { knows: { type: knows, from: [Person], to: [Person] } },
+});
+
+const sqlite = new Database(":memory:");
+const db = drizzle(sqlite);
+sqlite.exec(getSqliteMigrationSQL());
+
+const backend = createSqliteBackend(db);
+const store = createStore(graph, backend);
+
+const alice = await store.nodes.Person.create({ name: "Alice" });
+const bob = await store.nodes.Person.create({ name: "Bob" });
+await store.edges.knows.create(alice, bob);
+```
+
+See the repo README for more.
+
+Examples: [github.com/nicia-ai/typegraph/tree/main/packages/typegraph/examples](https://github.com/nicia-ai/typegraph/tree/main/packages/typegraph/examples)

package/dist/ast-BVyihVbP.d.cts

@@ -0,0 +1,564 @@
+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;
+/**
+ * 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;
+    name: 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;
+    name: 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[]>;
+/**
+ * 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;
+
+declare const MAX_JSON_POINTER_DEPTH: 5;
+type JsonPointer = string & {
+    readonly __jsonPointer: unique symbol;
+};
+type JsonPointerSegment = string | number;
+type JsonPointerSegments = readonly JsonPointerSegment[];
+type Depth = 0 | 1 | 2 | 3 | 4 | 5;
+interface DepthDecrementMap {
+    0: 0;
+    1: 0;
+    2: 1;
+    3: 2;
+    4: 3;
+    5: 4;
+}
+type Decrement<Current extends Depth> = DepthDecrementMap[Current];
+type NonNegativeIntegerString = Exclude<`${bigint}`, `-${string}`>;
+type ObjectPointerKey<T> = Exclude<Extract<keyof T, string>, NonNegativeIntegerString>;
+type EncodeTilde<S extends string> = S extends `${infer Head}~${infer Tail}` ? `${EncodeTilde<Head>}~0${EncodeTilde<Tail>}` : S;
+type EncodeSlash<S extends string> = S extends `${infer Head}/${infer Tail}` ? `${EncodeSlash<Head>}~1${EncodeSlash<Tail>}` : S;
+type EncodePointerSegment<S extends string> = EncodeSlash<EncodeTilde<S>>;
+type DecodePointerSegment<S extends string> = S extends `${infer Head}~1${infer Tail}` ? `${DecodePointerSegment<Head>}/${DecodePointerSegment<Tail>}` : S extends `${infer Head}~0${infer Tail}` ? `${DecodePointerSegment<Head>}~${DecodePointerSegment<Tail>}` : S;
+type PointerForArray<T, Current extends Depth> = `/${NonNegativeIntegerString}` | (Current extends 1 ? never : `/${NonNegativeIntegerString}${JsonPointerFor<T, Decrement<Current>>}`);
+type PointerForObject<T, Current extends Depth> = {
+    [K in ObjectPointerKey<T>]: `/${EncodePointerSegment<K>}` | (Current extends 1 ? never : `/${EncodePointerSegment<K>}${JsonPointerFor<T[K], Decrement<Current>>}`);
+}[ObjectPointerKey<T>];
+type JsonPointerFor<T, Current extends Depth = 5> = "" | (Current extends 0 ? "" : T extends readonly (infer U)[] ? PointerForArray<U, Current> : never) | (Current extends 0 ? "" : T extends Record<string, unknown> ? PointerForObject<T, Current> : never);
+type PointerSegmentsForArray<T, Current extends Depth> = readonly [number] | (Current extends 1 ? readonly [number] : readonly [number, ...JsonPointerSegmentsFor<T, Decrement<Current>>]);
+type PointerSegmentsForObject<T, Current extends Depth> = {
+    [K in ObjectPointerKey<T>]: readonly [K] | (Current extends 1 ? readonly [K] : readonly [K, ...JsonPointerSegmentsFor<T[K], Decrement<Current>>]);
+}[ObjectPointerKey<T>];
+type JsonPointerSegmentsFor<T, Current extends Depth = 5> = readonly [] | (Current extends 0 ? readonly [] : T extends readonly (infer U)[] ? PointerSegmentsForArray<U, Current> : never) | (Current extends 0 ? readonly [] : T extends Record<string, unknown> ? PointerSegmentsForObject<T, Current> : never);
+type JsonPointerInput<T> = JsonPointerFor<T> | JsonPointerSegmentsFor<T> | JsonPointer;
+type ResolveJsonPointer<T, Pointer extends string> = Pointer extends "" ? T : Pointer extends `/${infer Head}/${infer Tail}` ? ResolveJsonPointer<ResolvePointerSegment<T, DecodePointerSegment<Head>>, `/${Tail}`> : Pointer extends `/${infer Head}` ? ResolvePointerSegment<T, DecodePointerSegment<Head>> : unknown;
+type ResolvePointerSegment<T, Segment extends string> = T extends readonly (infer U)[] ? Segment extends NonNegativeIntegerString ? U : unknown : T extends Record<string, unknown> ? Segment extends keyof T ? Segment extends NonNegativeIntegerString ? unknown : T[Segment] : unknown : unknown;
+type ResolveJsonPointerSegments<T, Segments extends readonly JsonPointerSegment[]> = Segments extends readonly [] ? T : Segments extends readonly [infer Head, ...infer Tail] ? ResolveJsonPointerSegments<ResolvePointerSegment<T, SegmentToString<Head>>, Extract<Tail, readonly JsonPointerSegment[]>> : unknown;
+type SegmentToString<Segment> = Segment extends number ? `${Segment}` : Segment extends string ? Segment : string;
+declare function jsonPointer(segments: JsonPointerSegments): JsonPointer;
+declare function normalizeJsonPointer<T>(input: JsonPointerInput<T>): JsonPointer;
+declare function parseJsonPointer(pointer: JsonPointer): readonly string[];
+declare function joinJsonPointers(base: JsonPointer | undefined, relative: JsonPointer): JsonPointer;
+
+/**
+ * Query AST types.
+ *
+ * Defines the abstract syntax tree for TypeGraph queries.
+ * This portable representation can be compiled to SQL (today)
+ * or other query languages (Cypher, SPARQL) in the future.
+ */
+
+/**
+ * A field reference in a predicate.
+ */
+type FieldRef = Readonly<{
+    __type: "field_ref";
+    alias: string;
+    path: readonly string[];
+    jsonPointer?: JsonPointer | undefined;
+    valueType?: ValueType | undefined;
+    elementType?: ValueType | undefined;
+}>;
+/**
+ * A literal value in a predicate.
+ */
+type LiteralValue = Readonly<{
+    __type: "literal";
+    value: string | number | boolean;
+    valueType?: ValueType | undefined;
+}>;
+/**
+ * Supported value types for predicates.
+ */
+type ValueType = "string" | "number" | "boolean" | "date" | "array" | "object" | "embedding" | "unknown";
+/**
+ * Comparison operators.
+ */
+type ComparisonOp = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "notIn";
+/**
+ * String operators.
+ */
+type StringOp = "contains" | "startsWith" | "endsWith" | "like" | "ilike";
+/**
+ * A comparison predicate.
+ */
+type ComparisonPredicate = Readonly<{
+    __type: "comparison";
+    op: ComparisonOp;
+    left: FieldRef;
+    right: LiteralValue | LiteralValue[];
+}>;
+/**
+ * A string predicate.
+ */
+type StringPredicate = Readonly<{
+    __type: "string_op";
+    op: StringOp;
+    field: FieldRef;
+    pattern: string;
+}>;
+/**
+ * A null check predicate.
+ */
+type NullPredicate = Readonly<{
+    __type: "null_check";
+    op: "isNull" | "isNotNull";
+    field: FieldRef;
+}>;
+/**
+ * A between predicate.
+ */
+type BetweenPredicate = Readonly<{
+    __type: "between";
+    field: FieldRef;
+    lower: LiteralValue;
+    upper: LiteralValue;
+}>;
+/**
+ * Array operators.
+ */
+type ArrayOp = "contains" | "containsAll" | "containsAny" | "isEmpty" | "isNotEmpty" | "lengthEq" | "lengthGt" | "lengthGte" | "lengthLt" | "lengthLte";
+/**
+ * An array predicate.
+ */
+type ArrayPredicate = Readonly<{
+    __type: "array_op";
+    op: ArrayOp;
+    field: FieldRef;
+    values?: readonly LiteralValue[];
+    length?: number;
+}>;
+/**
+ * Object operators.
+ */
+type ObjectOp = "hasKey" | "hasPath" | "pathEquals" | "pathContains" | "pathIsNull" | "pathIsNotNull";
+/**
+ * An object/JSON predicate.
+ */
+type ObjectPredicate = Readonly<{
+    __type: "object_op";
+    op: ObjectOp;
+    field: FieldRef;
+    pointer: JsonPointer;
+    value?: LiteralValue;
+    valueType?: ValueType;
+    elementType?: ValueType;
+}>;
+/**
+ * Logical AND predicate.
+ */
+type AndPredicate = Readonly<{
+    __type: "and";
+    predicates: readonly PredicateExpression[];
+}>;
+/**
+ * Logical OR predicate.
+ */
+type OrPredicate = Readonly<{
+    __type: "or";
+    predicates: readonly PredicateExpression[];
+}>;
+/**
+ * Logical NOT predicate.
+ */
+type NotPredicate = Readonly<{
+    __type: "not";
+    predicate: PredicateExpression;
+}>;
+/**
+ * An aggregate comparison predicate (for HAVING clauses).
+ */
+type AggregateComparisonPredicate = Readonly<{
+    __type: "aggregate_comparison";
+    op: ComparisonOp;
+    aggregate: AggregateExpr;
+    value: LiteralValue;
+}>;
+/**
+ * An EXISTS subquery predicate.
+ * Tests whether the subquery returns any rows.
+ */
+type ExistsSubquery = Readonly<{
+    __type: "exists";
+    subquery: QueryAst;
+    negated: boolean;
+}>;
+/**
+ * An IN subquery predicate.
+ * Tests whether a field value is in the subquery results.
+ */
+type InSubquery = Readonly<{
+    __type: "in_subquery";
+    field: FieldRef;
+    subquery: QueryAst;
+    negated: boolean;
+}>;
+/**
+ * Vector similarity metric types.
+ */
+type VectorMetricType = "cosine" | "l2" | "inner_product";
+/**
+ * A vector similarity predicate.
+ * Finds nodes with embeddings similar to the query embedding.
+ *
+ * This predicate affects query execution by:
+ * - Joining with the embeddings table
+ * - Adding ORDER BY distance (ascending)
+ * - Applying LIMIT (top k results)
+ * - Optionally filtering by minimum score
+ */
+type VectorSimilarityPredicate = Readonly<{
+    __type: "vector_similarity";
+    /** The embedding field reference */
+    field: FieldRef;
+    /** The query embedding to compare against */
+    queryEmbedding: readonly number[];
+    /** Similarity metric to use */
+    metric: VectorMetricType;
+    /** Maximum number of results to return */
+    limit: number;
+    /** Optional minimum similarity score (0-1 for cosine) */
+    minScore?: number;
+}>;
+/**
+ * All predicate expression types.
+ */
+type PredicateExpression = ComparisonPredicate | StringPredicate | NullPredicate | BetweenPredicate | ArrayPredicate | ObjectPredicate | AndPredicate | OrPredicate | NotPredicate | AggregateComparisonPredicate | ExistsSubquery | InSubquery | VectorSimilarityPredicate;
+/**
+ * The starting point of a query (the FROM clause).
+ */
+type QueryStart = Readonly<{
+    alias: string;
+    kinds: readonly string[];
+    includeSubClasses: boolean;
+}>;
+/**
+ * Direction of edge traversal.
+ */
+type TraversalDirection = "out" | "in";
+/**
+ * Variable-length traversal specification for recursive graph traversals.
+ */
+type VariableLengthSpec = Readonly<{
+    /** Minimum number of hops before including results (default: 1) */
+    minDepth: number;
+    /** Maximum number of hops (-1 = unlimited, default: -1) */
+    maxDepth: number;
+    /** Include the traversal path as an array in results */
+    collectPath: boolean;
+    /** Column alias for path array (default: "{nodeAlias}_path") */
+    pathAlias?: string;
+    /** Column alias for depth (default: "{nodeAlias}_depth") */
+    depthAlias?: string;
+}>;
+/**
+ * A traversal step in the query.
+ */
+type Traversal = Readonly<{
+    edgeAlias: string;
+    edgeKinds: readonly string[];
+    direction: TraversalDirection;
+    nodeAlias: string;
+    nodeKinds: readonly string[];
+    joinFromAlias: string;
+    joinEdgeField: "from_id" | "to_id";
+    /** If true, use LEFT JOIN instead of INNER JOIN (optional match) */
+    optional: boolean;
+    /** Variable-length traversal configuration (for recursive CTEs) */
+    variableLength?: VariableLengthSpec;
+}>;
+/**
+ * Supported aggregate functions.
+ */
+type AggregateFunction = "count" | "countDistinct" | "sum" | "avg" | "min" | "max";
+/**
+ * An aggregate expression.
+ */
+type AggregateExpr = Readonly<{
+    __type: "aggregate";
+    function: AggregateFunction;
+    field: FieldRef;
+}>;
+/**
+ * A GROUP BY specification.
+ */
+type GroupBySpec = Readonly<{
+    fields: readonly FieldRef[];
+}>;
+/**
+ * A projected field in the SELECT clause.
+ * Can be either a direct field reference or an aggregate expression.
+ */
+type ProjectedField = Readonly<{
+    outputName: string;
+    source: FieldRef | AggregateExpr;
+    /** Override the CTE alias for this field (used for edge fields in node CTEs) */
+    cteAlias?: string;
+}>;
+/**
+ * The projection (SELECT) clause.
+ */
+type Projection = Readonly<{
+    fields: readonly ProjectedField[];
+}>;
+/**
+ * A selectively projected field for optimized queries.
+ *
+ * Used when the select callback only accesses specific fields,
+ * allowing the compiler to generate optimized SQL that fetches
+ * only those fields instead of the full props blob.
+ */
+type SelectiveField = Readonly<{
+    /** The alias (node or edge) this field belongs to */
+    alias: string;
+    /** The field name (e.g., "email", "name", "id") */
+    field: string;
+    /** The output column name in the result (e.g., "p_email") */
+    outputName: string;
+    /** True if this is a system field (id, kind, etc.), false for props */
+    isSystemField: boolean;
+    /**
+     * Optional value type for props fields.
+     *
+     * When present, the compiler can use type-aware JSON extraction
+     * (e.g. numeric/date casts) to better match predicate compilation
+     * and enable expression index coverage.
+     */
+    valueType?: ValueType | undefined;
+}>;
+/**
+ * Null ordering preference.
+ */
+type NullOrdering = "first" | "last";
+/**
+ * Sort direction.
+ */
+type SortDirection = "asc" | "desc";
+/**
+ * An ordering specification.
+ */
+type OrderSpec = Readonly<{
+    field: FieldRef;
+    direction: SortDirection;
+    nulls?: NullOrdering;
+}>;
+/**
+ * A predicate applied to a specific node or edge alias.
+ */
+type NodePredicate = Readonly<{
+    targetAlias: string;
+    /** Whether this predicate targets a node or edge. Defaults to "node". */
+    targetType?: "node" | "edge";
+    expression: PredicateExpression;
+}>;
+/**
+ * Temporal query options.
+ */
+type TemporalOptions = Readonly<{
+    mode: TemporalMode;
+    asOf?: string;
+}>;
+/**
+ * The complete query AST.
+ */
+type QueryAst = Readonly<{
+    /** The graph ID this query is for (used for subqueries) */
+    graphId?: string;
+    start: QueryStart;
+    traversals: readonly Traversal[];
+    predicates: readonly NodePredicate[];
+    projection: Projection;
+    temporalMode: TemporalOptions;
+    orderBy?: readonly OrderSpec[];
+    limit?: number;
+    offset?: number;
+    /** GROUP BY specification for aggregate queries */
+    groupBy?: GroupBySpec;
+    /** HAVING clause - predicates applied after GROUP BY */
+    having?: PredicateExpression;
+    /**
+     * Selective fields for optimized queries.
+     * When present, the compiler generates SQL that only fetches these specific
+     * fields instead of the full props blob, enabling covered index usage.
+     */
+    selectiveFields?: readonly SelectiveField[];
+}>;
+/**
+ * Set operation types for combining queries.
+ */
+type SetOperationType = "union" | "unionAll" | "intersect" | "except";
+/**
+ * A set operation combining two queries.
+ */
+type SetOperation = Readonly<{
+    __type: "set_operation";
+    operator: SetOperationType;
+    left: ComposableQuery;
+    right: ComposableQuery;
+    orderBy?: readonly OrderSpec[];
+    limit?: number;
+    offset?: number;
+}>;
+/**
+ * A composable query - either a base query or a set operation.
+ */
+type ComposableQuery = QueryAst | SetOperation;
+
+export { type AnyEdgeType as A, type Traversal as B, type ComparisonOp as C, type DeleteBehavior as D, type EdgeType as E, type FieldRef as F, type GraphDefaults as G, type NodePredicate as H, type ProjectedField as I, type JsonPointer as J, type GroupBySpec as K, type TraversalDirection as L, MAX_JSON_POINTER_DEPTH as M, type NodeType as N, type OrderSpec as O, type PredicateExpression as P, type QueryAst as Q, type ResolveJsonPointer as R, type SortDirection as S, type TemporalMode as T, type UniqueConstraint as U, type ValueType as V, type ComposableQuery as W, type SetOperationType as X, type SetOperation as Y, type JsonPointerFor as a, type JsonPointerSegmentsFor as b, type AggregateExpr as c, type AggregateComparisonPredicate as d, type Cardinality as e, type Collation as f, type EdgeProps as g, type EdgeRegistration as h, type EdgeTypeWithEndpoints as i, type EndpointExistence as j, type JsonPointerInput as k, type JsonPointerSegment as l, type JsonPointerSegments as m, type NodeId as n, type NodeProps as o, type NodeRegistration as p, type ResolveJsonPointerSegments as q, type UniquenessScope as r, isEdgeType as s, isEdgeTypeWithEndpoints as t, isNodeType as u, joinJsonPointers as v, jsonPointer as w, normalizeJsonPointer as x, parseJsonPointer as y, type VectorMetricType as z };