import EventEmitter from "node:events";
import { Keyv, KeyvStoreAdapter, StoredData, StoredDataRaw } from "keyv";

//#region src/keyv-adapter.d.ts
type CacheManagerStore = {
  name: string;
  isCacheable?: (value: unknown) => boolean;
  get(key: string): Promise<any>;
  mget(...keys: string[]): Promise<unknown[]>;
  set(key: string, value: any, ttl?: number): Promise<any>;
  mset(data: Record<string, any>, ttl?: number): Promise<void>;
  del(key: string): Promise<void>;
  mdel(...keys: string[]): Promise<void>;
  ttl(key: string, ttl?: number): Promise<number>;
  keys(): Promise<string[]>;
  reset?(): Promise<void>;
  on?(event: string, listener: (...arguments_: any[]) => void): void;
  disconnect?(): Promise<void>;
};
declare class KeyvAdapter implements KeyvStoreAdapter {
  opts: any;
  namespace?: string | undefined;
  private readonly _cache;
  constructor(store: CacheManagerStore);
  get<T>(key: string): Promise<StoredData<T> | undefined>;
  set(key: string, value: any, ttl?: number): Promise<boolean>;
  delete(key: string): Promise<boolean>;
  clear(): Promise<void>;
  has?(key: string): Promise<boolean>;
  getMany?<T>(keys: string[]): Promise<Array<StoredData<T | undefined>>>;
  deleteMany?(key: string[]): Promise<boolean>;
  on(event: string, listener: (...arguments_: any[]) => void): this;
  disconnect?(): Promise<void>;
}
//#endregion
//#region src/index.d.ts
type CreateCacheOptions = {
  stores?: Keyv[];
  ttl?: number;
  refreshThreshold?: number;
  refreshAllStores?: boolean;
  nonBlocking?: boolean;
  cacheId?: string;
};
type WrapOptions<T> = {
  ttl?: number | ((value: T) => number);
  refreshThreshold?: number | ((value: T) => number);
};
type WrapOptionsRaw<T> = WrapOptions<T> & {
  raw: true;
};
type Cache = {
  get: <T>(key: string) => Promise<T | undefined>;
  mget: <T>(keys: string[]) => Promise<Array<T | undefined>>;
  ttl: (key: string) => Promise<number | undefined>;
  set: <T>(key: string, value: T, ttl?: number) => Promise<T>;
  mset: <T>(list: Array<{
    key: string;
    value: T;
    ttl?: number;
  }>) => Promise<Array<{
    key: string;
    value: T;
    ttl?: number;
  }>>;
  del: (key: string) => Promise<boolean>;
  mdel: (keys: string[]) => Promise<boolean>;
  clear: () => Promise<boolean>;
  on: <E extends keyof Events>(event: E, listener: Events[E]) => EventEmitter;
  off: <E extends keyof Events>(event: E, listener: Events[E]) => EventEmitter;
  disconnect: () => Promise<undefined>;
  cacheId: () => string;
  stores: Keyv[];
  wrap<T>(key: string, fnc: () => T | Promise<T>, ttl?: number | ((value: T) => number), refreshThreshold?: number | ((value: T) => number)): Promise<T>;
  wrap<T>(key: string, fnc: () => T | Promise<T>, options: WrapOptions<T>): Promise<T>;
  wrap<T>(key: string, fnc: () => T | Promise<T>, options: WrapOptionsRaw<T>): Promise<StoredDataRaw<T>>;
};
type Events = {
  get: <T>(data: {
    key: string;
    value?: T;
    error?: unknown;
  }) => void;
  mget: <T>(data: {
    keys: string[];
    value?: T[];
    error?: unknown;
  }) => void;
  set: <T>(data: {
    key: string;
    value: T;
    error?: unknown;
  }) => void;
  mset: <T>(data: {
    list: Array<{
      key: string;
      value: T;
      ttl?: number;
    }>;
    error?: unknown;
  }) => void;
  del: (data: {
    key: string;
    error?: unknown;
  }) => void;
  clear: (error?: unknown) => void;
  refresh: <T>(data: {
    key: string;
    value: T;
    error?: unknown;
  }) => void;
};
declare const createCache: (options?: CreateCacheOptions) => Cache;
//#endregion
export { Cache, type CacheManagerStore, CreateCacheOptions, Events, KeyvAdapter, createCache };