lakutata/vendor/TypeDef.internal.17.d.ts

An IoC-based universal application framework.

import EventEmitter from 'node:events';
import { Keyv, StoredDataRaw } from './TypeDef.internal.18.js';

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;
};

export type { Cache };