@lakutata/cache 3.0.0-beta.0

package/dist/cjs/cache/options/SqliteCacheOptions.js

@@ -0,0 +1,61 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteCacheOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+/**
+ * The options of the SQLite store: one row per entry in a table of a SQLite database file. It needs the optional peer
+ * dependency `sqlite3` (`npm install sqlite3`): without it, the cache's creation fails with
+ * `CacheDriverNotFoundException`.
+ *
+ * When the cache starts, it opens the database (creating the file) and creates the table when missing:
+ * `(key VARCHAR(255) PRIMARY KEY, value TEXT)`. An expired row is a miss; it stays in the table until it is read,
+ * overwritten or cleared. The values are kept as JSON.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildCacherOptions} from 'lakutata/com/cacher'
+ *
+ * Application.run(() => ({
+ *     id: 'sqlite-cache.app',
+ *     name: 'SqliteCache',
+ *     components: {
+ *         cache: buildCacherOptions({
+ *             stores: {type: 'sqlite', database: './cache.db', table: 'cache', namespace: 'app'}
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+class SqliteCacheOptions extends core_1.DTO {
+}
+exports.SqliteCacheOptions = SqliteCacheOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().allow('sqlite').only().required()),
+    __metadata("design:type", String)
+], SqliteCacheOptions.prototype, "type", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], SqliteCacheOptions.prototype, "database", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], SqliteCacheOptions.prototype, "table", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().positive().integer().optional().default(10000)),
+    __metadata("design:type", Number)
+], SqliteCacheOptions.prototype, "busyTimeout", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], SqliteCacheOptions.prototype, "namespace", void 0);

package/dist/cjs/cache/stores/CacheStore.d.ts

@@ -0,0 +1,44 @@
+import { CacheEntry } from '../lib/Serializer.js';
+export type CacheStoreSetEntry = {
+    key: string;
+    value: unknown;
+    ttl?: number;
+};
+/**
+ * Whether an entry has expired
+ * @param entry
+ */
+export declare function isExpired(entry: CacheEntry): boolean;
+/**
+ * The expiration time of a ttl
+ * @param ttl
+ */
+export declare function expiresOf(ttl?: number): number | undefined;
+/**
+ * A cache store
+ * The ttls are in milliseconds, a missing or zero ttl never expires
+ */
+export declare abstract class CacheStore {
+    /**
+     * Report the errors of the background operations
+     */
+    onError: (error: Error) => void;
+    /**
+     * Connect to the backend
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the backend
+     */
+    disconnect(): Promise<void>;
+    abstract get(key: string): Promise<CacheEntry | undefined>;
+    abstract getMany(keys: string[]): Promise<(CacheEntry | undefined)[]>;
+    abstract set(key: string, value: unknown, ttl?: number): Promise<void>;
+    abstract setMany(entries: CacheStoreSetEntry[]): Promise<void>;
+    abstract delete(key: string): Promise<boolean>;
+    abstract deleteMany(keys: string[]): Promise<boolean>;
+    /**
+     * Delete the entries of the namespace, or all the entries without namespace
+     */
+    abstract clear(): Promise<void>;
+}

package/dist/cjs/cache/stores/CacheStore.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheStore = void 0;
+exports.isExpired = isExpired;
+exports.expiresOf = expiresOf;
+/**
+ * Whether an entry has expired
+ * @param entry
+ */
+function isExpired(entry) {
+    return typeof entry.expires === 'number' && Date.now() > entry.expires;
+}
+/**
+ * The expiration time of a ttl
+ * @param ttl
+ */
+function expiresOf(ttl) {
+    return ttl ? Date.now() + ttl : undefined;
+}
+/**
+ * A cache store
+ * The ttls are in milliseconds, a missing or zero ttl never expires
+ */
+class CacheStore {
+    constructor() {
+        /**
+         * Report the errors of the background operations
+         */
+        this.onError = () => undefined;
+    }
+    /**
+     * Connect to the backend
+     */
+    async connect() {
+    }
+    /**
+     * Disconnect from the backend
+     */
+    async disconnect() {
+    }
+}
+exports.CacheStore = CacheStore;

package/dist/cjs/cache/stores/CreateCacheStore.d.ts

@@ -0,0 +1,7 @@
+import { CacheStore } from './CacheStore.js';
+import { CacheStoreOptions } from '../types/CacheStoreOptions.js';
+/**
+ * Create the store of the options
+ * @param options
+ */
+export declare function createCacheStore(options: CacheStoreOptions): CacheStore | undefined;

package/dist/cjs/cache/stores/CreateCacheStore.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCacheStore = createCacheStore;
+const FileStore_js_1 = require("./FileStore.js");
+const MemoryStore_js_1 = require("./MemoryStore.js");
+const RedisStore_js_1 = require("./RedisStore.js");
+const MemcacheStore_js_1 = require("./MemcacheStore.js");
+const MongoStore_js_1 = require("./MongoStore.js");
+const SqliteStore_js_1 = require("./SqliteStore.js");
+const PostgresStore_js_1 = require("./PostgresStore.js");
+const MysqlStore_js_1 = require("./MysqlStore.js");
+/**
+ * Create the store of the options
+ * @param options
+ */
+function createCacheStore(options) {
+    switch (options.type) {
+        case 'memory':
+            return new MemoryStore_js_1.MemoryStore(options.sweepInterval);
+        case 'file':
+            return new FileStore_js_1.FileStore(options);
+        case 'redis':
+            return new RedisStore_js_1.RedisStore(options);
+        case 'memcache':
+            return new MemcacheStore_js_1.MemcacheStore(options);
+        case 'mongo':
+            return new MongoStore_js_1.MongoStore(options);
+        case 'sqlite':
+            return new SqliteStore_js_1.SqliteStore(options);
+        case 'postgres':
+            return new PostgresStore_js_1.PostgresStore(options);
+        case 'mysql':
+            return new MysqlStore_js_1.MysqlStore(options);
+        default:
+            return undefined;
+    }
+}

package/dist/cjs/cache/stores/FileStore.d.ts

@@ -0,0 +1,51 @@
+import { SerializedCacheStore, SerializedEntry } from './SerializedCacheStore.js';
+import { FileCacheOptions } from '../options/FileCacheOptions.js';
+type FileRecord = {
+    expire?: number;
+    value: string;
+};
+/**
+ * The file store, the entries are kept in memory and written to the file in batches
+ * File format: {"cache":[[key,{"expire":ms,"value":serialized entry}]],"lastExpire":ms}
+ */
+export declare class FileStore extends SerializedCacheStore {
+    protected readonly filename: string;
+    protected readonly expiredCheckDelay: number;
+    protected readonly writeDelay: number;
+    protected records: Map<string, FileRecord>;
+    protected lastExpire: number;
+    protected saveTimer?: NodeJS.Timeout;
+    protected saving: Promise<void>;
+    constructor(options: FileCacheOptions);
+    /**
+     * Whether a record has expired
+     * @param record
+     * @protected
+     */
+    protected isExpired(record: FileRecord): boolean;
+    /**
+     * Remove the expired records, at most once in each expiredCheckDelay
+     * @protected
+     */
+    protected removeExpired(): void;
+    /**
+     * Save the records after the write delay
+     * @protected
+     */
+    protected scheduleSave(): void;
+    /**
+     * Write the records to the file, through a temporary file
+     * @protected
+     */
+    protected save(): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    protected read(key: string): Promise<string | undefined>;
+    protected readMany(keys: string[]): Promise<(string | undefined)[]>;
+    protected write(entry: SerializedEntry): Promise<void>;
+    protected writeMany(entries: SerializedEntry[]): Promise<void>;
+    protected remove(key: string): Promise<boolean>;
+    protected removeMany(keys: string[]): Promise<boolean>;
+    clear(): Promise<void>;
+}
+export {};

package/dist/cjs/cache/stores/FileStore.js

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileStore = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const SerializedCacheStore_js_1 = require("./SerializedCacheStore.js");
+const Serializer_js_1 = require("../lib/Serializer.js");
+/**
+ * The file store, the entries are kept in memory and written to the file in batches
+ * File format: {"cache":[[key,{"expire":ms,"value":serialized entry}]],"lastExpire":ms}
+ */
+class FileStore extends SerializedCacheStore_js_1.SerializedCacheStore {
+    constructor(options) {
+        super(options.namespace);
+        this.records = new Map();
+        this.lastExpire = Date.now();
+        this.saving = Promise.resolve();
+        this.filename = node_path_1.default.resolve(options.filename);
+        this.expiredCheckDelay = options.expiredCheckDelay ?? 3600000;
+        this.writeDelay = options.writeDelay ?? 100;
+    }
+    /**
+     * Whether a record has expired
+     * @param record
+     * @protected
+     */
+    isExpired(record) {
+        return typeof record.expire === 'number' && record.expire <= Date.now();
+    }
+    /**
+     * Remove the expired records, at most once in each expiredCheckDelay
+     * @protected
+     */
+    removeExpired() {
+        const now = Date.now();
+        if (now - this.lastExpire <= this.expiredCheckDelay)
+            return;
+        this.lastExpire = now;
+        for (const [key, record] of this.records)
+            if (this.isExpired(record))
+                this.records.delete(key);
+    }
+    /**
+     * Save the records after the write delay
+     * @protected
+     */
+    scheduleSave() {
+        if (this.saveTimer)
+            return;
+        this.saveTimer = setTimeout(() => {
+            this.saveTimer = undefined;
+            this.saving = this.saving.then(() => this.save()).catch((error) => this.onError(error));
+        }, this.writeDelay);
+    }
+    /**
+     * Write the records to the file, through a temporary file
+     * @protected
+     */
+    async save() {
+        this.removeExpired();
+        const content = (0, Serializer_js_1.serialize)({ cache: [...this.records], lastExpire: this.lastExpire });
+        const temporary = `${this.filename}.${process.pid}.tmp`;
+        await (0, promises_1.mkdir)(node_path_1.default.dirname(this.filename), { recursive: true });
+        await (0, promises_1.writeFile)(temporary, content);
+        await (0, promises_1.rename)(temporary, this.filename);
+    }
+    async connect() {
+        let text;
+        try {
+            text = await (0, promises_1.readFile)(this.filename, 'utf8');
+        }
+        catch (e) {
+            if (e.code === 'ENOENT')
+                return;
+            throw e;
+        }
+        const content = (0, Serializer_js_1.deserialize)(text);
+        this.records = new Map(Array.isArray(content.cache) ? content.cache : Object.entries(content.cache));
+        if (typeof content.lastExpire === 'number')
+            this.lastExpire = content.lastExpire;
+    }
+    async disconnect() {
+        if (this.saveTimer) {
+            clearTimeout(this.saveTimer);
+            this.saveTimer = undefined;
+            this.saving = this.saving.then(() => this.save());
+        }
+        await this.saving;
+    }
+    async read(key) {
+        const record = this.records.get(key);
+        if (record === undefined)
+            return undefined;
+        if (this.isExpired(record)) {
+            await this.remove(key);
+            return undefined;
+        }
+        return record.value;
+    }
+    async readMany(keys) {
+        return Promise.all(keys.map((key) => this.read(key)));
+    }
+    async write(entry) {
+        this.records.set(entry.key, { expire: entry.expires, value: entry.data });
+        this.scheduleSave();
+    }
+    async writeMany(entries) {
+        for (const entry of entries)
+            this.records.set(entry.key, { expire: entry.expires, value: entry.data });
+        this.scheduleSave();
+    }
+    async remove(key) {
+        if (!this.records.delete(key))
+            return false;
+        this.scheduleSave();
+        return true;
+    }
+    async removeMany(keys) {
+        let removed = false;
+        for (const key of keys)
+            removed = this.records.delete(key) || removed;
+        if (removed)
+            this.scheduleSave();
+        return removed;
+    }
+    async clear() {
+        if (this.namespace) {
+            const prefix = `${this.namespace}:`;
+            for (const key of this.records.keys())
+                if (key.startsWith(prefix))
+                    this.records.delete(key);
+        }
+        else {
+            this.records.clear();
+        }
+        this.lastExpire = Date.now();
+        this.scheduleSave();
+    }
+}
+exports.FileStore = FileStore;

package/dist/cjs/cache/stores/MemcacheStore.d.ts

@@ -0,0 +1,42 @@
+import { SerializedCacheStore, SerializedEntry } from './SerializedCacheStore.js';
+import { MemcacheCacheOptions } from '../options/MemcacheCacheOptions.js';
+interface MemcacheClient {
+    get(key: string): Promise<{
+        value: Buffer | null;
+    }>;
+    set(key: string, value: string, options: {
+        expires?: number;
+    }): Promise<boolean>;
+    delete(key: string): Promise<boolean>;
+    flush(): Promise<unknown>;
+    close(): void;
+}
+/**
+ * The Memcache store
+ * Key format: "{namespace}:{namespace}:{key}", or "{key}" without namespace
+ */
+export declare class MemcacheStore extends SerializedCacheStore {
+    protected readonly options: MemcacheCacheOptions;
+    protected client: MemcacheClient;
+    constructor(options: MemcacheCacheOptions);
+    protected storeKey(key: string): string;
+    /**
+     * The memcached expiration of an entry, the entries expire after their expiration time
+     * @param entry
+     * @protected
+     */
+    protected expiration(entry: SerializedEntry): number;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    protected read(key: string): Promise<string | undefined>;
+    protected readMany(keys: string[]): Promise<(string | undefined)[]>;
+    protected write(entry: SerializedEntry): Promise<void>;
+    protected writeMany(entries: SerializedEntry[]): Promise<void>;
+    protected remove(key: string): Promise<boolean>;
+    protected removeMany(keys: string[]): Promise<boolean>;
+    /**
+     * Memcached cannot list the keys, all the entries are flushed
+     */
+    clear(): Promise<void>;
+}
+export {};

package/dist/cjs/cache/stores/MemcacheStore.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemcacheStore = void 0;
+const SerializedCacheStore_js_1 = require("./SerializedCacheStore.js");
+const LoadDriver_js_1 = require("../lib/LoadDriver.js");
+//Larger expiration times are unix timestamps for memcached
+const MAX_RELATIVE_EXPIRATION = 60 * 60 * 24 * 30;
+/**
+ * The Memcache store
+ * Key format: "{namespace}:{namespace}:{key}", or "{key}" without namespace
+ */
+class MemcacheStore extends SerializedCacheStore_js_1.SerializedCacheStore {
+    constructor(options) {
+        super(options.namespace);
+        this.options = options;
+    }
+    storeKey(key) {
+        return this.namespace ? `${this.namespace.trim()}:${`${this.namespace}:${key}`.trim()}` : key;
+    }
+    /**
+     * The memcached expiration of an entry, the entries expire after their expiration time
+     * @param entry
+     * @protected
+     */
+    expiration(entry) {
+        if (!entry.ttl || !entry.expires)
+            return 0;
+        const seconds = Math.ceil(entry.ttl / 1000) + 1;
+        return seconds > MAX_RELATIVE_EXPIRATION ? Math.ceil(entry.expires / 1000) + 1 : seconds;
+    }
+    async connect() {
+        const driver = await (0, LoadDriver_js_1.loadDriver)('Client', 'memjs');
+        const options = this.options;
+        this.client = driver.Client.create(`${options.host}:${options.port ?? 11211}`, {
+            username: options.username,
+            password: options.password
+        });
+    }
+    async disconnect() {
+        this.client?.close();
+    }
+    async read(key) {
+        const { value } = await this.client.get(key);
+        return value === null ? undefined : value.toString();
+    }
+    async readMany(keys) {
+        return Promise.all(keys.map((key) => this.read(key)));
+    }
+    async write(entry) {
+        await this.client.set(entry.key, entry.data, { expires: this.expiration(entry) });
+    }
+    async writeMany(entries) {
+        await Promise.all(entries.map((entry) => this.write(entry)));
+    }
+    async remove(key) {
+        return await this.client.delete(key);
+    }
+    async removeMany(keys) {
+        const removed = await Promise.all(keys.map((key) => this.remove(key)));
+        return removed.some((result) => result);
+    }
+    /**
+     * Memcached cannot list the keys, all the entries are flushed
+     */
+    async clear() {
+        await this.client.flush();
+    }
+}
+exports.MemcacheStore = MemcacheStore;

package/dist/cjs/cache/stores/MemoryStore.d.ts

@@ -0,0 +1,34 @@
+import { CacheStore, CacheStoreSetEntry } from './CacheStore.js';
+import { CacheEntry } from '../lib/Serializer.js';
+/**
+ * The in-memory store, the values are kept by reference
+ */
+export declare class MemoryStore extends CacheStore {
+    protected readonly sweepInterval: number;
+    protected readonly entries: Map<string, CacheEntry>;
+    protected sweeper?: NodeJS.Timeout;
+    /**
+     * @param sweepInterval ms, remove the expired entries in each interval
+     */
+    constructor(sweepInterval?: number);
+    /**
+     * Remove the expired entries
+     * @protected
+     */
+    protected sweep(): void;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    /**
+     * Read an entry, the expired entries are removed
+     * @param key
+     * @protected
+     */
+    protected read(key: string): CacheEntry | undefined;
+    get(key: string): Promise<CacheEntry | undefined>;
+    getMany(keys: string[]): Promise<(CacheEntry | undefined)[]>;
+    set(key: string, value: unknown, ttl?: number): Promise<void>;
+    setMany(entries: CacheStoreSetEntry[]): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    deleteMany(keys: string[]): Promise<boolean>;
+    clear(): Promise<void>;
+}

package/dist/cjs/cache/stores/MemoryStore.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryStore = void 0;
+const CacheStore_js_1 = require("./CacheStore.js");
+/**
+ * The in-memory store, the values are kept by reference
+ */
+class MemoryStore extends CacheStore_js_1.CacheStore {
+    /**
+     * @param sweepInterval ms, remove the expired entries in each interval
+     */
+    constructor(sweepInterval = 60000) {
+        super();
+        this.sweepInterval = sweepInterval;
+        this.entries = new Map();
+    }
+    /**
+     * Remove the expired entries
+     * @protected
+     */
+    sweep() {
+        const now = Date.now();
+        for (const [key, entry] of this.entries)
+            if (typeof entry.expires === 'number' && now > entry.expires)
+                this.entries.delete(key);
+    }
+    async connect() {
+        this.sweeper = setInterval(() => this.sweep(), this.sweepInterval);
+        this.sweeper.unref();
+    }
+    async disconnect() {
+        clearInterval(this.sweeper);
+    }
+    /**
+     * Read an entry, the expired entries are removed
+     * @param key
+     * @protected
+     */
+    read(key) {
+        const entry = this.entries.get(key);
+        if (entry === undefined)
+            return undefined;
+        if ((0, CacheStore_js_1.isExpired)(entry)) {
+            this.entries.delete(key);
+            return undefined;
+        }
+        return entry;
+    }
+    async get(key) {
+        return this.read(key);
+    }
+    async getMany(keys) {
+        return keys.map((key) => this.read(key));
+    }
+    async set(key, value, ttl) {
+        this.entries.set(key, { value: value, expires: (0, CacheStore_js_1.expiresOf)(ttl) });
+    }
+    async setMany(entries) {
+        for (const entry of entries)
+            this.entries.set(entry.key, { value: entry.value, expires: (0, CacheStore_js_1.expiresOf)(entry.ttl) });
+    }
+    async delete(key) {
+        return this.entries.delete(key);
+    }
+    async deleteMany(keys) {
+        let deleted = false;
+        for (const key of keys)
+            deleted = this.entries.delete(key) || deleted;
+        return deleted;
+    }
+    async clear() {
+        this.entries.clear();
+    }
+}
+exports.MemoryStore = MemoryStore;

package/dist/cjs/cache/stores/MongoStore.d.ts

@@ -0,0 +1,55 @@
+import { SerializedCacheStore, SerializedEntry } from './SerializedCacheStore.js';
+import { MongoCacheOptions } from '../options/MongoCacheOptions.js';
+type MongoDocument = {
+    key: string;
+    value: string;
+    expiresAt?: Date | null;
+};
+interface MongoCollection {
+    createIndex(keys: Record<string, number>, options: Record<string, unknown>): Promise<unknown>;
+    findOne(filter: Record<string, unknown>, options?: Record<string, unknown>): Promise<MongoDocument | null>;
+    find(filter: Record<string, unknown>, options?: Record<string, unknown>): {
+        toArray(): Promise<MongoDocument[]>;
+    };
+    updateOne(filter: Record<string, unknown>, update: Record<string, unknown>, options: Record<string, unknown>): Promise<unknown>;
+    bulkWrite(operations: Record<string, unknown>[], options: Record<string, unknown>): Promise<unknown>;
+    deleteOne(filter: Record<string, unknown>): Promise<{
+        deletedCount: number;
+    }>;
+    deleteMany(filter: Record<string, unknown>): Promise<{
+        deletedCount: number;
+    }>;
+}
+interface MongoClient {
+    connect(): Promise<unknown>;
+    close(): Promise<void>;
+    db(name: string): {
+        collection(name: string): MongoCollection;
+    };
+}
+/**
+ * The MongoDB store
+ * Document format: {key: "{namespace}:{key}", value: serialized entry, expiresAt: Date | null}, removed by a TTL index
+ */
+export declare class MongoStore extends SerializedCacheStore {
+    protected readonly options: MongoCacheOptions;
+    protected client: MongoClient;
+    protected collection: MongoCollection;
+    constructor(options: MongoCacheOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    protected read(key: string): Promise<string | undefined>;
+    protected readMany(keys: string[]): Promise<(string | undefined)[]>;
+    /**
+     * The upsert of an entry
+     * @param entry
+     * @protected
+     */
+    protected update(entry: SerializedEntry): [Record<string, unknown>, Record<string, unknown>];
+    protected write(entry: SerializedEntry): Promise<void>;
+    protected writeMany(entries: SerializedEntry[]): Promise<void>;
+    protected remove(key: string): Promise<boolean>;
+    protected removeMany(keys: string[]): Promise<boolean>;
+    clear(): Promise<void>;
+}
+export {};