@asaidimu/anansi 4.0.2 → 8.6.2

package/index.d.ts

@@ -1,2347 +0,0 @@
-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';
-
-/**
- * hints.ts
- *
- * Defines type hints for generating form input controls based on schema field definitions.
- * Each hint type corresponds to a specific input control, providing metadata for code generation.
- */
-/**
- * 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;
-};
-/**
- * Hints for generating a text-based input control.
- */
-type TextHint = {
-    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;
-};
-/**
- * Hints for generating a number-based input control.
- */
-type NumberHint = {
-    type: "number" | "range";
-    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;
-};
-/**
- * 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;
-    }>;
-};
-/**
- * Hints for generating an array input control.
- */
-type ArrayHint = {
-    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;
-};
-/**
- * Hints for generating an object input control.
- */
-type ObjectHint = {
-    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;
-};
-/**
- * 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;
-};
-/**
- * Union type for all possible input hints.
- * Note: DynamicHint removed to avoid overlap with TextHint; use TextHint for generic text needs.
- */
-type InputHint = FileHint | TextHint | SecretHint | NumberHint | BooleanHint | EnumHint | ArrayHint | SetHint | ObjectHint | DateHint | CodeHint;
-/**
- * Defines metadata for a group of inputs at the schema level.
- */
-type GroupDefinition = {
-    name: string;
-    label?: string;
-    description?: string;
-};
-/**
- * Defines hints at the schema level, including group metadata.
- */
-type SchemaHint = {
-    groups?: GroupDefinition[];
-};
-
-/**
- * Basic field types supported by the schema system.
- */
-type FieldType = "string" | "number" | "boolean" | "array" | "set" | "enum" | "object" | "record" | "union" | "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, 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;
- * };
- * ```
- */
-type Predicate = <T, K extends FieldType = any>(params: {
-    data: T;
-    field?: keyof T;
-    arguments: PredicateParameters<K>;
-}) => boolean;
-/**
- * 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;
- *    }
- * };
- * ```
- */
-type PredicateMap = Record<string, Predicate>;
-/**
- * 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"
- * ```
- */
-type PredicateName<T extends PredicateMap = any> = keyof T;
-/**
- * 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 }
- * ```
- */
-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>;
-/**
- * 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."
- * };
- * ```
- */
-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>>;
-}
-/**
- * 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
- * ];
- * ```
- */
-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[];
-}
-/**
- * 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
- *        }
- *    }
- * };
- * ```
- */
-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;
-    };
-}
-/**
- * Condition for partial indexes, allowing conditional indexing based on field values.
- *
- * @example
- * ```typescript
- * const activeCondition: PartialIndexCondition = {
- *    operator: "and",
- *    field: "isActive",
- *    value: true
- * };
- * ```
- */
-interface PartialIndexCondition {
-    operator: LogicalOperator;
-    field: string;
-    value?: any;
-    conditions?: PartialIndexCondition[];
-}
-/**
- * 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 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()
- *            }
- *        };
- *    }
- * };
- * ```
- */
-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>;
-}
-/**
- * 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"}
- *        }
- *    }
- * }
- * ```
- */
-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>>;
-};
-/**
- * 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>;
-/**
- * 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 })
- * };
- * ```
- */
-interface DataTransform<Initial, Next> {
-    forward: TransformFunction<Initial, Next>;
-    backward: TransformFunction<Next, Initial>;
-}
-/**
- * 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"
- * };
- * ```
- */
-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;
-}
-/**
- * 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() };
- * };
- * ```
- */
-type Generator<T, TReturn, TNext> = Iterator<T, TReturn, TNext>;
-
-/**
- * Defines the interface for a migration engine.
- * The migration engine is responsible for applying, rolling back, and tracking schema migrations.
- */
-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>;
-}
-
-/**
- * @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[];
-
-/**
- * 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: "migration:committed";
-    currentVersion: string;
-    previousVersion: string;
-    changes: SchemaChange<any>[];
-    dryRun?: boolean;
-} | {
-    type: "migration:rollingBack";
-    currentVersion: string;
-    targetVersion: string;
-    changes: SchemaChange<any>[];
-    dryRun?: boolean;
-} | {
-    type: "migration:rolledBack";
-    currentVersion: string;
-    previousVersion: string;
-    changes: SchemaChange<any>[];
-    dryRun?: boolean;
-} | {
-    type: "migration:ended";
-    currentVersion: string;
-    status: "committed" | "rolledBack";
-};
-/**
- * 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;
-}
-/**
- * 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;
-}
-/**
- * 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;
-}
-/**
- * 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;
-    };
-}
-/**
- * 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;
-}
-/**
- * Metadata for Persistence or PersistenceCollection.
- */
-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;
-}
-/**
- * Interface for querying observability data.
- */
-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 for event handling and task scheduling.
- */
-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 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>;
-}
-/**
- * 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 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;
-    };
-}
-
-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;
-}
-
-/**
- * @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);
-}
-/**
- * @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;
-}
-
-/**
- * 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>[];
-}
-/**
- * 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 };