import { CacheKey, CacheOptions } from './types.js';

type Listener = (...args: any[]) => unknown;
type Unsubscribe = () => void;
type Subscribe<TListener extends Listener> = (listener: TListener) => Unsubscribe;
declare class Subscribable<TListener extends Listener> {
    protected listeners: Set<TListener>;
    subscribe: Subscribe<TListener>;
    protected notify: () => void;
}

type ExtractPartial<TTarget extends Record<string, unknown>, TExtractor extends Partial<TTarget>> = Extract<TTarget, TExtractor>;

declare const hashCacheKey: (key: CacheKey) => string;

declare const enum CacheStatus {
    Idle = "idle",
    Pending = "pending",
    Resolved = "resolved",
    Rejected = "rejected"
}
type AllStatusCached<TData, TCacheKey extends CacheKey = CacheKey> = {
    status: CacheStatus.Idle;
    promiseToSuspend: undefined;
    cacheKey: TCacheKey;
    hashedCacheKey: ReturnType<typeof hashCacheKey>;
    state: {
        promise: undefined;
        data: undefined;
        error: undefined;
    };
} | {
    status: CacheStatus.Pending;
    promiseToSuspend: Promise<void>;
    cacheKey: TCacheKey;
    hashedCacheKey: ReturnType<typeof hashCacheKey>;
    state: {
        promise: Promise<TData>;
        data: undefined;
        error: undefined;
    };
} | {
    status: CacheStatus.Resolved;
    promiseToSuspend: Promise<void>;
    cacheKey: TCacheKey;
    hashedCacheKey: ReturnType<typeof hashCacheKey>;
    state: {
        promise: Promise<TData>;
        data: TData;
        error: undefined;
    };
} | {
    status: CacheStatus.Rejected;
    promiseToSuspend: Promise<void>;
    cacheKey: TCacheKey;
    hashedCacheKey: ReturnType<typeof hashCacheKey>;
    state: {
        promise: Promise<TData>;
        data: undefined;
        error: unknown;
    };
};
type IdleCached<TData, TCacheKey extends CacheKey = CacheKey> = ExtractPartial<AllStatusCached<TData, TCacheKey>, {
    status: CacheStatus.Idle;
}>;
type PendingCached<TData, TCacheKey extends CacheKey = CacheKey> = ExtractPartial<AllStatusCached<TData, TCacheKey>, {
    status: CacheStatus.Pending;
}>;
type ResolvedCached<TData, TCacheKey extends CacheKey = CacheKey> = ExtractPartial<AllStatusCached<TData, TCacheKey>, {
    status: CacheStatus.Resolved;
}>;
type RejectedCached<TData, TCacheKey extends CacheKey = CacheKey> = ExtractPartial<AllStatusCached<TData, TCacheKey>, {
    status: CacheStatus.Rejected;
}>;
type Cached<TData, TCacheKey extends CacheKey = CacheKey> = IdleCached<TData, TCacheKey> | PendingCached<TData, TCacheKey> | ResolvedCached<TData, TCacheKey> | RejectedCached<TData, TCacheKey>;
/**
 * @experimental This is experimental feature.
 */
declare class Cache extends Subscribable<() => void> {
    private cache;
    reset: (options?: Pick<CacheOptions<unknown, CacheKey>, "cacheKey">) => void;
    remove: (options: Pick<CacheOptions<unknown, CacheKey>, "cacheKey">) => void;
    clearError: (options?: Pick<CacheOptions<unknown, CacheKey>, "cacheKey">) => void;
    suspend: <TData, TCacheKey extends CacheKey = CacheKey>({ cacheKey, cacheFn, }: CacheOptions<TData, TCacheKey>) => ResolvedCached<TData, TCacheKey>;
    getData: (options: Pick<CacheOptions<unknown, CacheKey>, "cacheKey">) => unknown;
    getError: (options: Pick<CacheOptions<unknown, CacheKey>, "cacheKey">) => unknown;
}

export { type AllStatusCached, Cache, type Cached, type IdleCached, type PendingCached, type RejectedCached, type ResolvedCached };