import { Request } from "express";
import { Connection } from "mysql";
import Extendable from "../Extendable.js";
import { Type } from "../Utils.js";
import ModelComponent from "./ModelComponent.js";
import ModelFactory, { PrimaryKeyValue } from "./ModelFactory.js";
import ModelQuery, { ModelFieldData, ModelQueryResult, QueryFields } from "./ModelQuery.js";
import Validator from "./Validator.js";
export default abstract class Model implements Extendable<ModelComponent<Model>> {
    static get table(): string;
    static getPrimaryKeyFields(): string[];
    static create<M extends Model>(this: ModelType<M>, data: Pick<M, keyof M>): M;
    static select<M extends Model>(this: ModelType<M>, ...fields: QueryFields): ModelQuery<M>;
    static update<M extends Model>(this: ModelType<M>, data: Pick<M, keyof M>): ModelQuery<M>;
    static delete<M extends Model>(this: ModelType<M>): ModelQuery<M>;
    static getById<M extends Model>(this: ModelType<M>, ...id: PrimaryKeyValue[]): Promise<M | null>;
    static paginate<M extends Model>(this: ModelType<M>, request: Request, perPage?: number, query?: ModelQuery<M>): Promise<ModelQueryResult<M>>;
    protected readonly _factory: ModelFactory<Model>;
    private readonly _components;
    private readonly _validators;
    private _exists;
    [key: string]: ModelFieldData;
    constructor(factory: ModelFactory<never>, isNew: boolean);
    protected init?(): void;
    protected setValidation<K extends keyof this>(propertyName: K): Validator<this[K]>;
    addComponent(modelComponent: ModelComponent<this>): void;
    as<C extends ModelComponent<Model>>(type: Type<C>): C;
    asOptional<C extends ModelComponent<Model>>(type: Type<C>): C | null;
    has<C extends ModelComponent<Model>>(type: Type<C>): boolean;
    require<C extends ModelComponent<Model>>(type: Type<C>): void;
    updateWithData(data: Pick<this, keyof this> | Record<string, unknown>): void;
    /**
     * Override this to automatically fill obvious missing data i.e. from relation or default value that are fetched
     * asynchronously.
     */
    protected autoFill?(): Promise<void>;
    protected beforeSave?(connection: Connection): Promise<void>;
    protected afterSave?(): Promise<void>;
    save(connection?: Connection, postHook?: (callback: () => Promise<void>) => void): Promise<void>;
    private saveTransaction;
    delete(): Promise<void>;
    validate(onlyFormat?: boolean, connection?: Connection): Promise<void[]>;
    exists(): boolean;
    equals(model: this): boolean;
    get table(): string;
    private get _properties();
    private hasProperty;
    getOrFail<K extends keyof this & string>(k: K): NonNullable<this[K]>;
}
export interface ModelType<M extends Model> extends Type<M> {
    table: string;
    new (factory: ModelFactory<never>, isNew: boolean): M;
    getPrimaryKeyFields(): (keyof M & string)[];
    select<M extends Model>(this: ModelType<M>, ...fields: QueryFields): ModelQuery<M>;
}