import DataLoader from 'dataloader';
type MatchingKeyof<T, V> = keyof {
    [P in keyof T as T[P] extends V ? P : never]: P;
};
export declare abstract class Loader<KeyType, ReturnType, FilterType> {
    config: any;
    idLoaders: PrimaryKeyLoader<any, ReturnType>[];
    constructor(config: any);
    abstract init(factory: DataLoaderFactory): any;
    abstract getDataLoader(cached: any, factory: DataLoaderFactory, filters?: FilterType): DataLoader<KeyType, ReturnType | undefined, string> | DataLoader<KeyType, ReturnType[], string>;
    addIdLoader(loader: PrimaryKeyLoader<any, ReturnType>): void;
}
export interface LoaderConfig<KeyType, ReturnType> {
    fetch: (ids: KeyType[], context: any) => Promise<ReturnType[]>;
    extractId?: MatchingKeyof<ReturnType, KeyType> | ((item: ReturnType) => KeyType);
    idLoader?: PrimaryKeyLoader<any, ReturnType> | PrimaryKeyLoader<any, ReturnType>[];
    options?: DataLoader.Options<KeyType, ReturnType, string>;
}
export declare class PrimaryKeyLoader<KeyType, ReturnType> extends Loader<KeyType, ReturnType, never> {
    config: LoaderConfig<KeyType, ReturnType>;
    extractId: (obj: ReturnType) => KeyType;
    constructor(config: LoaderConfig<KeyType, ReturnType>);
    init(factory: DataLoaderFactory): DataLoader<KeyType, ReturnType, string>;
    getDataLoader(cached: DataLoader<KeyType, ReturnType | undefined, string>): DataLoader<KeyType, ReturnType | undefined, string>;
}
export interface ManyJoinedType<KeyType, ReturnType> {
    key: KeyType;
    value: ReturnType;
}
export interface BaseManyLoaderConfig<KeyType, ReturnType, FilterType> {
    skipCache?: boolean;
    maxBatchSize?: number;
    cacheKeyFn?: (key: KeyType) => string;
    keysFromFilter?: (filter: FilterType | undefined) => KeyType[];
    idLoader?: PrimaryKeyLoader<any, ReturnType> | PrimaryKeyLoader<any, ReturnType>[];
}
export declare abstract class BaseManyLoader<KeyType, ReturnType, FilterType> extends Loader<KeyType, ReturnType, FilterType> {
    config: BaseManyLoaderConfig<KeyType, ReturnType, FilterType>;
    constructor(config: BaseManyLoaderConfig<KeyType, ReturnType, FilterType>);
    init(factory: DataLoaderFactory): Map<any, any>;
    prime(loader: PrimaryKeyLoader<any, ReturnType>, factory: DataLoaderFactory, items: any): void;
    abstract groupItems(items: ReturnType[] | ManyJoinedType<KeyType, ReturnType>[], dedupekeys: Map<string, KeyType>): Record<string, ReturnType[]>;
    abstract filterItems(items: ReturnType[] | ManyJoinedType<KeyType, ReturnType>[], filters: FilterType | undefined): ReturnType[] | ManyJoinedType<KeyType, ReturnType>[];
    getDataLoader(cached: Map<string, FilteredStorageObject<KeyType, ReturnType>>, factory: DataLoaderFactory, filters?: FilterType): DataLoader<KeyType, ReturnType[], string>;
    getCache(cached: Map<string, FilteredStorageObject<KeyType, ReturnType>>, filters?: FilterType): Map<string, Promise<ReturnType[]>> | undefined;
}
export interface OneToManyLoaderConfig<KeyType, ReturnType, FilterType> extends BaseManyLoaderConfig<KeyType, ReturnType, FilterType> {
    fetch: (keys: KeyType[], filters: FilterType, context: any) => Promise<ReturnType[]>;
    extractKey?: MatchingKeyof<ReturnType, KeyType> | ((item: ReturnType) => KeyType);
    matchKey?: (key: KeyType, item: ReturnType) => boolean;
}
export declare class OneToManyLoader<KeyType, ReturnType, FilterType = undefined> extends BaseManyLoader<KeyType, ReturnType, FilterType> {
    constructor(config: OneToManyLoaderConfig<KeyType, ReturnType, FilterType>);
    filterItems: (items: ReturnType[], filters: FilterType | undefined) => ReturnType[];
    groupItems: (items: ReturnType[], dedupekeys: Map<string, KeyType>) => Record<string, ReturnType[]>;
}
export interface ManyJoinedLoaderConfig<KeyType, ReturnType, FilterType> extends BaseManyLoaderConfig<KeyType, ReturnType, FilterType> {
    fetch: (keys: KeyType[], filters: FilterType, context: any) => Promise<ManyJoinedType<KeyType, ReturnType>[]>;
}
export declare class ManyJoinedLoader<KeyType, ReturnType, FilterType = undefined> extends BaseManyLoader<KeyType, ReturnType, FilterType> {
    constructor(config: ManyJoinedLoaderConfig<KeyType, ReturnType, FilterType>);
    groupItems(items: ManyJoinedType<KeyType, ReturnType>[]): Record<string, ReturnType[]>;
    filterItems(items: ManyJoinedType<KeyType, ReturnType>[], filters: FilterType | undefined): ManyJoinedType<KeyType, ReturnType>[];
    prime(loader: PrimaryKeyLoader<any, ReturnType>, factory: DataLoaderFactory, items: ManyJoinedType<KeyType, ReturnType>[]): void;
}
export interface ManyToManyLoaderConfig<KeyType, ReturnType, FilterType> extends BaseManyLoaderConfig<KeyType, ReturnType, FilterType> {
    fetch: (keys: KeyType[], filters: FilterType, context: any) => Promise<ReturnType[]>;
    extractKeys?: MatchingKeyof<ReturnType, KeyType[]> | ((item: ReturnType) => KeyType[]);
    matchKey?: (key: KeyType, item: ReturnType) => boolean;
}
export declare class ManyToManyLoader<KeyType, ReturnType, FilterType = undefined> extends BaseManyLoader<KeyType, ReturnType, FilterType> {
    constructor(config: ManyToManyLoaderConfig<KeyType, ReturnType, FilterType>);
    filterItems: (items: ReturnType[], filters: FilterType | undefined) => ReturnType[];
    groupItems: (items: ReturnType[], dedupekeys: Map<string, KeyType>) => Record<string, ReturnType[]>;
}
export interface ParentDocumentLoaderConfig<KeyType, ReturnType> {
    fetch: (ids: KeyType[], context: any) => Promise<ReturnType[]>;
    childIds: (item: ReturnType) => KeyType[];
    parentId?: MatchingKeyof<ReturnType, KeyType> | ((item: ReturnType) => KeyType);
    idLoader?: PrimaryKeyLoader<any, ReturnType> | PrimaryKeyLoader<any, ReturnType>[];
    options?: DataLoader.Options<KeyType, ReturnType, string>;
}
export declare class ParentDocumentLoader<KeyType, ReturnType> extends Loader<KeyType, ReturnType, never> {
    config: ParentDocumentLoaderConfig<KeyType, ReturnType>;
    childIds: (obj: ReturnType) => KeyType[];
    parentId: (obj: ReturnType) => KeyType;
    constructor(config: ParentDocumentLoaderConfig<KeyType, ReturnType>);
    init(factory: DataLoaderFactory): DataLoader<KeyType, ReturnType, string>;
    getDataLoader(cached: DataLoader<KeyType, ReturnType | undefined, string>): DataLoader<KeyType, ReturnType | undefined, string>;
}
export interface BestMatchLoaderConfig<KeyType, ReturnType> extends Omit<LoaderConfig<KeyType, ReturnType>, 'extractId'> {
    fetch: (keys: KeyType[], context: any) => Promise<ReturnType[]>;
    scoreMatch?: (key: KeyType, item: ReturnType) => number;
}
export declare class BestMatchLoader<KeyType, ReturnType> extends Loader<KeyType, ReturnType, never> {
    constructor(config: BestMatchLoaderConfig<KeyType, ReturnType>);
    init(factory: DataLoaderFactory): DataLoader<KeyType, ReturnType, string>;
    getDataLoader(cached: DataLoader<KeyType, ReturnType | undefined, string>): DataLoader<KeyType, ReturnType | undefined, string>;
}
export interface FilteredStorageObject<KeyType, ReturnType> {
    loader: DataLoader<KeyType, ReturnType[], string>;
    cache?: Map<string, Promise<ReturnType[]>>;
}
export declare class DataLoaderFactory<ContextType = any> {
    private loaders;
    context: ContextType;
    constructor(context?: ContextType);
    get<KeyType, ReturnType>(loader: PrimaryKeyLoader<KeyType, ReturnType>): DataLoader<KeyType, ReturnType | undefined, string>;
    get<KeyType, ReturnType>(loader: BestMatchLoader<KeyType, ReturnType>): DataLoader<KeyType, ReturnType | undefined, string>;
    get<KeyType, ReturnType, FilterType>(loader: BaseManyLoader<KeyType, ReturnType, FilterType>, filters?: FilterType): DataLoader<KeyType, ReturnType[], string>;
    prime<KeyType, ReturnType>(loader: PrimaryKeyLoader<KeyType, ReturnType>, values: ReturnType | ReturnType[]): void;
    loadMany<KeyType, ReturnType>(loader: PrimaryKeyLoader<KeyType, ReturnType>, keys: KeyType[]): Promise<ReturnType[]>;
    loadMany<KeyType, ReturnType>(loader: ParentDocumentLoader<KeyType, ReturnType>, keys: KeyType[]): Promise<ReturnType[]>;
    loadMany<KeyType, ReturnType>(loader: BestMatchLoader<KeyType, ReturnType>, keys: KeyType[]): Promise<ReturnType[]>;
    loadMany<KeyType, ReturnType, FilterType>(loader: BaseManyLoader<KeyType, ReturnType, FilterType>, keys: KeyType[], filters?: FilterType): Promise<ReturnType[]>;
    getCache<KeyType, ReturnType, FilterType>(loader: PrimaryKeyLoader<KeyType, ReturnType>, filters?: FilterType): Map<string, Promise<ReturnType>> | undefined;
    getCache<KeyType, ReturnType, FilterType>(loader: BestMatchLoader<KeyType, ReturnType>, filters?: FilterType): Map<string, Promise<ReturnType>> | undefined;
    getCache<KeyType, ReturnType, FilterType>(loader: BaseManyLoader<KeyType, ReturnType, FilterType>, filters?: FilterType): Map<string, Promise<ReturnType[]>> | undefined;
    clear(): void;
}
export {};