type ExposedPromiseKeys = 'then' | 'finally' | 'catch';
type Promisish<T> = Pick<Promise<T>, keyof Promise<T> & ExposedPromiseKeys>;
declare abstract class Executable<T> implements Promisish<T> {
    private promise;
    protected abstract execute(): Promise<T>;
    protected isExecuting(): boolean;
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
    finally(onfinally?: (() => void) | undefined | null): Promise<T>;
}
type Keys<T> = keyof T & string;
type Filtered<T, I extends keyof T, E extends keyof T> = T extends null | undefined ? T : Omit<Pick<T, I>, E>;
type FilterExec<T, I extends keyof T, E extends keyof T> = (includes: Keys<T>[] | undefined, excludes: Keys<T>[] | undefined) => Promise<Filtered<T, I, E>[]>;
export declare class FilteredQuery<T, I extends keyof T = keyof T, E extends keyof T = never> extends Executable<Filtered<T, I, E>[]> {
    private readonly exec;
    private includes;
    private excludes;
    constructor(exec: FilterExec<T, I, E>);
    protected execute(): Promise<Filtered<T, I, E>[]>;
    include<NI extends Keys<T>>(includes: NI[] | null): FilteredQuery<T, NI, E>;
    exclude<NE extends Keys<T>>(excludes: NE[] | null): FilteredQuery<T, I, NE>;
}
export {};