import { Constructor } from '@noeldemartin/utils';
import { Nullable } from '@noeldemartin/utils';
import { Pretty } from '@noeldemartin/utils';

export declare type ArrayFieldDefinition<T = unknown> = FieldDefinitionBase<T> & {
    type: typeof FieldType.Array;
    items: Omit<FieldDefinition<T>, 'required'>;
};

export declare type Attributes = Record<string, AttributeValue>;

export declare type AttributeValue = any;

export declare type BasicFieldDefinition<T = unknown> = FieldDefinitionBase<T> & {
    type: Exclude<FieldTypeValue, typeof FieldType.Array | typeof FieldType.Object>;
};

export declare class BelongsToManyRelation<Parent extends Model = Model, Related extends Model = Model, RelatedClass extends ModelConstructor<Related> = ModelConstructor<Related>> extends MultiModelRelation<Parent, Related, RelatedClass> {
    isEmpty(): boolean | null;
    load(): Promise<Related[]>;
    setForeignAttributes(related: Related): void;
    clearForeignAttributes(related: Related): void;
}

export declare class BelongsToOneRelation<Parent extends Model = Model, Related extends Model = Model, RelatedClass extends ModelConstructor<Related> = ModelConstructor<Related>> extends SingleModelRelation<Parent, Related, RelatedClass> {
    isEmpty(): boolean | null;
    load(): Promise<Related | null>;
    setForeignAttributes(related: Related): void;
    clearForeignAttributes(related: Related): void;
}

export declare type BootedArrayFieldDefinition<T = unknown> = BootedFieldDefinitionBase<T> & {
    type: typeof FieldType.Array;
    items: Omit<BootedFieldDefinition<T>, 'required'>;
};

export declare type BootedBasicFieldDefinition<T = unknown> = BootedFieldDefinitionBase<T> & {
    type: Exclude<FieldTypeValue, typeof FieldType.Array | typeof FieldType.Object>;
};

export declare type BootedFieldDefinition<T = unknown> = BootedBasicFieldDefinition<T> | BootedArrayFieldDefinition<T> | BootedObjectFieldDefinition<T>;

export declare type BootedFieldDefinitionBase<T = unknown> = T & {
    required: boolean;
    alias?: string;
    cast?: (value: unknown) => unknown;
    set?: (this: Model, value: unknown) => void;
    get?: (this: Model) => unknown;
    serialize?: (value: any) => unknown;
    deserialize?: (value: any) => unknown;
};

export declare type BootedFieldsDefinition<T = unknown> = Record<string, BootedFieldDefinition<T>>;

export declare type BootedObjectFieldDefinition<T = unknown> = BootedFieldDefinitionBase<T> & {
    type: typeof FieldType.Object;
    fields: BootedFieldsDefinition<T>;
};

export declare function bootModels(models: Record<string, typeof Model>): void;

export declare function bootModelsFromViteGlob(glob: Record<string, Record<string, unknown>>, ignoreSuffixes?: string[]): void;

export declare function bootModelsFromWebpackContext(context: __WebpackModuleApi.RequireContext, ignoreSuffixes?: string[]): void;

export declare function closeEngineConnections(): Promise<void>;

export declare interface ClosesConnections {
    closeConnections(): Promise<void>;
}

export declare function defineModelSchema<Schema extends SchemaDefinition>(definition: Schema): Constructor<MagicAttributes<Schema, Key>> & ModelConstructor;

export declare function defineModelSchema<BaseModel extends Model, Schema extends SchemaDefinition>(baseModel: ModelConstructor<BaseModel>, definition: Schema): Constructor<MagicAttributes<Schema, Key>> & ModelConstructor<BaseModel>;

export declare class DocumentAlreadyExists extends SoukaiError {
    readonly id: string;
    constructor(id: string);
}

export declare class DocumentNotFound extends SoukaiError {
    readonly id: string;
    readonly collection?: string;
    constructor(id: string, collection?: string);
}

export declare function emitModelEvent<T extends keyof ModelClassEvents>(modelClass: ModelConstructor, ...args: ModelEmitArgs<T>): Promise<void>;

export declare function emitModelEvent<T extends keyof ModelEvents>(model: Model, ...args: ModelEmitArgs<T>): Promise<void>;

export declare interface Engine {
    create(collection: string, document: EngineDocument, id?: string): Promise<string>;
    readOne(collection: string, id: string): Promise<EngineDocument>;
    readMany(collection: string, filters?: EngineFilters): Promise<EngineDocumentsCollection>;
    update(collection: string, id: string, updates: EngineUpdates): Promise<void>;
    delete(collection: string, id: string): Promise<void>;
}

export declare type EngineAttributeFilter = EngineAttributeValue | {
    $eq: EngineAttributeValue;
} | {
    $or: EngineAttributeFilter[];
} | {
    $in: EngineAttributeLeafValue[];
} | {
    $contains: EngineAttributeFilter | EngineAttributeFilter[];
};

export declare type EngineAttributeLeafValue = string | number | boolean | null | Date;

export declare type EngineAttributeUpdate = EngineAttributeValue | EngineAttributeUpdateMap | EngineAttributeUpdateOperation | {
    $apply: EngineAttributeUpdateOperation[];
};

export declare interface EngineAttributeUpdateMap extends Record<string, EngineAttributeUpdate> {
}

export declare type EngineAttributeUpdateOperation = {
    $update: EngineAttributeUpdate;
} | {
    $updateItems: EngineUpdateItemsOperatorData | EngineUpdateItemsOperatorData[];
} | {
    $unset: string | string[] | true;
} | {
    $push: EngineAttributeValue;
};

export declare type EngineAttributeValue = EngineAttributeLeafValue | EngineAttributeValueMap | EngineAttributeValueArray | EngineAttributeValueArrayMap;

export declare interface EngineAttributeValueArray extends Array<EngineAttributeValue> {
}

export declare interface EngineAttributeValueArrayMap extends Array<Record<string, EngineAttributeValue>> {
}

export declare interface EngineAttributeValueMap extends Record<string, EngineAttributeValue> {
}

export declare function engineClosesConnections(engine: Engine): engine is Engine & ClosesConnections;

export declare type EngineDocument = Record<string, EngineAttributeValue>;

export declare type EngineDocumentsCollection = Record<string, EngineDocument>;

export declare type EngineFilters = EngineRootFilter & Record<string, EngineAttributeFilter>;

export declare class EngineHelper {
    private rootFilters;
    private rootUpdates;
    private attributeFilters;
    private attributeUpdates;
    constructor();
    filterDocuments(documents: EngineDocumentsCollection, filters?: EngineFilters): EngineDocumentsCollection;
    updateAttributes(attributes: Record<string, EngineAttributeValue>, updates: EngineUpdates): void;
    obtainDocumentId(id?: string): string;
    private filterDocument;
    private filterValue;
    private documentsIn;
    private documentOverwrite;
    private attributeEq;
    private attributeContains;
    private attributeOr;
    private attributeIn;
    private attributeUpdate;
    private attributeUpdateItems;
    private attributePush;
    private attributeUnset;
    private attributeApply;
    private attributeOverwrite;
    private isOperation;
    private runOperation;
    private requireArrayProperty;
}

export declare interface EngineRootFilter {
    $in?: (string | number | Record<string, string | number>)[];
}

export declare interface EngineUpdateItemsOperatorData {
    $where?: EngineFilters;
    $update?: EngineAttributeUpdate;
    $override?: EngineAttributeValueMap;
    $unset?: true;
}

export declare type EngineUpdates = Record<string, EngineAttributeUpdate> | {
    $unset: string | string[];
} | {
    $overwrite: EngineAttributeValue;
};

export declare function ensureInverseRelationsBooted(): void;

export declare function extractFinalEngine(engine: Engine): Engine;

export declare type FieldDefinition<T = unknown> = BasicFieldDefinition<T> | ArrayFieldDefinition<T> | ObjectFieldDefinition<T> | FieldTypeValue | Record<string, FieldTypeValue>;

export declare type FieldDefinitionBase<T = unknown> = T & {
    required?: boolean;
    alias?: string;
    cast?: (value: unknown) => unknown;
    set?: (this: Model, value: unknown) => void;
    get?: (this: Model) => unknown;
    serialize?: (value: any) => unknown;
    deserialize?: (value: any) => unknown;
};

export declare const FieldRequired: {
    Required: true;
    Optional: false;
};

export declare type FieldsDefinition<T = unknown> = Record<string, FieldDefinition<T>>;

export declare const FieldType: {
    Number: "number";
    String: "string";
    Boolean: "boolean";
    Array: "array";
    Object: "object";
    Date: "date";
    Key: "key";
    Any: "any";
};

export declare type FieldTypeValue = (typeof FieldType)[keyof typeof FieldType];

export declare type GetArrayFields<F extends FieldsDefinition> = {
    [K in keyof F]: F[K] extends {
        type: typeof FieldType.Array;
    } ? K : never;
}[keyof F];

export declare function getBootedModels(): Map<string, typeof Model>;

export declare type GetDefinedFields<F extends FieldsDefinition> = {
    [K in keyof F]: F[K] extends string | {
        type: string;
    } ? K : F[K] extends Record<string, string> ? K : never;
}[keyof F];

export declare function getEngine(): Engine | undefined;

export declare type GetFieldsDefinition<D extends SchemaDefinition> = D extends {
    fields: infer F;
} ? F extends undefined ? {} : F : {};

export declare type GetFieldType<T extends FieldDefinition> = T extends FieldTypeValue ? T : T extends BasicFieldDefinition ? T['type'] : T extends ArrayFieldDefinition ? T['items'][] : T extends ObjectFieldDefinition ? T['fields'] : T;

export declare function getFinalEngine(): Engine | undefined;

export declare function getModelsFromViteGlob(glob: Record<string, Record<string, unknown>>, ignoreSuffixes?: string[]): Record<string, typeof Model>;

export declare function getModelsFromWebpackContext(context: __WebpackModuleApi.RequireContext, ignoreSuffixes?: string[]): Record<string, typeof Model>;

export declare type GetRequiredFields<F extends FieldsDefinition> = {
    [K in keyof F]: F[K] extends {
        required: true;
    } ? K : never;
}[keyof F];

export declare type GetTimestampsDefinition<D extends SchemaDefinition> = D extends {
    timestamps: infer T;
} ? T extends undefined ? true : T : true;

export declare class HasManyRelation<Parent extends Model = Model, Related extends Model = Model, RelatedClass extends ModelConstructor<Related> = ModelConstructor<Related>> extends MultiModelRelation<Parent, Related, RelatedClass> {
    load(): Promise<Related[]>;
    setForeignAttributes(related: Related): void;
    clearForeignAttributes(related: Related): void;
}

export declare class HasOneRelation<Parent extends Model = Model, Related extends Model = Model, RelatedClass extends ModelConstructor<Related> = ModelConstructor<Related>> extends SingleModelRelation<Parent, Related, RelatedClass> {
    load(): Promise<Related | null>;
    setForeignAttributes(related: Related): void;
    clearForeignAttributes(related: Related): void;
}

export declare class IndexedDBEngine implements Engine, ClosesConnections {
    private database;
    private helper;
    private lock;
    private _metadata?;
    private _metadataConnection?;
    private _documentsConnection?;
    constructor(database?: null | string);
    getCollections(): Promise<string[]>;
    dropCollections(collections: string[]): Promise<void>;
    purgeDatabase(): Promise<void>;
    closeConnections(): Promise<void>;
    create(collection: string, document: EngineDocument, id?: string): Promise<string>;
    readOne(collection: string, id: string): Promise<EngineDocument>;
    readMany(collection: string, filters?: EngineFilters): Promise<EngineDocumentsCollection>;
    update(collection: string, id: string, updates: EngineUpdates): Promise<void>;
    delete(collection: string, id: string): Promise<void>;
    private __getCollections;
    private collectionExists;
    private documentExists;
    private getDocument;
    private createDocument;
    private updateDocument;
    private deleteDocument;
    private withMetadataTransaction;
    private withDocumentsTransaction;
    private getDocumentsConnection;
    private getMetadata;
    private initializeMetadata;
    private retryingOnTransactionInactive;
    private createCollection;
    private throwDatabaseBlockedError;
}

/**
 * Engine that stores data in memory. Data can be accessed with the [[database]] property to
 * get an [[InMemoryEngineDatabase]].
 */
export declare class InMemoryEngine implements Engine {
    private helper;
    private _database;
    constructor();
    get database(): InMemoryEngineDatabase;
    create(collectionName: string, document: EngineDocument, id?: string): Promise<string>;
    readOne(collectionName: string, id: string): Promise<EngineDocument>;
    readMany(collection: string, filters?: EngineFilters): Promise<EngineDocumentsCollection>;
    update(collectionName: string, id: string, updates: EngineUpdates): Promise<void>;
    delete(collectionName: string, id: string): Promise<void>;
    private hasCollection;
    private collection;
}

export declare interface InMemoryEngineCollection {
    [id: string]: EngineDocument;
}

export declare interface InMemoryEngineDatabase {
    [collection: string]: InMemoryEngineCollection;
}

export declare class InvalidModelAttributes extends SoukaiError {
    readonly modelName: string;
    readonly attributes: Attributes;
    constructor(modelName: string, attributes: Attributes, options?: SoukaiErrorOptions);
}

export declare class InvalidModelDefinition extends SoukaiError {
    readonly modelName: string;
    constructor(modelName: string, message: string);
}

/**
 * @deprecated Use ProxyEngine class instead.
 */
export declare interface IProxyEngine {
    getProxySubject(): Engine;
}

export declare function isArrayFieldDefinition(fieldDefinition: BootedFieldDefinition): fieldDefinition is BootedArrayFieldDefinition;

export declare function isArrayFieldDefinition(fieldDefinition: Omit<BootedFieldDefinition, 'required'>): fieldDefinition is Omit<BootedArrayFieldDefinition, 'required'>;

export declare function isObjectFieldDefinition(fieldDefinition: BootedFieldDefinition): fieldDefinition is BootedObjectFieldDefinition;

export declare function isObjectFieldDefinition(fieldDefinition: Omit<BootedFieldDefinition, 'required'>): fieldDefinition is Omit<BootedObjectFieldDefinition, 'required'>;

export declare function isProxyEngine(engine: Engine): engine is Engine & IProxyEngine;

export declare type Key = string | number | Record<string, string | number>;

export declare class LocalStorageEngine implements Engine {
    private prefix;
    private helper;
    constructor(prefix?: string);
    clear(): void;
    create(collection: string, document: EngineDocument, id?: string): Promise<string>;
    readOne(collection: string, id: string): Promise<EngineDocument>;
    readMany(collection: string, filters?: EngineFilters): Promise<EngineDocumentsCollection>;
    update(collection: string, id: string, updates: EngineUpdates): Promise<void>;
    delete(collection: string, id: string): Promise<void>;
    private readItem;
    private writeItem;
    private serializeAttributes;
    private serializeAttributeValue;
    private deserializeAttributes;
    private deserializeAttributeValue;
}

export declare class LogEngine<SubjectEngine extends Engine = Engine> extends ProxyEngine<SubjectEngine> {
    constructor(subject: SubjectEngine);
}

export declare type MagicAttributeProperties<T extends FieldsDefinition, TKey extends Key> = {
    -readonly [K in keyof T]: T[K] extends {
        deserialize: (value: any) => infer TValue;
    } ? TValue : MagicAttributeValue<GetFieldType<T[K]>, TKey>;
};

export declare type MagicAttributes<S extends SchemaDefinition, TKey extends Key> = Pretty<MagicAttributeProperties<{
    id: typeof FieldType.String;
}, TKey> & NestedMagicAttributes<GetFieldsDefinition<S>, TKey> & MagicTimestampAttributes<GetTimestampsDefinition<S>>>;

export declare type MagicAttributeValue<T, TKey extends Key> = T extends FieldsDefinition ? NestedMagicAttributes<T, TKey> : T extends FieldTypeValue ? ResolveFieldType<T, TKey> : T extends Array<infer R> ? R extends FieldTypeValue ? ResolveFieldType<R, TKey>[] : never : never;

export declare type MagicTimestampAttributes<T extends TimestampsDefinition> = T extends false ? {} : T extends (typeof TimestampField.CreatedAt)[] ? {
    createdAt: Date;
} : T extends (typeof TimestampField.UpdatedAt)[] ? {
    updatedAt: Date;
} : {
    createdAt: Date;
    updatedAt: Date;
};

export declare class Model {
    static collection: string;
    static primaryKey: string;
    static timestamps: TimestampsDefinition;
    static fields: FieldsDefinition;
    static modelName: string;
    static classFields: string[];
    static relations: string[];
    static hooks: ModelHooks;
    static __attributeGetters: Map<string, () => unknown>;
    static __attributeSetters: Map<string, (value: unknown) => void>;
    private static instances;
    private static pureInstances;
    private static bootedModels;
    private static engines;
    private static ignoringTimestamps;
    private static fieldAliases;
    static boot<T extends Model>(this: ModelConstructor<T>, name?: string): void;
    static ensureBooted<T extends Model>(this: ModelConstructor<T>): void;
    static updateSchema(schema: SchemaDefinition | ModelConstructor): Promise<void>;
    static create<T extends Model>(this: ModelConstructor<T>, attributes?: Attributes): Promise<T>;
    static createFromEngineDocument<T extends Model>(this: ModelConstructor<T>, id: Key, document: EngineDocument): Promise<T>;
    static createManyFromEngineDocuments<T extends Model>(this: ModelConstructor<T>, documents: Record<string, EngineDocument>): Promise<T[]>;
    static findOrFail<T extends Model>(this: ModelConstructor<T>, id: Key): Promise<T>;
    static find<T extends Model>(this: ModelConstructor<T>, id: Key): Promise<T | null>;
    static all<T extends Model>(this: ModelConstructor<T>, filters?: EngineFilters): Promise<T[]>;
    static first<T extends Model>(this: ModelConstructor<T>, filters?: EngineFilters): Promise<T | null>;
    static newInstance<T extends Model>(this: ModelConstructor<T>, ...params: ConstructorParameters<ModelConstructor<T>>): T;
    static on<TModel extends Model, TEvent extends keyof ModelEvents | keyof ModelClassEvents>(this: ModelConstructor<TModel>, event: TEvent, listener: ModelListener<TModel, TEvent>): () => void;
    static instance<T extends Model>(this: ModelConstructor<T>): T;
    static hasAutomaticTimestamp(timestamp: TimestampFieldValue): boolean;
    static hasAutomaticTimestamps(): boolean;
    static getEngine(): Engine | undefined;
    static getFinalEngine(): Engine | undefined;
    static requireEngine<T extends Engine = Engine>(): T;
    static requireFinalEngine<T extends Engine = Engine>(): T;
    static setEngine(engine?: Engine): void;
    static withEngine<T>(this: T, engine: Engine): T;
    static withEngine<T>(engine: Engine, operation: () => T): T;
    static withEngine<T>(engine: Engine, operation: () => Promise<T>): Promise<T>;
    static withCollection<Result>(collection: string | undefined, operation: () => Result | Promise<Result>): Promise<Result>;
    static withoutTimestamps<T>(operation: () => Promise<T>): Promise<T>;
    static exclusive<T>(operation: () => Promise<T> | T): Promise<T>;
    protected static pureInstance<T extends Model>(this: ModelConstructor<T>): T;
    protected static bootModelName(name?: string): string;
    protected static bootCollection(): string;
    protected static bootTimestamps(timestamps: TimestampFieldValue[] | boolean | undefined, fieldDefinitions: BootedFieldsDefinition): TimestampFieldValue[];
    protected static bootFields(fields: FieldsDefinition | undefined, primaryKey: string, timestamps: TimestampFieldValue[], fieldDefinitions: BootedFieldsDefinition): {
        fields: BootedFieldsDefinition;
        fieldAliases: Record<string, string>;
    };
    protected static bootClassDefinitions(): {
        classFields: string[];
        relations: string[];
        attributeGetters: Map<string, () => unknown>;
        attributeSetters: Map<string, (value: unknown) => void>;
    };
    protected static bootHooks(hooks?: ModelHooks): ModelHooks;
    protected static performSchemaUpdate(schema: SchemaDefinition | ModelConstructor): Promise<void>;
    id: string;
    protected _exists: boolean;
    protected _wasRecentlyCreated: boolean;
    protected _proxy: this;
    protected _attributes: Attributes;
    protected _originalAttributes: Attributes;
    protected _dirtyAttributes: Attributes;
    protected _malformedDocumentAttributes: Record<string, string[]>;
    protected _relations: {
        [relation: string]: Relation;
    };
    private _engine?;
    private _recentlyDeletedPrimaryKey?;
    constructor(attributes?: Attributes, _?: boolean);
    static(property: 'fields'): BootedFieldsDefinition;
    static(property: 'timestamps'): TimestampFieldValue[];
    static<T extends typeof Model>(): T;
    static<T extends typeof Model, K extends keyof T>(property: K): T[K];
    newInstance<T extends Model>(this: T, ...params: ConstructorParameters<ModelConstructor<T>>): T;
    fresh(): Promise<this>;
    update(attributes?: Attributes): Promise<this>;
    hasRelation(relation: string): boolean;
    getRelation<T extends Relation = Relation>(relation: string): T | null;
    requireRelation<T extends Relation = Relation>(relation: string): T;
    getEngine(): Engine | undefined;
    getFinalEngine(): Engine | undefined;
    requireEngine<T extends Engine>(): T;
    requireFinalEngine<T extends Engine>(): T;
    getDefaultCollection(): string;
    loadRelation<T extends Model | null | Model[] = Model | null | Model[]>(relation: string): Promise<T>;
    loadRelationIfUnloaded<T extends Model | null | Model[] = Model | null | Model[]>(relation: string): Promise<T>;
    unloadRelation(relation: string): void;
    getRelationModel<T extends Model>(relation: string): T | null;
    getRelationModels<T extends Model>(relation: string): T[] | null;
    setRelationModel(relation: string, model: Model | null): void;
    setRelationModels(relation: string, models: Model[] | null): void;
    isRelationLoaded(relation: string): boolean;
    hasAttribute(field: string): boolean;
    setAttribute(field: string, value: unknown): void;
    setAttributeValue(field: string, value: unknown): void;
    hasAttributeSetter(field: string): boolean;
    callAttributeSetter(field: string, value: unknown): void;
    getOriginalAttribute<T = unknown>(field: string): T;
    getDeletedPrimaryKey(): Key | null;
    setOriginalAttribute(field: string, value: unknown): void;
    setAttributes(attributes: Attributes): void;
    getMalformedDocumentAttributes(): Record<string, string[]>;
    setMalformedDocumentAttributes(malformedAttributes: Record<string, string[]>): void;
    setEngine(engine?: Engine): void;
    withEngine(engine: Engine): this;
    withEngine<T>(engine: Engine, operation: (model: this) => T): T;
    withEngine<T>(engine: Engine, operation: (model: this) => Promise<T>): Promise<T>;
    withoutTimestamps<T>(operation: () => Promise<T>): Promise<T>;
    getAttribute<T = unknown>(field: string, includeUndefined?: boolean): T;
    getAttributeValue<T = unknown>(field: string, includeUndefined?: boolean): T;
    getAttributes(includeUndefined?: boolean): Attributes;
    hasAttributeGetter(field: string): boolean;
    callAttributeGetter(field: string): unknown;
    unsetAttribute(field: string): void;
    hasIncompleteAttributes(): boolean;
    is(another: this): boolean;
    isDirty(field?: string): boolean;
    cleanDirty(): void;
    reset(): void;
    getPrimaryKey(): Key | null;
    getSerializedPrimaryKey(): string | null;
    delete(): Promise<this>;
    save(): Promise<this>;
    fixMalformedAttributes(): void;
    /**
     * Set the `updatedAt` attribute to the current time.
     */
    touch(): void;
    setExists(exists: boolean): void;
    exists(): boolean;
    wasRecentlyCreated(): boolean;
    wasRecentlyDeleted(): boolean;
    clone(options?: ModelCloneOptions): this;
    clone<T extends Model>(options?: ModelCloneOptions): T;
    protected initialize(attributes: Attributes, exists: boolean): void;
    protected initializeProxy(): void;
    protected initializeAttributes(attributes: Attributes, exists: boolean): void;
    protected initializeRelations(): void;
    protected createFromEngineDocument(id: Key, document: EngineDocument): Promise<this>;
    protected createManyFromEngineDocuments(documents: Record<string, EngineDocument>): Promise<this[]>;
    protected beforeSave(): Promise<void>;
    protected performSave(): Promise<void>;
    protected afterSave(): Promise<void>;
    protected performDelete(): Promise<void>;
    protected performMalformedAttributeFixes(): void;
    protected emit<T extends keyof ModelEvents>(...args: ModelEmitArgs<T>): Promise<void>;
    protected syncDirty(): Promise<string>;
    protected getCascadeModels(): Promise<Model[]>;
    protected deleteModelsFromEngine(models: Model[]): Promise<void>;
    /**
     * @deprecated use `reset` instead.
     */
    protected resetEngineData(): void;
    /**
     * Creates a relation when this model is referenced by one instance of another model.
     *
     * @param relatedClass - Related model class.
     * @param foreignKeyField - Name of the foreign key field in the related model.
     * @param localKeyField - Name of the local key field in the local model. Defaults to
     * the primary key name defined in the local model class.
     */
    protected hasOne<T extends typeof Model>(relatedClass: T, foreignKeyField?: string, localKeyField?: string): HasOneRelation;
    /**
     * Creates a relation when this model references one instance of another model.
     *
     * @param relatedClass - Related model class.
     * @param foreignKeyField - Name of the foreign key field in the local model.
     * @param localKeyField - Name of the local key field in the related model. Defaults to
     * the primary key name defined in the related model class.
     */
    protected belongsToOne<T extends typeof Model>(relatedClass: T, foreignKeyField?: string, localKeyField?: string): BelongsToOneRelation;
    /**
     * Creates a relation when this model is referenced by multiple instances of another model.
     *
     * @param relatedClass - Related model class.
     * @param foreignKeyField - Name of the foreign key field in the related model.
     * @param localKeyField - Name of the local key field in the local model. Defaults to
     * the primary key name defined in the local model class.
     */
    protected hasMany<T extends typeof Model>(relatedClass: T, foreignKeyField?: string, localKeyField?: string): HasManyRelation;
    /**
     * Creates a relation when this model references multiple instances of another model.
     *
     * @param relatedClass - Related model class.
     * @param foreignKeyField - Name of the foreign key field in the local model.
     * @param localKeyField - Name of the local key field in the related model. Defaults to
     * the primary key name defined in the related model class.
     */
    protected belongsToMany<T extends typeof Model>(relatedClass: T, foreignKeyField?: string, localKeyField?: string): BelongsToManyRelation;
    protected loadEmptyRelations(): Promise<void>;
    protected attributeValueChanged(originalValue: unknown, newValue: unknown): boolean;
    protected markAttributeDirty(field: string, originalValue: unknown, newValue: unknown): boolean;
    protected castAttributes(attributes: Attributes, definitions: BootedFieldsDefinition, malformedAttributes?: Record<string, string[]>, fieldPrefix?: string): Attributes;
    protected castAttribute(value: unknown, { field, definition, malformedAttributes }?: ModelCastAttributeOptions): unknown;
    protected toEngineDocument(): EngineDocument;
    protected getDirtyEngineDocumentUpdates(): EngineUpdates;
    protected populateCascadeModels(cascadeModels: Set<Model>): Promise<void>;
    protected parseEngineDocumentAttributes(id: Key, document: EngineDocument): Promise<Attributes>;
    protected serializeKey(key: Key): string;
    protected parseKey(key: string): Key;
}

export declare type ModelCastAttributeOptions = {
    field?: string;
    definition?: BootedFieldDefinition;
    malformedAttributes?: Record<string, string[]>;
};

export declare interface ModelClassEvents {
    'schema-updated': SchemaDefinition;
}

export declare type ModelCloneOptions = Partial<{
    clean: boolean;
    clones: WeakMap<Model, Model>;
    constructors: WeakMap<typeof Model, typeof Model> | [typeof Model, typeof Model][];
}>;

export declare type ModelConstructor<T extends Model = Model> = Constructor<T> & typeof Model;

export declare type ModelEmitArgs<T extends keyof ModelEvents | keyof ModelClassEvents> = T extends keyof ModelEvents ? ModelEvents[T] extends void ? [event: T] : [event: T, payload: ModelEvents[T]] : T extends keyof ModelClassEvents ? ModelClassEvents[T] extends void ? [event: T] : [event: T, payload: ModelClassEvents[T]] : never;

/**
 * @deprecated Use ModelEvents keys instead.
 */
export declare const ModelEvent: {
    Created: "created";
    Deleted: "deleted";
    Updated: "updated";
};

export declare interface ModelEvents {
    created: void;
    deleted: void;
    updated: void;
    modified: string;
    'relation-loaded': Relation;
}

/**
 * @deprecated Use ModelEvents keys instead.
 */
export declare type ModelEventValue = (typeof ModelEvent)[keyof typeof ModelEvent];

export declare interface ModelHooks {
    beforeSave?: (this: Model) => Promise<void> | void;
    afterSave?: (this: Model) => Promise<void> | void;
    afterInitialize?: (this: Model) => void;
}

export declare class ModelKey {
    static from(value: unknown): ModelKey;
    private value;
    constructor(rawValue: unknown);
    equals(other: ModelKey): boolean;
    toString(): string;
}

export declare type ModelListener<TModel extends Model = Model, TEvent extends keyof ModelEvents | keyof ModelClassEvents = keyof ModelEvents | keyof ModelClassEvents> = (...args: ModelListenerArgs<TModel, TEvent>) => unknown;

export declare type ModelListenerArgs<TModel extends Model, TEvent extends keyof ModelEvents | keyof ModelClassEvents> = TEvent extends keyof ModelEvents ? ModelEvents[TEvent] extends void ? [model: TModel] : [model: TModel, payload: ModelEvents[TEvent]] : TEvent extends keyof ModelClassEvents ? ModelClassEvents[TEvent] extends void ? [] : [payload: ModelClassEvents[TEvent]] : never;

export declare interface ModelsRegistry {
}

export declare abstract class MultiModelRelation<Parent extends Model = Model, Related extends Model = Model, RelatedClass extends ModelConstructor<Related> = ModelConstructor<Related>> extends Relation<Parent, Related, RelatedClass> {
    constructor(parent: Parent, relatedClass: RelatedClass, foreignKeyName?: string, localKeyName?: string);
    get related(): Related[] | undefined;
    set related(related: Related[] | undefined);
    attach(model?: Related): Related;
    attach(attributes: Attributes): Related;
    create(attributes?: Attributes): Promise<Related>;
    addRelated(related: Related): void;
    removeRelated(related: Related): void;
    abstract load(): Promise<Related[]>;
    isRelated(model: Related): boolean;
    protected onRelatedUpdated(oldValue: Nullable<Model[]>, newValue: Nullable<Model[]>): void;
    protected assertLoaded(method: string): this is {
        related: Related[];
    };
}

export declare type NestedMagicAttributes<T extends FieldsDefinition, TKey extends Key> = MagicAttributeProperties<Pick<T, GetRequiredFields<T>>, TKey> & Partial<MagicAttributeProperties<Pick<T, GetDefinedFields<T>>, TKey>>;

export declare type ObjectFieldDefinition<T = unknown> = FieldDefinitionBase<T> & {
    type: typeof FieldType.Object;
    fields: FieldsDefinition<T>;
};

export declare class ProxyEngine<SubjectEngine extends Engine = Engine> implements Engine, IProxyEngine {
    readonly subject: SubjectEngine;
    private overrides;
    constructor(subject: SubjectEngine, overrides?: Partial<Engine>);
    getProxySubject(): Engine;
    create(collection: string, document: EngineDocument, id?: string): Promise<string>;
    readOne(collection: string, id: string): Promise<EngineDocument>;
    readMany(collection: string, filters?: EngineFilters): Promise<EngineDocumentsCollection>;
    update(collection: string, id: string, updates: EngineUpdates): Promise<void>;
    delete(collection: string, id: string): Promise<void>;
}

export declare function registerModelListener<TModel extends Model, TEvent extends keyof ModelEvents | keyof ModelClassEvents>(modelClass: ModelConstructor<TModel>, event: TEvent, listener: ModelListener<TModel, TEvent>): () => void;

export declare abstract class Relation<Parent extends Model = Model, Related extends Model = Model, RelatedClass extends ModelConstructor<Related> = ModelConstructor<Related>> {
    static inverseHasRelationClasses: Constructor<Relation>[];
    static inverseBelongsToRelationClasses: Constructor<Relation>[];
    name: string;
    parent: Parent;
    relatedClass: RelatedClass;
    foreignKeyName: string;
    localKeyName: string;
    enabled: boolean;
    deleteStrategy: RelationDeleteStrategy;
    protected _related?: Related[] | Related | null;
    constructor(parent: Parent, relatedClass: RelatedClass, foreignKeyName: string, localKeyName?: string);
    get loaded(): boolean;
    get related(): Nullable<Related[] | Related>;
    set related(related: Nullable<Related[] | Related>);
    static(): RelationConstructor<this>;
    enable(): void;
    disable(): void;
    abstract load(): Promise<Related[] | Related | null>;
    abstract setForeignAttributes(related: Related): void;
    abstract clearForeignAttributes(related: Related): void;
    abstract addRelated(related: Related): void;
    abstract removeRelated(related: Related): void;
    abstract isRelated(model: Related): boolean;
    /**
     * @deprecated This method has been renamed to `load`.
     */
    resolve(): Promise<Related[] | Related | null>;
    isEmpty(): boolean | null;
    getModels(): Promise<Related[]>;
    getLoadedModels(): Related[];
    unload(): void;
    onDelete(strategy: RelationDeleteStrategy): this;
    clone(options?: RelationCloneOptions): this;
    initializeInverseRelations(model: Related): void;
    clearInverseRelations(model: Related): void;
    isInverseOf(other: Relation): boolean;
    protected onRelatedUpdated(oldValue: Nullable<Model[] | Model>, newValue: Nullable<Model[] | Model>): void;
}

export declare type RelationCloneOptions = Partial<{
    clones: WeakMap<Model, Model>;
    constructors: WeakMap<typeof Model, typeof Model>;
}>;

export declare type RelationConstructor<T extends Relation = Relation> = Constructor<T> & typeof Relation;

export declare type RelationDeleteStrategy = null | 'cascade';

export declare function requireBootedModel<T extends keyof ModelsRegistry>(name: T): ModelsRegistry[T];

export declare function requireBootedModel<T extends ModelConstructor<Model> = ModelConstructor<Model>>(name: string): T;

export declare function requireEngine<T extends Engine = Engine>(): T;

export declare function requireFinalEngine<T extends Engine = Engine>(): T;

export declare function resetModelListeners(): void;

export declare type ResolveFieldType<T extends FieldTypeValue, TKey extends Key> = T extends typeof FieldType.Number ? number : T extends typeof FieldType.String ? string : T extends typeof FieldType.Boolean ? boolean : T extends typeof FieldType.Date ? Date : T extends typeof FieldType.Key ? TKey : T extends typeof FieldType.Any ? any : never;

export declare type SchemaDefinition<T = unknown> = Partial<{
    primaryKey: string;
    timestamps: TimestampsDefinition;
    fields: FieldsDefinition<T>;
    hooks?: ModelHooks;
}>;

export declare function setEngine(engine: Engine | null): void;

export declare abstract class SingleModelRelation<Parent extends Model = Model, Related extends Model = Model, RelatedClass extends ModelConstructor<Related> = ModelConstructor<Related>> extends Relation<Parent, Related, RelatedClass> {
    constructor(parent: Parent, relatedClass: RelatedClass, foreignKeyName?: string, localKeyName?: string);
    get related(): Related | undefined | null;
    set related(related: Related | undefined | null);
    attach(model?: Related): Related;
    attach(attributes: Attributes): Related;
    addRelated(related: Related): void;
    removeRelated(related: Related): void;
    isRelated(related: Related): boolean;
    abstract load(): Promise<Related | null>;
    protected onRelatedUpdated(oldValue: Nullable<Model>, newValue: Nullable<Model>): void;
}

export declare class SoukaiError extends Error {
    constructor(message?: string, options?: SoukaiErrorOptions);
}

export declare interface SoukaiErrorOptions {
    cause?: unknown;
}

export declare const TimestampField: {
    CreatedAt: "createdAt";
    UpdatedAt: "updatedAt";
};

export declare type TimestampFieldValue = (typeof TimestampField)[keyof typeof TimestampField];

export declare type TimestampsDefinition = TimestampFieldValue[] | boolean;

export declare function withEngine<T>(engine: Engine, operation: () => T): T;

export declare function withEngine<T>(engine: Engine, operation: () => Promise<T>): Promise<T>;

export { }