@types/levelup
Version:
TypeScript definitions for levelup
181 lines (152 loc) • 5.98 kB
TypeScript
/// <reference types="node" />
import {
AbstractBatch,
AbstractGetOptions,
AbstractIterator,
AbstractIteratorOptions,
AbstractLevelDOWN,
AbstractOptions,
ErrorCallback,
ErrorValueCallback,
} from "abstract-leveldown";
import { EventEmitter } from "events";
import {
EncodingError,
InitializationError,
LevelUPError,
NotFoundError,
OpenError,
ReadError,
WriteError,
} from "level-errors";
type LevelUpPut<K, V, O> =
& ((key: K, value: V, callback: ErrorCallback) => void)
& ((key: K, value: V, options: O, callback: ErrorCallback) => void)
& ((key: K, value: V, options?: O) => Promise<void>);
type LevelUpGet<K, V, O> =
& ((key: K, callback: ErrorValueCallback<V>) => void)
& ((key: K, options: O, callback: ErrorValueCallback<V>) => void)
& ((key: K, options?: O) => Promise<V>);
type LevelUpGetMany<K, V, O> =
& ((keys: K[], callback: ErrorValueCallback<V[]>) => void)
& ((keys: K[], options: O, callback: ErrorValueCallback<V[]>) => void)
& ((keys: K[], options?: O) => Promise<V[]>);
type LevelUpDel<K, O> =
& ((key: K, callback: ErrorCallback) => void)
& ((key: K, options: O, callback: ErrorCallback) => void)
& ((key: K, options?: O) => Promise<void>);
type LevelUpClear<O> =
& ((callback: ErrorCallback) => void)
& ((options: O, callback: ErrorCallback) => void)
& ((options?: O) => Promise<void>);
type LevelUpBatch<K, O> =
& ((key: K, callback: ErrorCallback) => void)
& ((key: K, options: O, callback: ErrorCallback) => void)
& ((key: K, options?: O) => Promise<void>);
type InferDBPut<DB> = DB extends { put: (key: infer K, value: infer V, options: infer O, cb: any) => void }
? LevelUpPut<K, V, O>
: LevelUpPut<any, any, AbstractOptions>;
type InferDBGet<DB> = DB extends
{ get: (key: infer K, options: infer O, callback: ErrorValueCallback<infer V>) => void } ? LevelUpGet<K, V, O>
: LevelUpGet<any, any, AbstractGetOptions>;
type InferDBGetMany<DB> = DB extends
{ getMany: (keys: Array<infer K>, options: infer O, callback: ErrorValueCallback<Array<infer V>>) => void }
? LevelUpGetMany<K, V, O>
: LevelUpGetMany<any, any, AbstractGetOptions>;
type InferDBDel<DB> = DB extends { del: (key: infer K, options: infer O, callback: ErrorCallback) => void }
? LevelUpDel<K, O>
: LevelUpDel<any, AbstractOptions>;
type InferDBClear<DB> = DB extends { clear: (options: infer O, callback: ErrorCallback) => void } ? LevelUpClear<O>
: LevelUpClear<AbstractClearOptions>;
interface AbstractClearOptions<K = any> extends AbstractOptions {
gt?: K | undefined;
gte?: K | undefined;
lt?: K | undefined;
lte?: K | undefined;
reverse?: boolean | undefined;
limit?: number | undefined;
}
declare namespace levelup {
interface LevelUpChain<K = any, V = any> {
readonly length: number;
put(key: K, value: V): this;
del(key: K): this;
clear(): this;
write(callback: ErrorCallback): this;
write(): Promise<this>;
}
interface LevelUp<DB = AbstractLevelDOWN, Iterator = AbstractIterator<any, any>> extends EventEmitter {
open(): Promise<void>;
open(callback?: ErrorCallback): void;
close(): Promise<void>;
close(callback?: ErrorCallback): void;
put: InferDBPut<DB>;
get: InferDBGet<DB>;
del: InferDBDel<DB>;
clear: InferDBClear<DB>;
getMany: InferDBGetMany<DB>;
batch(array: AbstractBatch[], options?: any): Promise<void>;
batch(array: AbstractBatch[], options: any, callback: (err?: any) => any): void;
batch(array: AbstractBatch[], callback: (err?: any) => any): void;
batch(): LevelUpChain;
iterator(options?: AbstractIteratorOptions): Iterator;
isOpen(): boolean;
isClosed(): boolean;
readonly status: "closed" | "open" | "opening" | "new" | "closing";
isOperational(): boolean;
createReadStream(options?: AbstractIteratorOptions): NodeJS.ReadableStream;
createKeyStream(options?: AbstractIteratorOptions): NodeJS.ReadableStream;
createValueStream(options?: AbstractIteratorOptions): NodeJS.ReadableStream;
/*
emitted when a new value is 'put'
*/
on(event: "put", cb: (key: any, value: any) => void): this;
/*
emitted when a value is deleted
*/
on(event: "del", cb: (key: any) => void): this;
/*
emitted when a batch operation has executed
*/
on(event: "batch", cb: (ary: any[]) => void): this;
/*
emitted when clear is called
*/
on(event: "clear", cb: (opts: any) => void): this;
/*
emitted on given event
*/
on(event: "open" | "ready" | "closed" | "opening" | "closing", cb: () => void): this;
}
interface LevelUpConstructor {
<DB extends AbstractLevelDOWN = AbstractLevelDOWN>(
db: DB,
options: any,
cb?: ErrorCallback,
): LevelUp<DB>;
<DB extends AbstractLevelDOWN = AbstractLevelDOWN>(
db: DB,
cb?: ErrorCallback,
): LevelUp<DB>;
new<DB extends AbstractLevelDOWN = AbstractLevelDOWN>(
db: DB,
options: any,
cb?: ErrorCallback,
): LevelUp<DB>;
new<DB extends AbstractLevelDOWN = AbstractLevelDOWN>(
db: DB,
cb?: ErrorCallback,
): LevelUp<DB>;
errors: {
LevelUPError: typeof LevelUPError;
InitializationError: typeof InitializationError;
OpenError: typeof OpenError;
ReadError: typeof ReadError;
WriteError: typeof WriteError;
NotFoundError: typeof NotFoundError;
EncodingError: typeof EncodingError;
};
}
}
declare const levelup: levelup.LevelUpConstructor;
export = levelup;