import { MixinTarget } from "@bleco/mixin";
import { Count, DataObject, DefaultCrudRepository, Entity, FilterExcludingWhere, juggler, Options, Where } from "@loopback/repository";
import { TimestampModel } from "./timestamp.model.mixin";
export interface TimestampRepositoryOperationOptions extends Options {
    skipUpdatedAt?: boolean;
}
export declare function TimestampRepositoryMixin<T extends Entity & TimestampModel, ID, Relations extends object, R extends MixinTarget<DefaultCrudRepository<T, ID, Relations>>>(superClass: R): {
    new (...args: any[]): {
        modelClass: juggler.PersistedModelClass;
        save(entity: T, options?: TimestampRepositoryOperationOptions): Promise<T>;
        update(entity: T, options?: TimestampRepositoryOperationOptions): Promise<void>;
        updateAll(data: DataObject<T>, where?: Where<T>, options?: TimestampRepositoryOperationOptions): Promise<Count>;
        updateById(id: ID, data: DataObject<T>, options?: TimestampRepositoryOperationOptions): Promise<void>;
        replaceById(id: ID, data: DataObject<T>, options?: TimestampRepositoryOperationOptions): Promise<void>;
        entityClass: typeof Entity & {
            prototype: T;
        };
        dataSource: juggler.DataSource;
        readonly inclusionResolvers: Map<string, import("@loopback/repository").InclusionResolver<T, Entity>>;
        create: (entity: DataObject<T>, options?: Options) => Promise<T>;
        createAll: (entities: DataObject<T>[], options?: Options) => Promise<T[]>;
        find: (filter?: import("@loopback/repository").Filter<T> | undefined, options?: Options) => Promise<(T & Relations)[]>;
        findOne: (filter?: import("@loopback/repository").Filter<T> | undefined, options?: Options) => Promise<(T & Relations) | null>;
        findById: (id: ID, filter?: FilterExcludingWhere<T> | undefined, options?: Options) => Promise<T & Relations>;
        delete: (entity: T, options?: Options) => Promise<void>;
        deleteAll: (where?: Where<T> | undefined, options?: Options) => Promise<Count>;
        deleteById: (id: ID, options?: Options) => Promise<void>;
        count: (where?: Where<T> | undefined, options?: Options) => Promise<Count>;
        exists: (id: ID, options?: Options) => Promise<boolean>;
        execute: {
            (command: import("@loopback/repository").Command, parameters: import("@loopback/repository").NamedParameters | import("@loopback/repository").PositionalParameters, options?: Options): Promise<import("@loopback/repository").AnyObject>;
            (collectionName: string, command: string, ...parameters: import("@loopback/repository").PositionalParameters): Promise<import("@loopback/repository").AnyObject>;
            (...args: import("@loopback/repository").PositionalParameters): Promise<import("@loopback/repository").AnyObject>;
        };
        registerInclusionResolver: (relationName: string, resolver: import("@loopback/repository").InclusionResolver<T, Entity>) => void;
    };
} & R;