import { DataTable } from '../database/DataTable';
import { PaginationResult } from '../database/PaginationResult';
import { Field } from '../database/query';
import { Condition, ConditionGroup, ExistsSubquery } from '../database/query/conditions';
import { OrderByDirection } from '../database/query/features/HasOrderByFields';
import { EntityQuery } from './EntityQuery';
import { Scope } from './Scope';
/** A concrete entity class: constructible and carrying the BaseEntity statics. */
export type EntityClass<T extends BaseEntity = BaseEntity> = typeof BaseEntity & (new () => T);
/**
 * Optional Active Record base class. Entities that extend BaseEntity get
 * instance-level save()/delete() and class-level query methods as convenience
 * delegates. All real logic lives in EntityRepository — BaseEntity is a
 * thin shell that calls Repository.get(this) and forwards.
 *
 * Entities that do NOT extend BaseEntity work identically through the
 * Repository directly: Repository.get(Country).where(...).find()
 *
 * Note: BaseEntity holds NO metadata. All metadata is stored inside
 * EntityRepository's internal store, populated exclusively by @Entity.
 */
export declare abstract class BaseEntity {
    private static _repo;
    /**
     * Called once per entity class the first time its repository is accessed.
     * Override to register global scopes:
     *
     *   protected static booted(): void {
     *     static.addGlobalScope('active', query => query.where('status', 'active'))
     *   }
     */
    protected static booted(): void;
    /**
     * Registers a named global scope applied to every query for this entity.
     *
     *   // Inline callback:
     *   static::addGlobalScope('active', query => query.where('status', 'active'))
     *
     *   // Reusable Scope object (key = class name):
     *   static::addGlobalScope(new ActiveScope)
     */
    static addGlobalScope<T extends BaseEntity>(this: EntityClass<T>, nameOrScope: string | Scope<T>, callback?: (query: EntityQuery<T>) => void | Promise<void>): void;
    /**
     * Returns an EntityQuery with the given named global scope(s) disabled.
     *
     *   Product.withoutGlobalScope('active').get()
     */
    static withoutGlobalScope<T extends BaseEntity>(this: EntityClass<T>, ...names: string[]): EntityQuery<T>;
    /**
     * Returns an EntityQuery with ALL global scopes disabled.
     *
     *   Product.withoutGlobalScopes().get()
     */
    static withoutGlobalScopes<T extends BaseEntity>(this: EntityClass<T>): EntityQuery<T>;
    static query<T extends BaseEntity>(this: EntityClass<T>): DataTable;
    static fromRow<T extends BaseEntity>(this: EntityClass<T>, row: Record<string, any>): T;
    /**
     * Re-hydrates a plain object (typically the output of toJSON, or JSON.parse
     * of a serialized entity) back into a typed entity instance. Date fields and
     * related entities are restored recursively.
     */
    static fromJSON<T extends BaseEntity>(this: EntityClass<T>, json: Record<string, any>): T;
    static find<T extends BaseEntity>(this: EntityClass<T>, id: any): Promise<T | null>;
    static get<T extends BaseEntity>(this: EntityClass<T>): Promise<T[]>;
    static first<T extends BaseEntity>(this: EntityClass<T>): Promise<T | null>;
    static count<T extends BaseEntity>(this: EntityClass<T>, column?: Field): Promise<number>;
    static paginate<T extends BaseEntity>(this: EntityClass<T>, perPage?: number, page?: number): Promise<PaginationResult<T>>;
    /**
     * SUM of a column across every row this entity's global scopes let you see.
     * Sums to 0 over an empty result set.
     *
     *   await Order.sum('amount')
     *   await Order.where('paid', true).sum('amount')
     */
    static sum<T extends BaseEntity>(this: EntityClass<T>, column: Field): Promise<number>;
    /** AVG of a column, scoped. Null when nothing matched. */
    static avg<T extends BaseEntity>(this: EntityClass<T>, column: Field): Promise<number | null>;
    /**
     * MIN of a column, scoped and uncast (see `DataTable.min`). Null when nothing
     * matched.
     *
     * The value type comes first among the type parameters so it can be given
     * explicitly — `Payment.min<Date>('settledAt')` — while the entity type stays
     * inferred from the call.
     */
    static min<V = any, T extends BaseEntity = BaseEntity>(this: EntityClass<T>, column: Field): Promise<V | null>;
    /** MAX of a column, scoped and uncast (see `DataTable.min`). Null when nothing matched. */
    static max<V = any, T extends BaseEntity = BaseEntity>(this: EntityClass<T>, column: Field): Promise<V | null>;
    /**
     * Drops down to the underlying DataTable with this entity's global scopes
     * already applied, so rows come back raw instead of hydrated. For grouped
     * aggregates and other projections that are not a row of the table — see
     * `EntityQuery.toBase`.
     */
    static toBase<T extends BaseEntity>(this: EntityClass<T>): Promise<DataTable>;
    static where<T extends BaseEntity>(this: EntityClass<T>, callback: (group: ConditionGroup) => void): EntityQuery<T>;
    static where<T extends BaseEntity>(this: EntityClass<T>, condition: Condition): EntityQuery<T>;
    static where<T extends BaseEntity>(this: EntityClass<T>, field: Field, value: any): EntityQuery<T>;
    static where<T extends BaseEntity>(this: EntityClass<T>, field: Field, operator: string, value: any): EntityQuery<T>;
    static whereIn<T extends BaseEntity>(this: EntityClass<T>, field: Field, values: any[]): EntityQuery<T>;
    static whereNotIn<T extends BaseEntity>(this: EntityClass<T>, field: Field, values: any[]): EntityQuery<T>;
    static whereBetween<T extends BaseEntity>(this: EntityClass<T>, field: Field, range: [any, any]): EntityQuery<T>;
    static whereNotBetween<T extends BaseEntity>(this: EntityClass<T>, field: Field, range: [any, any]): EntityQuery<T>;
    static whereNull<T extends BaseEntity>(this: EntityClass<T>, field: Field): EntityQuery<T>;
    static whereNotNull<T extends BaseEntity>(this: EntityClass<T>, field: Field): EntityQuery<T>;
    static whereLike<T extends BaseEntity>(this: EntityClass<T>, field: Field, pattern: string): EntityQuery<T>;
    static whereNotLike<T extends BaseEntity>(this: EntityClass<T>, field: Field, pattern: string): EntityQuery<T>;
    static whereColumn<T extends BaseEntity>(this: EntityClass<T>, field: Field, column: Field): EntityQuery<T>;
    static whereColumn<T extends BaseEntity>(this: EntityClass<T>, field: Field, operator: string, column: Field): EntityQuery<T>;
    static whereExists<T extends BaseEntity>(this: EntityClass<T>, subquery: ExistsSubquery): EntityQuery<T>;
    static whereArrayContains<T extends BaseEntity>(this: EntityClass<T>, field: Field, value: any): EntityQuery<T>;
    static whereNotExists<T extends BaseEntity>(this: EntityClass<T>, subquery: ExistsSubquery): EntityQuery<T>;
    static orderBy<T extends BaseEntity>(this: EntityClass<T>, field: Field, direction?: OrderByDirection): EntityQuery<T>;
    static orderByDesc<T extends BaseEntity>(this: EntityClass<T>, field: Field): EntityQuery<T>;
    static groupBy<T extends BaseEntity>(this: EntityClass<T>, ...fields: Field[]): EntityQuery<T>;
    static having<T extends BaseEntity>(this: EntityClass<T>, condition: Condition): EntityQuery<T>;
    static having<T extends BaseEntity>(this: EntityClass<T>, field: Field, value: any): EntityQuery<T>;
    static having<T extends BaseEntity>(this: EntityClass<T>, field: Field, operator: string, value: any): EntityQuery<T>;
    static orHaving<T extends BaseEntity>(this: EntityClass<T>, condition: Condition): EntityQuery<T>;
    static orHaving<T extends BaseEntity>(this: EntityClass<T>, field: Field, value: any): EntityQuery<T>;
    static orHaving<T extends BaseEntity>(this: EntityClass<T>, field: Field, operator: string, value: any): EntityQuery<T>;
    static distinct<T extends BaseEntity>(this: EntityClass<T>): EntityQuery<T>;
    static limit<T extends BaseEntity>(this: EntityClass<T>, value: number): EntityQuery<T>;
    static offset<T extends BaseEntity>(this: EntityClass<T>, value: number): EntityQuery<T>;
    static select<T extends BaseEntity>(this: EntityClass<T>, ...fields: (Field | Field[])[]): EntityQuery<T>;
    static when<T extends BaseEntity>(this: EntityClass<T>, condition: any, callback: (query: EntityQuery<T>) => void): EntityQuery<T>;
    static with<T extends BaseEntity>(this: EntityClass<T>, relations: Record<string, (query: EntityQuery<T>) => void>): EntityQuery<T>;
    static with<T extends BaseEntity>(this: EntityClass<T>, relations: string | string[], ...rest: string[]): EntityQuery<T>;
    static whereHas<T extends BaseEntity>(this: EntityClass<T>, relationName: string, callback?: (query: EntityQuery<T>) => void): EntityQuery<T>;
    static orWhereHas<T extends BaseEntity>(this: EntityClass<T>, relationName: string, callback?: (query: EntityQuery<T>) => void): EntityQuery<T>;
    static joinRelationship<T extends BaseEntity>(this: EntityClass<T>, relationName: string): EntityQuery<T>;
    static innerJoinRelationship<T extends BaseEntity>(this: EntityClass<T>, relationName: string): EntityQuery<T>;
    static leftJoinRelationship<T extends BaseEntity>(this: EntityClass<T>, relationName: string): EntityQuery<T>;
    /**
     * Inserts the given records in a single batch statement. Mirrors Eloquent's
     * `Model::insert($values)`:
     *
     *   await Match.insert([
     *     { roundId: 4, position: 0, homeCompetitorIds: [1], status: 0 },
     *     { roundId: 4, position: 1, homeCompetitorIds: [2], status: 0 }
     *   ])
     *
     * Values are expressed as entity properties and mapped to columns with their
     * declared casts. Auto-generated columns are never written and generated keys
     * are not read back. Returns the number of affected rows.
     */
    static insert<T extends BaseEntity>(this: EntityClass<T>, values: Record<string, any>[]): Promise<number>;
    /**
     * Inserts the given records, updating the conflicting columns when a row
     * already exists. Mirrors Eloquent's `Model::upsert($values, $uniqueBy, $update)`:
     *
     *   await PlayerStatistics.upsert(
     *     [{ playerId: 7, points: 120, updatedAt: new Date() }],
     *     'playerId',                 // unique-by property (or properties)
     *     ['points', 'updatedAt']     // properties to overwrite on conflict (optional)
     *   )
     *
     * When `update` is omitted, every provided column that is not part of
     * `uniqueBy` is updated. Returns the number of affected rows.
     */
    static upsert<T extends BaseEntity>(this: EntityClass<T>, values: Record<string, any>[], uniqueBy: string | string[], update?: string[]): Promise<number>;
    save(): Promise<void>;
    delete(): Promise<void>;
    /**
     * True if this entity (or, when given, a specific property) has unsaved
     * changes relative to its last hydration/save.
     *
     *   user.email = 'new@x.com'
     *   user.isDirty()          // true
     *   user.isDirty('name')    // false
     */
    isDirty(field?: string): boolean;
    /**
     * Returns a `{ property: value }` map of only the properties that changed
     * since this entity's last hydration/save.
     */
    getDirty(): Record<string, any>;
    toDto(): Record<string, any>;
    /**
     * Serializes this entity into a plain, JSON-safe object: Date values become
     * ISO-8601 strings and loaded relationships are serialized recursively.
     * Delegates to the EntityRepository so behaviour matches
     * Repository.get(EntityClass).toJSON(instance).
     */
    toJSON(): Record<string, any>;
}