import { type CursorPaginatedResult, type PaginatedResult } from "../pagination/index.ts";
import { type BelongsToManyRelation, type BelongsToRelation, type HasManyRelation, type HasManyThroughRelation, type MorphManyRelation, type MorphOneRelation, type MorphToRelation } from "./relationships.ts";
import { RepositoryQuery } from "./repositoryQuery.ts";
import type { TableDefinition } from "./table.ts";
import type { MutationValues, QueryOptions, QueryWhere, UpdateValues } from "./types.ts";
import type { WhereNode } from "./whereBuilder.ts";
type ExtendedQueryOptions<TEntity extends object> = QueryOptions<TEntity> & {
    whereNodes?: WhereNode<TEntity>[];
};
interface DatabaseConnection {
    unsafe<T>(query: string, params?: readonly unknown[]): Promise<T[]>;
    begin?<T>(callback: (transaction: DatabaseConnection) => Promise<T>): Promise<T>;
    /** SQLite closes synchronously; pooled drivers return a promise. */
    close?(): void | Promise<void>;
}
interface SqlDatabaseConnection extends DatabaseConnection {
    (strings: TemplateStringsArray, ...values: unknown[]): Promise<unknown[]>;
}
type ErrorFactory<TValue> = (value: TValue) => Error;
declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TEntity & string> {
    protected readonly table: TableDefinition<TEntity, PrimaryKey>;
    protected readonly connection: DatabaseConnection;
    constructor(table: TableDefinition<TEntity, PrimaryKey>, connection?: DatabaseConnection);
    count(options?: ExtendedQueryOptions<TEntity>): Promise<number>;
    findAll(options?: ExtendedQueryOptions<TEntity>): Promise<TEntity[]>;
    paginate(options: {
        page: number;
        perPage: number;
    } & Omit<ExtendedQueryOptions<TEntity>, "limit" | "offset">): Promise<PaginatedResult<TEntity>>;
    chunk(count: number, callback: (rows: TEntity[]) => Promise<boolean | void>, options?: Omit<ExtendedQueryOptions<TEntity>, "limit" | "offset">): Promise<void>;
    chunkById(count: number, callback: (rows: TEntity[]) => Promise<boolean | undefined>, options?: Omit<ExtendedQueryOptions<TEntity>, "limit" | "offset" | "orderBy">): Promise<void>;
    cursorPaginate(options: {
        perPage: number;
        cursor?: TEntity[PrimaryKey];
        cursorColumn?: PrimaryKey;
        direction?: "asc" | "desc";
    } & Omit<ExtendedQueryOptions<TEntity>, "limit" | "offset">): Promise<CursorPaginatedResult<TEntity, TEntity[PrimaryKey]>>;
    findById(id: TEntity[PrimaryKey]): Promise<TEntity | null>;
    findByIdOrThrow(id: TEntity[PrimaryKey], errorFactory?: ErrorFactory<TEntity[PrimaryKey]>): Promise<TEntity>;
    findByIds(ids: readonly TEntity[PrimaryKey][]): Promise<TEntity[]>;
    firstOrNull(where: QueryWhere<TEntity>, options?: Omit<QueryOptions<TEntity>, "where" | "limit">): Promise<TEntity | null>;
    upsert(values: MutationValues<TEntity>, conflictColumns: readonly (keyof TEntity & string)[], updateColumns?: readonly (keyof TEntity & string)[]): Promise<TEntity | null>;
    incrementById(id: TEntity[PrimaryKey], column: keyof TEntity & string, amount?: number, extra?: UpdateValues<TEntity, PrimaryKey>): Promise<TEntity | null>;
    decrementById(id: TEntity[PrimaryKey], column: keyof TEntity & string, amount?: number, extra?: UpdateValues<TEntity, PrimaryKey>): Promise<TEntity | null>;
    create(values: MutationValues<TEntity>): Promise<TEntity>;
    updateById(id: TEntity[PrimaryKey], changes: UpdateValues<TEntity, PrimaryKey>): Promise<TEntity | null>;
    updateByIdOrThrow(id: TEntity[PrimaryKey], changes: UpdateValues<TEntity, PrimaryKey>, errorFactory?: ErrorFactory<TEntity[PrimaryKey]>): Promise<TEntity>;
    deleteById(id: TEntity[PrimaryKey]): Promise<boolean>;
    softDeleteById(id: TEntity[PrimaryKey]): Promise<boolean>;
    forceDeleteById(id: TEntity[PrimaryKey]): Promise<boolean>;
    restoreById(id: TEntity[PrimaryKey]): Promise<TEntity | null>;
    withConnection(connection: DatabaseConnection): this;
    getConnection(): DatabaseConnection;
    getTable(): TableDefinition<TEntity, PrimaryKey>;
    query(where?: QueryWhere<TEntity>): RepositoryQuery<TEntity, PrimaryKey>;
    protected findWhere(where: QueryWhere<TEntity>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<TEntity[]>;
    protected countWhere(where?: QueryWhere<TEntity>, options?: Pick<QueryOptions<TEntity>, "withTrashed" | "onlyTrashed" | "joins" | "groupBy">, whereNodes?: readonly WhereNode<TEntity>[]): Promise<number>;
    protected averageColumn(column: keyof TEntity & string, where?: QueryWhere<TEntity>): Promise<number>;
    protected averageExpression(expression: string, alias: string, where?: QueryWhere<TEntity>): Promise<number>;
    sum(column: keyof TEntity & string, where?: QueryWhere<TEntity>): Promise<number>;
    avg(column: keyof TEntity & string, where?: QueryWhere<TEntity>): Promise<number>;
    min(column: keyof TEntity & string, where?: QueryWhere<TEntity>): Promise<number>;
    max(column: keyof TEntity & string, where?: QueryWhere<TEntity>): Promise<number>;
    private aggregateColumn;
    protected pluckNumberValues(expression: string, alias: string, options?: QueryOptions<TEntity>): Promise<number[]>;
    protected countGroupedBy<K extends keyof TEntity & string>(column: K, where?: QueryWhere<TEntity>): Promise<Array<{
        value: TEntity[K] | null;
        count: number;
    }>>;
    findByHasManyRelation<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, parentId: TParent[LocalKey], options?: Omit<QueryOptions<TEntity>, "where">): Promise<TEntity[]>;
    loadHasManyForParents<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(parents: readonly TParent[], relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<Map<TParent[LocalKey], TEntity[]>>;
    findHasManyThrough<TParent extends object, LocalKey extends keyof TParent & string, FirstKey extends string, SecondLocalKey extends string, SecondKey extends keyof TEntity & string>(parentId: unknown, relation: HasManyThroughRelation<TParent, TEntity, LocalKey, FirstKey, SecondLocalKey, SecondKey>, options?: QueryOptions<TEntity>): Promise<TEntity[]>;
    loadHasManyThroughForParents<TParent extends object, LocalKey extends keyof TParent & string, FirstKey extends string, SecondLocalKey extends string, SecondKey extends keyof TEntity & string>(parents: readonly TParent[], relation: HasManyThroughRelation<TParent, TEntity, LocalKey, FirstKey, SecondLocalKey, SecondKey>, options?: QueryOptions<TEntity>): Promise<Map<TParent[LocalKey], TEntity[]>>;
    private throughSoftDeleteClause;
    private buildThroughWhere;
    loadBelongsToForParents<TChild extends object, TParent extends object, ForeignKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], relation: BelongsToRelation<TChild, TParent, ForeignKey, OwnerKey>, parentRepository: BaseRepository<TParent, OwnerKey>, options?: Omit<QueryOptions<TParent>, "where">): Promise<Map<TChild[ForeignKey], TParent>>;
    loadMorphManyForParents<TParent extends object, LocalKey extends keyof TParent & string, MorphTypeKey extends keyof TEntity & string, MorphIdKey extends keyof TEntity & string>(parents: readonly TParent[], relation: MorphManyRelation<TParent, TEntity, LocalKey, MorphTypeKey, MorphIdKey>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<Map<TParent[LocalKey], TEntity[]>>;
    loadMorphOneForParents<TParent extends object, LocalKey extends keyof TParent & string, MorphTypeKey extends keyof TEntity & string, MorphIdKey extends keyof TEntity & string>(parents: readonly TParent[], relation: MorphOneRelation<TParent, TEntity, LocalKey, MorphTypeKey, MorphIdKey>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<Map<TParent[LocalKey], TEntity | undefined>>;
    loadMorphToForChildren<TChild extends object, TParent extends object, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], relation: MorphToRelation<TChild, MorphTypeKey, MorphIdKey>, repositoriesByType: ReadonlyMap<string, BaseRepository<TParent, OwnerKey>>, options?: Omit<QueryOptions<TParent>, "where">): Promise<Map<TChild[MorphIdKey], TParent>>;
    loadBelongsToManyForParents<TParent extends object, TRelated extends object, Pivot extends object, ParentKey extends keyof TParent & string, RelatedKey extends keyof TRelated & string, ForeignPivotKey extends keyof Pivot & string, RelatedPivotKey extends keyof Pivot & string>(parents: readonly TParent[], relation: BelongsToManyRelation<TParent, TRelated, Pivot, ParentKey, RelatedKey, ForeignPivotKey, RelatedPivotKey>, relatedRepository: BaseRepository<TRelated, RelatedKey>, options?: Omit<QueryOptions<TRelated>, "where">): Promise<Map<TParent[ParentKey], TRelated[]>>;
}
export { BaseRepository };
export default BaseRepository;
export type { DatabaseConnection, SqlDatabaseConnection };