@asaidimu/anansi 1.1.0

package/index.d.ts

@@ -0,0 +1,1920 @@
+import { Faker } from '@faker-js/faker';
+import { QueryDSL, QueryFilter } from '@asaidimu/query';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { z } from 'zod';
+
+/**
+ * Schema-related interfaces
+ */
+
+/**
+ * Logical operators for constraints and partial indexes.
+ */
+type LogicalOperator = "and" | "or" | "not" | "nor" | "xor";
+/**
+ * Basic field types supported by the schema system.
+ */
+type FieldType = "string" | "number" | "boolean" | "array" | "object" | "dynamic";
+/**
+ * Index types for optimizing different query patterns.
+ */
+type IndexType = "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite";
+/**
+ * Defines a predicate function for data validation.
+ * @template T The type of the data object.
+ * @template K The type of the field being validated.
+ * @param {object} params - The parameters for the predicate.
+ * @param {T} params.data - The data object being validated.
+ * @param {keyof T} params.field - The field being validated.
+ * @param {ConstraintParameters<K>} params.arguments - The constraint parameters.
+ * @returns {boolean} True if the data is valid, false otherwise.
+ */
+type Predicate = <T, K extends FieldType = any>(params: {
+    data: T;
+    field?: keyof T;
+    arguments: PredicateParameters<K>;
+}) => boolean;
+/**
+ * A map of constraint names to predicate functions.
+ * @template T The type of the data object.
+ */
+type PredicateMap = Record<string, Predicate>;
+type FunctionMap = Record<string, Function>;
+/** @deprecated */
+type ConstraintsMap = Record<string, Predicate>;
+/**
+ * Supported constraint names.
+ * @template T The type of the constraints map.
+ */
+type PredicateName<T extends PredicateMap = any> = keyof T;
+/**
+ * Constraint parameters based on field type.
+ * @template T The field type.
+ */
+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" ? number | {
+    minItems: number;
+    maxItems: number;
+} : T extends "object" ? {
+    schema: Record<string, unknown>;
+} : never;
+/** @deprecated */
+type ConstraintParameters<T extends FieldType> = PredicateParameters<T>;
+/**
+ * Defines a constraint on a field.
+ * @template T The field type.
+ */
+type Constraint<T extends FieldType> = {
+    type?: "schema";
+    /** The predicate function for the constraint */
+    predicate: string;
+    /** The field the constraint applies to */
+    field?: keyof any;
+    /** The parameters for the constraint. */
+    parameters?: PredicateParameters<T>;
+    /** The name of the constraint. */
+    name: string;
+    /** A description of the constraint. */
+    description?: string;
+    /** A custom error message for the constraint. */
+    errorMessage?: string;
+};
+/**
+ * Group of constraint rules with a logical operator.
+ * @template T The field type.
+ */
+interface ConstraintGroup<T extends FieldType> {
+    /** The name of the constraint. */
+    name: string;
+    /** The logical operator for the group (AND or OR). */
+    operator: LogicalOperator;
+    /** The rules in the group, which can be constraints or other constraint groups. */
+    rules: Array<Constraint<T> | ConstraintGroup<T>>;
+}
+/**
+ * Definition of a field within the schema.
+ * @template T The type of the field.
+ */
+interface FieldDefinition<T> {
+    /** The type of the field. */
+    type: FieldType;
+    /** Whether the field is required. */
+    required?: boolean;
+    /** The constraints on the field. */
+    constraints?: Constraint<any>[];
+    /** The default value of the field. */
+    default?: T;
+    /** The type of items in an array field. */
+    itemsType?: FieldType;
+    /** The schema for nested objects. */
+    nestedSchema?: Record<string, FieldDefinition<any>>;
+    /** Whether the field is deprecated. */
+    deprecated?: boolean;
+    /** A reference to another schema and field. */
+    reference?: {
+        schema: string;
+        field: string;
+    };
+    /** A description of the field. */
+    description?: string;
+    /** Whether the field is unique. */
+    unique?: boolean;
+}
+/**
+ * Condition for partial indexes.
+ */
+interface PartialIndexCondition {
+    /** The logical operator for the condition. */
+    operator: LogicalOperator;
+    /** The field to which condition applies. */
+    field: string;
+    /** The value to compare against (optional). */
+    value?: any;
+    /** Nested conditions (optional). */
+    conditions?: PartialIndexCondition[];
+}
+/**
+ * Definition of an index.
+ */
+interface IndexDefinition {
+    /** The fields included in the index. */
+    fields: string[];
+    /** The type of the index. */
+    type: IndexType;
+    /** Whether the index is unique. */
+    unique?: boolean;
+    /** A partial index condition. */
+    partial?: PartialIndexCondition;
+    /** A description of the index. */
+    description?: string;
+    /** Sorting order for the index */
+    order?: "asc" | "desc";
+    /** A name for the index. */
+    name: string;
+}
+/**
+ * Schema constraint definition.
+ * @template T The field type.
+ */
+type SchemaConstraint<T extends FieldType> = Array<Constraint<T> | ConstraintGroup<T>>;
+/**
+ * Complete schema definition.
+ */
+interface SchemaDefinition {
+    /** The name of the schema. */
+    name: string;
+    /** The version of the schema. */
+    version: string;
+    /** A description of the schema. */
+    description?: string;
+    /** The field definitions in the schema. */
+    fields: Record<string, FieldDefinition<any>>;
+    /** The indexes defined for the schema. */
+    indexes?: IndexDefinition[];
+    /** The constraints defined for the schema. */
+    constraints?: SchemaConstraint<any>;
+    /** Metadata associated with the schema. */
+    metadata?: Record<string, any>;
+    /** Dependencies of the schema. */
+    dependencies?: string[];
+    /** Migrations associated with the schema. */
+    migrations?: Array<Migration<any>>;
+    /** A Mock associated with the schema. */
+    mock?: <T>(faker: Faker) => Generator<T, void, unknown>;
+}
+/**
+ * Defines a change that can be made to a schema.
+ * @template T The type of the field being changed.
+ */
+type SchemaChange<T> = {
+    type: "addField";
+    name: string;
+    definition: FieldDefinition<T>;
+} | {
+    type: "removeField";
+    name: string;
+} | {
+    type: "modifyField";
+    name: string;
+    changes: Partial<FieldDefinition<T>>;
+} | {
+    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";
+    name: string;
+};
+/**
+ * Defines a transform function for data migration.
+ * @template Initial The initial data type.
+ * @template Next The transformed data type.
+ * @param {Initial} data - The initial data.
+ * @returns {Next | Promise<Next>} The transformed data or a promise that resolves to the transformed data.
+ */
+type TransformFunction<Initial, Next> = (data: Initial) => Next | Promise<Next>;
+/**
+ * Represents a pair of transformations for data migration (forward and backward).
+ * @template Initial The initial data type.
+ * @template Next The transformed data type.
+ */
+interface DataTransform<Initial, Next> {
+    /** The forward transformation function. */
+    forward: TransformFunction<Initial, Next>;
+    /** The backward transformation function. */
+    backward: TransformFunction<Next, Initial>;
+}
+/**
+ * Defines a migration, which consists of a series of schema changes and data transforms.
+ * Each migration is a set of atomic changes that can be applied in a single operation.
+ * @template T The type of the data being migrated.
+ */
+interface Migration<T> {
+    /** A unique identifier for the migration. */
+    id: string;
+    /** the schema version for which this migration is applicable */
+    schemaVersion: string;
+    /** A list of schema changes to be applied in the migration. */
+    changes: SchemaChange<T>[];
+    /** A description of what the migration does. */
+    description: string;
+    /** The current status of the migration. */
+    status: "pending" | "applied" | "failed";
+    /** An optional list of schema changes to revert the migration. */
+    rollback?: SchemaChange<T>[];
+    /**
+     * A checksum/string/url representing the js file exporting
+     * the data transforms for this migration.
+     * Each transform file exports a `DataTransform` object.
+     */
+    transform: string | DataTransform<any, any>;
+    /** A timestamp for when the migration was created (in ISO 8601 format). */
+    createdAt: string;
+    /** @deprecated An optional list of migration IDs that must be applied before this one. */
+    dependencies?: string[];
+    /**
+     * A checksum to ensure the integrity of the migration.
+     * This is the hash of the stringified/minified version of this object,
+     * excluding the `checksum` field itself (to avoid circular dependencies).
+     */
+    checksum: string;
+}
+
+type schemaDefinition_Constraint<T extends FieldType> = Constraint<T>;
+type schemaDefinition_ConstraintGroup<T extends FieldType> = ConstraintGroup<T>;
+type schemaDefinition_ConstraintParameters<T extends FieldType> = ConstraintParameters<T>;
+type schemaDefinition_ConstraintsMap = ConstraintsMap;
+type schemaDefinition_DataTransform<Initial, Next> = DataTransform<Initial, Next>;
+type schemaDefinition_FieldDefinition<T> = FieldDefinition<T>;
+type schemaDefinition_FieldType = FieldType;
+type schemaDefinition_FunctionMap = FunctionMap;
+type schemaDefinition_IndexDefinition = IndexDefinition;
+type schemaDefinition_IndexType = IndexType;
+type schemaDefinition_LogicalOperator = LogicalOperator;
+type schemaDefinition_Migration<T> = Migration<T>;
+type schemaDefinition_PartialIndexCondition = PartialIndexCondition;
+type schemaDefinition_Predicate = Predicate;
+type schemaDefinition_PredicateMap = PredicateMap;
+type schemaDefinition_PredicateName<T extends PredicateMap = any> = PredicateName<T>;
+type schemaDefinition_PredicateParameters<T extends FieldType> = PredicateParameters<T>;
+type schemaDefinition_SchemaChange<T> = SchemaChange<T>;
+type schemaDefinition_SchemaConstraint<T extends FieldType> = SchemaConstraint<T>;
+type schemaDefinition_SchemaDefinition = SchemaDefinition;
+type schemaDefinition_TransformFunction<Initial, Next> = TransformFunction<Initial, Next>;
+declare namespace schemaDefinition {
+  export type { schemaDefinition_Constraint as Constraint, schemaDefinition_ConstraintGroup as ConstraintGroup, schemaDefinition_ConstraintParameters as ConstraintParameters, schemaDefinition_ConstraintsMap as ConstraintsMap, schemaDefinition_DataTransform as DataTransform, schemaDefinition_FieldDefinition as FieldDefinition, schemaDefinition_FieldType as FieldType, schemaDefinition_FunctionMap as FunctionMap, schemaDefinition_IndexDefinition as IndexDefinition, schemaDefinition_IndexType as IndexType, schemaDefinition_LogicalOperator as LogicalOperator, schemaDefinition_Migration as Migration, schemaDefinition_PartialIndexCondition as PartialIndexCondition, schemaDefinition_Predicate as Predicate, schemaDefinition_PredicateMap as PredicateMap, schemaDefinition_PredicateName as PredicateName, schemaDefinition_PredicateParameters as PredicateParameters, schemaDefinition_SchemaChange as SchemaChange, schemaDefinition_SchemaConstraint as SchemaConstraint, schemaDefinition_SchemaDefinition as SchemaDefinition, schemaDefinition_TransformFunction as TransformFunction };
+}
+
+/**
+ * Defines the interface for a migration engine.
+ * The migration engine is responsible for applying, rolling back, and tracking schema migrations.
+ */
+interface MigrationEngine$1<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>;
+}
+
+declare namespace migrations {
+  export type { MigrationEngine$1 as MigrationEngine };
+}
+
+/**
+ * @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;
+} | {
+    op: "remove";
+    path: string;
+} | {
+    op: "removeValue";
+    path: string;
+    value: any;
+} | {
+    op: "replace";
+    path: string;
+    value: any;
+} | {
+    op: "test";
+    path: string;
+    value: any;
+} | {
+    op: "copy";
+    from: string;
+    path: 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[];
+
+type patch_JsonPatchError = JsonPatchError;
+declare const patch_JsonPatchError: typeof JsonPatchError;
+type patch_PatchOperation = PatchOperation;
+declare const patch_applyPatch: typeof applyPatch;
+declare const patch_createPatch: typeof createPatch;
+declare const patch_normalizePath: typeof normalizePath;
+declare const patch_schemaChangeToPatch: typeof schemaChangeToPatch;
+declare namespace patch {
+  export { patch_JsonPatchError as JsonPatchError, type patch_PatchOperation as PatchOperation, patch_applyPatch as applyPatch, patch_createPatch as createPatch, patch_normalizePath as normalizePath, patch_schemaChangeToPatch as schemaChangeToPatch };
+}
+
+/**
+ * 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;
+    /**
+     * Returns the list of changes made through this helper.
+     * @returns An array of schema changes.
+     */
+    changes(): {
+        migrate: SchemaChange<any>[];
+        rollback: SchemaChange<any>[];
+    };
+}
+
+/**
+ * Interface defining persistence operations for data management.
+ * Provides methods for CRUD operations, transactions, validation, and event subscription.
+ *
+ * @generic DataType - The type of data being persisted.
+ * @generic FunctionMap - A map of functions used in the persistence operations (default: Record<string, any>).
+ */
+interface Persistence<FunctionMap> {
+    /**
+     * Returns a list of all collections
+     * @returns A promise that resolves to a list 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 when the collection is created.
+     */
+    createCollection<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 when the collection is deleted.
+     */
+    deleteCollection(id: string): Promise<void>;
+    /**
+     * Retrieves the schema definition for the specified collection.
+     * @param id - The ID of the collection.
+     * @returns A promise that resolves to the schema definition of the collection.
+     */
+    schema(id: string): Promise<SchemaDefinition>;
+    /**
+     * Returns an object that can be used to interact with a collection of data
+     *
+     */
+    collection<T>(id: string): PersistenceCollection<T, FunctionMap>;
+    /**
+     * Subscribe to persistence events
+     * @param event - The event to subscribe to
+     * @param callback - A callback to handle the event
+     * @returns A callback that can be used to unsubscribe from the event
+     */
+    subscribe(event: PersistenceEventType, callback: (payload: PersistenceEvent<any>) => void): () => void;
+    /**
+     * Executes a transaction with multiple operations.
+     * @param callback A function that receives a PersistenceTransaction object to perform multiple operations.
+     * @param callback.tx The PersistenceTransaction object used to perform transactional operations.
+     * @returns A promise that resolves to the result of the transaction.
+     */
+    transact<ReturnType>(callback: (tx: PersistenceTransaction<FunctionMap>) => Promise<ReturnType>): Promise<ReturnType>;
+}
+type PersistenceTransaction<F> = Omit<Persistence<F>, "subscribe" | "transact">;
+interface PersistenceCollection<T, FunctionMap> {
+    /**
+     * Creates a new record or multiple records in the specified collection.
+     * @param params An object containing the data to create and the collection name.
+     * @param params.data The data to be inserted; can be a single record or an array of records.
+     * @param params.collection The name of the collection to create records in.
+     * @returns A promise that resolves to the created record(s) with their generated IDs.
+     */
+    create(params: {
+        data: T | T[];
+    }): Promise<T | T[]>;
+    /**
+     * Retrieves one or more records from the specified collection.
+     * @param params An object containing the query and collection name.
+     * @param params.query The query defining the filter, sort, pagination, and projection options.
+     * @returns A promise that resolves to a single record or an array of matching records.
+     */
+    read(params: {
+        query: QueryDSL<T, FunctionMap>;
+    }): Promise<T | T[]>;
+    /**
+     * Updates one or more records in the specified collection.
+     * @param params An object containing the updated data, query, and collection name.
+     * @param params.data The updated data to be applied; can be a single partial record or an array of partial records.
+     * @param params.query The query defining which records to update.
+     * @returns A promise that resolves to the updated records.
+     */
+    update(params: {
+        data?: Partial<T>;
+        patch?: PatchOperation | Array<PatchOperation>;
+        query: QueryFilter<T, any>;
+    }): Promise<Array<T>>;
+    /**
+     * Deletes one or more records from the specified collection.
+     * @param params An object containing either the query or records to delete, and the collection name.
+     * @param params.query The query defining which records to delete.
+     * @param params.records An array of records to delete.
+     * @returns A promise that resolves to the number of deleted records or the deleted records themselves.
+     */
+    delete(params: {
+        query: QueryFilter<T, any>;
+    }): Promise<number>;
+    /**
+     * Validates an object against a schema.
+     * @param params An object containing the data, and collection name.
+     * @param params.data The object to validate.
+     * @returns An object containing validation results.
+     */
+    validate(data: any): {
+        valid: boolean;
+        issues: ReadonlyArray<StandardSchemaV1.Issue> | null;
+    };
+    /**
+     * Subscribe to persistence events
+     * @param event - The event to subscribe to
+     * @param callback - A callback to handle the event
+     * @returns A callback that can be used to unsubscribe from the event
+     */
+    subscribe(event: PersistenceEventType, callback: (payload: PersistenceEvent<T>) => void): () => void;
+    rollback(version?: string, dryRun?: boolean): Promise<{
+        newSchema: SchemaDefinition;
+        dataPreview: ReadableStream<any>;
+    } | undefined>;
+    migrate(description: string, cb: (h: Omit<SchemaMigrationHelper, "changes">) => DataTransform<any, any> | undefined, dryRun?: boolean): Promise<{
+        newSchema: SchemaDefinition;
+        dataPreview: ReadableStream<any>;
+    } | undefined>;
+}
+/**
+ * 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" | "read: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:update:start" | "collection:update:success" | "collection:update:failed" | "collection:delete:start" | "collection:delete:success" | "collection:delete:failed";
+/**
+ * Interface representing events emitted during persistence operations
+ */
+interface PersistenceEvent<DataType> {
+    /**
+     * The type of event (e.g., 'create:start', 'read:success')
+     */
+    type: PersistenceEventType;
+    /**
+     * Timestamp when the event occurred
+     */
+    timestamp: number;
+    /**
+     * The operation being performed (e.g., 'create', 'read')
+     */
+    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.
+     * Useful for performance monitoring.
+     */
+    duration?: number;
+    /**
+     * Additional context or metadata specific to the operation.
+     * This field can be used to include extra debugging or contextual data.
+     */
+    context?: Record<string, any>;
+}
+
+type persistence_Persistence<FunctionMap> = Persistence<FunctionMap>;
+type persistence_PersistenceCollection<T, FunctionMap> = PersistenceCollection<T, FunctionMap>;
+type persistence_PersistenceEvent<DataType> = PersistenceEvent<DataType>;
+type persistence_PersistenceEventType = PersistenceEventType;
+type persistence_PersistenceTransaction<F> = PersistenceTransaction<F>;
+declare namespace persistence {
+  export type { persistence_Persistence as Persistence, persistence_PersistenceCollection as PersistenceCollection, persistence_PersistenceEvent as PersistenceEvent, persistence_PersistenceEventType as PersistenceEventType, persistence_PersistenceTransaction as PersistenceTransaction };
+}
+
+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 SchemaRegistry {
+    /** Initialize a new registry */
+    init(): Promise<void>;
+    /** Clone an existing registry from a remote source */
+    clone(): 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 predicate names required by a specific schema version (or latest if no version is provided) */
+    predicates(name: string, version?: string): Promise<string[]>;
+    /** 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[]>;
+}
+
+type registry_MigrationMetadata = MigrationMetadata;
+type registry_RegistryLock = RegistryLock;
+type registry_RegistryMetadata = RegistryMetadata;
+type registry_SchemaIndex = SchemaIndex;
+type registry_SchemaMetadata = SchemaMetadata;
+type registry_SchemaRegistry = SchemaRegistry;
+type registry_SchemaVersion = SchemaVersion;
+declare namespace registry {
+  export type { registry_MigrationMetadata as MigrationMetadata, registry_RegistryLock as RegistryLock, registry_RegistryMetadata as RegistryMetadata, registry_SchemaIndex as SchemaIndex, registry_SchemaMetadata as SchemaMetadata, registry_SchemaRegistry as SchemaRegistry, registry_SchemaVersion as SchemaVersion };
+}
+
+/**
+ * Creates an ephemeral persistence instance with in-memory storage.
+ * @template {PredicateMap} Predicates
+ * @template FunctionMap
+ * @param {FunctionMap} functionMap - Map of function names to their implementations
+ * @param {Predicates} predicateMap - Map of predicate names to their implementations
+ * @returns {Persistence<FunctionMap>} A persistence instance
+ */
+declare function createEphemeralPersistence<Predicates extends PredicateMap, FunctionMap>(functionMap: FunctionMap, predicateMap: Predicates): Persistence<FunctionMap>;
+
+declare namespace index$3 {
+  export { createEphemeralPersistence as default };
+}
+
+/**
+ * Creates and returns a new SchemaRegistry instance.
+ * @returns {Promise<SchemaRegistry>} A promise that resolves to the SchemaRegistry instance.
+ */
+declare function createRegistry(credentials: {
+    username: string;
+    password: string;
+    repository: string;
+}, dir?: string, proxy?: string): Promise<SchemaRegistry>;
+
+declare namespace index$2 {
+  export { createRegistry as default };
+}
+
+/**
+ * @fileoverview Provides a MigrationEngine class that handles schema migrations,
+ * including validation, checksum generation, and migration application.
+ * @author Your Name
+ */
+
+/**
+ * @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);
+}
+/**
+ * @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"
+}
+/**
+ * @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;
+}
+
+type index$1_MigrationError = MigrationError;
+declare const index$1_MigrationError: typeof MigrationError;
+type index$1_MigrationErrorCode = MigrationErrorCode;
+declare const index$1_MigrationErrorCode: typeof MigrationErrorCode;
+declare namespace index$1 {
+  export { index$1_MigrationError as MigrationError, index$1_MigrationErrorCode as MigrationErrorCode, MigrationEngine as default };
+}
+
+/**
+ * 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 {Object} An object with methods to build migration changes and retrieve the changes.
+ */
+declare const createSchemaMigrationHelper: <T>(schema: Readonly<SchemaDefinition>) => SchemaMigrationHelper;
+
+declare const MigrationSchema: z.ZodObject<{
+    id: z.ZodString;
+    schemaVersion: z.ZodString;
+    changes: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"addField">;
+        name: z.ZodString;
+        definition: any;
+    }, "strip", z.ZodTypeAny, {
+        type: "addField";
+        name: string;
+        definition?: any;
+    }, {
+        type: "addField";
+        name: string;
+        definition?: any;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"removeField">;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "removeField";
+        name: string;
+    }, {
+        type: "removeField";
+        name: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"modifyField">;
+        name: z.ZodString;
+        changes: any;
+    }, "strip", z.ZodTypeAny, {
+        type: "modifyField";
+        name: string;
+        changes?: any;
+    }, {
+        type: "modifyField";
+        name: string;
+        changes?: any;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"addIndex">;
+        definition: z.ZodObject<{
+            fields: z.ZodArray<z.ZodString, "many">;
+            type: z.ZodEnum<["normal", "unique", "btree", "hash", "spatial", "fulltext", "gi", "expression", "composite"]>;
+            unique: z.ZodOptional<z.ZodBoolean>;
+            partial: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
+            description: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+            name: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite";
+            fields: string[];
+            unique?: boolean | undefined;
+            description?: string | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        }, {
+            type: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite";
+            fields: string[];
+            unique?: boolean | undefined;
+            description?: string | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        type: "addIndex";
+        definition: {
+            type: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite";
+            fields: string[];
+            unique?: boolean | undefined;
+            description?: string | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        };
+    }, {
+        type: "addIndex";
+        definition: {
+            type: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite";
+            fields: string[];
+            unique?: boolean | undefined;
+            description?: string | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        };
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"removeIndex">;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "removeIndex";
+        name: string;
+    }, {
+        type: "removeIndex";
+        name: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"modifyIndex">;
+        name: z.ZodString;
+        changes: z.ZodObject<{
+            fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            type: z.ZodOptional<z.ZodEnum<["normal", "unique", "btree", "hash", "spatial", "fulltext", "gi", "expression", "composite"]>>;
+            unique: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+            partial: z.ZodOptional<z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>>;
+            description: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            order: z.ZodOptional<z.ZodOptional<z.ZodEnum<["asc", "desc"]>>>;
+            name: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            unique?: boolean | undefined;
+            type?: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite" | undefined;
+            description?: string | undefined;
+            fields?: string[] | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        }, {
+            unique?: boolean | undefined;
+            type?: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite" | undefined;
+            description?: string | undefined;
+            fields?: string[] | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        type: "modifyIndex";
+        name: string;
+        changes: {
+            unique?: boolean | undefined;
+            type?: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite" | undefined;
+            description?: string | undefined;
+            fields?: string[] | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        };
+    }, {
+        type: "modifyIndex";
+        name: string;
+        changes: {
+            unique?: boolean | undefined;
+            type?: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite" | undefined;
+            description?: string | undefined;
+            fields?: string[] | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        };
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"addConstraint">;
+        constraint: z.ZodUnion<[z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            predicate: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodOptional<z.ZodType<(params: any) => boolean, z.ZodTypeDef, (params: any) => boolean>>;
+            description: z.ZodOptional<z.ZodString>;
+            field: z.ZodOptional<z.ZodString>;
+            errorMessage: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            type?: string | undefined;
+            description?: string | undefined;
+            predicate?: string | undefined;
+            field?: string | undefined;
+            parameters?: ((params: any) => boolean) | undefined;
+            errorMessage?: string | undefined;
+        }, {
+            name: string;
+            type?: string | undefined;
+            description?: string | undefined;
+            predicate?: string | undefined;
+            field?: string | undefined;
+            parameters?: ((params: any) => boolean) | undefined;
+            errorMessage?: string | undefined;
+        }>, any]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "addConstraint";
+        constraint?: any;
+    }, {
+        type: "addConstraint";
+        constraint?: any;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"removeConstraint">;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "removeConstraint";
+        name: string;
+    }, {
+        type: "removeConstraint";
+        name: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"modifyConstraint">;
+        name: z.ZodString;
+        changes: z.ZodObject<{
+            type: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            name: z.ZodOptional<z.ZodString>;
+            predicate: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            parameters: z.ZodOptional<z.ZodOptional<z.ZodType<(params: any) => boolean, z.ZodTypeDef, (params: any) => boolean>>>;
+            description: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            field: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            errorMessage: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            type?: string | undefined;
+            description?: string | undefined;
+            name?: string | undefined;
+            predicate?: string | undefined;
+            field?: string | undefined;
+            parameters?: ((params: any) => boolean) | undefined;
+            errorMessage?: string | undefined;
+        }, {
+            type?: string | undefined;
+            description?: string | undefined;
+            name?: string | undefined;
+            predicate?: string | undefined;
+            field?: string | undefined;
+            parameters?: ((params: any) => boolean) | undefined;
+            errorMessage?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        type: "modifyConstraint";
+        name: string;
+        changes: {
+            type?: string | undefined;
+            description?: string | undefined;
+            name?: string | undefined;
+            predicate?: string | undefined;
+            field?: string | undefined;
+            parameters?: ((params: any) => boolean) | undefined;
+            errorMessage?: string | undefined;
+        };
+    }, {
+        type: "modifyConstraint";
+        name: string;
+        changes: {
+            type?: string | undefined;
+            description?: string | undefined;
+            name?: string | undefined;
+            predicate?: string | undefined;
+            field?: string | undefined;
+            parameters?: ((params: any) => boolean) | undefined;
+            errorMessage?: string | undefined;
+        };
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"deprecateField">;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "deprecateField";
+        name: string;
+    }, {
+        type: "deprecateField";
+        name: string;
+    }>]>, "many">;
+    description: z.ZodString;
+    status: z.ZodEnum<["pending", "applied", "failed"]>;
+    rollback: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"addField">;
+        name: z.ZodString;
+        definition: any;
+    }, "strip", z.ZodTypeAny, {
+        type: "addField";
+        name: string;
+        definition?: any;
+    }, {
+        type: "addField";
+        name: string;
+        definition?: any;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"removeField">;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "removeField";
+        name: string;
+    }, {
+        type: "removeField";
+        name: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"modifyField">;
+        name: z.ZodString;
+        changes: any;
+    }, "strip", z.ZodTypeAny, {
+        type: "modifyField";
+        name: string;
+        changes?: any;
+    }, {
+        type: "modifyField";
+        name: string;
+        changes?: any;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"addIndex">;
+        definition: z.ZodObject<{
+            fields: z.ZodArray<z.ZodString, "many">;
+            type: z.ZodEnum<["normal", "unique", "btree", "hash", "spatial", "fulltext", "gi", "expression", "composite"]>;
+            unique: z.ZodOptional<z.ZodBoolean>;
+            partial: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
+            description: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+            name: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite";
+            fields: string[];
+            unique?: boolean | undefined;
+            description?: string | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        }, {
+            type: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite";
+            fields: string[];
+            unique?: boolean | undefined;
+            description?: string | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        type: "addIndex";
+        definition: {
+            type: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite";
+            fields: string[];
+            unique?: boolean | undefined;
+            description?: string | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        };
+    }, {
+        type: "addIndex";
+        definition: {
+            type: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite";
+            fields: string[];
+            unique?: boolean | undefined;
+            description?: string | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        };
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"removeIndex">;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "removeIndex";
+        name: string;
+    }, {
+        type: "removeIndex";
+        name: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"modifyIndex">;
+        name: z.ZodString;
+        changes: z.ZodObject<{
+            fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            type: z.ZodOptional<z.ZodEnum<["normal", "unique", "btree", "hash", "spatial", "fulltext", "gi", "expression", "composite"]>>;
+            unique: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+            partial: z.ZodOptional<z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>>;
+            description: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            order: z.ZodOptional<z.ZodOptional<z.ZodEnum<["asc", "desc"]>>>;
+            name: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            unique?: boolean | undefined;
+            type?: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite" | undefined;
+            description?: string | undefined;
+            fields?: string[] | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        }, {
+            unique?: boolean | undefined;
+            type?: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite" | undefined;
+            description?: string | undefined;
+            fields?: string[] | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        type: "modifyIndex";
+        name: string;
+        changes: {
+            unique?: boolean | undefined;
+            type?: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite" | undefined;
+            description?: string | undefined;
+            fields?: string[] | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        };
+    }, {
+        type: "modifyIndex";
+        name: string;
+        changes: {
+            unique?: boolean | undefined;
+            type?: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite" | undefined;
+            description?: string | undefined;
+            fields?: string[] | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        };
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"addConstraint">;
+        constraint: z.ZodUnion<[z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            predicate: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodOptional<z.ZodType<(params: any) => boolean, z.ZodTypeDef, (params: any) => boolean>>;
+            description: z.ZodOptional<z.ZodString>;
+            field: z.ZodOptional<z.ZodString>;
+            errorMessage: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            type?: string | undefined;
+            description?: string | undefined;
+            predicate?: string | undefined;
+            field?: string | undefined;
+            parameters?: ((params: any) => boolean) | undefined;
+            errorMessage?: string | undefined;
+        }, {
+            name: string;
+            type?: string | undefined;
+            description?: string | undefined;
+            predicate?: string | undefined;
+            field?: string | undefined;
+            parameters?: ((params: any) => boolean) | undefined;
+            errorMessage?: string | undefined;
+        }>, any]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "addConstraint";
+        constraint?: any;
+    }, {
+        type: "addConstraint";
+        constraint?: any;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"removeConstraint">;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "removeConstraint";
+        name: string;
+    }, {
+        type: "removeConstraint";
+        name: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"modifyConstraint">;
+        name: z.ZodString;
+        changes: z.ZodObject<{
+            type: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            name: z.ZodOptional<z.ZodString>;
+            predicate: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            parameters: z.ZodOptional<z.ZodOptional<z.ZodType<(params: any) => boolean, z.ZodTypeDef, (params: any) => boolean>>>;
+            description: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            field: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            errorMessage: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            type?: string | undefined;
+            description?: string | undefined;
+            name?: string | undefined;
+            predicate?: string | undefined;
+            field?: string | undefined;
+            parameters?: ((params: any) => boolean) | undefined;
+            errorMessage?: string | undefined;
+        }, {
+            type?: string | undefined;
+            description?: string | undefined;
+            name?: string | undefined;
+            predicate?: string | undefined;
+            field?: string | undefined;
+            parameters?: ((params: any) => boolean) | undefined;
+            errorMessage?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        type: "modifyConstraint";
+        name: string;
+        changes: {
+            type?: string | undefined;
+            description?: string | undefined;
+            name?: string | undefined;
+            predicate?: string | undefined;
+            field?: string | undefined;
+            parameters?: ((params: any) => boolean) | undefined;
+            errorMessage?: string | undefined;
+        };
+    }, {
+        type: "modifyConstraint";
+        name: string;
+        changes: {
+            type?: string | undefined;
+            description?: string | undefined;
+            name?: string | undefined;
+            predicate?: string | undefined;
+            field?: string | undefined;
+            parameters?: ((params: any) => boolean) | undefined;
+            errorMessage?: string | undefined;
+        };
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"deprecateField">;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "deprecateField";
+        name: string;
+    }, {
+        type: "deprecateField";
+        name: string;
+    }>]>, "many">>;
+    transform: z.ZodUnknown;
+    createdAt: z.ZodString;
+    checksum: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    changes: ({
+        type: "addField";
+        name: string;
+        definition?: any;
+    } | {
+        type: "removeField";
+        name: string;
+    } | {
+        type: "modifyField";
+        name: string;
+        changes?: any;
+    } | {
+        type: "addIndex";
+        definition: {
+            type: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite";
+            fields: string[];
+            unique?: boolean | undefined;
+            description?: string | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        };
+    } | {
+        type: "removeIndex";
+        name: string;
+    } | {
+        type: "modifyIndex";
+        name: string;
+        changes: {
+            unique?: boolean | undefined;
+            type?: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite" | undefined;
+            description?: string | undefined;
+            fields?: string[] | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        };
+    } | {
+        type: "addConstraint";
+        constraint?: any;
+    } | {
+        type: "removeConstraint";
+        name: string;
+    } | {
+        type: "modifyConstraint";
+        name: string;
+        changes: {
+            type?: string | undefined;
+            description?: string | undefined;
+            name?: string | undefined;
+            predicate?: string | undefined;
+            field?: string | undefined;
+            parameters?: ((params: any) => boolean) | undefined;
+            errorMessage?: string | undefined;
+        };
+    } | {
+        type: "deprecateField";
+        name: string;
+    })[];
+    status: "pending" | "applied" | "failed";
+    id: string;
+    schemaVersion: string;
+    createdAt: string;
+    rollback?: ({
+        type: "addField";
+        name: string;
+        definition?: any;
+    } | {
+        type: "removeField";
+        name: string;
+    } | {
+        type: "modifyField";
+        name: string;
+        changes?: any;
+    } | {
+        type: "addIndex";
+        definition: {
+            type: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite";
+            fields: string[];
+            unique?: boolean | undefined;
+            description?: string | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        };
+    } | {
+        type: "removeIndex";
+        name: string;
+    } | {
+        type: "modifyIndex";
+        name: string;
+        changes: {
+            unique?: boolean | undefined;
+            type?: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite" | undefined;
+            description?: string | undefined;
+            fields?: string[] | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        };
+    } | {
+        type: "addConstraint";
+        constraint?: any;
+    } | {
+        type: "removeConstraint";
+        name: string;
+    } | {
+        type: "modifyConstraint";
+        name: string;
+        changes: {
+            type?: string | undefined;
+            description?: string | undefined;
+            name?: string | undefined;
+            predicate?: string | undefined;
+            field?: string | undefined;
+            parameters?: ((params: any) => boolean) | undefined;
+            errorMessage?: string | undefined;
+        };
+    } | {
+        type: "deprecateField";
+        name: string;
+    })[] | undefined;
+    transform?: unknown;
+    checksum?: string | undefined;
+}, {
+    description: string;
+    changes: ({
+        type: "addField";
+        name: string;
+        definition?: any;
+    } | {
+        type: "removeField";
+        name: string;
+    } | {
+        type: "modifyField";
+        name: string;
+        changes?: any;
+    } | {
+        type: "addIndex";
+        definition: {
+            type: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite";
+            fields: string[];
+            unique?: boolean | undefined;
+            description?: string | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        };
+    } | {
+        type: "removeIndex";
+        name: string;
+    } | {
+        type: "modifyIndex";
+        name: string;
+        changes: {
+            unique?: boolean | undefined;
+            type?: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite" | undefined;
+            description?: string | undefined;
+            fields?: string[] | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        };
+    } | {
+        type: "addConstraint";
+        constraint?: any;
+    } | {
+        type: "removeConstraint";
+        name: string;
+    } | {
+        type: "modifyConstraint";
+        name: string;
+        changes: {
+            type?: string | undefined;
+            description?: string | undefined;
+            name?: string | undefined;
+            predicate?: string | undefined;
+            field?: string | undefined;
+            parameters?: ((params: any) => boolean) | undefined;
+            errorMessage?: string | undefined;
+        };
+    } | {
+        type: "deprecateField";
+        name: string;
+    })[];
+    status: "pending" | "applied" | "failed";
+    id: string;
+    schemaVersion: string;
+    createdAt: string;
+    rollback?: ({
+        type: "addField";
+        name: string;
+        definition?: any;
+    } | {
+        type: "removeField";
+        name: string;
+    } | {
+        type: "modifyField";
+        name: string;
+        changes?: any;
+    } | {
+        type: "addIndex";
+        definition: {
+            type: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite";
+            fields: string[];
+            unique?: boolean | undefined;
+            description?: string | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        };
+    } | {
+        type: "removeIndex";
+        name: string;
+    } | {
+        type: "modifyIndex";
+        name: string;
+        changes: {
+            unique?: boolean | undefined;
+            type?: "normal" | "unique" | "btree" | "hash" | "spatial" | "fulltext" | "gi" | "expression" | "composite" | undefined;
+            description?: string | undefined;
+            fields?: string[] | undefined;
+            partial?: any;
+            order?: "asc" | "desc" | undefined;
+            name?: string | undefined;
+        };
+    } | {
+        type: "addConstraint";
+        constraint?: any;
+    } | {
+        type: "removeConstraint";
+        name: string;
+    } | {
+        type: "modifyConstraint";
+        name: string;
+        changes: {
+            type?: string | undefined;
+            description?: string | undefined;
+            name?: string | undefined;
+            predicate?: string | undefined;
+            field?: string | undefined;
+            parameters?: ((params: any) => boolean) | undefined;
+            errorMessage?: string | undefined;
+        };
+    } | {
+        type: "deprecateField";
+        name: string;
+    })[] | undefined;
+    transform?: unknown;
+    checksum?: string | undefined;
+}>;
+declare function validateMigration<T>(change: any): change is Migration<T>;
+declare function validateSchemaChange<T>(change: any): change is SchemaChange<T>;
+declare function validateSchemaDefinition(schema: any): schema is SchemaDefinition;
+declare const validate: typeof validateSchemaDefinition;
+
+declare const index_MigrationSchema: typeof MigrationSchema;
+declare const index_createSchemaMigrationHelper: typeof createSchemaMigrationHelper;
+declare const index_validate: typeof validate;
+declare const index_validateMigration: typeof validateMigration;
+declare const index_validateSchemaChange: typeof validateSchemaChange;
+declare const index_validateSchemaDefinition: typeof validateSchemaDefinition;
+declare namespace index {
+  export { index_MigrationSchema as MigrationSchema, index_createSchemaMigrationHelper as createSchemaMigrationHelper, index_validate as validate, index_validateMigration as validateMigration, index_validateSchemaChange as validateSchemaChange, index_validateSchemaDefinition as validateSchemaDefinition };
+}
+
+/**
+ * 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>;
+
+declare const crypto_generateSHA256Hash: typeof generateSHA256Hash;
+declare namespace crypto {
+  export { crypto_generateSHA256Hash as generateSHA256Hash };
+}
+
+/**
+ * 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;
+
+declare const merge_deepMerge: typeof deepMerge;
+declare namespace merge {
+  export { merge_deepMerge as deepMerge };
+}
+
+/**
+ * Converts a schema definition into TypeScript type definitions
+ * @param schema - The schema definition
+ * @returns A string containing all type definitions
+ */
+declare function schemaToTypes(schema: SchemaDefinition): string;
+
+declare const typegen_schemaToTypes: typeof schemaToTypes;
+declare namespace typegen {
+  export { schemaToTypes as default, typegen_schemaToTypes as schemaToTypes };
+}
+
+/**
+ * Creates a Standard Schema validator that conforms to the StandardSchemaV1 interface.
+ * The validator uses a closure pattern to maintain internal state and avoid prop drilling.
+ * Instead of only returning a boolean, the validator collects detailed error issues if validation fails.
+ *
+ * @template T - The type of the data object to validate
+ * @param {SchemaDefinition} schema - The schema definition containing field and constraint rules
+ * @param {PredicateMap} constraintsMap - A map of constraint names to predicate functions
+ * @returns {StandardSchemaV1<T, T>} An object conforming to the StandardSchemaV1 interface
+ *
+ * @example
+ * const validator = createStandardSchemaValidator(mySchema, myConstraints);
+ * const result = validator["~standard"].validate(data);
+ * if ('issues' in result) {
+ *   console.log('Validation failed:', result.issues);
+ * }
+ */
+declare function createStandardSchemaValidator<T extends Record<string, any>>(schema: SchemaDefinition, constraintsMap: PredicateMap): StandardSchemaV1<T, T>;
+
+declare const validator_createStandardSchemaValidator: typeof createStandardSchemaValidator;
+declare namespace validator {
+  export { validator_createStandardSchemaValidator as createStandardSchemaValidator };
+}
+
+/**
+ * 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 const version_calculateNextVersion: typeof calculateNextVersion;
+declare const version_compareSemanticVersions: typeof compareSemanticVersions;
+declare const version_sortSemanticVars: typeof sortSemanticVars;
+declare namespace version {
+  export { version_calculateNextVersion as calculateNextVersion, version_compareSemanticVersions as compareSemanticVersions, version_sortSemanticVars as sortSemanticVars };
+}
+
+export { migrations as MigrationTypes, persistence as PersistenceTypes, registry as RegistryType, schemaDefinition as SchemaTypes, crypto, merge, index$1 as migration, patch, index$3 as persistence, index$2 as registry, index as schema, typegen, validator, version };