1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 |
|
12 | import { EventEmitter } from 'events';
|
13 | import { AbstractLevelDOWN, AbstractIteratorOptions, AbstractBatch, ErrorCallback, AbstractOptions, ErrorValueCallback, AbstractGetOptions, AbstractIterator } from 'abstract-leveldown';
|
14 | import { LevelUPError, InitializationError, OpenError, ReadError, WriteError, NotFoundError, EncodingError } from 'level-errors';
|
15 |
|
16 | type LevelUpPut<K, V, O> =
|
17 | ((key: K, value: V, callback: ErrorCallback) => void) &
|
18 | ((key: K, value: V, options: O, callback: ErrorCallback) => void) &
|
19 | ((key: K, value: V, options?: O) => Promise<void>);
|
20 |
|
21 | type LevelUpGet<K, V, O> =
|
22 | ((key: K, callback: ErrorValueCallback<V>) => void) &
|
23 | ((key: K, options: O, callback: ErrorValueCallback<V>) => void) &
|
24 | ((key: K, options?: O) => Promise<V>);
|
25 |
|
26 | type LevelUpGetMany<K, V, O> =
|
27 | ((keys: K[], callback: ErrorValueCallback<V[]>) => void) &
|
28 | ((keys: K[], options: O, callback: ErrorValueCallback<V[]>) => void) &
|
29 | ((keys: K[], options?: O) => Promise<V[]>);
|
30 |
|
31 | type LevelUpDel<K, O> =
|
32 | ((key: K, callback: ErrorCallback) => void) &
|
33 | ((key: K, options: O, callback: ErrorCallback) => void) &
|
34 | ((key: K, options?: O) => Promise<void>);
|
35 |
|
36 | type LevelUpClear<O> =
|
37 | ((callback: ErrorCallback) => void) &
|
38 | ((options: O, callback: ErrorCallback) => void) &
|
39 | ((options?: O) => Promise<void>);
|
40 |
|
41 | type LevelUpBatch<K, O> =
|
42 | ((key: K, callback: ErrorCallback) => void) &
|
43 | ((key: K, options: O, callback: ErrorCallback) => void) &
|
44 | ((key: K, options?: O) => Promise<void>);
|
45 |
|
46 | type InferDBPut<DB> =
|
47 | DB extends { put: (key: infer K, value: infer V, options: infer O, cb: any) => void } ?
|
48 | LevelUpPut<K, V, O> :
|
49 | LevelUpPut<any, any, AbstractOptions>;
|
50 |
|
51 | type InferDBGet<DB> =
|
52 | DB extends { get: (key: infer K, options: infer O, callback: ErrorValueCallback<infer V>) => void } ?
|
53 | LevelUpGet<K, V, O> :
|
54 | LevelUpGet<any, any, AbstractGetOptions>;
|
55 |
|
56 | type InferDBGetMany<DB> =
|
57 | DB extends { getMany: (keys: Array<infer K>, options: infer O, callback: ErrorValueCallback<Array<infer V>>) => void } ?
|
58 | LevelUpGetMany<K, V, O> :
|
59 | LevelUpGetMany<any, any, AbstractGetOptions>;
|
60 |
|
61 | type InferDBDel<DB> =
|
62 | DB extends { del: (key: infer K, options: infer O, callback: ErrorCallback) => void } ?
|
63 | LevelUpDel<K, O> :
|
64 | LevelUpDel<any, AbstractOptions>;
|
65 |
|
66 | type InferDBClear<DB> =
|
67 | DB extends { clear: (options: infer O, callback: ErrorCallback) => void } ?
|
68 | LevelUpClear<O> :
|
69 | LevelUpClear<AbstractClearOptions>;
|
70 |
|
71 | interface AbstractClearOptions<K = any> extends AbstractOptions {
|
72 | gt?: K | undefined;
|
73 | gte?: K | undefined;
|
74 | lt?: K | undefined;
|
75 | lte?: K | undefined;
|
76 | reverse?: boolean | undefined;
|
77 | limit?: number | undefined;
|
78 | }
|
79 |
|
80 | declare namespace levelup {
|
81 | interface LevelUpChain<K = any, V = any> {
|
82 | readonly length: number;
|
83 | put(key: K, value: V): this;
|
84 | del(key: K): this;
|
85 | clear(): this;
|
86 | write(callback: ErrorCallback): this;
|
87 | write(): Promise<this>;
|
88 | }
|
89 | interface LevelUp<DB = AbstractLevelDOWN, Iterator = AbstractIterator<any, any>> extends EventEmitter {
|
90 | open(): Promise<void>;
|
91 | open(callback?: ErrorCallback): void;
|
92 | close(): Promise<void>;
|
93 | close(callback?: ErrorCallback): void;
|
94 |
|
95 | put: InferDBPut<DB>;
|
96 | get: InferDBGet<DB>;
|
97 | del: InferDBDel<DB>;
|
98 | clear: InferDBClear<DB>;
|
99 | getMany: InferDBGetMany<DB>;
|
100 |
|
101 | batch(array: AbstractBatch[], options?: any): Promise<void>;
|
102 | batch(array: AbstractBatch[], options: any, callback: (err?: any) => any): void;
|
103 | batch(array: AbstractBatch[], callback: (err?: any) => any): void;
|
104 |
|
105 | batch(): LevelUpChain;
|
106 | iterator(options?: AbstractIteratorOptions): Iterator;
|
107 |
|
108 | isOpen(): boolean;
|
109 | isClosed(): boolean;
|
110 |
|
111 | readonly status: "closed" | "open" | "opening" | "new" | "closing";
|
112 | isOperational(): boolean;
|
113 |
|
114 | createReadStream(options?: AbstractIteratorOptions): NodeJS.ReadableStream;
|
115 | createKeyStream(options?: AbstractIteratorOptions): NodeJS.ReadableStream;
|
116 | createValueStream(options?: AbstractIteratorOptions): NodeJS.ReadableStream;
|
117 |
|
118 | |
119 |
|
120 |
|
121 | on(event: 'put', cb: (key: any, value: any) => void): this;
|
122 | |
123 |
|
124 |
|
125 | on(event: 'del', cb: (key: any) => void): this;
|
126 | |
127 |
|
128 |
|
129 | on(event: 'batch', cb: (ary: any[]) => void): this;
|
130 | |
131 |
|
132 |
|
133 | on(event: 'clear', cb: (opts: any) => void): this;
|
134 | |
135 |
|
136 |
|
137 | on(event: 'open' | 'ready' | 'closed' | 'opening' | 'closing', cb: () => void): this;
|
138 | }
|
139 |
|
140 | interface LevelUpConstructor {
|
141 | <DB extends AbstractLevelDOWN = AbstractLevelDOWN>(
|
142 | db: DB,
|
143 | options: any,
|
144 | cb?: ErrorCallback): LevelUp<DB>;
|
145 |
|
146 | <DB extends AbstractLevelDOWN = AbstractLevelDOWN>(
|
147 | db: DB,
|
148 | cb?: ErrorCallback): LevelUp<DB>;
|
149 |
|
150 | new <DB extends AbstractLevelDOWN = AbstractLevelDOWN>(
|
151 | db: DB,
|
152 | options: any,
|
153 | cb?: ErrorCallback): LevelUp<DB>;
|
154 |
|
155 | new <DB extends AbstractLevelDOWN = AbstractLevelDOWN>(
|
156 | db: DB,
|
157 | cb?: ErrorCallback): LevelUp<DB>;
|
158 |
|
159 | errors: {
|
160 | LevelUPError: typeof LevelUPError;
|
161 | InitializationError: typeof InitializationError;
|
162 | OpenError: typeof OpenError;
|
163 | ReadError: typeof ReadError;
|
164 | WriteError: typeof WriteError;
|
165 | NotFoundError: typeof NotFoundError;
|
166 | EncodingError: typeof EncodingError;
|
167 | };
|
168 | }
|
169 | }
|
170 |
|
171 | declare const levelup: levelup.LevelUpConstructor;
|
172 |
|
173 | export = levelup;
|