@asaidimu/anansi 4.0.2 → 8.6.2

package/index.d.cts

@@ -1,10 +1,405 @@
-import * as _faker_js_faker from '@faker-js/faker';
-import { Faker } from '@faker-js/faker';
-import { LogicalOperator, QueryDSL, QueryFilter } from '@asaidimu/query';
-import { StandardSchemaV1 } from '@standard-schema/spec';
-import LightningFS from '@isomorphic-git/lightning-fs';
-import { FieldValues, ResolverOptions, ResolverResult } from 'react-hook-form';
-
+import "@asaidimu/query";
+//#region src/schema/generated.d.ts
+type ComparisonOperator = "eq" | "neq" | "lt" | "lte" | "gt" | "gte" | "in" | "nin" | "contains" | "ncontains" | "exists" | "nexists";
+type Constraint = ConstraintMetadata & ConstraintUnion;
+interface ConstraintGroup {
+  operator: LogicalOperatorEnum;
+  rules: ConstraintUnion[];
+}
+interface ConstraintMetadata {
+  description?: string;
+  name: string;
+}
+interface ConstraintRule {
+  fields?: String[];
+  parameters?: unknown;
+  predicate: string;
+}
+type ConstraintUnion = ConstraintRule | ConstraintGroup;
+interface FieldDefinition {
+  default?: unknown;
+  deprecated?: boolean;
+  description?: string;
+  metadata?: unknown;
+  name: string;
+  nullable?: boolean;
+  required?: boolean;
+  schema?: SchemaReference | SchemaReferenceArray | InlineTypeDescriptor;
+  type: FieldType;
+  unique?: boolean;
+}
+type FieldType = "unknown" | "string" | "number" | "integer" | "decimal" | "boolean" | "array" | "enum" | "object" | "record" | "union" | "composite" | "geometry" | "bytes";
+interface IndexCondition {
+  field: string;
+  operator: ComparisonOperator;
+  value: unknown;
+}
+interface IndexConditionGroup {
+  conditions: IndexConditionUnion[];
+  operator: LogicalOperatorEnum;
+}
+type IndexConditionUnion = IndexCondition | IndexConditionGroup;
+interface IndexDefinition {
+  condition?: IndexCondition | IndexConditionGroup;
+  description?: string;
+  fields: String[];
+  name: string;
+  order?: IndexOrder;
+  type: IndexType;
+  unique?: boolean;
+}
+type IndexOrder = "asc" | "desc";
+type IndexType = "normal" | "unique" | "primary" | "spatial" | "fulltext";
+interface InlineTypeDescriptor {
+  type: InlineTypeKind;
+  values?: Unknown[];
+}
+type InlineTypeKind = "string" | "number" | "integer" | "decimal" | "boolean" | "bytes" | "unknown" | "record";
+type LogicalOperatorEnum = "and" | "or" | "not" | "nor" | "xor" | "nand" | "xnor";
+interface NestedSchemaDefinition {
+  concrete?: boolean;
+  constraints?: Record<string, Constraint>;
+  default?: unknown;
+  description?: string;
+  fields?: Record<string, FieldDefinition>;
+  indexes?: Record<string, IndexDefinition>;
+  metadata?: unknown;
+  name: string;
+  schema?: SchemaReference | SchemaReferenceArray | InlineTypeDescriptor;
+  type?: FieldType;
+  values?: Unknown[];
+}
+interface SchemaReference {
+  constraints?: Record<string, Constraint>;
+  id: string;
+  indexes?: Record<string, IndexDefinition>;
+}
+type SchemaReferenceArray = SchemaReference[];
+type String = string;
+type Unknown = unknown;
+/** Meta-schema defining the structure of schema definitions */
+interface SchemaDefinition {
+  constraints?: Record<string, Constraint>;
+  description?: string;
+  fields?: Record<string, FieldDefinition>;
+  indexes?: Record<string, IndexDefinition>;
+  metadata?: unknown;
+  name: string;
+  schemas?: Record<string, NestedSchemaDefinition>;
+  version: string;
+}
+//#endregion
+//#region src/schema/types.d.ts
+/** FieldDefinition plus Go-supported field-level enum `values`. */
+type FieldDef = FieldDefinition & {
+  values?: unknown[];
+};
+/**
+ * Parsed literal wrapper — mirrors Go LiteralValue zero/null semantics:
+ * absent key → "zero", explicit JSON null → "null".
+ */
+declare class Literal {
+  readonly kind: "zero" | "null" | "string" | "integer" | "float" | "boolean" | "object" | "array";
+  readonly value: unknown;
+  constructor(kind: "zero" | "null" | "string" | "integer" | "float" | "boolean" | "object" | "array", value: unknown);
+  isZero(): boolean;
+  isNull(): boolean;
+  static fromJSON(v: unknown): Literal;
+}
+declare function parseSchema(data: string | SchemaDefinition | Record<string, unknown>): SchemaDefinition;
+//#endregion
+//#region src/schema/compile.d.ts
+/** Canonical field-type union, straight from the meta schema. */
+type FieldType$2 = FieldType;
+interface ResolvedEnum {
+  lookup: Map<string, unknown>;
+  complex: unknown[];
+  expectNumeric: boolean;
+}
+interface ResolvedNested {
+  id: string;
+  name: string;
+  effectiveType: FieldType$2;
+  fields: ResolvedField[];
+  isRecursive: boolean;
+  values?: unknown[];
+  enumDef?: ResolvedEnum;
+}
+interface ResolvedContainer {
+  itemSchema?: ResolvedNested;
+  itemType?: FieldType$2;
+  itemEnum?: ResolvedEnum;
+  record: boolean;
+}
+type ResolvedKind = {
+  tag: "scalar";
+} | {
+  tag: "enum";
+  enumDef: ResolvedEnum;
+} | {
+  tag: "object";
+  schema: ResolvedNested;
+} | {
+  tag: "container";
+  c: ResolvedContainer;
+} | {
+  tag: "union";
+  variants: ResolvedNested[];
+} | {
+  tag: "composite";
+  parts: ResolvedNested[];
+} | {
+  tag: "recursive";
+  schemaId: string;
+};
+interface ResolvedField {
+  id: string;
+  name: string;
+  path: string;
+  type: FieldType$2;
+  required: boolean;
+  deprecated: boolean;
+  unique: boolean;
+  nullable: boolean;
+  hasDefault: boolean;
+  kind: ResolvedKind;
+}
+declare class Compiler {
+  readonly source: SchemaDefinition;
+  private readonly nested;
+  private readonly building;
+  constructor(source: SchemaDefinition);
+  compile(): {
+    root: ResolvedField[];
+    schemas: Map<string, ResolvedNested>;
+  };
+  private compileNested;
+  private compileFields;
+  private compileField;
+  private resolve;
+  private require;
+  private synthesizeInline;
+}
+declare function buildEnum(values: unknown[], t?: FieldType$2): ResolvedEnum;
+//#endregion
+//#region src/schema/link.d.ts
+declare const FD_NO_CHILD = 63;
+declare const MAX_SCHEMA_SLOTS = 63;
+declare const MULTI_STEP_BASE: number;
+type FieldKind = 0 | 1 | 2 | 3;
+interface FieldDescriptor {
+  raw: number;
+  dt: number;
+  kind: FieldKind;
+  schemaIdx: number;
+  fieldIdx: number;
+  childSchemaIdx: number;
+  terminal: boolean;
+  required: boolean;
+  hasDefault: boolean;
+  deprecated: boolean;
+  unique: boolean;
+  nullable: boolean;
+  recursive: boolean;
+}
+/** Internal DataPoint (side-table identity) — compiled.go:186 formula. */
+declare function internalDP(fd: FieldDescriptor): number;
+declare function makeDescriptor(dt: number, kind: FieldKind, schemaIdx: number, fieldIdx: number, o: {
+  required: boolean;
+  hasDefault: boolean;
+  deprecated: boolean;
+  unique: boolean;
+  terminal: boolean;
+  nullable: boolean;
+  recursive: boolean;
+  child: number;
+}): FieldDescriptor;
+declare function unpackDescriptor(raw: number): FieldDescriptor;
+interface Slot {
+  fieldStart: number;
+  fieldCount: number;
+  footprint: number;
+}
+interface FieldMeta {
+  name: string;
+  path: string;
+}
+/** A linked field: everything the wire codec needs. */
+interface LinkedField {
+  meta: FieldMeta;
+  fd: FieldDescriptor;
+  /** Canonical user-data DataPoint written by the Sparse format. */
+  dp: number;
+  /** Absolute descriptor index across all slots. */
+  abs: number;
+  /** For array_object fields: the linked child slot's fields. */
+  child?: LinkedSlot;
+}
+interface LinkedSlot {
+  idx: number;
+  slot: Slot;
+  fields: LinkedField[];
+}
+interface LinkResult {
+  slots: Slot[];
+  metas: FieldMeta[];
+  descriptors: FieldDescriptor[];
+  localOffsets: number[];
+  fieldTypes: FieldType$2[];
+  root: LinkedSlot;
+  /** abs index of each root-level array_object field's linked child */
+  childrenByPath: Map<string, LinkedSlot>;
+}
+/**
+ * Address computation (address.go computeAddress).
+ * steps = [(schemaIdx,fieldIdx), ...] with the LAST step being the leaf.
+ */
+declare function addressForSteps(slots: Slot[], descriptors: FieldDescriptor[], localOffsets: number[], steps: Array<[number, number]>): number;
+/** Canonical Sparse DataPoint for an addressed leaf. */
+declare function userDataDP(dt: number, addr: number): number;
+declare function link(source: SchemaDefinition): LinkResult;
+interface ManifestField {
+  /** Field's declared name (relative to its own slot). */
+  name: string;
+  /** Full dotted mount path from the document root ("address.street"). */
+  path: string;
+  /** container.DataType name tag. */
+  t: string;
+  /** Canonical Sparse DataPoint. */
+  dp: number;
+  /** TypeArrayObject element fields (full mount paths). */
+  child?: ManifestField[];
+}
+/** Build the language-neutral wire manifest from linked tables. */
+declare function buildManifest(l: LinkResult): ManifestField[];
+//#endregion
+//#region src/schema/dt.d.ts
+declare const container: {
+  readonly TypeUnknown: 0;
+  readonly TypeInt: 1;
+  readonly TypeFloat: 2;
+  readonly TypeString: 3;
+  readonly TypeBool: 4;
+  readonly TypeBytes: 5;
+  readonly TypeGeometry: 6;
+  readonly TypeRecord: 7;
+  readonly TypeArrayUnknown: 8;
+  readonly TypeArrayInt: 9;
+  readonly TypeArrayFloat: 10;
+  readonly TypeArrayString: 11;
+  readonly TypeArrayBool: 12;
+  readonly TypeArrayBytes: 13;
+  readonly TypeArrayObject: 14;
+  readonly TypeArrayGeometry: 15;
+};
+//#endregion
+//#region src/wire/packet.d.ts
+declare const FLAG_COMPRESSED = 4;
+declare const FLAG_ENCRYPTED = 64;
+declare const FLAG_HASH_PRESENT = 128;
+type EncodeKind = "auto" | "dense" | "sparse";
+declare function encodeDocument(fields: ManifestField[], doc: Record<string, unknown>, fullVersion?: number, kind?: EncodeKind): Uint8Array;
+declare function decodeDocument(data: Uint8Array, fields: ManifestField[]): {
+  version: number;
+  doc: Record<string, unknown>;
+};
+declare function encodeBatchRows(fields: ManifestField[], docs: Record<string, unknown>[], fullVersion?: number): Uint8Array;
+declare function encodeBatchColumnar(fields: ManifestField[], docs: Record<string, unknown>[], fullVersion?: number): Uint8Array;
+declare function decodeBatch(data: Uint8Array, fields: ManifestField[]): {
+  version: number;
+  docs: Record<string, unknown>[];
+};
+//#endregion
+//#region src/wire/transforms.d.ts
+interface EncodeTransforms {
+  /** Compress the packet body (flags bit 2). */
+  compression?: boolean;
+  /** Embed BLAKE3-truncated digest over the plaintext body (bit 7). */
+  integrity?: boolean;
+  /** Seal with AES-256-GCM under this 32-byte key (bit 6). */
+  encryptionKey?: Uint8Array;
+}
+interface DecodeTransforms {
+  decryptionKey?: Uint8Array;
+}
+/** Full-duplex single-document encode with transforms. */
+declare function encodeAnansiPacket(fields: ManifestField[], doc: Record<string, unknown>, fullVersion?: number, opts?: EncodeTransforms & {
+  kind?: EncodeKind;
+}): Promise<Uint8Array>;
+/** Full-duplex single-document decode with transforms. */
+declare function decodeAnansiPacket(data: Uint8Array, fields: ManifestField[], opts?: DecodeTransforms): Promise<{
+  version: number;
+  doc: Record<string, unknown>;
+}>;
+/** Batch row-oriented encode with transforms. */
+declare function encodeAnansiBatchRows(fields: ManifestField[], docs: Record<string, unknown>[], fullVersion?: number, opts?: EncodeTransforms): Promise<Uint8Array>;
+/**
+ * Columnar batch encode. Transforms are supported only on the row paths —
+ * columnar ENCODE parity is still pending in TS; pass empty options to emit
+ * a plain packet (decoding transformed columnar packets IS supported).
+ */
+/** Columnar batch encode with transforms — full duplex. */
+declare function encodeAnansiBatchColumnar(fields: ManifestField[], docs: Record<string, unknown>[], fullVersion?: number, opts?: EncodeTransforms): Promise<Uint8Array>;
+/** Full-duplex batch decode (row dense/sparse and columnar) with transforms. */
+declare function decodeAnansiBatch(data: Uint8Array, fields: ManifestField[], opts?: DecodeTransforms): Promise<{
+  version: number;
+  docs: Record<string, unknown>[];
+}>;
+//#endregion
+//#region src/codec.d.ts
+interface AnansiCodecOptions extends EncodeTransforms {
+  /** Schema version stamped into outgoing packets (0–1023). */
+  fullVersion?: number;
+  /** Force Dense/Sparse instead of the density heuristic. */
+  kind?: EncodeKind;
+  /** Key used to decrypt incoming packets (if the server encrypts). */
+  decryptionKey?: Uint8Array;
+}
+declare class AnansiCodec {
+  readonly linked: LinkResult;
+  readonly fields: ManifestField[];
+  readonly fullVersion: number;
+  private readonly kind;
+  private readonly enc;
+  private readonly dec;
+  private constructor();
+  /**
+   * Compile a schema definition and bind it to a codec instance.
+   *
+   * ```ts
+   * const codec = await AnansiCodec.create(schemaJSON);            // plain
+   * const codec = await AnansiCodec.create(schemaJSON, {
+   *   fullVersion: 7,
+   *   transforms: { compression: true, integrity: true },
+   * });
+   * ```
+   *
+   * Instances are immutable; cache one per schema version (or per endpoint)
+   * and share it freely across requests.
+   */
+  static create(schema: string | SchemaDefinition | Record<string, unknown>, opts?: AnansiCodecOptions): Promise<AnansiCodec>;
+  /** Encode a single document (Dense/Sparse per configured strategy). */
+  encode(doc: Record<string, unknown>): Promise<Uint8Array>;
+  /** Decode a single-document packet. Accepts plain and transformed frames. */
+  decode(data: Uint8Array): Promise<{
+    version: number;
+    doc: Record<string, unknown>;
+  }>;
+  /** Encode many documents as one row-oriented batch. */
+  encodeBatch(docs: Record<string, unknown>[]): Promise<Uint8Array>;
+  /** Decode any batch packet (row dense/sparse, columnar, transformed). */
+  decodeBatch(data: Uint8Array): Promise<{
+    version: number;
+    docs: Record<string, unknown>[];
+  }>;
+  /**
+   * Columnar batch encode. Note: columnar output with transforms enabled is
+   * pending in TypeScript — with transforms unset this emits plain packets.
+   */
+  encodeColumnar(docs: Record<string, unknown>[]): Promise<Uint8Array>;
+}
+//#endregion
+//#region src/validation/types/hints.d.ts
 /**
  * hints.ts
  *
@@ -15,142 +410,142 @@ import { FieldValues, ResolverOptions, ResolverResult } from 'react-hook-form';
  * Hints for generating a file input control.
  */
 type FileHint = {
-    type: "file";
-    subtype: "video" | "audio" | "image" | "pdf" | "doc" | "txt";
-    label?: string;
-    embed?: boolean;
-    mimes?: string | string[];
-    preview?: boolean;
-    size?: {
-        max?: number;
-        min?: number;
-    };
-    dimensions?: {
-        width: number;
-        height: number;
-    };
-    group?: string;
-    ignore?: boolean;
+  type: "file";
+  subtype: "video" | "audio" | "image" | "pdf" | "doc" | "txt";
+  label?: string;
+  embed?: boolean;
+  mimes?: string | string[];
+  preview?: boolean;
+  size?: {
+    max?: number;
+    min?: number;
+  };
+  dimensions?: {
+    width: number;
+    height: number;
+  };
+  group?: string;
+  ignore?: boolean;
 };
 /**
  * Hints for generating a text-based input control.
  */
 type TextHint = {
-    type: "text" | "email" | "tel" | "url" | "textarea";
-    label?: string;
-    placeholder?: string;
-    group?: string;
-    ignore?: boolean;
+  type: "text" | "email" | "tel" | "url" | "textarea";
+  label?: string;
+  placeholder?: string;
+  group?: string;
+  ignore?: boolean;
 };
 /**
  * Hints for generating a secret input control (e.g., passwords, API keys).
  */
 type SecretHint = {
-    type: "secret";
-    label?: string;
-    placeholder?: string;
-    password?: boolean;
-    group?: string;
-    ignore?: boolean;
+  type: "secret";
+  label?: string;
+  placeholder?: string;
+  password?: boolean;
+  group?: string;
+  ignore?: boolean;
 };
 /**
  * Hints for generating a number-based input control.
  */
 type NumberHint = {
-    type: "number" | "range";
-    label?: string;
-    step?: number;
-    group?: string;
-    ignore?: boolean;
+  type: "number" | "range" | "integer" | "decimal";
+  label?: string;
+  step?: number;
+  group?: string;
+  ignore?: boolean;
 };
 /**
  * Hints for generating a boolean input control.
  */
 type BooleanHint = {
-    type: "checkbox" | "radio";
-    label?: string;
-    radioLabels?: {
-        true: string;
-        false: string;
-    };
-    group?: string;
-    ignore?: boolean;
+  type: "checkbox" | "radio";
+  label?: string;
+  radioLabels?: {
+    true: string;
+    false: string;
+  };
+  group?: string;
+  ignore?: boolean;
 };
 /**
  * Hints for generating an enum input control.
  */
 type EnumHint = {
-    type: "select" | "radio";
-    label?: string;
-    group?: string;
-    ignore?: boolean;
-    options?: Array<{
-        value: string | number;
-        label: string;
-    }>;
+  type: "select" | "radio";
+  label?: string;
+  group?: string;
+  ignore?: boolean;
+  options?: Array<{
+    value: string | number;
+    label: string;
+  }>;
 };
 /**
  * Hints for generating an array input control.
  */
 type ArrayHint = {
-    type: "list";
-    label?: string;
-    itemHint?: {
-        type: string;
-    };
-    group?: string;
-    ignore?: boolean;
+  type: "list";
+  label?: string;
+  itemHint?: {
+    type: string;
+  };
+  group?: string;
+  ignore?: boolean;
 };
 /**
  * Hints for generating a set input control.
  */
 type SetHint = {
-    type: "tags";
-    label?: string;
-    itemHint?: {
-        type: string;
-    };
-    group?: string;
-    ignore?: boolean;
+  type: "tags";
+  label?: string;
+  itemHint?: {
+    type: string;
+  };
+  group?: string;
+  ignore?: boolean;
 };
 /**
  * Hints for generating an object input control.
  */
 type ObjectHint = {
-    type: "group";
-    label?: string;
-    collapsible?: boolean;
-    group?: string;
-    ignore?: boolean;
+  type: "group";
+  label?: string;
+  collapsible?: boolean;
+  group?: string;
+  ignore?: boolean;
 };
 /**
  * Hints for generating a date input control.
  */
 type DateHint = {
-    type: "date" | "datetime" | "time";
-    label?: string;
-    placeholder?: string;
-    min?: string;
-    max?: string;
-    group?: string;
-    ignore?: boolean;
+  type: "date" | "datetime" | "time";
+  label?: string;
+  placeholder?: string;
+  min?: string;
+  max?: string;
+  group?: string;
+  ignore?: boolean;
 };
 /**
  * Hints for generating a code input control (e.g., for code snippets or scripts).
  */
 type CodeHint = {
-    type: "code";
-    label?: string;
-    language?: string;
-    placeholder?: string;
-    readonly?: boolean;
-    editorOptions?: {
-        lineNumbers?: boolean;
-        wordWrap?: boolean;
-        minimap?: boolean;
-    };
-    group?: string;
-    ignore?: boolean;
+  type: "code";
+  label?: string;
+  language?: string;
+  placeholder?: string;
+  readonly?: boolean;
+  editorOptions?: {
+    lineNumbers?: boolean;
+    wordWrap?: boolean;
+    minimap?: boolean;
+  };
+  group?: string;
+  ignore?: boolean;
 };
 /**
  * Union type for all possible input hints.
@@ -161,2187 +556,526 @@ type InputHint = FileHint | TextHint | SecretHint | NumberHint | BooleanHint | E
  * Defines metadata for a group of inputs at the schema level.
  */
 type GroupDefinition = {
-    name: string;
-    label?: string;
-    description?: string;
+  name: string;
+  label?: string;
+  description?: string;
 };
 /**
  * Defines hints at the schema level, including group metadata.
  */
 type SchemaHint = {
-    groups?: GroupDefinition[];
+  groups?: GroupDefinition[];
 };
-
+//#endregion
+//#region src/validation/types/schema-definition.d.ts
 /**
  * Basic field types supported by the schema system.
+ * Matches the `FieldTypeEnum` in the meta‑schema.
  */
-type FieldType = "string" | "number" | "boolean" | "array" | "set" | "enum" | "object" | "record" | "union" | "dynamic";
+type FieldType$1 = "unknown" | "string" | "number" | "integer" | "decimal" | "boolean" | "array" | "set" | "enum" | "object" | "record" | "union" | "composite" | "geometry" | "bytes";
 /**
  * Index types for optimizing different query patterns.
+ * Matches the `IndexTypeEnum` in the meta‑schema.
  */
-type IndexType = "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite";
+type IndexType$1 = "normal" | "unique" | "primary" | "spatial" | "fulltext";
 /**
- * Defines a predicate function for data validation, mapped to a PredicateMap at runtime.
- *
- * @example
- * ```typescript
- * const isEmail: Predicate = ({ data, field, arguments: regex }) => {
- *    if (field && typeof data[field] === 'string') {
- *        return regex.test(data[field]);
- *    }
- *    return false;
- * };
- * ```
+ * Logical operators used in constraint groups and index condition groups.
+ * Matches the `LogicalOperatorEnum` in the meta‑schema.
  */
-type Predicate = <T, K extends FieldType = any>(params: {
-    data: T;
-    field?: keyof T;
-    arguments: PredicateParameters<K>;
-}) => boolean;
+type LogicalOperatorEnum$1 = "and" | "or" | "not" | "nor" | "xor" | "nand" | "xnor";
 /**
- * A map of predicate names to their validation functions, implemented by the runtime environment.
- *
- * @example
- * ```typescript
- * const predicateMap: PredicateMap = {
- *    isEmail: isEmail,
- *    isPositive: ({ data, field, arguments: min }) => {
- *        if (field && typeof data[field] === 'number'){
- *            return data[field] > min;
- *        }
- *        return false;
- *    }
- * };
- * ```
+ * Comparison operators for index conditions.
+ * Matches the `ComparisonOperatorEnum` in the meta‑schema.
  */
-type PredicateMap = Record<string, Predicate>;
+type ComparisonOperator$1 = "eq" | "neq" | "lt" | "lte" | "gt" | "gte" | "in" | "nin" | "contains" | "ncontains" | "exists" | "nexists";
 /**
- * A map of function names to generic functions, used elsewhere in the system.
- *
- * @example
- * ```typescript
- * const functionMap: FunctionMap = {
- *    calculateTotal: (items: { price: number; quantity: number }[]) => {
- *        return items.reduce((acc, item) => acc + item.price * item.quantity, 0);
- *    }
- * };
- * ```
- */
-type FunctionMap = Record<string, Function>;
-/** @deprecated Use PredicateMap instead. */
-type ConstraintsMap = Record<string, Predicate>;
-/**
- * Names of supported predicates, derived from a PredicateMap.
- *
- * @example
- * ```typescript
- * type AvailablePredicates = PredicateName<typeof predicateMap>; // "isEmail" | "isPositive"
- * ```
+ * Inline type descriptor kinds.
+ * Matches the `InlineTypeEnum` in the meta‑schema.
  */
-type PredicateName<T extends PredicateMap = any> = keyof T;
+type InlineTypeKind$1 = "string" | "number" | "integer" | "decimal" | "boolean" | "bytes" | "unknown" | "record";
 /**
- * Parameters for predicates, tailored to each field type.
- *
- * @example
- * ```typescript
- * type StringParams = PredicateParameters<"string">; // string | string[] | RegExp | { field: string }
- * type NumberParams = PredicateParameters<"number">; // number | number[] | { precision: number; scale?: number } | { field: string }
- * ```
+ * Sort order for index fields.
+ * Matches the `IndexOrderEnum` in the meta‑schema.
  */
-type PredicateParameters<T extends FieldType> = T extends "string" ? string | string[] | RegExp | {
-    field: string;
-} : T extends "number" ? number | number[] | {
-    precision: number;
-    scale?: number;
-} | {
-    field: string;
-} : T extends "boolean" ? boolean : T extends "array" | "set" ? number | {
-    minItems: number;
-    maxItems: number;
-} : T extends "enum" ? string[] | number[] | {
-    field: string;
-} : T extends "object" ? {
-    schema: Record<string, unknown>;
-} : T extends "record" ? Record<string, unknown> : T extends "dynamic" ? any : never;
-/** @deprecated Use PredicateParameters instead. */
-type ConstraintParameters<T extends FieldType> = PredicateParameters<T>;
+type IndexOrder$1 = "asc" | "desc";
 /**
- * Defines a constraint on a field or schema, using a predicate for validation.
- *
- * @example
- * ```typescript
- * const emailConstraint: Constraint<"string"> = {
- *    name: "email",
- *    predicate: "isEmail",
- *    parameters: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
- *    errorMessage: "Must be a valid email address."
- * };
- * ```
+ * Shared metadata properties for most schema components.
  */
-type Constraint<T extends FieldType> = {
-    type?: "schema";
-    predicate: string;
-    field?: keyof any;
-    parameters?: PredicateParameters<T>;
-    name: string;
-    description?: string;
-    errorMessage?: string;
-};
-/**
- * Groups multiple constraints with a logical operator for complex validation logic.
- *
- * @example
- * ```typescript
- * const compositeConstraint: ConstraintGroup<"number"> = {
- *    name: "positiveAndLessThan100",
- *    operator: "and",
- *    rules: [
- *        { name: "positive", predicate: "isPositive", parameters: 0 },
- *        { name: "lessThan100", predicate: "isLessThan", parameters: 100 }
- *    ]
- * };
- * ```
- */
-interface ConstraintGroup<T extends FieldType> {
-    name: string;
-    operator: LogicalOperator;
-    rules: Array<Constraint<T> | ConstraintGroup<T>>;
+interface BaseMetadata extends Record<string, any> {
+  description?: string;
+  /** Arbitrary key‑value pairs for implementation‑specific metadata. */
+  metadata?: Record<string, unknown>;
 }
 /**
- * Collection of constraints or groups applied at the schema or nested level.
- *
- * @example
- * ```typescript
- * const schemaConstraints: SchemaConstraint<"number"> = [
- *    { name: "positive", predicate: "isPositive", parameters: 0 },
- *    compositeConstraint
- * ];
- * ```
+ * Metadata for components that also have a human‑readable name.
  */
-type SchemaConstraint<T extends FieldType> = Array<Constraint<T> | ConstraintGroup<T>>;
-/** Reference to a nested schema (mini-SchemaDefinition) with optional overrides. */
-interface FieldSchema {
-    id: string;
-    constraints?: SchemaConstraint<any>;
-    indexes?: IndexDefinition[];
+interface NamedMetadata extends BaseMetadata {
+  name: string;
 }
 /**
- * Defines a field within a schema, including its type, constraints, and nesting.
- *
- * @example
- * ```typescript
- * const ageField: FieldDefinition<number> = {
- *    name: "age",
- *    type: "number",
- *    required: true,
- *    constraints: [{ name: "positive", predicate: "isPositive", parameters: 0 }],
- *    default: 25,
- *    hint: {
- *        input: {
- *            min : 0,
- *            max : 100
- *        }
- *    }
- * };
- * ```
+ * Reference to another schema (e.g., for `object`, `array`, `union` types).
+ * May include local overrides for indexes and constraints.
  */
-interface FieldDefinition<T> {
-    name: string;
-    type: FieldType;
-    required?: boolean;
-    constraints?: Array<Constraint<any> | ConstraintGroup<any>>;
-    default?: T;
-    /** For type 'enum', specifies the allowed values. */
-    values?: Array<string | number>;
-    /** For type 'union', specifies the array of allowed schemas.
-     * For type 'object' specifies the schema of the object
-     * */
-    schema?: FieldSchema | Array<FieldSchema>;
-    itemsType?: FieldType;
-    nestedSchema?: FieldSchema;
-    deprecated?: boolean;
-    reference?: {
-        schema: string;
-        field: string;
-    };
-    description?: string;
-    unique?: boolean;
-    hint?: {
-        input: InputHint;
-    };
+interface SchemaReference$1 extends BaseMetadata {
+  id: string;
+  indexes?: Record<string, IndexDefinition$1>;
+  constraints?: Record<string, Constraint$1 | ConstraintGroup$1>;
 }
 /**
- * Condition for partial indexes, allowing conditional indexing based on field values.
- *
- * @example
- * ```typescript
- * const activeCondition: PartialIndexCondition = {
- *    operator: "and",
- *    field: "isActive",
- *    value: true
- * };
- * ```
+ * Inline type descriptor – used when a simple type is defined directly
+ * without a separate schema reference.
  */
-interface PartialIndexCondition {
-    operator: LogicalOperator;
-    field: string;
-    value?: any;
-    conditions?: PartialIndexCondition[];
+interface InlineTypeDescriptor$1 extends BaseMetadata {
+  type: InlineTypeKind$1;
+  values?: Array<string | number>;
 }
 /**
- * Defines an index for optimizing queries or enforcing uniqueness.
- *
- * @example
- * ```typescript
- * const nameIndex: IndexDefinition = {
- *    name: "nameIndex",
- *    fields: ["firstName", "lastName"],
- *    type: "composite",
- *    unique: true
- * };
- * ```
- */
-interface IndexDefinition {
-    fields: string[];
-    type: IndexType;
-    unique?: boolean;
-    partial?: PartialIndexCondition;
-    description?: string;
-    order?: "asc" | "desc";
-    name: string;
+ * Defines a field within a schema.
+ * Matches the `Field` schema in the meta‑schema.
+ */
+interface FieldDefinition$1<T = unknown> extends NamedMetadata {
+  type: FieldType$1;
+  required?: boolean;
+  nullable?: boolean;
+  deprecated?: boolean;
+  unique?: boolean;
+  default?: T;
+  /**
+   * The `schema` property is used for complex types:
+   * - For `array`/`set`: a single `SchemaReference` pointing to the item schema.
+   * - For `object`: a single `SchemaReference` pointing to the object schema.
+   * - For `union`: an array of `SchemaReference`s.
+   * - For `enum`: an `InlineTypeDescriptor` (or `values` on the field itself).
+   * - For primitive overrides: an `InlineTypeDescriptor`.
+   */
+  schema?: SchemaReference$1 | SchemaReference$1[] | InlineTypeDescriptor$1;
+  /** @deprecated Use `schema` instead. */
+  nestedSchema?: SchemaReference$1;
+  hint?: {
+    input: InputHint;
+  };
 }
 /**
- * Defines a reusable nested schema structure.
- * This can represent either a complex object with defined fields, or a direct primitive literal (string, number, boolean).
- * Nested schemas are stored in the `nestedSchemas` map of a `SchemaDefinition` and referenced by their `id`.
- * They facilitate schema reusability, modularity, and the definition of polymorphic structures.
- *
- */
-type NestedSchemaDefinition<T = any> = {
-    /**
-     * The unique name or identifier of the nested schema within the parent schema's `nestedSchemas` map.
-     * This `name` is used by `FieldDefinition.schema.id` to reference this nested schema.
-     * @example "AddressSchema" or "EmailString"
-     */
-    name: string;
-    /**
-     * A clear and concise description of the nested schema's purpose, structure, or expected data.
-     * This is crucial for documentation and understanding the schema's intent.
-     */
-    description?: string;
-    /**
-     * Defines database indexes for the fields within this nested schema.
-     * This is primarily applicable when `concrete` is `true`, indicating that the schema
-     * maps directly to a persistent data store table. Indexes help optimize data retrieval.
-     */
-    indexes?: IndexDefinition[];
-    /**
-     * Optional generic metadata associated with the structured schema.
-     * This can store any additional information relevant to tooling, UI generation,
-     * or specific domain requirements that are not covered by other properties.
-     * @example `{ graphqlType: "Address", apiEndpoint: "/api/addresses" }`
-     */
-    metadata?: Record<string, any>;
-} & ({
-    /**
-     * Optional constraints for additional validation rules that apply to the entire structured schema.
-     * These constraints provide an extra layer of data integrity beyond basic type checking.
-     * They are less strictly necessary when using discriminated field sets (`fields` as an array),
-     * as much of the variant logic can be enforced structurally through the `when` clauses.
-     */
-    constraints?: SchemaConstraint<any>;
-    /**
-     * Indicates whether this schema represents a standalone entity (`true`) or is embedded (`false`).
-     * - When `true` (`concrete: true`), the schema is treated as a distinct, fixed-structure entity,
-     * often suitable for direct mapping to RDBMS tables. In this case, `fields` *must* be a
-     * `Record<string, FieldDefinition<any>>` to ensure a consistent, non-polymorphic structure.
-     * - When `false` (`concrete: false` or omitted), the schema is considered embedded or polymorphic.
-     * `fields` can be either a `Record<string, FieldDefinition<any>>` (for a fixed embedded object)
-     * or an `Array<{ fields: Record<string, FieldDefinition<any>>; when?: { field: string; value: any } }>`,
-     * allowing discriminated field sets based on a specific field's value (e.g., a 'type' field).
-     * The array form enables defining variants within a single schema without imposing strict concrete
-     * constraints, but is not supported for `concrete: true` schemas to maintain simplicity in RDBMS table mappings.
-     * @default false
-     */
-    concrete?: boolean;
-    /**
-     * Defines the fields (properties) that constitute this nested schema.
-     * The structure of `fields` depends on the `concrete` property:
-     * - If `concrete` is `true`, `fields` must be a `Record<string, FieldDefinition<any>>`
-     * to define a fixed set of named fields (e.g., for a database table).
-     * - If `concrete` is `false` (or omitted), `fields` can be:
-     * - A `Record<string, FieldDefinition<any>>` for a simple, embedded object.
-     * - An `Array<{ fields: Record<string, FieldDefinition<any>>; when?: { field: string; value: any } }>`
-     * to define a discriminated union or polymorphic structure. Each object in the array defines a
-     * set of fields that apply `when` a specified `field` (within this schema's own fields)
-     * has a particular `value`. This allows for variant-specific fields.
-     */
-    fields: Record<string, FieldDefinition<any>> | Array<{
-        /**
-         * A set of field definitions that apply when the `when` condition is met.
-         */
-        fields: Record<string, FieldDefinition<any>>;
-        /**
-         * An optional condition that makes this set of fields active.
-         * This object specifies a `field` (its name within this schema) and a `value`.
-         * When the specified `field` in the data matches this `value`, these `fields` are considered active.
-         * Used for discriminated unions or polymorphic structures (e.g., `when: { field: "type", value: "car" }`).
-         * If `when` is omitted for an entry in the array, those fields are always present in the union's base,
-         * or it acts as a fallback if no other `when` condition matches.
-         */
-        when?: {
-            field: string;
-            value: any;
-        };
-    }>;
-} | (Pick<FieldDefinition<T>, "name" | "default" | "schema" | "itemsType" | "constraints"> & {
-    /**
-     * The basic primitive type that this literal schema represents.
-     */
-    type: "string" | "number" | "boolean" | "array" | "set" | "enum" | "record";
-}));
-/**
- * Defines a complete schema, intended as an atomic unit within a larger domain model.
- *
- * @example
- * ```typescript
- * const userSchema: SchemaDefinition = {
- *    name: "user",
- *    version: "1.0.0",
- *    fields: {
- *        id: { name: "id", type: "string", required: true },
- *        name: { name: "name", type: "string" },
- *        address: { name: "address", type: "object", schema: { id: "address" } }
- *    },
- *    nestedSchemas: {
- *        address: addressSchema
- *    },
- *    indexes: [{ name: "nameIndex", fields: ["name"], type: "normal" }],
- *    mock: (faker) => {
- *        return {
- *            id: faker.string.uuid(),
- *            name: faker.person.fullName(),
- *            address: {
- *                street: faker.location.streetAddress(),
- *                city: faker.location.city(),
- *                zip: faker.location.zipCode()
- *            }
- *        };
- *    }
- * };
- * ```
+ * A single index condition (leaf node).
+ * Matches the `IndexCondition` schema in the meta‑schema.
  */
-interface SchemaDefinition {
-    name: string;
-    version: string;
-    description?: string;
-    fields: Record<string, FieldDefinition<any>>;
-    /** Reusable nested schema definitions, now as mini-SchemaDefinitions. */
-    nestedSchemas?: Record<string, NestedSchemaDefinition<any>>;
-    indexes?: IndexDefinition[];
-    constraints?: SchemaConstraint<any>;
-    metadata?: Record<string, any>;
-    /** @deprecated Use dependencies in DomainModel instead. */
-    dependencies?: string[];
-    migrations?: Array<Migration<any>>;
-    hint?: SchemaHint;
-    mock?: <T>(faker: typeof _faker_js_faker) => Generator<T, void, unknown>;
+interface IndexCondition$1 extends BaseMetadata {
+  operator: ComparisonOperator$1;
+  field: string;
+  value: unknown;
 }
 /**
- * Defines a change that can be made to a schema during migration.
- * Updated to support the new NestedSchemaDefinition structure.
- *
- * @example
- * ```typescript
- * const addEmailField: SchemaChange<string> = {
- *    type: "addField",
- *    id: "email",
- *    definition: { name: "email", type: "string" }
- * };
- *
- * const modifyAddressSchema: SchemaChange<any> = {
- *    type: "modifyNestedSchema",
- *    id: "address",
- *    changes: {
- *        fields: {
- *            country: {name: "country", type: "string"}
- *        }
- *    }
- * }
- * ```
+ * A group of index conditions combined with a logical operator.
+ * Matches the `IndexConditionGroup` schema in the meta‑schema.
  */
-type SchemaChange<T> = {
-    type: "modifyProperty";
-    id: keyof Omit<SchemaDefinition, "fields" | "indexes" | "constraints" | "nestedSchemas">;
-    changes: Partial<Omit<SchemaDefinition, "fields" | "indexes" | "constraints" | "nestedSchemas">>;
-} | {
-    type: "addField";
-    id: string;
-    definition: FieldDefinition<T>;
-} | {
-    type: "removeField";
-    id: string;
-} | {
-    type: "modifyField";
-    id: string;
-    changes: Partial<FieldDefinition<T>>;
-    nestedSchemaChanges?: {
-        id?: string;
-        constraints?: SchemaConstraint<any>;
-        indexes?: IndexDefinition[];
-    };
-} | {
-    type: "addIndex";
-    definition: IndexDefinition;
-} | {
-    type: "removeIndex";
-    name: string;
-} | {
-    type: "modifyIndex";
-    name: string;
-    changes: Partial<IndexDefinition>;
-} | {
-    type: "addConstraint";
-    constraint: Constraint<any> | ConstraintGroup<any>;
-} | {
-    type: "removeConstraint";
-    name: string;
-} | {
-    type: "modifyConstraint";
-    name: string;
-    changes: Partial<SchemaConstraint<any> | Constraint<any>>;
-} | {
-    type: "deprecateField";
-    id: string;
-} | {
-    type: "addNestedSchema";
-    id: string;
-    definition: NestedSchemaDefinition<any>;
-} | {
-    type: "removeNestedSchema";
-    id: string;
-} | {
-    type: "modifyNestedSchema";
-    id: string;
-    changes: Partial<NestedSchemaDefinition<any>>;
-};
+interface IndexConditionGroup$1 extends BaseMetadata {
+  operator: LogicalOperatorEnum$1;
+  conditions: Array<IndexCondition$1 | IndexConditionGroup$1>;
+}
 /**
- * Defines a transform function for data migration between schema versions.
- *
- * @example
- * ```typescript
- * const transformEmail: TransformFunction<{ oldEmail: string }, { email: string }> = (data) => {
- * return { email: data.oldEmail };
- * };
- * ```
- */
-type TransformFunction<Initial, Next> = (data: Initial) => Next | Promise<Next>;
+ * Defines an index for optimizing queries or enforcing uniqueness.
+ * Matches the `Index` schema in the meta‑schema.
+ */
+interface IndexDefinition$1 extends NamedMetadata {
+  unique?: boolean;
+  type: IndexType$1;
+  fields: string[];
+  order?: IndexOrder$1;
+  condition?: IndexCondition$1 | IndexConditionGroup$1;
+}
 /**
- * Represents a pair of transformations for bidirectional data migration.
- *
- * @example
- * ```typescript
- * const emailMigration: DataTransform<{ oldEmail: string }, { email: string }> = {
- * forward: transformEmail,
- * backward: (data) => ({ oldEmail: data.email })
- * };
- * ```
+ * A predicate‑based constraint rule.
+ * Matches the `ConstraintRule` schema in the meta‑schema.
  */
-interface DataTransform<Initial, Next> {
-    forward: TransformFunction<Initial, Next>;
-    backward: TransformFunction<Next, Initial>;
+interface ConstraintRule$1 extends NamedMetadata {
+  predicate: string;
+  parameters?: unknown;
+  fields?: string[];
 }
 /**
- * Defines a migration, consisting of schema changes and data transforms.
- *
- * @example
- * ```typescript
- * const emailMigration: Migration<string> = {
- * id: "emailMigration",
- * schemaVersion: "2.0.0",
- * changes: [addEmailField],
- * description: "Adds email field",
- * status: "pending",
- * transform: emailMigration,
- * createdAt: new Date().toISOString(),
- * checksum: "someChecksum"
- * };
- * ```
+ * A group of constraints combined with a logical operator.
+ * Matches the `ConstraintGroup` schema in the meta‑schema.
  */
-interface Migration<T> {
-    id: string;
-    schemaVersion: string;
-    changes: SchemaChange<T>[];
-    description: string;
-    status: "pending" | "applied" | "failed";
-    rollback?: SchemaChange<T>[];
-    transform: string | DataTransform<any, any>;
-    createdAt: string;
-    /** @deprecated Use dependencies in DomainModel instead. */
-    dependencies?: string[];
-    checksum: string;
+interface ConstraintGroup$1 extends NamedMetadata {
+  operator: LogicalOperatorEnum$1;
+  rules: Array<ConstraintRule$1 | ConstraintGroup$1>;
 }
 /**
- * Generator type for mock data functions (used with Faker).
- *
- * @example
- * ```typescript
- * const mockGenerator: Generator<{ name: string }, void, unknown> = function* (faker) {
- * yield { name: faker.person.fullName() };
- * };
- * ```
+ * A constraint can be either a single rule or a logical group of rules.
+ * Matches the `Constraint` composite in the meta‑schema.
  */
-type Generator<T, TReturn, TNext> = Iterator<T, TReturn, TNext>;
-
+type Constraint$1 = ConstraintRule$1 | ConstraintGroup$1;
 /**
- * Defines the interface for a migration engine.
- * The migration engine is responsible for applying, rolling back, and tracking schema migrations.
+ * A reusable nested schema definition.
+ * Matches the `NestedSchema` schema in the meta‑schema.
+ *
+ * A nested schema can be either:
+ * - An **object schema** (with `fields`, and optionally `indexes`, `constraints`),
+ * - A **primitive type alias** (with `type` and optionally `default`, `values`, `schema`).
  */
-interface MigrationEngineInterface<T> {
-    /**
-     * Applies all pending migrations.
-     * @returns A promise that resolves when all migrations are applied.
-     */
-    applyMigrations(): Promise<void>;
-    /**
-     * Rolls back the most recently applied migration.
-     * @returns A promise that resolves when the migration is rolled back.
-     */
-    rollbackLastMigration(): Promise<void>;
-    /**
-     * Rolls back all migrations to a specific version.
-     * @param targetVersion The version to roll back to.
-     * @returns A promise that resolves when the rollback is complete.
-     */
-    rollbackToVersion(targetVersion: string): Promise<void>;
-    /**
-     * Returns the current schema version.
-     * @returns A promise that resolves to the current schema version.
-     */
-    getCurrentVersion(): Promise<string>;
-    /**
-     * Returns the list of applied migrations.
-     * @returns A promise that resolves to an array of applied migrations.
-     */
-    getAppliedMigrations(): Promise<Migration<T>[]>;
-    /**
-     * Returns the list of pending migrations.
-     * @returns A promise that resolves to an array of pending migrations.
-     */
-    getPendingMigrations(): Promise<Migration<T>[]>;
-    /**
-     * Validates the integrity of all migrations.
-     * @returns A promise that resolves to `true` if all migrations are valid, otherwise `false`.
-     */
-    validateMigrations(): Promise<boolean>;
-    /**
-     * Adds a new migration to the migration registry.
-     * @param migration The migration to add.
-     * @returns A promise that resolves when the migration is added.
-     */
-    addMigration(migration: Migration<T>): Promise<void>;
-    /**
-     * Removes a migration from the migration registry.
-     * @param migrationId The ID of the migration to remove.
-     * @returns A promise that resolves when the migration is removed.
-     */
-    removeMigration(migrationId: string): Promise<void>;
+type NestedSchemaDefinition$1<T = unknown> = NamedMetadata & {
+  indexes?: Record<string, IndexDefinition$1>;
+  constraints?: Record<string, Constraint$1>;
+} & ({
+  /**
+   * Object schema: defines the fields of the nested object.
+   * The `fields` record maps field IDs to `FieldDefinition`s.
+   */
+  fields: Record<string, FieldDefinition$1>;
+} | {
+  /**
+   * Primitive type alias.
+   * The `type` must not be `"object"``.
+   */
+  type: Exclude<FieldType$1, "object">;
+  default?: T;
+  values?: Array<string | number>;
+  schema?: SchemaReference$1 | SchemaReference$1[];
+});
+/**
+ * Defines a complete schema.
+ * Matches the top‑level `Schema` structure in the meta‑schema.
+ */
+interface SchemaDefinition$1 extends NamedMetadata {
+  version: string;
+  /** Map of field IDs to field definitions. */
+  fields: Record<string, FieldDefinition$1>;
+  /** Map of index IDs to index definitions. */
+  indexes?: Record<string, IndexDefinition$1>;
+  /** Map of constraint IDs to constraint definitions. */
+  constraints?: Record<string, Constraint$1>;
+  /** Map of nested schema IDs to nested schema definitions. */
+  schemas?: Record<string, NestedSchemaDefinition$1>;
+  /**
+   * Optional data migration definitions.
+   * @extension
+   */
+  migrations?: Array<Migration>;
+  /**
+   * UI/input hints.
+   * @extension
+   */
+  hints?: SchemaHint;
+  /**
+   * Mock data generator.
+   * @extension
+   */
+  mock?: <T>(
+  /** Lazy-typed: @faker-js/faker is a dev-only peer; kept out of bundle. */
+  faker: unknown) => Generator<T, void, unknown>;
+  /**
+   * Domain dependencies.
+   * @extension
+   */
+  dependencies?: string[];
+  /** @deprecated Use `schemas` instead. */
+  nestedSchemas?: Record<string, NestedSchemaDefinition$1>;
+  /** @deprecated Use top‑level `indexes`, `constraints`, `schemas` directly. */
+  registry?: {
+    schemas?: Record<string, NestedSchemaDefinition$1>;
+    constraints?: Record<string, Constraint$1>;
+    indexes?: Record<string, IndexDefinition$1>;
+  };
 }
-
-/**
- * @module JsonPatch
- * @description A library for creating and applying JSON Patch operations according to RFC 6902
- * @note This implementation includes an additional non-standard 'removeValue' operation that removes all instances of a value from an array.
- */
-
 /**
- * Represents a single JSON Patch operation as defined in RFC 6902
- */
-type PatchOperation = {
-    op: "add";
-    path: string;
-    value: any;
+ * Implements Partial Update Semantics:
+ * - `undefined`: No change to the property.
+ * - `null`: Clear/remove the property (if allowed by NonNullable).
+ * - `value`: Set the property to the provided value.
+ */
+type Patch<T, NonNullable extends keyof T = never> = { [K in keyof T]?: K extends NonNullable ? T[K] : T[K] | null; };
+type FieldPatch = Patch<FieldDefinition$1, "name" | "type">;
+type ConstraintPatch = Patch<Constraint$1, "name">;
+type IndexPatch = Patch<IndexDefinition$1, "name">;
+type SchemaChange = {
+  type: "modifyProperty";
+  id: keyof NamedMetadata | "version";
+  value: any;
 } | {
-    op: "remove";
-    path: string;
+  type: "addField";
+  id: string;
+  definition: FieldDefinition$1;
 } | {
-    op: "removeValue";
-    path: string;
-    value: any;
+  type: "removeField";
+  id: string;
 } | {
-    op: "replace";
-    path: string;
-    value: any;
+  type: "modifyField";
+  id: string;
+  changes: FieldPatch;
 } | {
-    op: "test";
-    path: string;
-    value: any;
+  type: "addIndex";
+  id: string;
+  definition: IndexDefinition$1;
 } | {
-    op: "copy";
-    from: string;
-    path: string;
+  type: "removeIndex";
+  id: string;
 } | {
-    op: "move";
-    from: string;
-    path: string;
-};
-/**
- * Error thrown when JSON Patch operations fail
- * @extends Error
- */
-declare class JsonPatchError extends Error {
-    operation?: PatchOperation | undefined;
-    constructor(message: string, operation?: PatchOperation | undefined);
-}
-/**
- * Converts a path string from dot notation to JSON Pointer notation
- * @param {string} path - Path in either dot notation (e.g., 'a.b.c') or slash notation (e.g., '/a/b/c')
- * @returns {string} Path in JSON Pointer notation
- * @throws {JsonPatchError} If the path is invalid
- */
-declare function normalizePath(path: string): string;
-/**
- * Applies a sequence of JSON Patch operations to an object
- * @template T
- * @param {T} target - Target object
- * @param {PatchOperation[]} patches - Array of patch operations
- * @returns {T} Modified object
- * @throws {JsonPatchError} If any operation fails
- */
-declare function applyPatch<T>(target: T, patches: PatchOperation[]): T;
-/**
- * Creates a sequence of JSON Patch operations that transform one object into another
- * @param {any} oldObj - Source object
- * @param {any} newObj - Target object
- * @returns {PatchOperation[]} Array of patch operations
- */
-declare function createPatch(oldObj: any, newObj: any): PatchOperation[];
-/**
- * Converts a schema change to JSON Patch operations
- * @param change The schema change to convert
- * @param schema The current schema definition
- * @returns Array of JSON Patch operations
- */
-declare function schemaChangeToPatch(change: SchemaChange<any>, schema: SchemaDefinition): PatchOperation[];
-
-/**
- * Schema event types.
- */
-type SchemaEventType = SchemaEvent["type"];
-/**
- * Represents a schema event.
- */
-type SchemaEvent = {
-    type: "migration:started";
-    description: string;
-    currentVersion: string;
-    changes: SchemaChange<any>[];
-    dryRun?: boolean;
+  type: "modifyIndex";
+  id: string;
+  changes: IndexPatch;
+} | {
+  type: "addConstraint";
+  id: string;
+  constraint: Constraint$1;
 } | {
-    type: "migration:committed";
-    currentVersion: string;
-    previousVersion: string;
-    changes: SchemaChange<any>[];
-    dryRun?: boolean;
+  type: "removeConstraint";
+  id: string;
 } | {
-    type: "migration:rollingBack";
-    currentVersion: string;
-    targetVersion: string;
-    changes: SchemaChange<any>[];
-    dryRun?: boolean;
+  type: "modifyConstraint";
+  id: string;
+  changes: ConstraintPatch;
 } | {
-    type: "migration:rolledBack";
-    currentVersion: string;
-    previousVersion: string;
-    changes: SchemaChange<any>[];
-    dryRun?: boolean;
+  type: "addSchema";
+  id: string;
+  definition: NestedSchemaDefinition$1;
 } | {
-    type: "migration:ended";
-    currentVersion: string;
-    status: "committed" | "rolledBack";
+  type: "removeSchema";
+  id: string;
+} | {
+  type: "modifySchema";
+  id: string;
+  changes: Array<SchemaChange>;
 };
-/**
- * Schema interface for managing schema evolution.
- * @template T The type of data associated with the schema.
- */
-interface Schema<T = any> {
-    /**
-     * Subscribes to schema events. The listener will be called for each event.
-     * @param event The type of schema event to subscribe to.
-     * @param listener The listener function that receives the schema event.
-     * @returns A function that, when called, unsubscribes the listener.
-     */
-    subscribe(event: SchemaEventType, listener: (event: SchemaEvent) => void): () => void;
-    /**
-     * Returns a read-only copy of the schema definition.
-     * @returns A read-only version of the current schema definition.
-     */
-    definition(): Readonly<SchemaDefinition>;
-    /**
-     * Returns a promise that resolves to a read-only copy of the migration history.
-     * @returns A promise that resolves to a read-only array of migrations.
-     */
-    migrations(): Promise<Readonly<Migration<any>[]>>;
-    /**
-     * Exports the schema state (definition and migrations) as a JSON string.
-     * @returns A JSON string representation of the schema state.
-     */
-    export(): string;
-    /**
-     * Imports the schema state (definition and migrations) from a JSON string.
-     * @param json The JSON string representing the schema state to import.
-     * @throws Error if the imported state is invalid.
-     */
-    import(json: string): void;
-    /**
-     * Creates a migration from a list of changes.
-     * @param description A description of the migration.
-     * @param changes A list of schema changes to apply.
-     * @param dryRun Indicates whether the migration should actually be executed
-     * @throws Error if the changes are not valid.
-     * @returns A promise that resolves when the migration is complete.
-     */
-    migrate(description: string, changes: SchemaChange<T>[], dryRun?: boolean): Promise<void>;
-    /**
-     * Rolls back a migration.
-     * @param version The version to rollback from. If not specified, rolls back the last migration.
-     * @throws Error if the rollback cannot be performed.
-     * @returns A promise that resolves when the rollback is complete.
-     */
-    rollback(version?: string): Promise<void>;
-    /**
-     * Creates a migration helper to assist in creating a migration.
-     * @param description A description of the migration.
-     * @returns A `SchemaMigrationHelper` instance to build the migration.
-     */
-    migrationHelper(description: string): SchemaMigrationHelper;
-}
-/**
- * Helper for building schema migrations.
- * @template T The type of data associated with the schema.
- */
-interface SchemaMigrationHelper {
-    /**
-     * Adds a new field to the schema.
-     * @param fieldName The name of the field to add.
-     * @param fieldDefinition The definition of the field to add.
-     */
-    addField(fieldName: string, fieldDefinition: FieldDefinition<any>): void;
-    /**
-     * Removes a field from the schema.  This marks the field as deprecated and scheduled for removal.
-     * @param fieldName The name of the field to deprecate.
-     */
-    removeField(fieldName: string): void;
-    /**
-     * Deprecates a field.
-     * @param {string} fieldName - The name of the field to deprecate.
-     */
-    deprecateField(fieldName: string): void;
-    /**
-     * Modifies an existing field in the schema.
-     * @param fieldName The name of the field to modify.
-     * @param changes The changes to apply to the field.
-     */
-    modifyField(fieldName: string, changes: Partial<FieldDefinition<any>>): void;
-    /**
-     * Adds a new index to the schema.
-     * @param indexDefinition The definition of the index to add.
-     */
-    addIndex(indexDefinition: IndexDefinition): void;
-    /**
-     * Removes an index from the schema.
-     * @param indexName The name of the index to remove.
-     */
-    removeIndex(indexName: string): void;
-    /**
-     * Modifies an existing index in the schema.
-     * @param indexName The name of the index to modify.
-     * @param changes The changes to apply to the index.
-     */
-    modifyIndex(indexName: string, changes: Partial<IndexDefinition>): void;
-    /**
-     * Adds a new constraint to the schema.
-     * @param constraint The constraint to add.
-     */
-    addConstraint(constraint: Constraint<any> | ConstraintGroup<any>): void;
-    /**
-     * Removes a constraint from the schema.
-     * @param constraintName The name of the constraint to remove.
-     */
-    removeConstraint(constraintName: string): void;
-    /**
-     * Modifies an existing constraint in the schema.
-     * @param constraintName The name of the constraint to modify.
-     * @param changes The changes to apply to the constraint.
-     */
-    modifyConstraint(constraintName: string, changes: Partial<Constraint<any>>): void;
-    /**
-     * Adds a new nested schema to the schema.
-     * @param {string} schemaId - The ID of the nested schema to add.
-     * @param {NestedSchemaDefinition} nestedDefinition - The definition of the nested schema to add.
-     */
-    addNestedSchema(schemaId: string, nestedDefinition: NestedSchemaDefinition<any>): void;
-    /**
-     * Removes a nested schema from the schema.
-     * @param {string} schemaId - The ID of the nested schema to remove.
-     */
-    removeNestedSchema(schemaId: string): void;
-    /**
-     * Modifies an existing nested schema in the schema.
-     * @param {string} schemaId - The ID of the nested schema to modify.
-     * @param {Partial<NestedSchemaDefinition>} changes - The changes to apply to the nested schema.
-     */
-    modifyNestedSchema(schemaId: string, changes: Partial<NestedSchemaDefinition<any>>): void;
-    /**
-     * Returns the list of changes made through this helper.
-     * @returns An array of schema changes.
-     */
-    changes(): {
-        migrate: SchemaChange<any>[];
-        rollback: SchemaChange<any>[];
-    };
-}
-
-/**
- * Defines the possible event types for persistence operations.
- */
-type PersistenceEventType = "create:start" | "create:success" | "create:failed" | "read:start" | "read:success" | "read:failed" | "migrate:start" | "migrate:success" | "migrate:failed" | "rollback:start" | "rollback:success" | "rollback:failed" | "update:start" | "update:success" | "update:failed" | "delete:start" | "delete:success" | "delete:failed" | "transaction:start" | "transaction:success" | "transaction:failed" | "telemetry" | "collection:create:start" | "collection:create:success" | "collection:create:failed" | "collection:delete:start" | "collection:delete:success" | "collection:delete:failed" | "subscription:register" | "subscription:unregister" | "trigger:register" | "trigger:unregister" | "trigger:execute" | "trigger:failed" | "task:register" | "task:unregister" | "task:start" | "task:success" | "task:failed" | "metadata:called";
-/**
- * Interface representing events emitted during persistence operations.
- */
-interface PersistenceEvent<DataType> {
-    /** The type of event (e.g., 'create:start', 'trigger:execute'). */
-    type: PersistenceEventType;
-    /** Timestamp when the event occurred. */
-    timestamp: number;
-    /** The operation being performed (e.g., 'create', 'trigger'). */
-    operation: string;
-    /** Name of the collection affected by the operation (if applicable). */
-    collection?: string;
-    /** Data passed to the operation (if applicable). */
-    input?: any;
-    /** Data returned by the operation (if applicable). */
-    output?: any;
-    /** Error object if the operation failed (if applicable). */
-    error?: Error;
-    /** Issues that caused the operation to fail (if applicable). */
-    issues?: Array<StandardSchemaV1.Issue>;
-    /** Query used in the operation (if applicable). */
-    query?: QueryDSL<DataType, any>;
-    /** Identifier for the transaction (if part of one). */
-    transactionId?: string;
-    /** Duration of the operation in milliseconds. */
-    duration?: number;
-    /** Additional context or metadata specific to the operation. */
-    context?: Record<string, any>;
-}
-/**
- * Describes a subscription configuration.
- */
-interface SubscriptionInfo {
-    /** The event subscribed to. */
-    event: PersistenceEventType;
-    /** Unique identifier for the callback. */
-    callbackId: string;
-    /** Optional short identifier (max 50 chars, unique within scope). */
-    label?: string;
-    /** Optional description of the subscription's purpose (max 500 chars). */
-    description?: string;
+type TransformFunction<Initial, Next> = (ctx: any, data: Initial) => Next | Promise<Next>;
+interface DataTransform<Initial, Next> {
+  forward: TransformFunction<Initial, Next>;
+  backward: TransformFunction<Next, Initial>;
 }
-/**
- * Describes a trigger configuration.
- */
-interface TriggerInfo<T, FunctionMap = Record<string, any>> {
-    /** The event(s) or pattern triggering the callback. */
-    event: PersistenceEventType | PersistenceEventType[] | `${string}:*`;
-    /** Optional condition for the trigger. */
-    condition?: QueryFilter<T, FunctionMap>;
-    /** Unique identifier for the callback. */
-    callbackId: string;
-    /** Whether the trigger executes synchronously. */
-    isSync: boolean;
-    /** Short identifier (max 50 chars, unique within scope). */
-    label: string;
-    /** Description of the trigger's purpose (max 500 chars). */
-    description: string;
+interface Migration<Initial = any, Next = any> {
+  id: string;
+  version: {
+    source: string;
+    target?: string;
+  };
+  changes: SchemaChange[];
+  description: string;
+  rollback?: SchemaChange[];
+  transform: string | DataTransform<Initial, Next>;
+  createdAt: string;
+  dependencies?: string[];
+  checksum: string;
 }
-/**
- * Describes a scheduled task configuration.
- */
-interface TaskInfo {
-    /** Unique identifier for the task. */
-    id: string;
-    /** Schedule for task execution. */
-    schedule: TaskSchedule;
-    /** Unique identifier for the callback. */
-    callbackId: string;
-    /** Whether the task executes synchronously. */
-    isSync: boolean;
-    /** Optional metadata for logging or telemetry. */
-    metadata?: Record<string, any>;
-    /** Short identifier (max 50 chars, unique within scope). */
-    label: string;
-    /** Description of the task's purpose (max 500 chars). */
-    description: string;
+//#endregion
+//#region src/validation/types/validator.d.ts
+/** A single validation failure produced by a node. */
+interface Issue {
+  /** Machine-readable error code (e.g. "TYPE_MISMATCH", "REQUIRED_FIELD_MISSING"). */
+  code: string;
+  /** Human-readable description. */
+  message: string;
+  /** Dot-separated path to the offending value (e.g. "user.address.street"). */
+  path: string;
 }
 /**
- * Filter criteria for metadata queries.
- */
-interface MetadataFilter {
-    /** Filter for subscriptions. */
-    subscriptions?: {
-        event?: PersistenceEventType | PersistenceEventType[];
-        label?: string;
-    };
-    /** Filter for triggers. */
-    triggers?: {
-        event?: PersistenceEventType | PersistenceEventType[] | `${string}:*`;
-        label?: string;
-    };
-    /** Filter for tasks. */
-    tasks?: {
-        id?: string;
-        metadata?: Record<string, any>;
-        label?: string;
-    };
-    /** Filter for schemas. */
-    schemas?: {
-        id?: string;
-    };
+ * Controls how strictly the validator interprets missing / unexpected fields.
+ *
+ * - `strict`        — full validation; required, unexpected, type, and constraint issues are all reported.
+ * - `partialStrict` — missing-required issues are suppressed; everything else is reported.
+ * - `loose`         — missing-required *and* unexpected-field issues are both suppressed.
+ */
+type ValidationMode = "strict" | "partialStrict" | "loose";
+interface ValidationConfig {
+  /** Maximum nesting depth before aborting recursive traversal. Default: 20. */
+  maxDepth: number;
+  /** Validation strictness mode. Default: "strict". */
+  mode: ValidationMode;
 }
-/**
- * Metadata for a single collection.
- */
-interface CollectionMetadata<T, FunctionMap = Record<string, any>> {
-    /** Collection identifier. */
-    id: string;
-    /** Active subscriptions for the collection. */
-    subscriptions: SubscriptionInfo[];
-    /** Active triggers for the collection. */
-    triggers: TriggerInfo<T, FunctionMap>[];
-    /** Scheduled tasks for the collection. */
-    tasks: TaskInfo[];
-    /** Number of records in the collection. */
-    recordCount: number;
-    /** Storage used by the collection in bytes. */
-    dataSizeBytes: number;
-    /** Schema definition for the collection. */
-    schema: SchemaDefinition;
-    /** Timestamp of the last operation on the collection. */
-    lastModified: number;
+declare function defaultValidationConfig(): ValidationConfig;
+/** Parameters passed to every predicate invocation. */
+interface PredicateParams {
+  /** The original top-level document (never changes across recursive calls). */
+  root: Record<string, unknown>;
+  /**
+   * The data being validated at the current scope.
+   * For global constraints this is the full root; for recursive/nested constraints
+   * this is the sub-document at the constraint's base path.
+   */
+  data: unknown;
+  /** Resolved field keys (relative to `data`) that the predicate should inspect. */
+  keys: string[];
+  /** Arbitrary predicate-specific parameters declared in the schema. */
+  parameters?: unknown;
 }
 /**
- * Metadata for Persistence or PersistenceCollection.
+ * A predicate function.
+ * Returns an array of Issues (empty = success).
+ * May be synchronous or asynchronous.
  */
-interface Metadata<T, FunctionMap = Record<string, any>> {
-    /** Active subscriptions. */
-    subscriptions: SubscriptionInfo[];
-    /** Active triggers. */
-    triggers: TriggerInfo<T, FunctionMap>[];
-    /** Scheduled tasks. */
-    tasks: TaskInfo[];
-    /** Number of collections (Persistence only). */
-    collectionCount?: number;
-    /** Total storage used by all collections in bytes (Persistence only). */
-    storageUsageBytes?: number;
-    /** Database connection status (Persistence only). */
-    connectionStatus?: "connected" | "disconnected" | "error";
-    /** Database connection error, if any (Persistence only). */
-    connectionError?: string | null;
-    /** Schema definitions for all collections, if requested (Persistence only). */
-    schemas?: SchemaDefinition[];
-    /** Per-collection metadata, if requested (Persistence only). */
-    collections?: CollectionMetadata<any, FunctionMap>[];
-    /** Number of records in the collection (PersistenceCollection only). */
-    recordCount?: number;
-    /** Storage used by the collection in bytes (PersistenceCollection only). */
-    dataSizeBytes?: number;
-    /** Schema definition for the collection (PersistenceCollection only). */
-    schema?: SchemaDefinition;
-    /** Timestamp of the last operation on the collection (PersistenceCollection only). */
-    lastModified?: number;
-}
+type PredicateFn = (params: PredicateParams) => Issue[] | Promise<Issue[]>;
+/** Map of predicate name → predicate function. */
+type PredicateMap = Record<string, PredicateFn>;
 /**
- * Interface for querying observability data.
+ * A leaf constraint: a named predicate with optional field paths and parameters.
+ * Mirrors Go's `ConstraintRule`.
  */
-interface ObservabilityInterface<T, FunctionMap = Record<string, any>> {
-    /**
-     * Returns metadata about active subscriptions, triggers, tasks, and system state.
-     * @param filter Optional filter to limit returned data (e.g., by event or label).
-     * @param includeCollections For Persistence, whether to include per-collection metadata.
-     * @param includeSchemas For Persistence, whether to include schema definitions.
-     * @param forceRefresh Whether to force real-time queries for storageUsageBytes and dataSizeBytes.
-     * @returns Metadata object containing observability data.
-     * @example
-     * // Collection metadata with label filter
-     * const metadata = collection.metadata({ triggers: { label: "user-*" } });
-     * console.log(metadata.triggers); // Triggers with label "user-*"
-     * console.log(metadata.dataSizeBytes); // Storage used
-     *
-     * // Persistence metadata
-     * const globalMetadata = persistence.metadata({ includeCollections: true });
-     * console.log(globalMetadata.storageUsageBytes); // Total storage
-     * console.log(globalMetadata.collections); // Per-collection metadata
-     */
-    metadata(filter?: MetadataFilter, includeCollections?: boolean, includeSchemas?: boolean, forceRefresh?: boolean): Metadata<T, FunctionMap>;
+interface ValidatorConstraintRule {
+  kind: "rule";
+  name: string;
+  description: string | undefined;
+  predicate: string;
+  parameters: unknown;
+  fields: string[];
 }
 /**
- * Interface for event handling and task scheduling.
+ * A logical group of constraints combined with a `LogicalOperator`.
+ * Mirrors Go's `ConstraintGroup`.
  */
-interface EventTaskInterface<T, FunctionMap = Record<string, any>> {
-    /**
-     * Subscribes to persistence events.
-     * @param event The event to subscribe to.
-     * @param callback The callback to handle the event.
-     * @param options Optional label and description for the subscription.
-     * @returns A function to unsubscribe from the event.
-     * @example
-     * const unsubscribe = persistence.subscribe("telemetry", (event) => {
-     *   console.log(event);
-     * }, { label: "telemetry-log", description: "Logs telemetry events" });
-     * unsubscribe();
-     */
-    subscribe(event: PersistenceEventType, callback: (payload: PersistenceEvent<T>) => void, options?: {
-        label?: string;
-        description?: string;
-    }): () => void;
-    /**
-     * Registers a trigger callback for specific events.
-     * @param config Configuration including event, callback, label, description, and options.
-     * @returns A function to unsubscribe the trigger.
-     * @example
-     * collection.trigger("create:success",
-     *   ({ collection, results }) => {
-     *     console.log(`Created: ${results.id}`);
-     *   },
-     *   {
-     *    label: "user-create-hook",
-     *    description: "Syncs new users with CRM",
-     *    sync: true
-     * });
-     */
-    trigger(event: PersistenceEventType | PersistenceEventType[] | `${string}:*`, callback: (context: TriggerContext<T, FunctionMap>) => void | Promise<void>, options: {
-        condition?: QueryFilter<T, FunctionMap>;
-        sync?: boolean;
-        label: string;
-        description: string;
-    }): () => void;
-    /**
-     * Schedules a task to run at specified times or intervals.
-     * @param config Configuration including ID, schedule, callback, label, description, and options.
-     * @returns A function to cancel the scheduled task.
-     * @example
-     * collection.schedule({
-     *   id: "cleanup-inactive",
-     *   label: "inactive-cleanup",
-     *   description: "Deletes inactive records hourly",
-     *   schedule: { cron: "0 * * * *" },
-     *   callback: ({ collection }) => {
-     *     collection.delete({ query: { filter: { status: { $eq: "inactive" } } } });
-     *   }
-     * });
-     */
-    schedule(config: {
-        id: string;
-        schedule: TaskSchedule;
-        callback: (context: TaskContext<T, FunctionMap>) => void | Promise<void>;
-        sync?: boolean;
-        metadata?: Record<string, any>;
-        label: string;
-        description: string;
-    }): () => void;
+interface ValidatorConstraintGroup {
+  kind: "group";
+  name: string;
+  description: string | undefined;
+  operator: string;
+  rules: ValidatorConstraint[];
 }
-/**
- * Interface defining persistence operations for data management.
- */
-interface Persistence<FunctionMap = Record<string, any>> extends ObservabilityInterface<any, FunctionMap>, EventTaskInterface<any, FunctionMap> {
-    /**
-     * Returns a list of all collection names.
-     * @returns A promise that resolves to an array of collection names.
-     */
-    collections(): Promise<Array<string>>;
-    /**
-     * Creates a new collection with the specified schema.
-     * @param schema The schema definition for the new collection.
-     * @returns A promise that resolves to the created PersistenceCollection.
-     */
-    create<T>(schema: SchemaDefinition): Promise<PersistenceCollection<T, FunctionMap>>;
-    /**
-     * Deletes the specified collection.
-     * @param id The ID of the collection to delete.
-     * @returns A promise that resolves indicating whether the collection was deleted.
-     */
-    delete(id: string): Promise<boolean>;
-    /**
-     * Retrieves the schema definition for the specified collection.
-     * @param id The ID of the collection.
-     * @returns A promise that resolves to the schema definition.
-     */
-    schema(id: string): Promise<SchemaDefinition>;
-    /**
-     * Returns a PersistenceCollection instance for interacting with a collection.
-     * @param id The ID of the collection.
-     * @returns The PersistenceCollection instance.
-     */
-    collection<T>(id: string): PersistenceCollection<T, FunctionMap>;
-    /**
-     * Executes a transaction with multiple operations.
-     * @param callback A function that receives a PersistenceTransaction object.
-     * @returns A promise that resolves to the transaction result.
-     */
-    transact<ReturnType>(callback: (tx: PersistenceTransaction<FunctionMap>) => Promise<ReturnType>): Promise<ReturnType>;
+/** A constraint is either a single rule or a logical group of rules. */
+type ValidatorConstraint = ValidatorConstraintRule | ValidatorConstraintGroup;
+/** Keyed map of constraint ID → ValidatorConstraint. */
+type SchemaConstraintMap = Record<string, ValidatorConstraint>;
+interface NodeResult {
+  issues: Issue[];
+  success: boolean;
+  skipped: boolean;
 }
-/**
- * Transaction interface, omitting subscribe, trigger, schedule, and transact methods.
- */
-type PersistenceTransaction<F> = Omit<Persistence<F>, "subscribe" | "trigger" | "schedule" | "transact">;
-/**
- * Interface for managing a single collection's data operations.
- */
-interface PersistenceCollection<T, FunctionMap = Record<string, any>> extends ObservabilityInterface<T, FunctionMap>, EventTaskInterface<T, FunctionMap> {
-    /**
-     * Creates a new record or multiple records in the collection.
-     * @param params The data to create.
-     * @returns A promise that resolves to the created record(s).
-     */
-    create(params: {
-        data: T | T[];
-    }): Promise<T | T[]>;
-    /**
-     * Retrieves one or more records from the collection.
-     * @param params The query defining the filter, sort, pagination, and projection.
-     * @returns A promise that resolves to the matching record or array of records.
-     */
-    read(params: {
-        query: QueryDSL<T, FunctionMap>;
-    }): Promise<T | Array<T>>;
-    /**
-     * Updates one or more records in the collection.
-     * @param params The updated data, patch, or query.
-     * @returns A promise that resolves to the updated records.
-     */
-    update(params: {
-        data?: Partial<T>;
-        patch?: PatchOperation | Array<PatchOperation>;
-        filter: QueryFilter<T, FunctionMap>;
-    }): Promise<Array<T>>;
-    /**
-     * Deletes one or more records from the collection.
-     * @param params The query defining which records to delete.
-     * @returns A promise that resolves to the number of deleted records.
-     */
-    delete(params: {
-        query: QueryFilter<T, FunctionMap>;
-    }): Promise<number>;
-    /**
-     * Validates an object against the collection's schema.
-     * @param data The object to validate.
-     * @returns Validation results.
-     */
-    validate(data: any): {
-        valid: boolean;
-        issues: ReadonlyArray<StandardSchemaV1.Issue> | null;
-    };
-    /**
-     * Rolls back the collection to a previous schema version.
-     * @param version The version to roll back to (optional).
-     * @param dryRun Whether to simulate the rollback.
-     * @returns A promise that resolves to the new schema and data preview, or undefined.
-     */
-    rollback(version?: string, dryRun?: boolean): Promise<{
-        schema: SchemaDefinition;
-        preview: ReadableStream<any>;
-    } | undefined>;
-    /**
-     * Applies a schema migration to the collection.
-     * @param description A description of the migration.
-     * @param cb A callback defining the transformation logic.
-     * @param dryRun Whether to simulate the migration.
-     * @returns A promise that resolves to the new schema and data preview, or undefined.
-     */
-    migrate(description: string, cb: (h: Omit<SchemaMigrationHelper, "changes">) => DataTransform<any, any> | undefined, dryRun?: boolean): Promise<{
-        schema: SchemaDefinition;
-        preview: ReadableStream<any>;
-    } | undefined>;
-}
-/**
- * Context for collection-specific triggers.
- */
-type CollectionTriggerContext<T, FunctionMap = Record<string, any>> = {
-    event: PersistenceEvent<T> & {
-        type: "create:start";
-        operation: "create";
-    };
-    persistence: Persistence<FunctionMap>;
-    collection: PersistenceCollection<T, FunctionMap>;
-    params: {
-        data: T | T[];
-    };
-    results: undefined;
-} | {
-    event: PersistenceEvent<T> & {
-        type: "create:success";
-        operation: "create";
-    };
-    persistence: Persistence<FunctionMap>;
-    collection: PersistenceCollection<T, FunctionMap>;
-    params: {
-        data: T | T[];
-    };
-    results: T | T[];
-} | {
-    event: PersistenceEvent<T> & {
-        type: "create:failed";
-        operation: "create";
-    };
-    persistence: Persistence<FunctionMap>;
-    collection: PersistenceCollection<T, FunctionMap>;
-    params: {
-        data: T | T[];
-    };
-    results: undefined;
-} | {
-    event: PersistenceEvent<T> & {
-        type: "read:start";
-        operation: "read";
-    };
-    persistence: Persistence<FunctionMap>;
-    collection: PersistenceCollection<T, FunctionMap>;
-    params: {
-        query: QueryDSL<T, FunctionMap>;
-    };
-    results: undefined;
-} | {
-    event: PersistenceEvent<T> & {
-        type: "read:success";
-        operation: "read";
-    };
-    persistence: Persistence<FunctionMap>;
-    collection: PersistenceCollection<T, FunctionMap>;
-    params: {
-        query: QueryDSL<T, FunctionMap>;
-    };
-    results: T | T[];
-} | {
-    event: PersistenceEvent<T> & {
-        type: "read:failed";
-        operation: "read";
-    };
-    persistence: Persistence<FunctionMap>;
-    collection: PersistenceCollection<T, FunctionMap>;
-    params: {
-        query: QueryDSL<T, FunctionMap>;
-    };
-    results: undefined;
-} | {
-    event: PersistenceEvent<T> & {
-        type: "update:start";
-        operation: "update";
-    };
-    persistence: Persistence<FunctionMap>;
-    collection: PersistenceCollection<T, FunctionMap>;
-    params: {
-        data?: Partial<T>;
-        patch?: PatchOperation | Array<PatchOperation>;
-        query: QueryFilter<T, FunctionMap>;
-    };
-    results: undefined;
-} | {
-    event: PersistenceEvent<T> & {
-        type: "update:success";
-        operation: "update";
-    };
-    persistence: Persistence<FunctionMap>;
-    collection: PersistenceCollection<T, FunctionMap>;
-    params: {
-        data?: Partial<T>;
-        patch?: PatchOperation | Array<PatchOperation>;
-        query: QueryFilter<T, FunctionMap>;
-    };
-    results: Array<T>;
-} | {
-    event: PersistenceEvent<T> & {
-        type: "update:failed";
-        operation: "update";
-    };
-    persistence: Persistence<FunctionMap>;
-    collection: PersistenceCollection<T, FunctionMap>;
-    params: {
-        data?: Partial<T>;
-        patch?: PatchOperation | Array<PatchOperation>;
-        query: QueryFilter<T, FunctionMap>;
-    };
-    results: undefined;
-} | {
-    event: PersistenceEvent<T> & {
-        type: "delete:start";
-        operation: "delete";
-    };
-    persistence: Persistence<FunctionMap>;
-    collection: PersistenceCollection<T, FunctionMap>;
-    params: {
-        query: QueryFilter<T, FunctionMap>;
-    };
-    results: undefined;
-} | {
-    event: PersistenceEvent<T> & {
-        type: "delete:success";
-        operation: "delete";
-    };
-    persistence: Persistence<FunctionMap>;
-    collection: PersistenceCollection<T, FunctionMap>;
-    params: {
-        query: QueryFilter<T, FunctionMap>;
-    };
-    results: number;
-} | {
-    event: PersistenceEvent<T> & {
-        type: "delete:failed";
-        operation: "delete";
-    };
-    persistence: Persistence<FunctionMap>;
-    collection: PersistenceCollection<T, FunctionMap>;
-    params: {
-        query: QueryFilter<T, FunctionMap>;
-    };
-    results: undefined;
-} | {
-    event: PersistenceEvent<T> & {
-        type: "migrate:start";
-        operation: "migrate";
-    };
-    persistence: Persistence<FunctionMap>;
-    collection: PersistenceCollection<T, FunctionMap>;
-    params: {
-        description: string;
-        dryRun?: boolean;
-    };
-    results: undefined;
-} | {
-    event: PersistenceEvent<T> & {
-        type: "migrate:success";
-        operation: "migrate";
-    };
-    persistence: Persistence<FunctionMap>;
-    collection: PersistenceCollection<T, FunctionMap>;
-    params: {
-        description: string;
-        dryRun?: boolean;
-    };
-    results: {
-        schema: SchemaDefinition;
-        preview: ReadableStream<any>;
-    } | undefined;
-} | {
-    event: PersistenceEvent<T> & {
-        type: "migrate:failed";
-        operation: "migrate";
-    };
-    persistence: Persistence<FunctionMap>;
-    collection: PersistenceCollection<T, FunctionMap>;
-    params: {
-        description: string;
-        dryRun?: boolean;
-    };
-    results: undefined;
-} | {
-    event: PersistenceEvent<T> & {
-        type: "rollback:start";
-        operation: "rollback";
-    };
-    persistence: Persistence<FunctionMap>;
-    collection: PersistenceCollection<T, FunctionMap>;
-    params: {
-        version?: string;
-        dryRun?: boolean;
-    };
-    results: undefined;
-} | {
-    event: PersistenceEvent<T> & {
-        type: "rollback:success";
-        operation: "rollback";
-    };
-    persistence: Persistence<FunctionMap>;
-    collection: PersistenceCollection<T, FunctionMap>;
-    params: {
-        version?: string;
-        dryRun?: boolean;
-    };
-    results: {
-        schema: SchemaDefinition;
-        preview: ReadableStream<any>;
-    } | undefined;
-} | {
-    event: PersistenceEvent<T> & {
-        type: "rollback:failed";
-        operation: "rollback";
-    };
-    persistence: Persistence<FunctionMap>;
-    collection: PersistenceCollection<T, FunctionMap>;
-    params: {
-        version?: string;
-        dryRun?: boolean;
-    };
-    results: undefined;
-};
-/**
- * Context for global triggers (Persistence-level, non-collection-specific).
- */
-type GlobalTriggerContext<T, FunctionMap = Record<string, any>> = {
-    event: PersistenceEvent<T> & {
-        type: "transaction:start" | "transaction:success" | "transaction:failed" | "collection:create:start" | "collection:create:success" | "collection:create:failed" | "collection:delete:start" | "collection:delete:success" | "collection:delete:failed" | "telemetry";
-        operation: "transaction" | "collection:create" | "collection:delete";
-    };
-    persistence: Persistence<FunctionMap>;
-    collection?: undefined;
-    params: any;
-    results: any;
-};
-/**
- * Union of trigger contexts.
- */
-type TriggerContext<T, FunctionMap = Record<string, any>> = CollectionTriggerContext<T, FunctionMap> | GlobalTriggerContext<T, FunctionMap>;
-/**
- * Defines a schedule for a task.
- */
-type TaskSchedule = {
-    cron: string;
-} | {
-    at: string;
-} | {
-    interval: number;
-};
-/**
- * Context provided to task callbacks.
- */
-type TaskContext<T, FunctionMap = Record<string, any>> = {
-    persistence: Persistence<FunctionMap>;
-    collection: PersistenceCollection<T, FunctionMap>;
-    taskId: string;
-    executionTime: number;
-    metadata?: Record<string, any>;
-    label: string;
-    description: string;
-} | {
-    persistence: Persistence<FunctionMap>;
-    collection?: undefined;
-    taskId: string;
-    executionTime: number;
-    metadata?: Record<string, any>;
-    label: string;
-    description: string;
-};
-
-type SchemaIndex = {
-    schema: string;
-    version: string;
-    history: Array<SchemaVersion>;
-    migrations: Record<string, MigrationMetadata>;
-};
-type SchemaVersion = {
-    version: string;
-    hash: string;
-    date: string;
-    description: string;
-    migrations?: string[];
-    predicates?: string[];
-    changelog: string[];
-};
-type MigrationMetadata = {
-    hash: string;
-    checksum: string;
-};
-type RegistryMetadata = {
-    schemas: Record<string, SchemaMetadata>;
-    created: string;
-    updated: string;
-};
-type SchemaMetadata = {
-    name: string;
-    version: string;
-    description: string;
-    created: string;
-    updated: string;
-};
-type RegistryLock = {
-    updated: string;
-    hashes: [filepath: string, filehash: string][];
-};
-interface SchemaRegistryInterface {
-    /** Initializes the repository **/
-    init(): Promise<void>;
-    /** Create a new schema version */
-    create(_: {
-        schema: SchemaDefinition;
-    }): Promise<void>;
-    /** Update an existing schema version */
-    update(_: {
-        schema: SchemaDefinition;
-    }): Promise<void>;
-    /** Delete a schema and its associated branch */
-    delete(_: {
-        name: string;
-    }): Promise<void>;
-    /** List all schemas with their latest version */
-    list(): Promise<{
-        name: string;
-        version: string;
-    }[]>;
-    /** Retrieve schema definition for a specific version (or latest if no version is provided) */
-    schema(_: {
-        name: string;
-        version?: string;
-        migrations?: boolean;
-    }): Promise<SchemaDefinition | null>;
-    /** Get schema statistics (returns the full SchemaIndex) */
-    stats(_: {
-        schema?: string;
-    }): Promise<SchemaIndex | RegistryMetadata>;
-    /** Regenerate index & lockfile, then push changes */
-    sync(): Promise<void>;
-    /** Retrieve all migrations for a specific schema version (or latest if no version is provided) */
-    migrations(_: {
-        name: string;
-        version?: string;
-    }): Promise<Array<Migration<any>>>;
-    /** Retrieve the full history of a schema */
-    history(_: {
-        name: string;
-    }): Promise<SchemaDefinition[]>;
+interface ValidationContext {
+  /** The original top-level document; never changes. */
+  originalRoot: Record<string, unknown>;
+  /** The current root being validated (may be a sub-document for recursive schemas). */
+  rootData: unknown;
+  /** Alias for rootData — kept for parity with Go. */
+  data: unknown;
+  /** The predicate function registry. */
+  functionMap: PredicateMap;
+  /** Maximum allowed nesting depth. */
+  maxDepth: number;
+  /** Validation strictness. */
+  mode: ValidationMode;
+  /**
+   * Per-node success state. Index = node ID, value = success (true) | failure (false) | absent (undefined).
+   * Used by the traversal loop to propagate skipping when a dependency failed.
+   */
+  visited: Map<number, boolean>;
+  /** Accumulated issues for this traversal. */
+  issues: Issue[];
 }
-
-/**
- * Interface for interacting with a remotely hosted repository (e.g., GitHub, GitLab).
- */
-interface RemoteRepository {
-    /**
-     * Creates a new repository on the remote service.
-     * @param options.name - The name of the repository.
-     * @param options.private - Whether the repository should be private (default: false).
-     * @returns A promise resolving to the repository's authenticated URL (e.g., "https://username:token@github.com/username/repo.git").
-     * @param options
-     */
-    create(options: {
-        name: string;
-        private?: boolean;
-    }): Promise<RemoteRepository>;
-    /**
-     * Checks if a repository exists on the remote service.
-     * @param options - Repository lookup details.
-     * @param options.name - The name of the repository.
-     * @returns A promise resolving to true if the repository exists, false otherwise.
-     */
-    exists({ name }: {
-        name: string;
-    }): Promise<boolean>;
-    /**
-     * Deletes a repository on the remote service.
-     */
-    remove(): Promise<void>;
-    /**
-     * Returns a properly formatted authenticated URL for a specific repository.
-     * @returns A string representing the auth-enabled URL (e.g., "https://username:token@github.com/username/repo.git").
-     */
-    authURL(): string;
-    /**
-     * Returns the plain URL to this repository.
-     * @returns A string representing the repository URL (e.g., "https://github.com/username/repo.git").
-     * @throws RemoteRepositoryError if no repository is set.
-     */
-    url(): string;
-    credentials(): {
-        username: string;
-        password: string;
-    };
+//#endregion
+//#region src/validation/nodes.d.ts
+interface ValidationNode {
+  execute(ctx: ValidationContext): Promise<NodeResult>;
+  getDependencies(): number[];
+  getID(): number;
+  getPath(): string;
+  getPathParts(): string[];
 }
-
-declare function createGitSchemaRegistry(rootDir?: string, options?: {
-    remote?: RemoteRepository;
-    mainBranch?: string;
-    createRemote?: boolean;
-    author?: {
-        name: string;
-        email: string;
-    };
-    proxy?: string;
-    cacheTtl?: number;
-}): Promise<SchemaRegistryInterface>;
-
-/**
- * Implementation of a schema registry using an in-memory LightningFS.
- * Combines refined filesystem management with original serialization for functions and mocks.
- */
-declare class SchemaRegistry implements SchemaRegistryInterface {
-    /** In-memory filesystem instance for storing registry data. */
-    fs: LightningFS;
-    /** Promise-based API for asynchronous filesystem operations. */
-    fsp: LightningFS.PromisifiedFS;
-    /** Root directory path in the filesystem (e.g., '/registry'). */
-    rootDir: string;
-    /**
-     * Constructs a new SchemaRegistryImpl instance.
-     * @param rootDir - The root directory for the registry (defaults to '/registry').
-     */
-    constructor(rootDir?: string);
-    /**
-     * Ensures the registry is initialized with base files if they don't exist.
-     * Implements refined conditional initialization for idempotency.
-     */
-    init(): Promise<void>;
-    /**
-     * Creates a new schema in the registry.
-     * @param params - Object containing the schema definition.
-     * @throws Error if schema name or version is missing, or if schema already exists.
-     */
-    create({ schema }: {
-        schema: SchemaDefinition;
-    }): Promise<void>;
-    /**
-     * Updates an existing schema in the registry.
-     * @param params - Object containing the updated schema definition.
-     * @throws Error if schema name or version is missing, or if schema doesn't exist.
-     */
-    update({ schema }: {
-        schema: SchemaDefinition;
-    }): Promise<void>;
-    /**
-     * Saves a schema (create or update) with serialization and metadata updates.
-     * @param schema - The schema definition to save.
-     * @param action - Whether this is a create or update operation.
-     * @private - Internal method to reduce duplication in create/update.
-     */
-    private saveSchema;
-    /**
-     * Deletes a schema and all its associated data from the registry.
-     * Implements refined full filesystem cleanup.
-     * @param params - Object containing the schema name to delete.
-     * @throws Error if schema doesn't exist.
-     */
-    delete({ name }: {
-        name: string;
-    }): Promise<void>;
-    /**
-     * Lists all schemas in the registry with their latest versions.
-     * @returns Array of schema names and versions.
-     */
-    list(): Promise<{
-        name: string;
-        version: string;
-    }[]>;
-    /**
-     * Retrieves a schema definition, optionally with a specific version and migrations.
-     * Incorporates original serialization for mocks.
-     * @param params - Object with schema name, optional version, and migrations flag.
-     * @returns Schema definition or null if not found.
-     */
-    schema({ name, version, migrations, }: {
-        name: string;
-        version?: string;
-        migrations?: boolean;
-    }): Promise<SchemaDefinition | null>;
-    /**
-     * Retrieves statistics for a specific schema or the entire registry.
-     * @param params - Optional schema name to get SchemaIndex instead of RegistryMetadata.
-     * @returns SchemaIndex or RegistryMetadata.
-     * @throws Error if specific schema stats requested but schema not found.
-     */
-    stats({ schema, }: {
-        schema?: string;
-    }): Promise<SchemaIndex | RegistryMetadata>;
-    /**
-     * Synchronizes the registry by updating the lockfile with current file hashes.
-     * Implements refined sync behavior.
-     */
-    sync(): Promise<void>;
-    /**
-     * Retrieves migrations for a schema up to a specified version.
-     * Incorporates original serialization for migration transforms.
-     * @param params - Object with schema name and optional version.
-     * @returns Array of migrations, sorted by version.
-     */
-    migrations({ name, version, }: {
-        name: string;
-        version?: string;
-    }): Promise<Array<Migration<any>>>;
-    /**
-     * Retrieves the version history of a schema.
-     * Incorporates original serialization for mocks and migrations.
-     * @param params - Object with schema name.
-     * @returns Array of schema definitions for each version.
-     */
-    history({ name }: {
-        name: string;
-    }): Promise<SchemaDefinition[]>;
-    /**
-     * Processes and stores migrations with serialization of transforms.
-     * Adopts original's approach to handling executable transforms.
-     * @param schemaDir - Directory path for the schema.
-     * @param schema - Schema definition containing migrations.
-     * @returns Array of migration metadata.
-     * @private
-     */
-    private processAndStoreMigrations;
-    /**
-     * Serializes a schema definition, handling mocks as per original.
-     * @param schema - Schema definition to serialize.
-     * @returns JSON string of serialized schema.
-     * @private
-     */
-    private serializeSchema;
-    /**
-     * Deserializes a schema content object, restoring mocks as per original.
-     * @param schemaContent - Raw schema content from JSON.
-     * @returns Deserialized schema definition.
-     * @private
-     */
-    private deserializeSchema;
-    /**
-     * Deserializes a migration content object, restoring transforms as per original.
-     * @param content - Raw migration content from JSON.
-     * @returns Deserialized migration object.
-     * @private
-     */
-    private deserializeMigration;
-    /**
-     * Writes the schema file to the filesystem.
-     * @param schemaDir - Directory path for the schema.
-     * @param content - Serialized schema content.
-     * @returns Path to the written schema file.
-     * @private
-     */
-    private writeSchemaFile;
-    /**
-     * Updates the schema index with new version history and migrations.
-     * @param schemaDir - Directory path for the schema.
-     * @param schema - Schema definition being saved.
-     * @param schemaHash - Hash of the schema content.
-     * @param migrations - Processed migration metadata.
-     * @param action - Whether this is a create or update operation.
-     * @private
-     */
-    private updateIndex;
-    /**
-     * Updates the registry metadata with schema information.
-     * @param schema - Schema definition being saved.
-     * @param action - Whether this is a create or update operation.
-     * @private
-     */
-    private updateRegistryMetadata;
-    /**
-     * Reads the registry metadata from the filesystem.
-     * @returns Parsed RegistryMetadata object.
-     * @private
-     */
-    private readRegistryMetadata;
-    /**
-     * Writes the registry metadata to the filesystem.
-     * @param metadata - RegistryMetadata object to write.
-     * @private
-     */
-    private writeRegistryMetadata;
-    /**
-     * Reads the schema index from the filesystem.
-     * @param name - Name of the schema.
-     * @returns Parsed SchemaIndex object.
-     * @throws Error if schema index not found.
-     * @private
-     */
-    private readSchemaIndex;
-    /**
-     * Checks if a file exists in the filesystem.
-     * @param path - Path to check.
-     * @returns True if file exists, false otherwise.
-     * @private
-     */
-    fileExists(path: string): Promise<boolean>;
-    /**
-     * Recursively removes a directory and its contents.
-     * @param path - Directory path to remove.
-     * @private
-     */
-    private rmdirRecursive;
-    /**
-     * Lists all files recursively in a directory.
-     * @param path - Directory path to scan.
-     * @returns Array of file paths.
-     * @private
-     */
-    private listFilesRecursive;
+//#endregion
+//#region src/validation/graph.d.ts
+declare class BuildContext {
+  /** Ref-count of schemas currently being built. */
+  private readonly buildingSchemas;
+  /** Cache of pre-built recursive graphs keyed by schemaID + constraint hash. */
+  private readonly recursiveGraphCache;
+  isRecursive(schemaID: string): boolean;
+  markBuilding(schemaID: string): void;
+  unmarkBuilding(schemaID: string): void;
+  makeGraphCacheKey(schemaID: string, constraints: SchemaConstraintMap): string;
+  getOrBuildRecursiveGraph(schemaID: string, schemaDef: NestedSchemaDefinition$1, instanceConstraints: SchemaConstraintMap, topLevelSchema: SchemaDefinition$1): Promise<ValidationGraph>;
 }
-
-/**
- * @fileoverview
- * Provides a MigrationEngine class that handles schema migrations,
- * including validation, checksum generation, and migration application.
- * @author Saidimu
- */
-
-/**
- * @class MigrationError
- * @extends Error
- * @param {string} message - The error message
- * @param {MigrationErrorCode} code - The error code
- * @param {string} [migrationId] - The ID of the migration that caused the error
- * @param {Error} [cause] - The underlying error that caused this error
- */
-declare class MigrationError extends Error {
-    readonly code: MigrationErrorCode;
-    readonly migrationId?: string | undefined;
-    readonly cause?: Error | undefined;
-    constructor(message: string, code: MigrationErrorCode, migrationId?: string | undefined, cause?: Error | undefined);
+/** Internal tracking node used only during graph construction. */
+interface TrackNode {
+  id: number;
+  deps: number[];
 }
-/**
- * @enum MigrationErrorCode
- * @description Error codes for migration-related errors
- */
-declare enum MigrationErrorCode {
-    INVALID_SCHEMA = "INVALID_SCHEMA",
-    INVALID_MIGRATION = "INVALID_MIGRATION",
-    CHECKSUM_MISMATCH = "CHECKSUM_MISMATCH",
-    TIMEOUT = "TIMEOUT",
-    MEMORY_LIMIT = "MEMORY_LIMIT",
-    CONCURRENT_OPERATION = "CONCURRENT_OPERATION",
-    TRANSFORM_ERROR = "TRANSFORM_ERROR",
-    VERSION_NOT_FOUND = "VERSION_NOT_FOUND",
-    CIRCULAR_DEPENDENCY = "CIRCULAR_DEPENDENCY",
-    STREAM_ERROR = "STREAM_ERROR",
-    ROLLBACK_ERROR = "ROLLBACK_ERROR",
-    MISSING_TRANSFORM = "MISSING_TRANSFORM"
+declare class ValidationGraph {
+  private nodes;
+  private dependencies;
+  private visitedState;
+  private executionOrder;
+  private nextNodeID;
+  /** Paths explicitly marked nullable:true (null is a legal value). */
+  readonly nullablePaths: Set<string>;
+  buildNodeID(): number;
+  addNode(node: ValidationNode): void;
+  private createUnexpectedFieldsNode;
+  private createRequiredFieldNode;
+  private createTypeCheckNode;
+  private createCompletionNode;
+  finalize(): void;
+  traverse(fmap: PredicateMap, document: Record<string, unknown>, mode: ValidationMode, maxDepth: number, originalRoot: Record<string, unknown>): Promise<Issue[]>;
+  /**
+   * Builds the validation graph from a SchemaDefinition.
+   * Returns the root TrackNodes (for wiring dependencies).
+   * Mirrors Go's `graph.buildFromSchema`.
+   */
+  buildFromSchema(schema: SchemaDefinition$1, basePath: string, baseParts: string[], addedConstraints: Map<string, boolean>, nsd: NestedSchemaDefinition$1 | null, schemaRefConstraints: SchemaConstraintMap, topLevelSchema: SchemaDefinition$1, buildCtx: BuildContext, skipUnexpectedCheck: boolean, skipUnexpectedForObjects: boolean): Promise<TrackNode[]>;
+  private buildFieldNodes;
+  private buildFieldTypeNodes;
+  private buildObjectFieldNodes;
+  /**
+   * Mirrors Go's `buildContainerNode`.
+   * Returns an ArrayValidationNode or RecordValidationNode depending on `itemKind`.
+   */
+  private buildContainerNode;
+  private buildEnumNode;
+  private buildUnionNode;
+  private buildCompositeNode;
+  private buildFromEffectiveConstraints;
+  private buildFromConstraintRuleWithScope;
+  /**
+   * Creates a standalone ValidationGraph for a single field, used by array /
+   * record / union / composite nodes.
+   * Mirrors Go's `graph.createSubGraph`.
+   */
+  createSubGraph(rootFieldName: string, rootFieldDef: FieldDefinition$1, basePath: string, originalTopLevelSchema: SchemaDefinition$1, buildCtx: BuildContext, skipUnexpectedCheck: boolean, skipUnexpectedForObjects: boolean): Promise<ValidationGraph>;
 }
-/**
- * @class MigrationEngine
- * @param {SchemaDefinition} currentSchema - The current schema definition
- * @param {Array<Migration<any>>} [migrations] - Optional array of migrations
- * @throws {MigrationError} If the initial schema or migrations are invalid
- */
-declare class MigrationEngine {
-    private currentSchema;
-    private history;
-    private migrations;
-    private isProcessing;
-    /**
-     * @constructor
-     * @param {SchemaDefinition} currentSchema - The current schema definition
-     * @param {Array<Migration<any>>} [migrations] - Optional array of migrations
-     */
-    constructor(currentSchema: SchemaDefinition, migrations?: Array<Migration<any>>, history?: Array<SchemaDefinition>);
-    /**
-     * Gets the current state of the migration helper
-     * @returns {Object} Current state containing schema, history, and migrations
-     * @example
-     * ```javascript
-     * const state = migrationEngine.data();
-     * // state contains currentSchema, history, and migrations
-     * ```
-     */
-    data(): {
-        schema: SchemaDefinition;
-        history: SchemaDefinition[];
-        migrations: Migration<any>[];
-    };
-    /**
-     * Generates a SHA-256 checksum for a migration
-     * @private
-     * @param {Omit<Migration<any>, "checksum">} migration - The migration object
-     * @returns {Promise<string>} The generated checksum
-     * @throws {MigrationError} If checksum generation fails
-     */
-    private generateChecksum;
-    /**
-     * Adds a new migration to the engine
-     * @async
-     * @param {Object} opts - Options for the new migration
-     * @param {SchemaChange<any>[]} opts.changes - Array of schema changes
-     * @param {string} opts.description - Description of the migration
-     * @param {SchemaChange<any>[]} [opts.rollback] - Optional rollback changes
-     * @param {DataTransform<any, any>} [opts.transform] - Optional data transform
-     * @throws {MigrationError} If adding the migration fails
-     */
-    add(opts: {
-        changes: SchemaChange<any>[];
-        description: string;
-        rollback?: SchemaChange<any>[];
-        transform?: string | DataTransform<any, any>;
-    }): Promise<void>;
-    /**
-     * Performs a dry run of the migration
-     * @async
-     * @param {ReadableStream<any>} input - Input data stream
-     * @param {"forward" | "backward"} direction - Direction of migration
-     * @param {version} version - Version to rollback to
-     * @returns {Promise<Object>} Object containing newSchema and dataPreview
-     * @throws {MigrationError} If dry run fails
-     */
-    dryRun(input: ReadableStream<any>, direction: "forward" | "backward", version?: string): Promise<{
-        newSchema: SchemaDefinition;
-        dataPreview: ReadableStream<any>;
-    }>;
-    /**
-     * Gets relevant migrations based on direction
-     * @private
-     * @param {"forward" | "backward"} direction - Direction of migration
-     * @returns {Array<Migration<any>>} Relevant migrations
-     */
-    private getRelevantMigrations;
-    /**
-     * Applies schema changes to a given schema
-     * @private
-     * @param {SchemaDefinition} schema - The schema to modify
-     * @param {SchemaChange<any>[]} changes - Array of schema changes
-     * @param {string} [migrationId] - ID of the migration
-     * @returns {SchemaDefinition} Modified schema
-     * @throws {MigrationError} If applying changes fails
-     */
-    private applySchemaChanges;
-    /**
-     * Prepares the list of pending migrations for application
-     * @async
-     * @returns {Promise<Array<Migration<any>>} List of pending migrations
-     * @throws {MigrationError} If preparation fails
-     */
-    prepareMigration(): Promise<Array<Migration<any>>>;
-    /**
-     * Applies pending migrations
-     * @async
-     * @param {ReadableStream<any>} input - Input data stream
-     * @returns {Promise<ReadableStream<any>>} Transformed data stream
-     * @throws {MigrationError} If migration fails
-     */
-    migrate(input: ReadableStream<any>): Promise<ReadableStream<any>>;
-    /**
-     * Validates migrations by checking their checksums
-     * @private
-     * @async
-     * @param {Array<Migration<any>>} migrations - Migrations to validate
-     * @throws {MigrationError} If validation fails
-     */
-    private validateMigrations;
-    /**
-     * Marks migrations as applied
-     * @private
-     * @param {Array<Migration<any>>} migrations - Migrations to mark as applied
-     */
-    private markMigrationsApplied;
-    /**
-     * Rolls back the last applied migration
-     * @async
-     * @param {ReadableStream<any>} input - Input data stream
-     * @returns {Promise<ReadableStream<any>>} Transformed data stream
-     */
-    rollback(input: ReadableStream<any>): Promise<ReadableStream<any>>;
-    /**
-     * Rolls back to a specific schema version
-     * @async
-     * @param {string} targetVersion - Target schema version
-     * @param {ReadableStream<any>} input - Input data stream
-     * @returns {Promise<ReadableStream<any>>} Transformed data stream
-     * @throws {Error} If target version is not found
-     */
-    rollbackToVersion(targetVersion: string, input: ReadableStream<any>): Promise<ReadableStream<any>>;
-    /**
-     * Processes a list of migrations on a data stream, applying transformations
-     * in the specified direction (forward or backward).
-     *
-     * @static
-     * @async
-     * @param {ReadableStream<any>} input - The input data stream to process
-     * @param {"forward" | "backward"} direction - Direction of migration (either "forward" or "backward")
-     * @param {Array<Migration<any>>} migrations - Array of Migration objects to process
-     * @returns {Promise<ReadableStream<any>>} Transformed data stream
-     * @throws {MigrationError} If any migration processing fails
-     */
-    static processMigrationList(input: ReadableStream<any>, direction: "forward" | "backward", migrations: Migration<any>[]): Promise<ReadableStream<any>>;
-    /**
-     * Resolves the transform function for a given migration in the specified direction.
-     *
-     * @private
-     * @async
-     * @param {Migration<any>} migration - The migration to resolve the transform for
-     * @param {"forward" | "backward"} direction - Direction of migration
-     * @returns {Promise<TransformFunction<any, any>>} Resolved transform function
-     * @throws {MigrationError} If transform resolution fails
-     */
-    private static resolveTransform;
-    /**
-     * Resolves a transform function from a remote URL.
-     *
-     * @private
-     * @async
-     * @param {string} url - URL of the transform module
-     * @param {"forward" | "backward"} direction - Direction of migration
-     * @returns {Promise<TransformFunction<any, any>>} Resolved transform function
-     * @throws {MigrationError} If resolution fails
-     */
-    private static resolveRemoteTransform;
-    /**
-     * Resolves a transform function from a local module path.
-     *
-     * @private
-     * @async
-     * @param {string} path - Local module path
-     * @param {"forward" | "backward"} direction - Direction of migration
-     * @returns {Promise<TransformFunction<any, any>>} Resolved transform function
-     * @throws {MigrationError} If resolution fails
-     */
-    private static resolveLocalTransform;
-    /**
-     * Transforms the schema either forward or backward
-     * @private
-     * @param {"forward" | "backward"} direction - Direction of transformation
-     * @throws {Error} If transformation fails
-     */
-    private transformSchema;
+//#endregion
+//#region src/validation/validator.d.ts
+declare class DocumentValidator {
+  private readonly fmap;
+  private readonly graph;
+  private readonly config;
+  protected constructor(graph: ValidationGraph, fmap: PredicateMap, config: ValidationConfig);
+  /**
+   * Full validation: reports missing required fields, unexpected fields,
+   * type mismatches, and constraint violations.
+   */
+  validate(document: Record<string, unknown>): Promise<Issue[]>;
+  /**
+   * Partial-strict validation: suppresses REQUIRED_FIELD_MISSING issues.
+   * Use when validating partial updates (e.g. PATCH payloads).
+   */
+  validatePartial(document: Record<string, unknown>): Promise<Issue[]>;
+  /**
+   * Loose validation: suppresses both REQUIRED_FIELD_MISSING and
+   * UNEXPECTED_FIELD issues.  Validates only present fields for type and
+   * constraints.
+   */
+  validateLoose(document: Record<string, unknown>): Promise<Issue[]>;
+  /**
+   * Builds a DocumentValidator from a SchemaDefinition.
+   *
+   * This compiles the schema into a validation DAG exactly once; subsequent
+   * calls to `validate()` / `validatePartial()` / `validateLoose()` traverse
+   * the pre-compiled graph and are fast.
+   *
+   * Throws if the schema contains structural errors that prevent graph construction
+   * (e.g. dangling schema references, composite parts with unsupported types).
+   */
+  static create(schema: SchemaDefinition$1, fmap: PredicateMap, config?: ValidationConfig): Promise<DocumentValidator>;
 }
-
-/**
- * Helper for building schema migrations with forward and rollback changes.
- * @template T The type of data associated with the schema.
- * @param {Readonly<SchemaDefinition>} schema - The original schema to base the migration on.
- * @returns {SchemaMigrationHelper} An object with methods to build migration changes and retrieve the changes.
- */
-declare const createSchemaMigrationHelper: <T>(schema: Readonly<SchemaDefinition>) => SchemaMigrationHelper;
-
-/**
- * Validates a migration object against the standard schema.
- * @template T The expected type of the migration data.
- * @param change The object to validate.
- * @returns A type guard indicating whether the object conforms to Migration<T>.
- * @throws {SchemaValidationError} If validation fails due to an unexpected error.
- */
-declare function validateMigration<T>(change: unknown): change is Migration<T>;
-/**
- * Validates a schema change object against the standard schema.
- * @template T The expected type of the schema change data.
- * @param change The object to validate.
- * @returns A type guard indicating whether the object conforms to SchemaChange<T>.
- * @throws {SchemaValidationError} If validation fails due to an unexpected error.
- */
-declare function validateSchemaChange<T>(change: unknown): change is SchemaChange<T>;
-/**
- * Validates a schema definition object against the standard schema.
- * @param schema The object to validate.
- * @returns A type guard indicating whether the object conforms to SchemaDefinition.
- * @throws {SchemaValidationError} If validation fails due to an unexpected error.
- */
-declare function validateSchemaDefinition(schema: unknown): schema is SchemaDefinition;
-/**
- * Alias for validateSchemaDefinition, provided for convenience.
- */
-declare const validate: typeof validateSchemaDefinition;
-
-/**
- * Represents a group of field definitions with optional metadata.
- */
-interface FieldGroup {
-    name: string;
-    label: string;
-    description?: string;
-    fields: FieldDefinition<any>[];
+//#endregion
+//#region src/validation/schema-validator.d.ts
+/**
+ * A dedicated validator for ensuring schema definitions themselves
+ * conform to the meta-schema rules.
+ */
+declare class SchemaValidator {
+  private static validator;
+  /**
+   * Validates a schema definition against the meta-schema rules.
+   */
+  static validate(schemaDef: SchemaDefinition$1): Promise<Issue[]>;
 }
-/**
- * Extracts all field definitions from a schema, organized into groups based on hint.input.group,
- * including those in nested schemas, with proper path prefixing to represent the field hierarchy.
- * The 'required' property of each field is adjusted to be true only if the field and all its parent
- * fields are required, ensuring alignment with validation behavior.
- *
- * @param schema - The schema definition to extract fields from
- * @returns Array of field groups, each containing grouped field definitions
- */
-declare function extractInputFieldGroups(schema: SchemaDefinition): FieldGroup[];
-/**
- * Generates a default data object from a schema definition, ensuring all fields have values.
- * Fields with explicit defaults use those values; otherwise, type-based defaults are applied.
- * An optional resolver can override type-based defaults for fields without explicit defaults.
- *
- * @param schema - The schema definition to generate defaults from
- * @param options - Optional configuration for custom defaults and discriminators
- * @returns A fully populated default object conforming to the schema’s structure
- */
-declare function schemaDefaults<T>(schema: SchemaDefinition, options?: {
-    resolver?: (field: FieldDefinition<any>) => any;
-    discriminator?: Record<string, any>;
-}): T;
-
-/**
- * Generates a SHA-256 hash of the input string.
- *
- * @param input - The string to hash.
- * @returns A promise that resolves to the hexadecimal hash string.
- */
-declare const generateSHA256Hash: (input: string) => Promise<string>;
-
-/**
- * Deeply merges a partial update into a target object
- * @param target The complete target object
- * @param update The partial update to apply
- * @returns Updated object of type T
- */
-declare function deepMerge<T extends object>(target: T, update: Partial<T>): T;
-
-/**
- * Converts a SchemaDefinition to TypeScript type definitions
- *
- * Analyzes a schema definition and generates TypeScript type declarations for the main schema,
- * nested schemas, and union types for enum fields and constraints. Uses field.name as-is for field names,
- * capitalized nestedSchema.name for type names, and handles required/optional fields, new types (enum,
- * record, union), discriminated unions with common fields, primitives, arrays, sets, references, and nested
- * structures with strict type safety. Introduces unique generics for each record field and adjusts object
- * fields referencing concrete schemas to use a string | NestedType union.
- *
- * @param schema - The schema definition to convert
- * @param includeComments - Whether to include JSDoc comments (default: true)
- * @param exportTypes - Whether to export the generated types (default: true)
- * @returns TypeScript type definitions as a string
- */
-declare function schemaToTypes(schema: SchemaDefinition, includeComments?: boolean, exportTypes?: boolean): string;
-
-/**
- * Serializes constraint parameters for error messages, handling special types like RegExp.
- *
- * @param params - The parameters to serialize.
- * @returns A string representation for error messages.
- */
-declare function serializeParams(params: any): string;
-/**
- * Creates a validator conforming to StandardSchemaV1 based on a schema definition.
- *
- * @template T - The type of the data object being validated.
- * @param schema - The schema definition.
- * @param constraintsMap - A map of predicate names to validation functions.
- * @returns A StandardSchemaV1 validator.
- */
-declare function createStandardSchemaValidator<T extends Record<string, any>>(schema: SchemaDefinition, constraintsMap: PredicateMap): StandardSchemaV1<T, T>;
-/**
- * Adapts a StandardSchemaV1 validator to React Hook Form's resolver interface.
- */
-declare function formResolver<TFieldValues extends FieldValues>(validator: ReturnType<typeof createStandardSchemaValidator>["~standard"]): (values: TFieldValues, context: unknown, options: ResolverOptions<TFieldValues>) => Promise<ResolverResult<TFieldValues>>;
-
-/**
- * Calculates the next version number based on schema changes.
- * @param currentVersion - Current semantic version string
- * @param changes - List of schema changes to apply
- * @param currentSchema - Current schema for context
- * @returns Next semantic version string
- * @throws {Error} If version format is invalid or changes are invalid
- */
-declare function calculateNextVersion(currentVersion: string, changes: SchemaChange<any>[], currentSchema?: SchemaDefinition): string;
-/**
- * compareSemanticVersions(a: string, b: string): number
- * Compares two semantic version strings.
- * @param {string} a - The first version string.
- * @param {string} b - The second version string.
- * @returns {number} - A negative number if `a` is smaller, a positive number if `b` is smaller, or 0 if they are equal.
- */
-declare function compareSemanticVersions(a: string, b: string): number;
-/**
- * Sorts an array of semantic version strings in ascending order.
- * @param {string[]} vars - The array of version strings to sort.
- * @returns {string[]} - The sorted array of version strings.
- */
-declare function sortSemanticVars(vars: string[]): string[];
-
-declare function docgen(schema: SchemaDefinition, options?: {
-    faker?: Faker;
-}): string;
-
-export { type ArrayHint, type BooleanHint, type CodeHint, type CollectionMetadata, type CollectionTriggerContext, type Constraint, type ConstraintGroup, type ConstraintParameters, type ConstraintsMap, type DataTransform, type DateHint, type EnumHint, type EventTaskInterface, type FieldDefinition, type FieldGroup, type FieldSchema, type FieldType, type FileHint, type FunctionMap, type GlobalTriggerContext, type GroupDefinition, type IndexDefinition, type IndexType, type InputHint, JsonPatchError, type Metadata, type MetadataFilter, type Migration, MigrationEngine, type MigrationEngineInterface, MigrationError, MigrationErrorCode, type MigrationMetadata, type NestedSchemaDefinition, type NumberHint, type ObjectHint, type ObservabilityInterface, type PartialIndexCondition, type PatchOperation, type Persistence, type PersistenceCollection, type PersistenceEvent, type PersistenceEventType, type PersistenceTransaction, type Predicate, type PredicateMap, type PredicateName, type PredicateParameters, type RegistryLock, type RegistryMetadata, type RemoteRepository, type Schema, type SchemaChange, type SchemaConstraint, type SchemaDefinition, type SchemaEvent, type SchemaEventType, type SchemaHint, type SchemaIndex, type SchemaMetadata, type SchemaMigrationHelper, SchemaRegistry, type SchemaRegistryInterface, type SchemaVersion, type SecretHint, type SetHint, type SubscriptionInfo, type TaskContext, type TaskInfo, type TaskSchedule, type TextHint, type TransformFunction, type TriggerContext, type TriggerInfo, applyPatch, calculateNextVersion, compareSemanticVersions, createGitSchemaRegistry, createPatch, createSchemaMigrationHelper, createStandardSchemaValidator, deepMerge, docgen, extractInputFieldGroups, formResolver, generateSHA256Hash, normalizePath, schemaChangeToPatch, schemaDefaults, schemaToTypes, serializeParams, sortSemanticVars, validate, validateMigration, validateSchemaChange, validateSchemaDefinition };
+//#endregion
+//#region src/validation/predicates.d.ts
+declare const metaSchemaPredicateMap: PredicateMap;
+//#endregion
+export { AnansiCodec, type AnansiCodecOptions, ComparisonOperator, Compiler, Constraint, ConstraintGroup, ConstraintMetadata, ConstraintRule, ConstraintUnion, container as DataTypes, type DecodeTransforms, DocumentValidator, type EncodeKind, type EncodeTransforms, FD_NO_CHILD, FLAG_COMPRESSED, FLAG_ENCRYPTED, FLAG_HASH_PRESENT, FieldDef, FieldDefinition, type FieldDescriptor, FieldType, IndexCondition, IndexConditionGroup, IndexConditionUnion, IndexDefinition, IndexOrder, IndexType, InlineTypeDescriptor, InlineTypeKind, type Issue, type LinkResult, type LinkedField, type LinkedSlot, Literal, LogicalOperatorEnum, MAX_SCHEMA_SLOTS, MULTI_STEP_BASE, type ManifestField, NestedSchemaDefinition, type PredicateMap, type ResolvedEnum, type ResolvedField, type ResolvedNested, SchemaDefinition, SchemaReference, SchemaReferenceArray, SchemaValidator, type Slot, String, Unknown, type ValidationConfig, addressForSteps, buildEnum, buildManifest, decodeAnansiBatch, decodeAnansiPacket, decodeBatch, decodeDocument, defaultValidationConfig, encodeAnansiBatchColumnar, encodeAnansiBatchRows, encodeAnansiPacket, encodeBatchColumnar, encodeBatchRows, encodeDocument, internalDP, link, makeDescriptor, metaSchemaPredicateMap, parseSchema, unpackDescriptor, userDataDP };