import { Collection, Cursor, FilterQuery, FindOneOptions, OptionalId, UpdateManyOptions, UpdateOneOptions, UpdateQuery } from "mongodb";
import MongoConnector from "./mongo_connector";
import { LRUCache } from "lru-cache";
export interface IDataLoader<S, T> {
    clear(id: string): void;
    clearAll(): void;
    load(key: string): any;
}
export interface Options<K, V> {
    batch?: boolean;
    cache?: boolean;
    cacheKeyFn?: (key: any) => any;
    cacheMap?: CacheWrapper<K, V> | "lru";
    cacheTTLMs?: number;
    cacheSize?: number;
    clearOnInsert?: boolean;
    clearOnUpdate?: boolean;
    selectorKeyFn?: (key: any) => any;
}
interface CacheWrapper<K, V> {
    clear(): any;
    get(key: K): V;
    set(key: K, value: V): any;
    delete(key: K): any;
}
export declare class LruCacheWrapper<K, V> implements CacheWrapper<K, V> {
    cache: LRUCache<K, V>;
    constructor(cacheSize?: number, ttl?: number);
    clear(): void;
    get(key: K): V;
    set(key: K, value: V): LRUCache<K, V, unknown>;
    delete(key: K): boolean;
}
export default class MongoEntity<T> {
    connector: MongoConnector;
    private _collectionName;
    private _collection;
    private _singleLoader;
    private _multiLoader;
    private _insertLoaders;
    private _updateLoaders;
    static DefaultCache: any;
    private _cache;
    get collection(): Collection<T>;
    constructor(connector: MongoConnector, collectionName: string, cache?: any);
    clearUpdateCaches(selector: any): void;
    clearInsertCaches(selector: any): void;
    assignFilter(object: Object, selector: Object, result: Object, include: 0 | 1): (k: string) => void;
    filter(object: Object, selector: Object): any;
    find(selector: FilterQuery<T>, projection?: Object, skip?: number, limit?: number): Cursor<T>;
    findOne(selector: FilterQuery<T>, options?: FindOneOptions<T>): Promise<T>;
    findOneCached(loader: IDataLoader<string, T>, key: string, selector?: Object): Promise<T>;
    findOneCachedById(id: string, selector?: Object): Promise<T>;
    findManyCached(loader: IDataLoader<string, T[]>, key: string, selector?: Object): Promise<T[]>;
    findAllCached(selector?: Object): Promise<T[]>;
    addCacheToOptions(options: any): any;
    insertOne(document: OptionalId<T>): Promise<import("mongodb").InsertOneWriteOpResult<import("mongodb").WithId<T>>>;
    insertMany(document: OptionalId<T>[]): Promise<import("mongodb").InsertWriteOpResult<import("mongodb").WithId<T>>>;
    deleteOne(selector: FilterQuery<T>, many?: boolean): Promise<import("mongodb").DeleteWriteOpResultObject>;
    deleteMany(selector: FilterQuery<T>, many?: boolean): Promise<import("mongodb").DeleteWriteOpResultObject>;
    dispose(): Promise<import("mongodb").DeleteWriteOpResultObject>;
    updateOne(selector: FilterQuery<T>, update: UpdateQuery<T>, options?: UpdateOneOptions): Promise<import("mongodb").UpdateWriteOpResult>;
    updateMany(selector: FilterQuery<T>, update: UpdateQuery<T>, options?: UpdateManyOptions): Promise<import("mongodb").UpdateWriteOpResult>;
    createLoader(selectorFunction: (key: any) => Promise<T>, options?: Options<any, T | T[]>): any;
}
export {};