import { Entity, EntityCrudRepository, juggler, Options } from '@loopback/repository';
import { PickKeys } from 'ts-essentials';
import { Driver } from './driver';
import { QueryFilter, QueryWhere } from './filter';
import { EntityClass } from './types';
export interface Query<T extends Entity, Relations extends object = {}> {
    entityClass: EntityClass<T>;
    /**
     * Find matching records
     *
     * @param filter - Query filter
     * @param options - Options for the operations
     * @returns A promise of an array of records found
     */
    find(filter?: QueryFilter<T>, options?: Options): Promise<(T & Relations)[]>;
    /**
     * Find one record that matches filter specification. Same as find, but limited to one result; Returns object, not collection.
     *
     * @param filter - Query filter
     * @param options - Options for the operations
     * @returns A promise of a record found
     */
    findOne(filter?: QueryFilter<T>, options?: Options): Promise<(T & Relations) | null>;
    /**
     * Count matching records
     * @param where - Matching criteria
     * @param options - Options for the operations
     * @returns A promise of number of records matched
     */
    count(where?: QueryWhere<T>, options?: Options): Promise<{
        count: number;
    }>;
}
export declare const QueryMethods: PickKeys<Query<Entity>, (...args: any) => any>[];
export declare const QueryProperties: (keyof Query<Entity>)[];
export declare class DefaultQuery<T extends Entity, Relations extends object = {}> implements Query<T, Relations> {
    readonly entityClass: EntityClass<T>;
    readonly dataSource: juggler.DataSource;
    readonly repo?: EntityCrudRepository<T, unknown, Relations>;
    readonly driver: Driver;
    constructor(repo: EntityCrudRepository<T, unknown, Relations>, dataSource?: juggler.DataSource);
    constructor(entityClass: EntityClass<T>, dataSource: juggler.DataSource);
    find(filter?: QueryFilter<T>, options?: Options): Promise<(T & Relations)[]>;
    findOne(filter?: QueryFilter<T>, options?: Options): Promise<(T & Relations) | null>;
    count(where?: QueryWhere<T>, options?: Options): Promise<{
        count: number;
    }>;
    protected toEntity<R extends T>(model: Record<string, any>): R;
    protected toEntities<R extends T>(models: Record<string, any>[]): R[];
}
export declare function isQuery<T extends Entity>(obj: any): obj is Query<T>;