import * as Rx from "rxjs";
import { Snowflake } from "../../types";
import { WatchOp } from "../resources";
export interface CacheStore<T> {
    size: () => Promise<number>;
    sizeForParent: (parentId: Snowflake) => Promise<number>;
    get: (resourceId: string) => Promise<T | undefined>;
    getSync?: (resourceId: string) => T | undefined;
    getForParent: (parentId: Snowflake) => Promise<ReadonlyMap<string, T>>;
    set: (parentId: Snowflake, resourceId: string, resource: T) => Promise<void>;
    delete: (parentId: Snowflake, resourceId: string) => Promise<void>;
    parentDelete: (parentId: Snowflake) => Promise<void>;
    effects$?: Rx.Observable<never>;
}
export interface CacheStoreWithTTL<T> extends CacheStore<T> {
    refreshTTL: (resourceId: string) => Promise<void>;
}
export interface NonParentCacheStore<T> {
    size: () => Promise<number>;
    get: (resourceId: string) => Promise<T | undefined>;
    getSync?: (resourceId: string) => T | undefined;
    set: (resourceId: string, resource: T) => Promise<void>;
    delete: (resourceId: string) => Promise<void>;
    effects$?: Rx.Observable<never>;
}
export interface NonParentCacheStoreWithTTL<T> extends NonParentCacheStore<T> {
    refreshTTL: (resourceId: string) => Promise<void>;
}
export type AnyCacheStore<T> = CacheStore<T> | CacheStoreWithTTL<T>;
export type AnyNonParentStore<T> = NonParentCacheStore<T> | NonParentCacheStoreWithTTL<T>;
type FallbackFn<T> = (id: Snowflake) => Promise<T>;
export type NonParentGetOrFn<T> = (fn: FallbackFn<T | undefined>) => FallbackFn<T | undefined>;
export type GetOrFn<T> = (fn: FallbackFn<T | undefined>, parentId: (item: T) => Snowflake) => FallbackFn<T | undefined>;
export type GetForParentOrFn<T> = (fn: FallbackFn<T[]>, id: (item: T) => string) => FallbackFn<ReadonlyMap<string, T>>;
export interface CacheStoreHelpers<T> {
    watch$: Rx.Observable<WatchOp<T>>;
    getOr: GetOrFn<T>;
    getForParentOr: GetForParentOrFn<T>;
}
export interface NonParentCacheStoreHelpers<T> {
    watch$: Rx.Observable<WatchOp<T>>;
    getOr: NonParentGetOrFn<T>;
}
export type CacheStoreWithHelpers<T> = CacheStore<T> & CacheStoreHelpers<T>;
export type TTLCacheStoreWithHelpers<T> = CacheStoreWithTTL<T> & CacheStoreHelpers<T>;
export type NonParentCacheStoreWithHelpers<T> = NonParentCacheStore<T> & NonParentCacheStoreHelpers<T>;
export type TTLNonParentCacheStoreWithHelpers<T> = NonParentCacheStoreWithTTL<T> & NonParentCacheStoreHelpers<T>;
export type CacheStoreFactory<T> = <S extends AnyCacheStore<T> = CacheStore<T>>(store?: S) => readonly [S & CacheStoreHelpers<T>, Rx.Observable<void>];
export type NonParentCacheStoreFactory<T> = <S extends AnyNonParentStore<T> = NonParentCacheStore<T>>(store?: S) => readonly [S & NonParentCacheStoreHelpers<T>, Rx.Observable<void>];
export declare const addHelpers: <T, S extends AnyCacheStore<T>>(store: S) => S & CacheStoreHelpers<T>;
export declare const addNonParentHelpers: <T, S extends AnyNonParentStore<T>>(store: S) => S & NonParentCacheStoreHelpers<T>;
export declare const fromWatch: <T>(watch$: Rx.Observable<WatchOp<T>>) => CacheStoreFactory<T>;
export declare const fromWatchNonParent: <T>(watch$: Rx.Observable<WatchOp<T>>) => NonParentCacheStoreFactory<T>;
type WithCachesResult<M extends {
    [key: string]: WithCachesFn<any>;
}> = {
    [K in keyof M]: M[K] extends WithCachesFn<infer V> ? V : never;
};
type WithCachesFn<T> = (guildId: Snowflake) => Promise<T | undefined>;
export declare const withCaches: <M extends {
    [key: string]: WithCachesFn<any>;
}>(stores: M) => <T>(getParentId: (resource: T) => Snowflake | undefined) => (source$: Rx.Observable<T>) => Rx.Observable<readonly [T, WithCachesResult<M> | undefined]>;
export declare const onlyWithCacheResults: () => <T, M>(source$: Rx.Observable<readonly [T, M | undefined]>) => Rx.Observable<readonly [T, M]>;
export {};