import { type AbstractMixable, type Args, type Model, type PrimaryKey, type SoftDeletes as SoftDeletesContract, type Where } from '../Contracts';
import type Repository from '../Repositories/Repository';
declare const _default: <TModel extends Model, TBase extends AbstractMixable<Repository<TModel>> = AbstractMixable<Repository<TModel>>>(Parent: TBase) => (abstract new (...params: Args) => {
    /**
     * Store given model into the storage.
     */
    store(model: TModel): Promise<TModel>;
    /**
     * Ensure that "delete at" attribute is set.
     */
    ensureOfSoftDeletes(model: TModel): TModel;
    /**
     * Delete model for the given key.
     */
    delete(key: PrimaryKey): Promise<void>;
    /**
     * Fill the "deleted at" column.
     */
    fillSoftDeletes(model: TModel): TModel;
    /**
     * Reset the "deleted at" column.
     */
    resetSoftDeletes(model: TModel): TModel;
    /**
     * Delete model for the given key.
     */
    forceDelete(key: PrimaryKey): Promise<void>;
    /**
     * Restore the delete model for given key.
     */
    restore(key: PrimaryKey): Promise<TModel>;
    /**
     * Apply soft-delete constraint.
     */
    applySoftDelete(): Repository<TModel> & SoftDeletesContract<TModel>;
    /**
     * Apply soft-delete constraint.
     */
    withoutTrashed(): Repository<TModel> & SoftDeletesContract<TModel>;
    /**
     * Ignore soft-delete constraint.
     */
    withTrashed(): Repository<TModel> & SoftDeletesContract<TModel>;
    /**
     * Apply only trashed record constraints.
     */
    onlyTrashed(): Repository<TModel> & SoftDeletesContract<TModel>;
    /**
     * Removes all scopes.
     */
    removeSoftDeleteQueries(): Repository<TModel> & SoftDeletesContract<TModel>;
    /**
     * Get soft-delete constraint.
     */
    scopeSoftDelete(): Where;
    /**
     * Get only trashed records constraint.
     */
    scopeTrashedRecords(): Where;
    /**
     * Determine whether a given resource is "soft-deleted".
     */
    isSoftDeleted(resource: Model): boolean;
    /**
     * Get name of `deleted_at` key.
     */
    getDeletedAtKey(): string;
    /**
     * Get value for `deleted_at` key.
     */
    getDeletedAtValue(): unknown;
    /**
     * Get a fresh timestamp for the model.
     */
    freshTimestamp(): unknown;
    /**
     * Get value for available records.
     *
     * @deprecated Use `getDeletedAtValueOnRestore` instead.
     */
    getSoftDeleteValue(): unknown;
    /**
     * Get value for available records.
     */
    getDeletedAtValueOnRestore(): unknown;
    wheres: Where[];
    orders: import("../Contracts").Order[];
    modifiers: import("../Contracts").QueryModifierCallback[];
    _transaction?: import("../Contracts").Transaction;
    transaction<V>(callback: import("../Contracts").TransactionCallback<V, any>): Promise<V>;
    setTransaction(transaction?: import("../Contracts").Transaction): any;
    getTransaction(): import("../Contracts").Transaction | undefined;
    runningInTransaction(): boolean;
    prepareTransaction(): Promise<import("../Contracts").Transaction>;
    where(where: Where | Where[]): any;
    setWheres(wheres: Where[]): any;
    getWheres(): Where[];
    order(order: import("../Contracts").Order | import("../Contracts").Order[]): any;
    setOrders(orders: import("../Contracts").Order[]): any;
    getOrders(): import("../Contracts").Order[];
    modify<T>(modifier: import("../Contracts").QueryModifierCallback<T>): any;
    find(key: PrimaryKey): Promise<import("../Contracts").Optional<TModel>>;
    whereKey(key: PrimaryKey): any;
    whereKeys(keys: Array<PrimaryKey>): any;
    fillModel(result: import("../Contracts").AnyRecord): TModel;
    search(search: string, page?: number, perPage?: number): Promise<import("../Contracts").SearchCollection>;
    all(wheres?: Where[]): Promise<TModel[]>;
    first(wheres?: Where[]): Promise<import("../Contracts").Optional<TModel>>;
    update(model: TModel): Promise<TModel>;
    model(): TModel;
}) & TBase;
export default _default;