@nicia-ai/typegraph 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1365 @@
+import { z, ZodType, ZodError } from 'zod';
+import { N as NodeType, E as EdgeType, c as AggregateExpr, F as FieldRef, C as ComparisonOp, d as AggregateComparisonPredicate } from './ast-BVyihVbP.js';
+export { A as AnyEdgeType, e as Cardinality, f as Collation, D as DeleteBehavior, g as EdgeProps, h as EdgeRegistration, i as EdgeTypeWithEndpoints, j as EndpointExistence, G as GraphDefaults, J as JsonPointer, a as JsonPointerFor, k as JsonPointerInput, l as JsonPointerSegment, m as JsonPointerSegments, b as JsonPointerSegmentsFor, M as MAX_JSON_POINTER_DEPTH, n as NodeId, o as NodeProps, p as NodeRegistration, O as OrderSpec, R as ResolveJsonPointer, q as ResolveJsonPointerSegments, S as SortDirection, T as TemporalMode, U as UniqueConstraint, r as UniquenessScope, s as isEdgeType, t as isEdgeTypeWithEndpoints, u as isNodeType, v as joinJsonPointers, w as jsonPointer, x as normalizeJsonPointer, y as parseJsonPointer } from './ast-BVyihVbP.js';
+import { I as InferenceType, M as MetaEdge, O as OntologyRelation, G as GraphDef, K as KindRegistry, A as AliasMap, E as EdgeAliasMap, Q as QueryBuilder, T as TraversalBuilder, C as CreateQueryBuilderOptions, a as SerializedNodeDef, b as SerializedEdgeDef, c as SerializedMetaEdge, d as SerializedOntologyRelation, e as SerializedClosures, f as SerializedSchema, g as SchemaHash } from './store-60Lcfi0w.js';
+export { h as AllEdgeTypes, i as AllNodeTypes, j as ChangeSeverity, k as ChangeType, l as CreateEdgeInput, m as CreateNodeInput, n as Edge, o as EdgeAccessor, p as EdgeChange, q as EdgeCollection, r as EdgeTypeNames, s as EmbeddingSchema, t as EmbeddingValue, u as ExecutableAggregateQuery, v as ExecutableQuery, F as FieldAccessor, w as GetEdgeType, x as GetNodeType, H as HookContext, J as JsonSchema, y as MetaEdgeProperties, N as Node, z as NodeAccessor, B as NodeAlias, D as NodeChange, L as NodeCollection, P as NodeRef, R as NodeTypeNames, U as OntologyChange, V as OperationHookContext, W as PaginateOptions, X as PaginatedResult, Y as Predicate, Z as PropsAccessor, _ as QueryHookContext, $ as QueryOptions, a0 as SchemaDiff, a1 as SchemaManagerOptions, a2 as SchemaValidationResult, a3 as SelectContext, a4 as SelectableEdge, a5 as SelectableNode, a6 as SerializedOntology, a7 as SerializedUniqueConstraint, S as Store, a8 as StoreConfig, a9 as StoreHooks, aa as StoreOptions, ab as StreamOptions, ac as TransactionContext, ad as TypedEdgeCollection, ae as TypedNodeRef, af as UpdateEdgeInput, ag as UpdateNodeInput, ah as computeSchemaDiff, ai as createStore, aj as createStoreWithSchema, ak as defineGraph, al as embedding, am as ensureSchema, an as exists, ao as fieldRef, ap as getActiveSchema, aq as getEdgeTypeNames, ar as getEmbeddingDimensions, as as getMigrationActions, at as getNodeTypeNames, au as getSchemaChanges, av as inSubquery, aw as initializeSchema, ax as isBackwardsCompatible, ay as isEmbeddingSchema, az as isGraphDef, aA as isMetaEdge, aB as isSchemaInitialized, aC as migrateSchema, aD as notExists, aE as notInSubquery } from './store-60Lcfi0w.js';
+export { G as GraphBackend, T as TransactionBackend } from './types-CjZ7g_7v.js';
+export { S as SqlDialect } from './types-BRzHlhKC.js';
+import 'drizzle-orm';
+
+/**
+ * Options for defining a node type.
+ */
+type DefineNodeOptions<S extends z.ZodObject<z.ZodRawShape>> = Readonly<{
+    /** Zod schema for node properties */
+    schema: S;
+    /** Optional description for documentation */
+    description?: string;
+}>;
+/**
+ * Creates a node type definition.
+ *
+ * @example
+ * ```typescript
+ * const Person = defineNode("Person", {
+ *   schema: z.object({
+ *     fullName: z.string().min(1),
+ *     email: z.string().email().optional(),
+ *   }),
+ *   description: "A person in the system",
+ * });
+ * ```
+ */
+declare function defineNode<K extends string, S extends z.ZodObject<z.ZodRawShape>>(name: K, options: DefineNodeOptions<S>): NodeType<K, S>;
+
+/**
+ * Options for defining an edge type.
+ */
+type DefineEdgeOptions<S extends z.ZodObject<z.ZodRawShape>, From extends readonly NodeType[] | undefined = undefined, To extends readonly NodeType[] | undefined = undefined> = Readonly<{
+    /** Zod schema for edge properties (defaults to empty object) */
+    schema?: S;
+    /** Optional description for documentation */
+    description?: string;
+    /** Node types that can be the source of this edge (domain constraint) */
+    from?: From;
+    /** Node types that can be the target of this edge (range constraint) */
+    to?: To;
+}>;
+declare const EMPTY_SCHEMA: z.ZodObject<{}, z.core.$strip>;
+type EmptySchema = typeof EMPTY_SCHEMA;
+/**
+ * Creates an edge type definition.
+ *
+ * @example
+ * ```typescript
+ * // Edge with no properties
+ * const hasEpisode = defineEdge("hasEpisode");
+ *
+ * // Edge with properties
+ * const employedAt = defineEdge("employedAt", {
+ *   schema: z.object({
+ *     isPrimary: z.boolean().default(true),
+ *     startedAt: z.date(),
+ *   }),
+ *   description: "Employment relationship",
+ * });
+ *
+ * // Edge with domain/range constraints (can be used directly in defineGraph)
+ * const worksAt = defineEdge("worksAt", {
+ *   schema: z.object({ role: z.string() }),
+ *   from: [Person],
+ *   to: [Company],
+ * });
+ * ```
+ */
+declare function defineEdge<K extends string>(name: K): EdgeType<K, EmptySchema>;
+declare function defineEdge<K extends string, S extends z.ZodObject<z.ZodRawShape>, From extends readonly NodeType[], To extends readonly NodeType[]>(name: K, options: DefineEdgeOptions<S, From, To> & {
+    from: From;
+    to: To;
+}): EdgeType<K, S, From, To>;
+declare function defineEdge<K extends string, S extends z.ZodObject<z.ZodRawShape>>(name: K, options: DefineEdgeOptions<S>): EdgeType<K, S>;
+
+/**
+ * Options for creating a meta-edge.
+ */
+type MetaEdgeOptions = Readonly<{
+    /** Whether the relationship is transitive (A→B, B→C implies A→C) */
+    transitive?: boolean;
+    /** Whether the relationship is symmetric (A→B implies B→A) */
+    symmetric?: boolean;
+    /** Whether the relationship is reflexive (A→A is always true) */
+    reflexive?: boolean;
+    /** Name of the inverse meta-edge */
+    inverse?: string;
+    /** How this meta-edge affects queries and validation */
+    inference?: InferenceType;
+    /** Optional description */
+    description?: string;
+}>;
+/**
+ * Creates a custom meta-edge definition.
+ *
+ * @example
+ * ```typescript
+ * // Custom meta-edge for regulatory relationships
+ * const regulatedBy = metaEdge("regulatedBy", {
+ *   description: "Type X is regulated by authority type Y",
+ *   transitive: false,
+ *   symmetric: false,
+ * });
+ * ```
+ */
+declare function metaEdge<K extends string>(name: K, options?: MetaEdgeOptions): MetaEdge<K>;
+
+/**
+ * External reference type for hybrid overlay patterns.
+ *
+ * Creates a Zod-compatible schema for referencing entities in external
+ * data sources (e.g., existing application tables) from TypeGraph nodes.
+ */
+
+/**
+ * Symbol key for storing external table name on the schema.
+ * This allows the schema introspector to detect external reference types
+ * and extract source information.
+ */
+declare const EXTERNAL_REF_TABLE_KEY: "_externalRefTable";
+/**
+ * The shape of an external reference value.
+ * Contains the source table identifier and the ID of the referenced record.
+ */
+type ExternalRefValue<T extends string = string> = Readonly<{
+    table: T;
+    id: string;
+}>;
+/**
+ * A Zod schema for external references with attached table metadata.
+ */
+type ExternalRefSchema<T extends string = string> = z.ZodType<ExternalRefValue<T>> & Readonly<{
+    [EXTERNAL_REF_TABLE_KEY]: T;
+}>;
+/**
+ * Creates a Zod schema for referencing external data sources.
+ *
+ * Use this when building a hybrid overlay where TypeGraph stores
+ * graph relationships and metadata while your existing tables
+ * remain the source of truth for entity data.
+ *
+ * @param table - The identifier for the external table/source (e.g., "users", "documents")
+ * @returns A Zod schema that validates external reference objects
+ *
+ * @example
+ * ```typescript
+ * import { defineNode, externalRef, embedding } from "@nicia-ai/typegraph";
+ *
+ * // Reference documents from your existing application database
+ * const Document = defineNode("Document", {
+ *   schema: z.object({
+ *     source: externalRef("documents"),
+ *     embedding: embedding(1536).optional(),
+ *     extractedTopics: z.array(z.string()).optional(),
+ *   }),
+ * });
+ *
+ * // Create a node referencing an external document
+ * await store.nodes.Document.create({
+ *   source: { table: "documents", id: "doc_abc123" },
+ *   embedding: await generateEmbedding(docContent),
+ * });
+ *
+ * // Query and hydrate with external data
+ * const results = await store
+ *   .query()
+ *   .from("Document", "d")
+ *   .whereNode("d", (d) => d.embedding.similarTo(query, 10))
+ *   .select((ctx) => ctx.d.source)
+ *   .execute();
+ *
+ * // Fetch full data from your app database
+ * const externalIds = results.map((r) => r.id);
+ * const fullDocs = await appDb.query.documents.findMany({
+ *   where: inArray(documents.id, externalIds),
+ * });
+ * ```
+ */
+declare function externalRef<T extends string>(table: T): ExternalRefSchema<T>;
+/**
+ * Checks if a value is an external reference schema.
+ */
+declare function isExternalRefSchema(value: unknown): value is ExternalRefSchema;
+/**
+ * Gets the table name from an external reference schema.
+ * Returns undefined if the schema is not an external reference schema.
+ */
+declare function getExternalRefTable(schema: z.ZodType): string | undefined;
+/**
+ * Helper function to create a typed external reference value.
+ * Useful when you want to avoid repeating the table name.
+ *
+ * @example
+ * ```typescript
+ * const docRef = createExternalRef("documents");
+ *
+ * await store.nodes.Document.create({
+ *   source: docRef("doc_123"),
+ *   embedding: [...],
+ * });
+ * ```
+ */
+declare function createExternalRef<T extends string>(table: T): (id: string) => ExternalRefValue<T>;
+
+/**
+ * Creates a subClassOf ontology relation.
+ */
+declare function subClassOf(child: NodeType, parent: NodeType): OntologyRelation;
+/**
+ * Creates a broader ontology relation.
+ */
+declare function broader(narrowerConcept: NodeType, broaderConcept: NodeType): OntologyRelation;
+/**
+ * Creates a narrower ontology relation.
+ */
+declare function narrower(broaderConcept: NodeType, narrowerConcept: NodeType): OntologyRelation;
+/**
+ * Creates a relatedTo ontology relation.
+ */
+declare function relatedTo(conceptA: NodeType, conceptB: NodeType): OntologyRelation;
+/**
+ * Creates an equivalentTo ontology relation.
+ * Can be used with external IRIs for cross-system mapping.
+ */
+declare function equivalentTo(kindA: NodeType, kindBOrIri: NodeType | string): OntologyRelation;
+/**
+ * Creates a sameAs ontology relation.
+ */
+declare function sameAs(kindA: NodeType, kindBOrIri: NodeType | string): OntologyRelation;
+/**
+ * Creates a differentFrom ontology relation.
+ */
+declare function differentFrom(kindA: NodeType, kindB: NodeType): OntologyRelation;
+/**
+ * Creates a disjointWith ontology relation.
+ */
+declare function disjointWith(kindA: NodeType, kindB: NodeType): OntologyRelation;
+/**
+ * Creates a partOf ontology relation.
+ */
+declare function partOf(part: NodeType, whole: NodeType): OntologyRelation;
+/**
+ * Creates a hasPart ontology relation.
+ */
+declare function hasPart(whole: NodeType, part: NodeType): OntologyRelation;
+/**
+ * Creates an inverseOf ontology relation.
+ * Edge A inverseOf edge B means traversing A is equivalent to traversing B backwards.
+ */
+declare function inverseOf(edgeA: EdgeType, edgeB: EdgeType): OntologyRelation;
+/**
+ * Creates an implies ontology relation.
+ * Edge A implies edge B means if A exists between two nodes, B should also exist.
+ */
+declare function implies(edgeA: EdgeType, edgeB: EdgeType): OntologyRelation;
+/**
+ * The core ontology module containing all built-in meta-edges
+ * and their relation factory functions.
+ */
+declare const core: {
+    readonly subClassOfMetaEdge: Readonly<{
+        name: "subClassOf";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly broaderMetaEdge: Readonly<{
+        name: "broader";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly narrowerMetaEdge: Readonly<{
+        name: "narrower";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly relatedToMetaEdge: Readonly<{
+        name: "relatedTo";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly equivalentToMetaEdge: Readonly<{
+        name: "equivalentTo";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly sameAsMetaEdge: Readonly<{
+        name: "sameAs";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly differentFromMetaEdge: Readonly<{
+        name: "differentFrom";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly disjointWithMetaEdge: Readonly<{
+        name: "disjointWith";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly partOfMetaEdge: Readonly<{
+        name: "partOf";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly hasPartMetaEdge: Readonly<{
+        name: "hasPart";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly inverseOfMetaEdge: Readonly<{
+        name: "inverseOf";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly impliesMetaEdge: Readonly<{
+        name: "implies";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly subClassOf: typeof subClassOf;
+    readonly broader: typeof broader;
+    readonly narrower: typeof narrower;
+    readonly relatedTo: typeof relatedTo;
+    readonly equivalentTo: typeof equivalentTo;
+    readonly sameAs: typeof sameAs;
+    readonly differentFrom: typeof differentFrom;
+    readonly disjointWith: typeof disjointWith;
+    readonly partOf: typeof partOf;
+    readonly hasPart: typeof hasPart;
+    readonly inverseOf: typeof inverseOf;
+    readonly implies: typeof implies;
+};
+
+/**
+ * TypeGraph Error Hierarchy
+ *
+ * All errors extend TypeGraphError with:
+ * - `code`: Machine-readable error code for programmatic handling
+ * - `category`: Classification for error handling strategies
+ * - `suggestion`: Optional recovery guidance for users
+ * - `details`: Structured context about the error
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await store.nodes.Person.create({ name: "" });
+ * } catch (error) {
+ *   if (isTypeGraphError(error)) {
+ *     console.error(error.toUserMessage());
+ *     if (isUserRecoverable(error)) {
+ *       // Show to user for correction
+ *     }
+ *   }
+ * }
+ * ```
+ */
+/**
+ * Error category for programmatic handling.
+ *
+ * - `user`: Caused by invalid input or incorrect usage. Recoverable by fixing input.
+ * - `constraint`: Business rule or schema constraint violation. Recoverable by changing data.
+ * - `system`: Internal error or infrastructure issue. May require investigation or retry.
+ */
+type ErrorCategory = "user" | "constraint" | "system";
+/**
+ * Options for TypeGraphError constructor.
+ */
+type TypeGraphErrorOptions = Readonly<{
+    /** Structured context about the error */
+    details?: Record<string, unknown>;
+    /** Error category for handling strategies */
+    category: ErrorCategory;
+    /** Recovery guidance for users */
+    suggestion?: string;
+    /** Underlying cause of the error */
+    cause?: unknown;
+}>;
+/**
+ * Base error class for all TypeGraph errors.
+ *
+ * Provides structured error information for both programmatic handling
+ * and user-friendly messages.
+ */
+declare class TypeGraphError extends Error {
+    /** Machine-readable error code (e.g., "VALIDATION_ERROR") */
+    readonly code: string;
+    /** Error category for handling strategies */
+    readonly category: ErrorCategory;
+    /** Structured context about the error */
+    readonly details: Readonly<Record<string, unknown>>;
+    /** Recovery guidance for users */
+    readonly suggestion?: string;
+    constructor(message: string, code: string, options: TypeGraphErrorOptions);
+    /**
+     * Returns a user-friendly error message with suggestion if available.
+     */
+    toUserMessage(): string;
+    /**
+     * Returns a detailed string representation for logging.
+     */
+    toLogString(): string;
+}
+/**
+ * Validation issue from Zod or custom validation.
+ */
+type ValidationIssue = Readonly<{
+    /** Path to the invalid field (e.g., "address.city") */
+    path: string;
+    /** Human-readable error message */
+    message: string;
+    /** Zod error code if from Zod validation */
+    code?: string;
+}>;
+/**
+ * Details for ValidationError.
+ */
+type ValidationErrorDetails = Readonly<{
+    /** Type of entity being validated */
+    entityType?: "node" | "edge";
+    /** Kind/type name of the entity */
+    kind?: string;
+    /** Operation being performed */
+    operation?: "create" | "update";
+    /** Entity ID if updating */
+    id?: string;
+    /** Individual validation issues */
+    issues: readonly ValidationIssue[];
+}>;
+/**
+ * Thrown when schema validation fails during node or edge operations.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await store.nodes.Person.create({ email: "invalid" });
+ * } catch (error) {
+ *   if (error instanceof ValidationError) {
+ *     console.log(error.details.issues);
+ *     // [{ path: "email", message: "Invalid email" }]
+ *   }
+ * }
+ * ```
+ */
+declare class ValidationError extends TypeGraphError {
+    readonly details: ValidationErrorDetails;
+    constructor(message: string, details: ValidationErrorDetails, options?: {
+        cause?: unknown;
+        suggestion?: string;
+    });
+}
+/**
+ * Thrown when a node is not found.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await store.nodes.Person.get("nonexistent-id");
+ * } catch (error) {
+ *   if (error instanceof NodeNotFoundError) {
+ *     console.log(error.details.kind, error.details.id);
+ *   }
+ * }
+ * ```
+ */
+declare class NodeNotFoundError extends TypeGraphError {
+    constructor(kind: string, id: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when an edge is not found.
+ */
+declare class EdgeNotFoundError extends TypeGraphError {
+    constructor(kind: string, id: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when a kind is not found in the graph registry.
+ */
+declare class KindNotFoundError extends TypeGraphError {
+    constructor(kind: string, type: "node" | "edge", options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when edge endpoint node does not exist or is deleted.
+ */
+declare class EndpointNotFoundError extends TypeGraphError {
+    constructor(details: Readonly<{
+        edgeKind: string;
+        endpoint: "from" | "to";
+        nodeKind: string;
+        nodeId: string;
+    }>, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when edge endpoint has wrong node type.
+ */
+declare class EndpointError extends TypeGraphError {
+    constructor(details: Readonly<{
+        edgeKind: string;
+        endpoint: "from" | "to";
+        actualKind: string;
+        expectedKinds: readonly string[];
+    }>, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when uniqueness constraint is violated.
+ */
+declare class UniquenessError extends TypeGraphError {
+    constructor(details: Readonly<{
+        constraintName: string;
+        kind: string;
+        existingId: string;
+        newId: string;
+        fields: readonly string[];
+    }>, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when cardinality constraint is violated.
+ */
+declare class CardinalityError extends TypeGraphError {
+    constructor(details: Readonly<{
+        edgeKind: string;
+        fromKind: string;
+        fromId: string;
+        cardinality: string;
+        existingCount: number;
+    }>, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when disjointness constraint is violated.
+ *
+ * Disjoint types cannot share the same ID - a node cannot be both
+ * a Person and an Organization if they are declared disjoint.
+ */
+declare class DisjointError extends TypeGraphError {
+    constructor(details: Readonly<{
+        nodeId: string;
+        attemptedKind: string;
+        conflictingKind: string;
+    }>, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when deletion is blocked due to existing edges (restrict behavior).
+ */
+declare class RestrictedDeleteError extends TypeGraphError {
+    constructor(details: Readonly<{
+        nodeKind: string;
+        nodeId: string;
+        edgeCount: number;
+        edgeKinds: readonly string[];
+    }>, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when optimistic locking detects a concurrent modification.
+ *
+ * This occurs when two operations try to update the same entity simultaneously.
+ * The operation with the stale version fails.
+ */
+declare class VersionConflictError extends TypeGraphError {
+    constructor(details: Readonly<{
+        kind: string;
+        id: string;
+        expectedVersion: number;
+        actualVersion: number;
+    }>, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when the schema in code doesn't match the schema in the database.
+ */
+declare class SchemaMismatchError extends TypeGraphError {
+    constructor(details: Readonly<{
+        graphId: string;
+        expectedHash: string;
+        actualHash: string;
+    }>, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when schema migration fails.
+ */
+declare class MigrationError extends TypeGraphError {
+    constructor(message: string, details: Readonly<{
+        graphId: string;
+        fromVersion: number;
+        toVersion: number;
+        reason?: string;
+    }>, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when graph configuration is invalid.
+ *
+ * This includes invalid schema definitions, ontology conflicts,
+ * and other configuration issues detected at graph creation time.
+ */
+declare class ConfigurationError extends TypeGraphError {
+    constructor(message: string, details?: Record<string, unknown>, options?: {
+        cause?: unknown;
+        suggestion?: string;
+    });
+}
+/**
+ * Thrown when a query predicate cannot be compiled for the target database.
+ */
+declare class UnsupportedPredicateError extends TypeGraphError {
+    constructor(message: string, details?: Readonly<Record<string, unknown>>, options?: {
+        cause?: unknown;
+        suggestion?: string;
+    });
+}
+/**
+ * Type guard for TypeGraphError.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await store.nodes.Person.create({});
+ * } catch (error) {
+ *   if (isTypeGraphError(error)) {
+ *     console.log(error.code, error.category);
+ *   }
+ * }
+ * ```
+ */
+declare function isTypeGraphError(error: unknown): error is TypeGraphError;
+/**
+ * Check if error is recoverable by user action (user or constraint error).
+ *
+ * User-recoverable errors can typically be resolved by:
+ * - Fixing invalid input data
+ * - Using different IDs or values
+ * - Deleting conflicting data first
+ *
+ * @example
+ * ```typescript
+ * if (isUserRecoverable(error)) {
+ *   showErrorToUser(error.toUserMessage());
+ * } else {
+ *   logAndAlertOps(error);
+ * }
+ * ```
+ */
+declare function isUserRecoverable(error: unknown): boolean;
+/**
+ * Check if error indicates a system/infrastructure issue.
+ *
+ * System errors typically require:
+ * - Retry logic (for transient failures)
+ * - Investigation (for persistent failures)
+ * - Ops team notification
+ */
+declare function isSystemError(error: unknown): boolean;
+/**
+ * Check if error is a constraint violation.
+ */
+declare function isConstraintError(error: unknown): boolean;
+/**
+ * Extract suggestion from error if available.
+ */
+declare function getErrorSuggestion(error: unknown): string | undefined;
+
+/**
+ * Contextual Validation Utilities
+ *
+ * Provides Zod validation wrappers that include full context about
+ * which entity (node/edge) and operation (create/update) failed.
+ *
+ * @example
+ * ```typescript
+ * const props = validateNodeProps(schema, input, {
+ *   kind: "Person",
+ *   operation: "create",
+ * });
+ * ```
+ */
+
+/**
+ * Context for validation operations.
+ */
+type ValidationContext = Readonly<{
+    /** Type of entity being validated */
+    entityType: "node" | "edge";
+    /** Kind/type name of the entity */
+    kind: string;
+    /** Operation being performed */
+    operation: "create" | "update";
+    /** Entity ID (for updates) */
+    id?: string;
+}>;
+/**
+ * Validates props with full context for error messages.
+ *
+ * @param schema - Zod schema to validate against
+ * @param props - Properties to validate
+ * @param context - Context about the entity and operation
+ * @returns Validated and transformed props
+ * @throws ValidationError with full context if validation fails
+ *
+ * @example
+ * ```typescript
+ * const validatedProps = validateProps(personSchema, input, {
+ *   entityType: "node",
+ *   kind: "Person",
+ *   operation: "create",
+ * });
+ * ```
+ */
+declare function validateProps<T>(schema: ZodType<T>, props: unknown, context: ValidationContext): T;
+/**
+ * Validates node props with full context.
+ *
+ * Convenience wrapper around validateProps for node operations.
+ *
+ * @example
+ * ```typescript
+ * const props = validateNodeProps(schema, input, {
+ *   kind: "Person",
+ *   operation: "create",
+ * });
+ * ```
+ */
+declare function validateNodeProps<T>(schema: ZodType<T>, props: unknown, context: Readonly<{
+    kind: string;
+    operation: "create" | "update";
+    id?: string;
+}>): T;
+/**
+ * Validates edge props with full context.
+ *
+ * Convenience wrapper around validateProps for edge operations.
+ *
+ * @example
+ * ```typescript
+ * const props = validateEdgeProps(schema, input, {
+ *   kind: "worksAt",
+ *   operation: "create",
+ * });
+ * ```
+ */
+declare function validateEdgeProps<T>(schema: ZodType<T>, props: unknown, context: Readonly<{
+    kind: string;
+    operation: "create" | "update";
+    id?: string;
+}>): T;
+/**
+ * Wraps a Zod error with TypeGraph context.
+ *
+ * Use this when you've already caught a ZodError and want to
+ * convert it to a ValidationError with context.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   schema.parse(input);
+ * } catch (error) {
+ *   if (error instanceof ZodError) {
+ *     throw wrapZodError(error, {
+ *       entityType: "node",
+ *       kind: "Person",
+ *       operation: "create",
+ *     });
+ *   }
+ *   throw error;
+ * }
+ * ```
+ */
+declare function wrapZodError(error: ZodError, context: ValidationContext): ValidationError;
+/**
+ * Creates a simple ValidationError without Zod context.
+ *
+ * Use this for custom validation rules that aren't part of a Zod schema.
+ *
+ * @example
+ * ```typescript
+ * if (startDate > endDate) {
+ *   throw createValidationError(
+ *     "Start date must be before end date",
+ *     [{ path: "startDate", message: "Must be before endDate" }],
+ *     { entityType: "edge", kind: "employment", operation: "create" }
+ *   );
+ * }
+ * ```
+ */
+declare function createValidationError(message: string, issues: ValidationIssue[], context?: Partial<ValidationContext>): ValidationError;
+
+/**
+ * Builder functions for creating KindRegistry from GraphDef.
+ */
+
+/**
+ * Builds a KindRegistry from a GraphDef.
+ *
+ * This precomputes all transitive closures for efficient runtime queries.
+ *
+ * @example
+ * ```typescript
+ * const graph = defineGraph({
+ *   id: "my_graph",
+ *   nodes: { Person: { type: Person }, Company: { type: Company } },
+ *   edges: { worksAt: { type: worksAt, from: [Person], to: [Company] } },
+ *   ontology: [subClassOf(Company, Organization)],
+ * });
+ *
+ * const registry = buildKindRegistry(graph);
+ * registry.isSubClassOf("Company", "Organization"); // true
+ * ```
+ */
+declare function buildKindRegistry<G extends GraphDef>(graph: G): KindRegistry;
+
+/**
+ * Recursive CTE Compilation
+ *
+ * Compiles variable-length path traversals using WITH RECURSIVE.
+ * Handles cycle detection and depth limiting using dialect-specific operations.
+ */
+
+/**
+ * Maximum depth for recursive CTE queries.
+ *
+ * This limit prevents runaway recursion in variable-length path queries.
+ * Even when a user specifies "unlimited" depth (-1), this limit is enforced.
+ * The limit of 100 is sufficient for most graph traversal use cases while
+ * preventing database resource exhaustion.
+ */
+declare const MAX_RECURSIVE_DEPTH = 100;
+
+/**
+ * Aggregate and HAVING Helper Functions
+ *
+ * Provides factory functions for creating aggregate expressions (COUNT, SUM, etc.)
+ * and HAVING clause predicates for use in GROUP BY queries.
+ */
+
+/**
+ * Creates a COUNT aggregate expression.
+ *
+ * @param alias - The node alias to count
+ * @param field - Optional field to count (defaults to counting nodes by ID)
+ *
+ * @example
+ * ```typescript
+ * // COUNT all persons
+ * count("p")
+ *
+ * // COUNT persons with email field
+ * count("p", "email")
+ * ```
+ */
+declare function count(alias: string, field?: string): AggregateExpr;
+/**
+ * Creates a COUNT DISTINCT aggregate expression.
+ *
+ * @param alias - The node alias to count
+ * @param field - Optional field to count distinct values of
+ */
+declare function countDistinct(alias: string, field?: string): AggregateExpr;
+/**
+ * Creates a SUM aggregate expression.
+ *
+ * @param alias - The node alias
+ * @param field - The numeric field to sum
+ */
+declare function sum(alias: string, field: string): AggregateExpr;
+/**
+ * Creates an AVG aggregate expression.
+ *
+ * @param alias - The node alias
+ * @param field - The numeric field to average
+ */
+declare function avg(alias: string, field: string): AggregateExpr;
+/**
+ * Creates a MIN aggregate expression.
+ *
+ * @param alias - The node alias
+ * @param field - The field to find minimum of
+ */
+declare function min(alias: string, field: string): AggregateExpr;
+/**
+ * Creates a MAX aggregate expression.
+ *
+ * @param alias - The node alias
+ * @param field - The field to find maximum of
+ */
+declare function max(alias: string, field: string): AggregateExpr;
+/**
+ * Creates a field reference for use in selectAggregate.
+ *
+ * @param alias - The node alias
+ * @param path - Path to the field. Use "id" for node ID, "kind" for node kind,
+ *               or the property name directly (e.g., "title", "year").
+ *
+ * @example
+ * ```typescript
+ * field("p", "id")      // Node ID
+ * field("p", "kind")    // Node kind
+ * field("p", "title")   // Property field
+ * field("p", "nested", "field")  // Nested property
+ * ```
+ */
+declare function field(alias: string, ...path: string[]): FieldRef;
+/**
+ * Creates a HAVING predicate that compares an aggregate to a value.
+ *
+ * @param aggregate - The aggregate expression (count, sum, avg, etc.)
+ * @param op - The comparison operator
+ * @param value - The value to compare against
+ *
+ * @example
+ * ```typescript
+ * // HAVING COUNT(*) > 10
+ * having(count("p"), "gt", 10)
+ *
+ * // HAVING AVG(salary) >= 50000
+ * having(avg("p", "salary"), "gte", 50000)
+ * ```
+ */
+declare function having(aggregate: AggregateExpr, op: ComparisonOp, value: number | string | boolean): AggregateComparisonPredicate;
+/**
+ * Creates a HAVING predicate: aggregate > value
+ */
+declare function havingGt(aggregate: AggregateExpr, value: number): AggregateComparisonPredicate;
+/**
+ * Creates a HAVING predicate: aggregate >= value
+ */
+declare function havingGte(aggregate: AggregateExpr, value: number): AggregateComparisonPredicate;
+/**
+ * Creates a HAVING predicate: aggregate < value
+ */
+declare function havingLt(aggregate: AggregateExpr, value: number): AggregateComparisonPredicate;
+/**
+ * Creates a HAVING predicate: aggregate <= value
+ */
+declare function havingLte(aggregate: AggregateExpr, value: number): AggregateComparisonPredicate;
+/**
+ * Creates a HAVING predicate: aggregate = value
+ */
+declare function havingEq(aggregate: AggregateExpr, value: number): AggregateComparisonPredicate;
+
+/**
+ * Query Fragment Composition
+ *
+ * Provides types and utilities for creating reusable query fragments
+ * that can be composed together using the pipe() method.
+ *
+ * @example
+ * ```typescript
+ * // Define a reusable fragment
+ * const activeUsers = createFragment<MyGraph>()((q) =>
+ *   q.whereNode("u", ({ status }) => status.eq("active"))
+ * );
+ *
+ * // Use in queries
+ * const results = await query()
+ *   .from("User", "u")
+ *   .pipe(activeUsers)
+ *   .select((ctx) => ctx.u)
+ *   .execute();
+ * ```
+ */
+
+/**
+ * A query fragment that transforms a QueryBuilder.
+ *
+ * Fragments are functions that take a builder and return a modified builder.
+ * They can add predicates, traversals, ordering, and other query operations.
+ *
+ * @typeParam G - The graph definition
+ * @typeParam InAliases - Input alias map (what the fragment requires)
+ * @typeParam OutAliases - Output alias map (what the fragment produces)
+ * @typeParam InEdgeAliases - Input edge alias map
+ * @typeParam OutEdgeAliases - Output edge alias map
+ */
+type QueryFragment<G extends GraphDef, InAliases extends AliasMap = AliasMap, OutAliases extends AliasMap = InAliases, InEdgeAliases extends EdgeAliasMap = EdgeAliasMap, OutEdgeAliases extends EdgeAliasMap = InEdgeAliases> = (builder: QueryBuilder<G, InAliases, InEdgeAliases>) => QueryBuilder<G, OutAliases, OutEdgeAliases>;
+/**
+ * A flexible query fragment that works with any compatible builder.
+ *
+ * Use this when you want a fragment that only requires certain aliases
+ * to exist, but doesn't care about other aliases that may be present.
+ */
+type FlexibleQueryFragment<G extends GraphDef, RequiredAliases extends AliasMap = AliasMap, AddedAliases extends AliasMap = AliasMap, RequiredEdgeAliases extends EdgeAliasMap = EdgeAliasMap, AddedEdgeAliases extends EdgeAliasMap = EdgeAliasMap> = <Aliases extends RequiredAliases, EdgeAliases extends RequiredEdgeAliases>(builder: QueryBuilder<G, Aliases, EdgeAliases>) => QueryBuilder<G, Aliases & AddedAliases, EdgeAliases & AddedEdgeAliases>;
+/**
+ * A traversal fragment that transforms a TraversalBuilder.
+ *
+ * Use this for reusable traversal patterns including edge filtering,
+ * recursive traversals, and path collection.
+ */
+type TraversalFragment<G extends GraphDef, EK extends keyof G["edges"] & string, EA extends string, InAliases extends AliasMap = AliasMap, InEdgeAliases extends EdgeAliasMap = EdgeAliasMap> = (builder: TraversalBuilder<G, InAliases, InEdgeAliases, EK, EA, any>) => unknown;
+declare function createFragment<G extends GraphDef>(): <InAliases extends AliasMap, OutAliases extends AliasMap, InEdgeAliases extends EdgeAliasMap, OutEdgeAliases extends EdgeAliasMap>(fn: (builder: QueryBuilder<G, InAliases, InEdgeAliases>) => QueryBuilder<G, OutAliases, OutEdgeAliases>) => QueryFragment<G, InAliases, OutAliases, InEdgeAliases, OutEdgeAliases>;
+/**
+ * Combines multiple fragments into a single fragment.
+ *
+ * Fragments are applied in order from left to right.
+ *
+ * @example
+ * ```typescript
+ * const combinedFragment = composeFragments(
+ *   activeOnly,
+ *   withManager,
+ *   recentlyUpdated
+ * );
+ *
+ * query()
+ *   .from("User", "u")
+ *   .pipe(combinedFragment)
+ *   .select(...)
+ * ```
+ */
+declare function composeFragments<G extends GraphDef, A1 extends AliasMap, A2 extends AliasMap, E1 extends EdgeAliasMap, E2 extends EdgeAliasMap>(f1: QueryFragment<G, A1, A2, E1, E2>): QueryFragment<G, A1, A2, E1, E2>;
+declare function composeFragments<G extends GraphDef, A1 extends AliasMap, A2 extends AliasMap, A3 extends AliasMap, E1 extends EdgeAliasMap, E2 extends EdgeAliasMap, E3 extends EdgeAliasMap>(f1: QueryFragment<G, A1, A2, E1, E2>, f2: QueryFragment<G, A2, A3, E2, E3>): QueryFragment<G, A1, A3, E1, E3>;
+declare function composeFragments<G extends GraphDef, A1 extends AliasMap, A2 extends AliasMap, A3 extends AliasMap, A4 extends AliasMap, E1 extends EdgeAliasMap, E2 extends EdgeAliasMap, E3 extends EdgeAliasMap, E4 extends EdgeAliasMap>(f1: QueryFragment<G, A1, A2, E1, E2>, f2: QueryFragment<G, A2, A3, E2, E3>, f3: QueryFragment<G, A3, A4, E3, E4>): QueryFragment<G, A1, A4, E1, E4>;
+declare function composeFragments<G extends GraphDef, A1 extends AliasMap, A2 extends AliasMap, A3 extends AliasMap, A4 extends AliasMap, A5 extends AliasMap, E1 extends EdgeAliasMap, E2 extends EdgeAliasMap, E3 extends EdgeAliasMap, E4 extends EdgeAliasMap, E5 extends EdgeAliasMap>(f1: QueryFragment<G, A1, A2, E1, E2>, f2: QueryFragment<G, A2, A3, E2, E3>, f3: QueryFragment<G, A3, A4, E3, E4>, f4: QueryFragment<G, A4, A5, E4, E5>): QueryFragment<G, A1, A5, E1, E5>;
+/**
+ * Creates a fragment that adds ordering.
+ *
+ * @example
+ * ```typescript
+ * const byCreatedAt = orderByFragment<MyGraph, "u">("u", "createdAt", "desc");
+ * ```
+ */
+declare function orderByFragment<G extends GraphDef, A extends string>(alias: A, field: string, direction?: "asc" | "desc"): QueryFragment<G, any, any, any, any>;
+/**
+ * Creates a fragment that adds a limit.
+ *
+ * @example
+ * ```typescript
+ * const first10 = limitFragment<MyGraph>(10);
+ * ```
+ */
+declare function limitFragment<G extends GraphDef>(n: number): QueryFragment<G, any, any, any, any>;
+/**
+ * Creates a fragment that adds an offset.
+ *
+ * @example
+ * ```typescript
+ * const skip10 = offsetFragment<MyGraph>(10);
+ * ```
+ */
+declare function offsetFragment<G extends GraphDef>(n: number): QueryFragment<G, any, any, any, any>;
+
+/**
+ * Fluent query builder for TypeGraph.
+ *
+ * Provides a type-safe, chainable API for building queries.
+ * Each method returns a new builder instance with expanded type information.
+ *
+ * This module re-exports from the builder submodules and provides the
+ * createQueryBuilder factory function.
+ */
+
+/**
+ * Creates a new query builder for a graph.
+ *
+ * @param graphId - The graph identifier
+ * @param registry - The kind registry for ontology lookups
+ * @param options - Optional backend and dialect configuration
+ * @returns A new QueryBuilder instance
+ *
+ * @example
+ * ```typescript
+ * // Without execution capability (compile only)
+ * const builder = createQueryBuilder<MyGraph>("my_graph", registry);
+ *
+ * // With execution capability
+ * const builder = createQueryBuilder<MyGraph>("my_graph", registry, {
+ *   backend: myBackend,
+ *   dialect: "sqlite",
+ * });
+ * ```
+ */
+declare function createQueryBuilder<G extends GraphDef>(graphId: string, registry: KindRegistry, options?: CreateQueryBuilderOptions): QueryBuilder<G>;
+
+/**
+ * Schema deserializer for loading stored schemas.
+ *
+ * Reconstructs runtime objects from SerializedSchema.
+ * Note: Zod schemas cannot be fully reconstructed from JSON Schema,
+ * so this provides access to the serialized data for introspection.
+ */
+
+/**
+ * A deserialized schema provides read-only access to schema metadata.
+ *
+ * Note: Unlike the original GraphDef, this does not include Zod schemas
+ * since those cannot be reconstructed from JSON Schema. Use this for
+ * introspection and metadata access only.
+ */
+type DeserializedSchema = Readonly<{
+    graphId: string;
+    version: number;
+    generatedAt: string;
+    /** Get node definition by name */
+    getNode: (name: string) => SerializedNodeDef | undefined;
+    /** Get all node names */
+    getNodeNames: () => readonly string[];
+    /** Get edge definition by name */
+    getEdge: (name: string) => SerializedEdgeDef | undefined;
+    /** Get all edge names */
+    getEdgeNames: () => readonly string[];
+    /** Get meta-edge definition by name */
+    getMetaEdge: (name: string) => SerializedMetaEdge | undefined;
+    /** Get all meta-edge names */
+    getMetaEdgeNames: () => readonly string[];
+    /** Get all ontology relations */
+    getRelations: () => readonly SerializedOntologyRelation[];
+    /** Get precomputed closures */
+    getClosures: () => SerializedClosures;
+    /** Get graph defaults */
+    getDefaults: () => SerializedSchema["defaults"];
+    /** Get the raw serialized schema */
+    getRaw: () => SerializedSchema;
+    /** Build a KindRegistry from the closures */
+    buildRegistry: () => KindRegistry;
+}>;
+/**
+ * Deserializes a SerializedSchema into a DeserializedSchema.
+ *
+ * @param schema - The serialized schema to deserialize
+ * @returns A deserialized schema with accessor methods
+ */
+declare function deserializeSchema(schema: SerializedSchema): DeserializedSchema;
+
+/**
+ * Serializes a GraphDef to a SerializedSchema.
+ *
+ * @param graph - The graph definition to serialize
+ * @param version - The schema version number
+ * @returns The serialized schema
+ */
+declare function serializeSchema<G extends GraphDef>(graph: G, version: number): SerializedSchema;
+/**
+ * A serialized predicate structure (matches UniqueConstraintPredicate from core/types).
+ */
+type SerializedPredicate = Readonly<{
+    __type: "unique_predicate";
+    field: string;
+    op: "isNull" | "isNotNull";
+}>;
+/**
+ * Field builder returned by the predicate proxy.
+ */
+type FieldPredicateBuilder = Readonly<{
+    isNull: () => SerializedPredicate;
+    isNotNull: () => SerializedPredicate;
+}>;
+/**
+ * Predicate builder type for where clause serialization.
+ */
+type PredicateBuilder = Readonly<Record<string, FieldPredicateBuilder>>;
+/**
+ * Deserializes a where predicate JSON back to a predicate function.
+ *
+ * This can be used to reconstruct a UniqueConstraint's where clause
+ * from a serialized schema.
+ *
+ * @param serialized - The JSON string from serialization
+ * @returns A where function that returns the predicate structure
+ */
+/**
+ * Unique predicate result type.
+ */
+type UniquePredicate = Readonly<{
+    __type: "unique_predicate";
+    field: string;
+    op: "isNull" | "isNotNull";
+}>;
+declare function deserializeWherePredicate(serialized: string): (builder: PredicateBuilder) => UniquePredicate;
+/**
+ * Computes a hash of the schema content for change detection.
+ *
+ * Excludes version and generatedAt since those change on every save.
+ */
+declare function computeSchemaHash(schema: SerializedSchema): SchemaHash;
+
+/**
+ * Encodes a Date to an ISO 8601 string for storage.
+ */
+declare function encodeDate(date: Date): string;
+/**
+ * Decodes an ISO 8601 string to a Date.
+ * Validates the string format first.
+ *
+ * @throws ValidationError if not a valid ISO datetime
+ */
+declare function decodeDate(isoString: string): Date;
+
+/**
+ * ID generation utilities.
+ *
+ * Default implementation uses nanoid.
+ * Benefits:
+ * - URL-safe
+ * - Compact (21 characters by default)
+ * - Secure random generation
+ */
+/**
+ * Generates a new unique ID.
+ */
+declare function generateId(): string;
+/**
+ * ID generator function type.
+ */
+type IdGenerator = () => string;
+/**
+ * Default ID generator configuration.
+ */
+type IdConfig = Readonly<{
+    /** Generator for node IDs */
+    nodeIdGenerator: IdGenerator;
+    /** Generator for edge IDs */
+    edgeIdGenerator: IdGenerator;
+}>;
+
+/**
+ * Result type for error handling without exceptions.
+ * Use at service boundaries and for operations that can fail.
+ */
+type Result<T, E = Error> = Readonly<{
+    success: true;
+    data: T;
+}> | Readonly<{
+    success: false;
+    error: E;
+}>;
+/**
+ * Creates a successful result.
+ */
+declare function ok<T = undefined>(data?: T): Result<T, never>;
+/**
+ * Creates a failed result.
+ */
+declare function err<E>(error: E): Result<never, E>;
+/**
+ * Unwraps a result, throwing if it's an error.
+ */
+declare function unwrap<T, E>(result: Result<T, E>): T;
+/**
+ * Unwraps a result or returns a default value.
+ */
+declare function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T;
+/**
+ * Type guard to check if result is successful.
+ */
+declare function isOk<T, E>(result: Result<T, E>): result is {
+    success: true;
+    data: T;
+};
+/**
+ * Type guard to check if result is an error.
+ */
+declare function isErr<T, E>(result: Result<T, E>): result is {
+    success: false;
+    error: E;
+};
+
+export { AliasMap, CardinalityError, ConfigurationError, type DefineEdgeOptions, type DefineNodeOptions, type DeserializedSchema, DisjointError, EdgeNotFoundError, EdgeType, EndpointError, EndpointNotFoundError, type ErrorCategory, type ExternalRefSchema, type ExternalRefValue, FieldRef, type FlexibleQueryFragment, GraphDef, type IdConfig, type IdGenerator, InferenceType, KindNotFoundError, KindRegistry, MAX_RECURSIVE_DEPTH, MetaEdge, type MetaEdgeOptions, MigrationError, NodeNotFoundError, NodeType, OntologyRelation, QueryBuilder, type QueryFragment, RestrictedDeleteError, type Result, SchemaHash, SchemaMismatchError, SerializedClosures, SerializedEdgeDef, SerializedMetaEdge, SerializedNodeDef, SerializedOntologyRelation, SerializedSchema, type TraversalFragment, TypeGraphError, type TypeGraphErrorOptions, UniquenessError, UnsupportedPredicateError, type ValidationContext, ValidationError, type ValidationErrorDetails, type ValidationIssue, VersionConflictError, avg, broader, buildKindRegistry, composeFragments, computeSchemaHash, core, count, countDistinct, createExternalRef, createFragment, createQueryBuilder, createValidationError, decodeDate, defineEdge, defineNode, deserializeSchema, deserializeWherePredicate, differentFrom, disjointWith, encodeDate, equivalentTo, err, externalRef, field, generateId, getErrorSuggestion, getExternalRefTable, hasPart, having, havingEq, havingGt, havingGte, havingLt, havingLte, implies, inverseOf, isConstraintError, isErr, isExternalRefSchema, isOk, isSystemError, isTypeGraphError, isUserRecoverable, limitFragment, max, metaEdge, min, narrower, offsetFragment, ok, orderByFragment, partOf, relatedTo, sameAs, serializeSchema, subClassOf, sum, unwrap, unwrapOr, validateEdgeProps, validateNodeProps, validateProps, wrapZodError };