import DataPack from "./datapack.js";
import { TypeWrapper, type FieldQueryArg, type FieldValue } from "./types.js";
import { type Transaction } from "./edinburgh.js";
import { PrimaryKey, NonPrimaryIndex, IndexRangeIterator, FindOptions, VersionInfo } from "./indexes.js";
/**
 * Configuration interface for model fields.
 * @template T - The field type.
 */
export interface FieldConfig<T> {
    /** The type wrapper that defines how this field is serialized/validated. */
    type: TypeWrapper<T>;
    /** Optional human-readable description of the field. */
    description?: string;
    /** Optional default value or function that generates default values. */
    default?: T | ((model: Record<string, any>) => T);
}
/**
 * Create a field definition for a model property.
 *
 * This function uses TypeScript magic to return the field configuration object
 * while appearing to return the actual field value type to the type system.
 * This allows for both runtime introspection and compile-time type safety.
 *
 * @template T - The field type.
 * @param type The type wrapper for this field.
 * @param options Additional field configuration options.
 * @returns The field value (typed as T, but actually returns FieldConfig<T>).
 *
 * @example
 * ```typescript
 * const User = E.defineModel("User", class {
 *   name = E.field(E.string, {description: "User's full name"});
 *   age = E.field(E.opt(E.number), {description: "User's age", default: 25});
 * });
 * ```
 */
export declare function field<TYPE extends TypeWrapper<any>>(type: TYPE, options?: Partial<FieldConfig<FieldValue<TYPE>>>): FieldValue<TYPE>;
export type Change = Record<any, any> | "created" | "deleted";
type FieldsOf<T> = T extends new () => infer I ? I : never;
type ModelFields<T extends new () => any> = FieldsOf<T>;
export interface ModelLookup<PKA extends readonly any[] = readonly any[]> {
    get(...args: PKA): any;
}
type ModelInstance<FIELDS, PKA extends readonly any[] = readonly any[]> = Model<FIELDS, ModelLookup<PKA>>;
type PublicModelOf<T extends new () => any> = Model<ModelFields<T>>;
type IndexSpec<T extends new () => any> = (keyof ModelFields<T> & string) | readonly (keyof ModelFields<T> & string)[] | ((instance: PublicModelOf<T>) => any);
type PKArgs<FIELDS, PK> = PK extends readonly (keyof FIELDS & string)[] ? {
    [I in keyof PK]: PK[I] extends keyof FIELDS ? FieldQueryArg<FIELDS[PK[I]]> : never;
} : PK extends keyof FIELDS & string ? [FieldQueryArg<FIELDS[PK]>] : [string];
type IndexArgs<FIELDS, SPEC> = SPEC extends readonly (keyof FIELDS & string)[] ? {
    [I in keyof SPEC]: SPEC[I] extends keyof FIELDS ? FieldQueryArg<FIELDS[SPEC[I]]> : never;
} : SPEC extends keyof FIELDS & string ? [FieldQueryArg<FIELDS[SPEC]>] : SPEC extends (instance: any) => infer R ? R extends (infer V)[] ? [V] : [R] : never;
type PublicIndexSpec<SPEC> = SPEC extends (instance: infer INSTANCE) => infer R ? (instance: INSTANCE) => R : SPEC;
type PublicIndexSpecs<SPECS> = {
    [K in keyof SPECS]: PublicIndexSpec<SPECS[K]>;
};
/**
 * A model constructor with its generic information erased.
 *
 * Useful when accepting or storing arbitrary registered model classes.
 */
export type AnyModelClass = ModelClass<object, any, readonly any[], any, any>;
type StaticMembers<T extends new () => any> = Pick<T, Exclude<keyof T, 'prototype'>>;
type SecondaryRegistry<FIELDS, PKA extends readonly any[]> = Record<string, NonPrimaryIndex<ModelInstance<FIELDS, PKA>, readonly (keyof FIELDS & string)[], readonly any[]>>;
export declare const modelRegistry: Record<string, AnyModelClass>;
export declare const pendingModelInits: Set<AnyModelClass>;
declare class ModelClassRuntime<FIELDS, PKA extends readonly any[], UNIQUE = {}, INDEX = {}> extends PrimaryKey<ModelInstance<FIELDS, PKA>, readonly (keyof FIELDS & string)[], PKA> {
    tableName: string;
    fields: Record<string | symbol | number, FieldConfig<unknown>>;
    _secondaries?: SecondaryRegistry<FIELDS, PKA>;
    _nonKeyFields: (keyof FIELDS & string)[];
    _lazyDescriptors: Record<string | symbol | number, PropertyDescriptor>;
    _resetDescriptors: Record<string | symbol | number, PropertyDescriptor>;
    _freezePrimaryKeyDescriptors: Record<string | symbol | number, PropertyDescriptor>;
    _currentVersion: number;
    _currentMigrateHash: number;
    _versions: Map<number, VersionInfo>;
    _serializeVersionValue(): Uint8Array;
    _initialize(reset?: boolean): Promise<void>;
    _getSecondary(name: string): NonPrimaryIndex<ModelInstance<FIELDS, PKA>, readonly (keyof FIELDS & string)[], readonly any[]>;
    _get(txn: Transaction, args: PKA | Uint8Array, loadNow: false | Uint8Array): ModelInstance<FIELDS, PKA>;
    _get(txn: Transaction, args: PKA | Uint8Array, loadNow: true): ModelInstance<FIELDS, PKA> | undefined;
    _lazyLoad(model: ModelInstance<FIELDS, PKA>): void;
    /**
     * Load a model by primary key inside the current transaction.
        *
        * For `link(...)` primary-key fields, each argument may be the linked model
        * instance or the linked model's primary key. Composite linked primary keys
        * are passed as a tuple in that argument slot.
     *
     * @returns The matching model, or `undefined` if no row exists.
     */
    get(...args: PKA): ModelInstance<FIELDS, PKA> | undefined;
    /**
     * Load a model by primary key without fetching its non-key fields immediately.
        *
        * Link-valued primary-key fields accept the same shorthand as `get()`.
     *
     * Accessing a lazy field later will load the remaining fields transparently.
     */
    getLazy(...args: PKA): ModelInstance<FIELDS, PKA>;
    _pairToInstance(txn: Transaction, keyBuffer: ArrayBuffer, valueBuffer: ArrayBuffer): ModelInstance<FIELDS, PKA>;
    /**
     * Load an existing instance by primary key and update it, or create a new one.
      * If a row already exists, its non-primary-key fields are updated in place.
      * Otherwise, a new instance is created with `obj` as its initial properties.
     *
     * @param obj Partial model data that **must** include every primary key field.
      * @returns The loaded-and-updated or newly created instance.
     */
    replaceInto(obj: Partial<FIELDS>): ModelInstance<FIELDS, PKA>;
    /**
     * Look up a model through a named unique index.
     *
     * @param name The name from the model's `unique` definition.
        * @param args The unique-index key values. For `link(...)` fields, pass
        * either the linked model instance or the linked model's primary key. If the
        * linked model uses a composite primary key, pass the full tuple in that slot.
     * @returns The matching model instance, if any.
     */
    getBy<K extends string & keyof UNIQUE>(name: K, ...args: IndexArgs<FIELDS, UNIQUE[K]>): ModelInstance<FIELDS, PKA> | undefined;
    /**
     * Query rows through a named unique or secondary index.
     *
     * This mirrors `find()`, but targets a named entry from the model's `unique`
        * or `index` registration. Link-valued index fields accept either the linked
        * model instance or the linked model's primary key tuple/value.
     */
    findBy<K extends string & keyof (UNIQUE & INDEX)>(name: K, opts: FindOptions<IndexArgs<FIELDS, (UNIQUE & INDEX)[K]>, 'first'>): ModelInstance<FIELDS, PKA> | undefined;
    findBy<K extends string & keyof (UNIQUE & INDEX)>(name: K, opts: FindOptions<IndexArgs<FIELDS, (UNIQUE & INDEX)[K]>, 'single'>): ModelInstance<FIELDS, PKA>;
    findBy<K extends string & keyof (UNIQUE & INDEX)>(name: K, opts?: FindOptions<IndexArgs<FIELDS, (UNIQUE & INDEX)[K]>>): IndexRangeIterator<ModelInstance<FIELDS, PKA>>;
    /**
     * Process rows from a named unique or secondary index in batched transactions.
     *
     * Uses the same range options as `findBy()`, plus batch limits.
     */
    batchProcessBy<K extends string & keyof (UNIQUE & INDEX)>(name: K, opts: FindOptions<IndexArgs<FIELDS, (UNIQUE & INDEX)[K]>> & {
        limitSeconds?: number;
        limitRows?: number;
    }, callback: (row: ModelInstance<FIELDS, PKA>) => any): Promise<void>;
    _loadValueFields(model: ModelInstance<FIELDS, PKA>, valueArray: Uint8Array): void;
    _loadVersionInfo(txnId: number, version: number): VersionInfo;
    _migrateValueFields(model: ModelInstance<FIELDS, PKA>, version: number, valuePack: DataPack): void;
    _serializeValue(data: Record<string, any>): Uint8Array;
}
/**
 * Runtime base constructor for model classes returned by `defineModel()`.
 *
 * Prefer the `ModelClass` type alias for annotations and the result of
 * `defineModel()` for concrete model classes.
 */
export declare const ModelClass: typeof ModelClassRuntime;
/**
 * The static side of a model class returned by `defineModel()`.
 *
 * Besides the class constructor itself, this includes primary-key lookup
 * helpers like `get()` and `getLazy()`, range-query helpers like `find()`, and
 * named-index helpers like `getBy()` and `findBy()`.
 *
 * @template FIELDS - The user-defined fields of the model instance.
 * @template PKA - Tuple of primary-key argument types.
 * @template UNIQUE - Named unique-index specifications.
 * @template INDEX - Named secondary-index specifications.
 */
export type ModelClass<STATICS, FIELDS, PKA extends readonly any[], UNIQUE = {}, INDEX = {}> = STATICS & ModelClassRuntime<FIELDS, PKA, UNIQUE, INDEX> & {
    new (initial?: Partial<FIELDS>, txn?: Transaction): ModelInstance<FIELDS, PKA>;
};
/**
 * Minimal instance-side model shape used for typing the constructor property.
 */
export interface ModelBase<LOOKUP extends ModelLookup = ModelLookup> {
    constructor: LOOKUP & AnyModelClass;
}
/**
 * Register a model class with the Edinburgh ORM system.
 *
 * Converts a plain class into a fully-featured model with database persistence,
 * typed fields, primary key access, and optional secondary and unique indexes.
 *
 * @param tableName The database table name for this model.
 * @param cls A plain class whose properties use E.field().
 * @param opts Registration options.
 * @param opts.pk Primary key field name or array of field names.
 * @param opts.unique Named unique index specifications (field name, field array, or compute function).
 * @param opts.index Named secondary index specifications (field name, field array, or compute function).
 * @param opts.override Replace a previous model with the same table name.
 * @returns The enhanced model constructor.
 */
export declare function defineModel<T extends new () => any, const PK extends (keyof ModelFields<T> & string) | readonly (keyof ModelFields<T> & string)[], const UNIQUE extends Record<string, IndexSpec<T>>, const INDEX extends Record<string, IndexSpec<T>>>(tableName: string, cls: T, opts?: {
    pk?: PK;
    unique?: UNIQUE;
    index?: INDEX;
    override?: boolean;
}): ModelClass<StaticMembers<T>, ModelFields<T>, PKArgs<ModelFields<T>, PK>, PublicIndexSpecs<UNIQUE>, PublicIndexSpecs<INDEX>>;
/**
 * Base class for all database models in the Edinburgh ORM.
 *
 * Models represent database entities with typed fields, automatic serialization,
 * change tracking, and relationship management. Model classes are created using
 * `E.defineModel()`.
 *
 * ### Schema Evolution
 *
 * Edinburgh tracks the schema version of each model automatically. When you add, remove, or
 * change the types of fields, or add/remove indexes, Edinburgh detects the new schema version.
 *
 * **Lazy migration:** Changes to non-key field values are migrated lazily, when a row with an
 * old schema version is read from disk, it is deserialized using the old schema and optionally
 * transformed by the static `migrate()` function. This happens transparently on every read
 * and requires no downtime or batch processing.
 *
 * **Batch migration (via `npx migrate-edinburgh` or `runMigration()`):** Certain schema changes
 * require an explicit migration run:
 * - Adding or removing secondary/unique indexes
 * - Changing the fields or types of an existing index
 * - A `migrate()` function that changes values used in secondary index fields
 *
 * The batch migration tool populates new indexes, deletes orphaned ones, and updates index
 * entries whose values were changed by `migrate()`. It does *not* rewrite primary data rows
 * (lazy migration handles that).
 *
 * ### Lifecycle Hooks
 *
 * - **`static migrate(record)`**: Called when deserializing rows written with an older schema
 *   version. Receives a plain record object; mutate it in-place to match the current schema.
 *
 * - **`preCommit()`**: Called on each modified instance right before the transaction commits.
 *   Useful for computing derived fields, enforcing cross-field invariants, or creating related
 *   instances.
 *
 * @example
 * ```typescript
 * const User = E.defineModel("User", class {
 *   id = E.field(E.identifier);
 *   name = E.field(E.string);
 *   email = E.field(E.string);
 * }, {
 *   pk: "id",
 *   unique: { email: "email" },
 * });
 * // Optional: declare a companion type so `let u: User` works.
 * // Not needed if you only use `new User()`, `User.find()`, etc.
 * type User = InstanceType<typeof User>;
 * ```
 */
export declare abstract class ModelBase {
    /**
     * Optional migration function called when deserializing rows written with an older schema version.
    * Receives a plain record with all fields and should mutate it in-place to match the current schema.
    * It runs during lazy loading and during `runMigration()`. Changing this method creates a new schema version.
    * If it updates values used by secondary or unique indexes, those index entries are refreshed only by `runMigration()`.
     *
     * @param record A plain object containing the row's field values from the older schema version.
     *
     * @example
     * ```typescript
     * const User = E.defineModel("User", class {
     *   id = E.field(E.identifier);
     *   name = E.field(E.string);
     *   role = E.field(E.string);
     *
     *   static migrate(record: Record<string, any>) {
     *     record.role ??= "user";
     *   }
     * }, { pk: "id" });
     * ```
     */
    static migrate?(record: Record<string, any>): void;
    /**
     * @internal
     * - _oldValues===undefined: New instance, not yet saved.
     * - _oldValues===null: Instance is to be deleted.
     * - _oldValues===false: Instance excluded from persistence (preventPersist).
     * - _oldValues is an object: Loaded (possibly only partial, still lazy) from disk, _oldValues contains (partial) old values
     */
    _oldValues: Record<string, any> | undefined | null | false;
    _primaryKey: Uint8Array | undefined;
    _primaryKeyHash: number | undefined;
    _txn: Transaction;
    /**
     * Optional hook called on each modified instance right before the transaction commits.
     * Runs before data is written to disk, so changes made here are included in the commit.
     *
     * Common use cases:
     * - Computing derived or denormalized fields
     * - Enforcing cross-field validation rules
     * - Creating or updating related model instances (newly created instances will also
     *   have their `preCommit()` called)
     *
     * @example
     * ```typescript
     * const Post = E.defineModel("Post", class {
     *   id = E.field(E.identifier);
     *   title = E.field(E.string);
     *   slug = E.field(E.string);
     *
     *   preCommit() {
     *     this.slug = this.title.toLowerCase().replace(/\s+/g, "-");
     *   }
     * }, { pk: "id" });
     * ```
     */
    preCommit?(): void;
    _setLoadedField(fieldName: string, value: any): void;
    _restoreLazyFields(): void;
    /**
     * @returns The primary key for this instance.
     */
    getPrimaryKey(): Uint8Array;
    _setPrimaryKey(key: Uint8Array, hash?: number): void;
    /**
     * @returns A 53-bit positive integer non-cryptographic hash of the primary key, or undefined if not yet saved.
     */
    getPrimaryKeyHash(): number;
    isLazyField(field: keyof this): boolean;
    _write(txn: Transaction): undefined | Change;
    /**
     * Prevent this instance from being persisted to the database.
     *
     * @returns This model instance for chaining.
     *
     * @example
     * ```typescript
     * const user = User.get("user123");
     * user.name = "New Name";
     * user.preventPersist(); // Changes won't be saved
     * ```
     */
    preventPersist(): this;
    /**
     * Delete this model instance from the database.
     *
     * Removes the instance and all its index entries from the database and prevents further persistence.
     *
     * @example
     * ```typescript
     * const user = User.get("user123");
     * user.delete(); // Removes from database
     * ```
     */
    delete(): void;
    /**
     * Validate all fields in this model instance.
     * @param raise If true, throw on first validation error.
     * @returns Array of validation errors (empty if valid).
     *
     * @example
     * ```typescript
     * const user = new User();
     * const errors = user.validate();
     * if (errors.length > 0) {
     *   console.log("Validation failed:", errors);
     * }
     * ```
     */
    validate(raise?: boolean): Error[];
    /**
     * Check if this model instance is valid.
     * @returns true if all validations pass.
     *
     * @example
     * ```typescript
     * const user = new User({name: "John"});
     * if (!user.isValid()) shoutAtTheUser();
     * ```
     */
    isValid(): boolean;
    getState(): "deleted" | "created" | "loaded" | "lazy";
    toString(): string;
}
/**
 * Delete every key/value entry in the database and reinitialize all registered models.
 *
 * This clears rows, index metadata, and schema-version records. It is mainly useful
 * for tests, local resets, or tooling that needs a completely empty database.
 */
export declare function deleteEverything(): Promise<void>;
/**
 * A model instance, including its user-defined fields.
 * @template FIELDS - The fields defined on this model.
 */
export type Model<FIELDS, LOOKUP extends ModelLookup = ModelLookup> = FIELDS & ModelBase<LOOKUP>;
export declare const Model: typeof ModelBase;
export {};