@nicia-ai/typegraph 0.2.0 → 0.3.0

package/dist/index.d.cts

@@ -1,9 +1,15 @@
-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.cjs';
-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.cjs';
-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-DNOOQEm8.cjs';
-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-DNOOQEm8.cjs';
-export { D as DEFAULT_SQL_SCHEMA, G as GraphBackend, S as SqlSchema, a as SqlTableNames, T as TransactionBackend, c as createSqlSchema } from './types-aapj0GLz.cjs';
+import { z } from 'zod';
+import { N as NodeType, E as EdgeType } from './types-DTJEu_-h.cjs';
+export { A as AnyEdgeType, d as Cardinality, C as Collation, D as DeleteBehavior, f as EdgeProps, b as EdgeRegistration, c as EdgeTypeWithEndpoints, e as EndpointExistence, G as GraphDefaults, g as NodeId, h as NodeProps, a as NodeRegistration, T as TemporalMode, i as UniqueConstraint, U as UniquenessScope, j as isEdgeType, k as isEdgeTypeWithEndpoints, l as isNodeType } from './types-DTJEu_-h.cjs';
+import { I as InferenceType, M as MetaEdge, O as OntologyRelation } from './types-DDP0MGBF.cjs';
+export { D as DEFAULT_SQL_SCHEMA, G as GraphBackend, j as MetaEdgeProperties, k as SqlSchema, l as SqlTableNames, T as TransactionBackend, m as createSqlSchema, n as isMetaEdge } from './types-DDP0MGBF.cjs';
+import { A as AliasMap, E as EdgeAliasMap, Q as QueryBuilder, T as TraversalBuilder, C as CreateQueryBuilderOptions } from './store-nbBybLWP.cjs';
+export { a as AggregateResult, b as CreateEdgeInput, c as CreateNodeInput, d as Edge, e as EdgeAccessor, f as EdgeCollection, g as EmbeddingSchema, h as EmbeddingValue, i as ExecutableAggregateQuery, j as ExecutableQuery, F as FieldAccessor, H as HookContext, N as Node, k as NodeAccessor, l as NodeAlias, m as NodeCollection, n as NodeRef, O as OperationHookContext, P as PaginateOptions, o as PaginatedResult, p as Predicate, q as PreparedQuery, r as PropsAccessor, s as QueryHookContext, t as QueryOptions, R as RecursiveTraversalOptions, u as SelectContext, v as SelectableEdge, w as SelectableNode, S as Store, x as StoreHooks, y as StoreOptions, z as StreamOptions, B as TransactionContext, D as TypedEdgeCollection, G as TypedNodeRef, U as UnionableQuery, I as UpdateEdgeInput, J as UpdateNodeInput, K as createStore, L as createStoreWithSchema, M as embedding, V as exists, W as fieldRef, X as getEmbeddingDimensions, Y as inSubquery, Z as isEmbeddingSchema, _ as isParameterRef, $ as notExists, a0 as notInSubquery, a1 as param } from './store-nbBybLWP.cjs';
+import { G as GraphDef, K as KindRegistry } from './manager-Jc5Btay9.cjs';
+export { A as AllEdgeTypes, l as AllNodeTypes, n as EdgeKinds, o as GetEdgeType, p as GetNodeType, q as NodeKinds, s as defineGraph, t as getEdgeKinds, u as getNodeKinds, v as isGraphDef } from './manager-Jc5Btay9.cjs';
+export { C as CardinalityError, b as CompilerInvariantError, c as ConfigurationError, D as DatabaseOperationError, d as DisjointError, E as EdgeNotFoundError, e as EndpointError, f as EndpointNotFoundError, g as ErrorCategory, K as KindNotFoundError, M as MigrationError, N as NodeNotFoundError, R as RestrictedDeleteError, S as SchemaMismatchError, T as TypeGraphError, h as TypeGraphErrorOptions, U as UniquenessError, i as UnsupportedPredicateError, a as ValidationError, j as ValidationErrorDetails, V as ValidationIssue, k as VersionConflictError, l as getErrorSuggestion, m as isConstraintError, n as isSystemError, o as isTypeGraphError, p as isUserRecoverable } from './index-Dkicw49A.cjs';
+import { A as AggregateExpr, F as FieldRef, C as ComparisonOp, c as AggregateComparisonPredicate } from './ast-D-3bOanX.cjs';
+export { J as JsonPointer, a as JsonPointerFor, d as JsonPointerInput, e as JsonPointerSegment, f as JsonPointerSegments, b as JsonPointerSegmentsFor, M as MAX_JSON_POINTER_DEPTH, O as OrderSpec, P as ParameterRef, R as ResolveJsonPointer, g as ResolveJsonPointerSegments, S as SortDirection, T as TraversalExpansion, j as joinJsonPointers, h as jsonPointer, n as normalizeJsonPointer, p as parseJsonPointer } from './ast-D-3bOanX.cjs';
 export { S as SqlDialect } from './types-BRzHlhKC.cjs';
 import 'drizzle-orm';
 
@@ -422,501 +428,6 @@ declare const core: {
     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
  *
@@ -925,14 +436,19 @@ declare function buildKindRegistry<G extends GraphDef>(graph: G): KindRegistry;
  */
 
 /**
- * Maximum depth for recursive CTE queries.
+ * Maximum depth for recursive CTE queries when maxDepth is unlimited (-1).
  *
- * 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.
+ * This default limit prevents runaway recursion for unbounded traversals while
+ * still supporting typical neighborhood/path use-cases.
  */
 declare const MAX_RECURSIVE_DEPTH = 100;
+/**
+ * Maximum depth for explicit maxDepth traversals.
+ *
+ * Explicit traversal bounds are opt-in and safe to allow at a higher ceiling
+ * for stress testing and long-path workloads.
+ */
+declare const MAX_EXPLICIT_RECURSIVE_DEPTH = 1000;
 
 /**
  * Aggregate and HAVING Helper Functions
@@ -993,7 +509,7 @@ declare function min(alias: string, field: string): AggregateExpr;
  */
 declare function max(alias: string, field: string): AggregateExpr;
 /**
- * Creates a field reference for use in selectAggregate.
+ * Creates a field reference for use in aggregate.
  *
  * @param alias - The node alias
  * @param path - Path to the field. Use "id" for node ID, "kind" for node kind,
@@ -1179,120 +695,6 @@ declare function offsetFragment<G extends GraphDef>(n: number): QueryFragment<G,
  */
 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): Promise<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.
  *
@@ -1320,46 +722,4 @@ type IdConfig = Readonly<{
     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 };
+export { AliasMap, type DefineEdgeOptions, type DefineNodeOptions, EdgeType, type ExternalRefSchema, type ExternalRefValue, FieldRef, type FlexibleQueryFragment, GraphDef, type IdConfig, type IdGenerator, InferenceType, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, MetaEdge, type MetaEdgeOptions, NodeType, OntologyRelation, QueryBuilder, type QueryFragment, type TraversalFragment, avg, broader, composeFragments, core, count, countDistinct, createExternalRef, createFragment, createQueryBuilder, defineEdge, defineNode, differentFrom, disjointWith, equivalentTo, externalRef, field, generateId, getExternalRefTable, hasPart, having, havingEq, havingGt, havingGte, havingLt, havingLte, implies, inverseOf, isExternalRefSchema, limitFragment, max, metaEdge, min, narrower, offsetFragment, orderByFragment, partOf, relatedTo, sameAs, subClassOf, sum };