keyv-file/lib/index.d.ts

File storage adapter for Keyv, using msgpack to serialize data fast and small.

import EventEmitter from 'events';
import type { KeyvStoreAdapter, StoredData } from 'keyv';
export interface Options {
    deserialize: (val: string) => any;
    dialect: string;
    /** milliseconds */
    expiredCheckDelay: number;
    filename: string;
    serialize: (val: any) => string;
    /** milliseconds */
    writeDelay: number;
    /** create lock file and check if exists */
    checkFileLock: boolean;
}
export declare const defaultOpts: Options;
export interface WrappedValue<T = any> {
    value: T;
    expire?: number;
}
export declare class KeyvFile extends EventEmitter implements KeyvStoreAdapter {
    ttlSupport: boolean;
    namespace?: string;
    opts: Options;
    private _cache;
    private _lastExpire;
    constructor(options?: Partial<Options>);
    private get _lockFile();
    acquireFileLock(): void;
    releaseFileLock(): void;
    get<Value>(key: string): Promise<StoredData<Value> | undefined>;
    getMany<Value>(keys: string[]): Promise<Array<StoredData<Value | undefined>>>;
    set(key: string, value: any, ttl?: number): Promise<any>;
    delete(key: string): Promise<boolean>;
    deleteMany(keys: string[]): Promise<boolean>;
    clear(): Promise<any>;
    has(key: string): Promise<boolean>;
    private isExpired;
    private clearExpire;
    private saveToDisk;
    private _savePromise?;
    private save;
    disconnect(): Promise<void>;
    iterator(namespace?: string): AsyncGenerator<any[], void, unknown>;
}
export default KeyvFile;
export declare class Field<T, D extends T | void = T | void> {
    protected kv: KeyvFile;
    protected key: string;
    protected defaults?: D | undefined;
    constructor(kv: KeyvFile, key: string, defaults?: D | undefined);
    get(): Promise<D>;
    get(def: D): Promise<D>;
    set(val: T, ttl?: number): Promise<any>;
    delete(): Promise<boolean>;
}
export declare function makeField<T = any, D = T>(kv: KeyvFile, key: string, defaults: T): Field<T, T>;