blackcat.js-database 1.0.0-test

package/dist/index.d.ts

@@ -0,0 +1,751 @@
+/**
+ * Represents the base driver interface for database operations.
+ */
+interface BaseDriver {
+    get<T = any>(key: string): Promise<T | null>;
+    set<T = any>(key: string, value: T): Promise<T>;
+    delete(key?: any): Promise<boolean>;
+    all(): Promise<Record<string, any>>;
+}
+/**
+ * Represents the configuration object of the database instance.
+ */
+interface DatabaseConfiguration {
+    driver: BaseDriver;
+    debug?: boolean;
+}
+/**
+ * Represents the nullish type (`T` or `null`) and excludes `undefined` from it.
+ *
+ * Type parameters:
+ *
+ * - `T` (`any`) - The type to make nullish.
+ *
+ * @template T - The type to make nullish.
+ */
+type Maybe<T> = Exclude<T | null, undefined>;
+/**
+ * Conditional type that returns the type based on the condition type result.
+ *
+ * Type parameters:
+ *
+ * - `T` (`boolean`) - The condition to return a boolean value.
+ * - `IfTrue` (`any`) - The type to be returned if the condition type `T` is `true`.
+ * - `IfFalse` (`null`, optional) - The type to be returned if the condition type `T` is `false`.
+ *
+ * @template T - The condition to return a boolean value.
+ * @template IfTrue - The type to be returned if the condition type `T` is `true`.
+ * @template IfFalse - The type to be returned if the condition type `T` is `false`.
+ */
+type If<T extends boolean, IfTrue, IfFalse = null> = T extends true ? IfTrue : IfFalse;
+/**
+ * Determines if the specified type is object and returns the checking result as boolean.
+ *
+ * Type parameters:
+ *
+ * - `T` (`any`) - The type to check.
+ *
+ * @template T - The type to check.
+ */
+type IsObject<T> = T extends null ? false : T extends undefined ? false : T extends any[] ? false : T extends Record<any, any> ? true : false;
+/**
+ * Represents a type that works as an array of specified type or `...spread` of specified type.
+ *
+ * Type parameters:
+ *
+ * - `T` (`any`) - The type to convert into rest-or-array type.
+ *
+ * @template T - The type to convert into rest-or-array type.
+ */
+type RestOrArray<T> = T[] | [T[]];
+/**
+ * From the type `A`, extracts the type `T` from the `Array<T>` type, or returns `A` if not array type was specified.
+ *
+ * Type parameters:
+ *
+ * - `A` (`any`) - The array type to extract the type from.
+ *
+ * @template A - The array type to extract the type from.
+ */
+type ExtractFromArray<A> = A extends Array<infer T> ? T : A;
+/**
+ * Represents a `predicate` callback function from array methods such as `Array.map()`, `Array.find()`, etc.
+ *
+ * Type parameters:
+ *
+ * - `T` (`any`) - The type of the item in the array.
+ * - `R` (`any`, optional) - The return type of the function.
+ *
+ * @template T - The type of the item in the array.
+ * @template R - The return type of the function.
+ */
+type QueryFunction<T, R = any> = (item: T, index: number, values: T[]) => R;
+/**
+ * Determines if the specified type is `any` and returns the checking result as boolean.
+ *
+ * Type parameters:
+ *
+ * - `T` (`any`) - The type to check.
+ *
+ * @template T - The type to check.
+ */
+type IsAny<T> = 0 extends (1 & T) ? true : false;
+/**
+ * Makes the string union type autocompletable with a `string` type.
+ *
+ * Type parameters:
+ *
+ * - `S` (`string`) - The autocompletable union string type to make compatible with a `string` type.
+ *
+ * @template S - The autocompletable union string type to make compatible with a `string` type.
+ */
+type AutocompletableString<S extends string> = S | (string & {});
+/**
+ * Extracts the first key from the specified object path.
+ * (for example, in key `member.user.id`, the first key will be `member`)
+ *
+ * Type parameters:
+ *
+ * - `TKey` (`ObjectPath<string, any>`) - The object path to extract the key from.
+ *
+ * @template TKey - The object path to extract the key from.
+ */
+type FirstObjectKey<TKey extends ObjectPath<string, any>> = TKey extends `${infer Key}.${infer _Rest}` ? Key : TKey extends string ? TKey : never;
+/**
+ * Represents a path to a nested property in an object.
+ *
+ * Type parameters:
+ *
+ * - `T` (`any`) - The object to get the path from.
+ * - `TKey` (`keyof T`, defaults to `keyof T`) - The key of the object to get the path from.
+ *
+ * @template T - The object to get the path from.
+ * @template TKey - The key of the object to get the path from.
+ */
+type ObjectPath<T, TKey extends keyof T = keyof T> = IsAny<T> extends true ? string : T extends string | number | boolean | symbol ? string : T extends Array<any> ? TKey & string : TKey extends string ? T[TKey] extends Array<any> ? TKey : T[TKey] extends Record<string, any> ? `${TKey}` | `${TKey}.${ObjectPath<T[TKey]>}` : TKey : never;
+/**
+ * Extracts the value from the specified object path.
+ *
+ * Type parameters:
+ *
+ * - `T` (`any`) - The object to extract the value from.
+ * - `P` (`ObjectPath<T>` or `AutocompletableString<ObjectPath<T>>`) - The object path to extract the value from.
+ *
+ * @template T - The object to extract the value from.
+ * @template P - The object path to extract the value from.
+ */
+type ObjectValue<T, P extends ObjectPath<T> | AutocompletableString<ObjectPath<T>>> = T extends AutocompletableString<P> | string | number | boolean | symbol ? T : P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? Rest extends ObjectPath<T[Key]> ? ObjectValue<T[Key], Rest> : null : never : P extends keyof T ? T[P] : T;
+
+/**
+ * Database class.
+ *
+ * Type parameters:
+ *
+ * - `V` (`any`) - The type of the values in the database.
+ *
+ * @template V (`any`) - The type of the values in the database.
+ *
+ * @example
+ *
+ * // JSON
+ * import { Database, JSONDriver } from "blackcat-database";
+ *
+ * const database = new Database({
+ *    driver: new JSONDriver({ filePath: "./database.json", minifyJSON: false }),
+ * });
+ *
+ *
+ */
+declare class Database<V = any> {
+    /**
+     * The low-level database driver handling basic operations.
+     */
+    driver: BaseDriver;
+    constructor(options: DatabaseConfiguration);
+    /**
+     * Gets all the database contents from the cache.
+     *
+     * Type parameters:
+     *
+     * - `T` (`object`, defaults to `Record<string, any>`) - The type of object of all the database object to be returned.
+     *
+     * @returns {T} Cached database contents.
+     *
+     * @template T (object, defaults to `Record<string, any>`) -
+     * The type of object of all the database object to be returned.
+     *
+     * @example
+     * const databaseContents = await database.all();
+     * console.log(databaseContents); // -> { ... (the object of all the data stored in database) }
+     */
+    all<T extends Record<string, any> = Record<string, any>>(): Promise<T>;
+    /**
+     * Retrieves a value from database by a key.
+     *
+     * @param {AutocompletableString<P>} key The key to access the target in database by.
+     * @returns {Maybe<ObjectValue<V, P>>} The value of the target in database.
+     *
+     * @example
+     * const simpleValue = await database.get("simpleValue");
+     * console.log(simpleValue); // -> 123
+     *
+     * const databaseObjectPropertyAccessed = await database.get("youCanAlso.accessDatabaseObjectProperties.likeThat");
+     * console.log(databaseObjectPropertyAccessed); // -> "hello world!"
+     *
+     * // Assuming that the initial database object for this example is:
+     * // {
+     * //    simpleValue: 123,
+     * //    youCanAlso: {
+     * //        accessDatabaseObjectProperties: {
+     * //            likeThat: "hello world!"
+     * //        }
+     * //    }
+     * // }
+     */
+    get<P extends AutocompletableString<ObjectPath<V>>>(key?: AutocompletableString<P>): Promise<Maybe<ObjectValue<V, P>> | V>;
+    /**
+     * Retrieves a value from database by a key.
+     *
+     * - This method is an alias for {@link Database.get()} method.
+     *
+     * @param {AutocompletableString<P>} key The key to access the target in database by.
+     * @returns {Maybe<ObjectValue<V, P>>} The value from database.
+     *
+     * @example
+     * const simpleValue = await database.fetch("simpleValue");
+     * console.log(simpleValue); // -> 123
+     *
+     * // You can use the dot notation to access the database object properties:
+     * const playerInventory = await database.fetch("player.inventory");
+     * console.log(playerInventory); // -> []
+     *
+     * // Assuming that the initial database object for this example is:
+     * // {
+     * //    simpleValue: 123,
+     * //    player: {
+     * //        inventory: []
+     * //    }
+     * // }
+     */
+    fetch<P extends AutocompletableString<ObjectPath<V>>>(key?: AutocompletableString<P>): Promise<Maybe<ObjectValue<V, P>> | V>;
+    /**
+     * Determines if the data is stored in database.
+     * @param {AutocompletableString<P>} key The key to access the target in database by.
+     * @returns {boolean} Whether the data is stored in database.
+     *
+     * @example
+     * const isSimpleValueInDatabase = await database.has("simpleValue");
+     * console.log(isSimpleValueInDatabase); // -> true
+     *
+     * const somethingElse = await database.has("somethingElse");
+     * console.log(somethingElse); // -> false
+     *
+     * // You can use the dot notation to check the database object properties:
+     * const isObjectInDatabase = await database.has("youCanAlso.accessObjectProperties.likeThat");
+     * console.log(isObjectInDatabase); // -> true
+     *
+     * // Assuming that the initial database object for this example is:
+     * // {
+     * //    simpleValue: 123,
+     * //    player: {
+     * //        inventory: []
+     * //    },
+     * //    youCanAlso: {
+     * //        accessObjectProperties: {
+     * //            likeThat: "hello world!"
+     * //        }
+     * //    }
+     * // }
+     */
+    has<P extends AutocompletableString<ObjectPath<V>>>(key: AutocompletableString<P>): Promise<boolean>;
+    /**
+     * Writes the specified value into database under the specified key.
+     *
+     * @param {AutocompletableString<P>} key The key to write in the target.
+     * @param {ObjectValue<V, P>} value The value to write.
+     *
+     * @returns {Promise<If<IsObject<V>, FirstObjectKey<P>, V>>}
+     * - If the `value` parameter's type is not an object (string, number, boolean, etc), then the specified
+     * `value` parameter (type of `ObjectValue<V, P>`) will be returned.
+     *
+     * - If an object is specified in the `value` parameter, then the object of the first key will be returned.
+     * (type of `FirstObjectKey<P>` - first object key (e.g. in key `member.user.id`, the first key will be `member`))
+     *
+     * @example
+     * // Assuming that the initial database object for this example is empty.
+     *
+     * await database.set("something", "hello");
+     * const hello = await database.get("something");
+     *
+     * console.log(hello); // -> "hello"
+     *
+     * // You can use the dot notation to write data in objects:
+     * const dotNotationSetResult = await database.set("member.user.id", 2000);
+     * console.log(dotNotationSetResult); // -> 2000
+     *
+     * await database.set("member.inventory", []);
+     * const inventory = await database.get("member.inventory");
+     *
+     * console.log(inventory); // -> []
+     *
+     * // Using objects as value will return the object of key `thats`:
+     * await database.set("member.user", { name: "Jerry" }); // -> { member: { user: { name: "Jerry" } } }
+     *
+     * // After these manipulations, the database object will look like this:
+     * // {
+     * //     "something": "hello",
+     * //     "member": {
+     * //       "inventory": [],
+     * //       "user": {
+     * //          "name": "Jerry",
+     * //          "id": 2000
+     * //       }
+     * //     }
+     * // }
+     */
+    set<P extends AutocompletableString<ObjectPath<V>>>(key: AutocompletableString<P>, value: ObjectValue<V, P>): Promise<If<IsObject<V>, ObjectValue<V, FirstObjectKey<P>>, V>>;
+    /**
+     * Update the specified value into database under the specified key.
+     *
+     * @param {AutocompletableString<P>} key The key to update the target.
+     * @param {ObjectValue<V, P>} value The value to update.
+     *
+     * @returns {Promise<If<IsObject<V>, FirstObjectKey<P>, V>>}
+     * - If the `value` parameter's type is not an object (string, number, boolean, etc), then the specified
+     * `value` parameter (type of `ObjectValue<V, P>`) will be returned.
+     *
+     * - If an object is specified in the `value` parameter, then the object of the first key will be returned.
+     * (type of `FirstObjectKey<P>` - first object key (e.g. in key `member.user.id`, the first key will be `member`))
+     */
+    update<P extends AutocompletableString<ObjectPath<V>>>(key: AutocompletableString<P>, value: ObjectValue<V, P>): Promise<If<IsObject<V>, ObjectValue<V, FirstObjectKey<P>>, V>>;
+    /**
+     * Performs an arithmetical addition on a target number in database.
+     *
+     * [!!!] The type of target value must be a number.
+     *
+     * @param {AutocompletableString<P>} key The key to access the target in database by.
+     * @param {number} numberToAdd The number to add to the target number in database.
+     * @returns {Promise<number>} Addition operation result.
+     *
+     * @example
+     * const additionResult = await database.add("points", 5);
+     * console.log(additionResult); // -> 10 (5 + 5 = 10)
+     *
+     * // Notice that we don't need to assign a value to unexistent properties in database
+     * // before performing an addition since the initial target value is 0 and will be used
+     * // as the value of the unexistent property:
+     * const unexistentAdditionResult = await database.add("somethingElse", 3);
+     *
+     * console.log(unexistentAdditionResult); // -> 3 (0 + 3 = 3)
+     * // the property didn't exist in database, that's why 0 is added to 3
+     *
+     * // Assuming that the initial database object for this example is:
+     * // {
+     * //    points: 5
+     * // }
+     */
+    add<P extends AutocompletableString<ObjectPath<V>>>(key: AutocompletableString<P>, numberToAdd: number): Promise<number>;
+    /**
+     * Performs an arithmetical subtraction on a target number in database.
+     *
+     * [!!!] The type of target value must be a number.
+     *
+     * @param {AutocompletableString<P>} key The key to access the target in database by.
+     * @param {number} numberToSubtract The number to subtract from the target number in database.
+     * @returns {Promise<number>} Subtraction operation result.
+     *
+     * @example
+     * const subtractionResult = await database.subtract("points", 5)
+     * console.log(subtractionResult) // -> 5 (10 - 5 = 5)
+     *
+     * // Notice that we don't need to assign a value to unexistent properties in database
+     * // before performing a subtraction since the initial target value is 0 and will be used
+     * // as the value of the unexistent property:
+     * const unexistentSubtractionitionResult = await database.subtract("somethingElse", 3)
+     *
+     * console.log(unexistentSubtractionitionResult) // -> 3 (0 - 3 = -3)
+     * // the property didn't exist in database, so 3 is subtracted from 0
+     *
+     * // Assuming that the initial database object for this example is:
+     * // {
+     * //    points: 10
+     * // }
+     */
+    subtract<P extends AutocompletableString<ObjectPath<V>>>(key: AutocompletableString<P>, numberToSubtract: number): Promise<number>;
+    /**
+     * Pushes the specified value(s) into the target array in database.
+     *
+     * [!!!] The type of target value must be an array.
+     * [!!!] get only values ​​not stored in the database.
+     *
+     * @param {AutocompletableString<P>} key The key to access the target in database by.
+     * @param {RestOrArray<ExtractFromArray<ObjectValue<V, P>>>} values
+     * The value(s) to be pushed into the target array in database.
+     *
+     * @returns {Promise<Array<ExtractFromArray<ObjectValue<V, P>>>>} Updated target array from database.
+     *
+     * @example
+     * console.log(await database.push("members", "Jerry")); // -> ["Tom", "Jerry"]
+     * // You can also pass in multiple values to push into the target array:
+     * console.log(await database.push("currencies", "VND")); // -> ["USD", "VND"]
+     *
+     * // Assuming that the initial database object for this example is:
+     * // {
+     * //    members: ["Tom"],
+     * //    currencies: ["USD"]
+     * // }
+     */
+    push<P extends ObjectPath<V>>(key: AutocompletableString<P>, ...values: RestOrArray<ExtractFromArray<ObjectValue<V, P>>>): Promise<ExtractFromArray<ObjectValue<V, P>>[]>;
+    /**
+    * Replaces the specified element in target array with the specified value in the target array in database.
+    *
+    * [!!!] The type of target value must be an array.
+    *
+    * @param {AutocompletableString<P>} key The key to access the target in database by.
+    * @param {number} targetArrayElementIndex The index to find the element in target array by.
+    * @param {V} value The value to be pushed into the target array in database.
+    * @returns {Promise<Array<ExtractFromArray<ObjectValue<V, P>>>>} Updated target array from database.
+    *
+    * @example
+    * console.log(await database.pull("members", 1, "James")); // -> ["Jerry", "James", "Tom"]
+    *
+    * // Assuming that the initial database object for this example is:
+    * // {
+    * //    members: ["Jerry", "William", "Tom"]
+    * // }
+    */
+    pull<P extends AutocompletableString<ObjectPath<V>>>(key: AutocompletableString<P>, targetArrayElementIndex: number, value: ExtractFromArray<ObjectValue<V, P>>): Promise<ExtractFromArray<ObjectValue<V, P>>[]>;
+    /**
+     * Removes the specified element(s) from the target array in database.
+     *
+     * [!!!] The type of target value must be an array.
+     *
+     * @param {AutocompletableString<P>} key The key to access the target in database by.
+     * @param {RestOrArray<ExtractFromArray<number>>} targetArrayElementIndexes
+     * The index(es) to find the element(s) in target array by.
+     *
+     * @returns {Promise<Array<ExtractFromArray<ObjectValue<V, P>>>>} Updated target array from database.
+     *
+     * @example
+     * console.log(await database.pop("members", 1)); // -> ["Jerry", "Tom"]
+     *
+     * console.log(await database.pop("currencies", 1)); // -> ["VND", "Euro"]
+     *
+     * // Assuming that the initial database object for this example is:
+     * // {
+     * //    members: ["Jerry", "William", "Tom"],
+     * //    currencies: ["VND", "USD", "Euro"]
+     * // }
+     */
+    pop<P extends AutocompletableString<ObjectPath<V>>>(key: AutocompletableString<P>, ...targetArrayElementIndexes: RestOrArray<ExtractFromArray<number>>): Promise<ExtractFromArray<ObjectValue<V, P>>[]>;
+    /**
+     * Determines whether the specified target is an array.
+     *
+     * @param {AutocompletableString<P>} key The key to access the target in database by.
+     * @returns {Promise<boolean>} Whether the target is an array.
+     *
+     * @example
+     * console.log(await databse.isTargetArray("array")); // => true
+     * console.log(await databse.isTargetArray("notArray")); // => false
+     *
+     * // Assuming that the initial database object for this example is:
+     * // {
+     * //    array: [],
+     * //    notArray: 123
+     * // }
+     */
+    isTargetArray<P extends AutocompletableString<ObjectPath<V>>>(key: AutocompletableString<P>): Promise<boolean>;
+    /**
+     * Determines whether the specified target is a number.
+     *
+     * @param {AutocompletableString<P>} key The key to access the target in database by.
+     * @returns {Promise<boolean>} Whether the target is a number.
+     *
+     * @example
+     * console.log(await database.isTargetNumber("number")); // -> true
+     * console.log(await database.isTargetNumber("notNumber")); // -> false
+     *
+     * // Assuming that the initial database object for this example is:
+     * // {
+     * //    number: 123,
+     * //    notNumber: []
+     * // }
+     */
+    isTargetNumber<P extends AutocompletableString<ObjectPath<V>>>(key: AutocompletableString<P>): Promise<boolean>;
+    /**
+     * Returns an array of object keys by specified database key.
+     *
+     * If `key` parameter is omitted, then an array of object keys of database root object will be returned.
+     *
+     * Type parameters:
+     *
+     * - `TKeys` (`TupleOrArray<string>`, defaults to `K[]`) - The tuple or array of a type of keys to be returned.
+     *
+     * @param {P} [key] The key to access the target in database by.
+     * @returns {Array<ObjectPath<P>>} Database object keys array.
+     *
+     * @example
+     * const prop3Keys = await database.keys("prop3");
+     * console.log(prop3Keys) // -> ["prop4", "prop5"]
+     *
+     * const prop5Keys = await database.keys("prop3.prop5");
+     * console.log(prop5Keys) // -> ["prop6"]
+     *
+     * const prop6Keys = await database.keys("prop3.prop5.prop6");
+     * console.log(prop6Keys)
+     * // -> [] (empty since the value in `prop6`, 111, is a primitive value and not an actual object)
+     *
+     * const databaseKeys = await database.keys();
+     * // in this example, `key` parameter is omitted - object keys of database object are being returned
+     *
+     * console.log(databaseKeys) // -> ["prop1", "prop2", "prop3"]
+     *
+     * const unexistentKeys = await database.keys("somethingElse");
+     * console.log(unexistentKeys) // -> [] (empty since the key `somethingElse` does not exist in database)
+     *
+     * // Assuming that the initial database object for this example is:
+     * // {
+     * //    prop1: 123,
+     * //    prop2: 456,
+     * //    prop3: {
+     * //       prop4: 789,
+     * //       prop5: {
+     * //          prop6: 111
+     * //       }
+     * //    }
+     * // }
+     */
+    keys<P extends AutocompletableString<ObjectPath<V>>>(key?: P): Promise<ObjectPath<P>[]>;
+    /**
+     * Determines the number of keys in the root of the database.
+     * @type {Promise<number>} amount of data.
+     */
+    size(): Promise<number>;
+    /**
+     * Returns an array of object values by specified database key.
+     *
+     * If `key` parameter is omitted, then an array of object values of database root object will be returned.
+     *
+     * @param {P} [key] The key to access the target in database by.
+     * @returns {Array<ObjectValue<V, P>>} Database object values array.
+     *
+     * @example
+     * const prop3Values = await database.values("prop3");
+     * console.log(prop3Values); // -> [789, { prop6: 111 }]
+     *
+     * const prop5Values = await database.values("prop3.prop5");
+     * console.log(prop5Values); // -> []
+     *
+     * const prop6Values = await database.values("prop3.prop5.prop6");
+     * console.log(prop6Values);
+     * // -> [] (empty since the value in `prop6`, 111, is a primitive value and not an actual object)
+     *
+     * const databaseValues = await database.values();
+     * // in this example, `key` parameter is omitted - object values of database object are being returned
+     *
+     * console.log(databaseValues); // -> [123, 456, { prop4: 789, prop5: { prop6: 111 } }]
+     *
+     * const unexistentValues = await database.values("somethingElse");
+     * console.log(unexistentValues); // -> [] (empty since the key `somethingElse` does not exist in database)
+     *
+     * // Assuming that the initial database object for this example is:
+     * // {
+     * //    prop1: 123,
+     * //    prop2: 456,
+     * //    prop3: {
+     * //       prop4: 789,
+     * //       prop5: {
+     * //          prop6: 111
+     * //       }
+     * //    }
+     * // }
+     */
+    values<P extends AutocompletableString<ObjectPath<V>>>(key?: P): Promise<ObjectValue<V, P>[]>;
+    /**
+     * This method works the same way as `Array.find()`.
+     *
+     * Iterates over root database values, finds the element in database values array
+     * by specified condition in the callback function and returns the result.
+     *
+     * @param {QueryFunction<V>} queryFunction
+     * A function that accepts up to three arguments.
+     * The `find` method calls the `queryFunction` once for each element in database object values array.
+     *
+     * @returns {Promise<Maybe<V>>} The search
+     */
+    find(queryFunction: QueryFunction<V>): Promise<Maybe<V>>;
+    /**
+     * This method works the same way as `Array.map()`.
+     *
+     * Calls a defined callback function on each element of an array,
+     * and returns an array that contains the results.
+     *
+     * @param {QueryFunction<V, TReturnType>} queryFunction
+     * A function that accepts up to three arguments.
+     * The `map` method calls the `queryFunction` once for each element in database object values array.
+     *
+     * @returns {Promise<TReturnType[]>}
+     */
+    map<TReturnType>(queryFunction: QueryFunction<V, TReturnType>): Promise<TReturnType[]>;
+    /**
+     * This method works the same way as `Array.findIndex()`.
+     *
+     * Iterates over root database values, finds the index of the element in database values array
+     * by specified condition in the callback function and returns the result.
+     *
+     * @param {QueryFunction<V>} queryFunction
+     * A function that accepts up to three arguments.
+     * The `findIndex` method calls the `queryFunction` once for each element in database object values array.
+     *
+     * @returns {Promise<number>}
+     */
+    findIndex(queryFunction: QueryFunction<V>): Promise<number>;
+    /**
+     * This method works the same way as `Array.filter()`.
+     *
+     * Iterates over root database values, finds all the element that match the
+     * specified condition in the callback function and returns the result.
+     *
+     * @param {QueryFunction<V>} queryFunction
+     * A function that accepts up to three arguments.
+     * The `filter` method calls the `queryFunction` once for each element in database object values array.
+     *
+     * @returns {Promise<V[]>}
+     */
+    filter(queryFunction: QueryFunction<V>): Promise<V[]>;
+    /**
+     * This method works the same way as `Array.some()`.
+     *
+     * Iterates over root database values and checks if the
+     * specified condition in the callback function returns `true`
+     * for **any** of the elements of the database object values array.
+     *
+     * @param {QueryFunction<V>} queryFunction
+     * A function that accepts up to three arguments.
+     * The `some` method calls the `queryFunction` once for each element in database object values array.
+     *
+     * @returns {Promise<boolean>}
+     */
+    some(queryFunction: QueryFunction<V>): Promise<boolean>;
+    /**
+     * This method works the same way as `Array.every()`.
+     *
+     * Iterates over root database values and checks if the
+     * specified condition in the callback function returns `true`
+     * for **all** of the elements of the database object values array.
+     *
+     * @param {QueryFunction<V>} queryFunction
+     * A function that accepts up to three arguments.
+     * The `every` method calls the `queryFunction` once for each element in database object values array.
+     *
+     * @returns {Promise<boolean>}
+     */
+    every(queryFunction: QueryFunction<V>): Promise<boolean>;
+    /**
+     * Picks a random element of array in database and returns the picked array element.
+     *
+     * [!!!] The type of target value must be an array.
+     *
+     * @param {AutocompletableString<P>} key The key to access the target in database by.
+     * @returns {Promise<Maybe<ObjectValue<V, P>>>} The randomly picked element in the database array.
+     *
+     * @example
+     * const array = await database.get("array"); // assuming that the array is ['example1', 'example2', 'example3']
+     * console.log(array); // -> ['example1', 'example2', 'example3']
+     *
+     * const randomArrayElement = await database.random("exampleArray");
+     * console.log(randomArrayElement); // -> randomly picked array element: either 'example1', 'example2', or 'example3'
+     */
+    random<P extends AutocompletableString<ObjectPath<V>>>(key: AutocompletableString<P>): Promise<Maybe<ObjectValue<V, P>>>;
+    /**
+     * Deletes the data from database by key.
+     * @param {AutocompletableString<P>} key The key to access the target in database by.
+     * @returns {Promise<boolean>} Whether the deletion was successful.
+     */
+    delete<P extends AutocompletableString<ObjectPath<V>>>(key?: AutocompletableString<P>): Promise<boolean>;
+    /**
+     * Deletes everything from the database.
+     *
+     * - This method is an alias for {@link QuickMongo.clear()} method.
+     * @returns {Promise<boolean>} `true` if cleared successfully, `false` otherwise.
+     */
+    deleteAll(): Promise<boolean>;
+}
+
+interface JSONDriverOptions {
+    /**
+     * JSON database file path.
+     * @type {string}
+     */
+    filePath: string;
+    /**
+     * Minifies the JSON content in database file to save some space.
+     * @type {boolean}
+     */
+    minifyJSON?: boolean;
+}
+/**
+ * JSONDriver class.
+ */
+declare class JSONDriver implements BaseDriver {
+    /**
+     * JSON database file path.
+     * @type {string}
+     */
+    private filePath;
+    /**
+     * Minifies the JSON content in database file to save some space.
+     * @type {boolean}
+     */
+    minifyJSON: boolean;
+    /**
+     * JSONDriver class.
+     * @param options.filePath Json database file path.
+     * @param options.minifyJSON Minifies the JSON content in database file to save some space.
+     */
+    constructor(options: JSONDriverOptions);
+    /**
+     * Returns all data from JSON database.
+     *
+     * @returns {Promise<any>} All data from JSON database.
+     *
+     * @template V The type of data being returned.
+     */
+    all<V>(): Promise<V>;
+    /**
+     * Parses the key and fetches the value from JSON database.
+     *
+     * Type parameters:
+     *
+     * - `V` - The type of data being returned.
+     *
+     * @param {string} key The key in JSON database.
+     * @returns {Promise<V>} The data from JSON database.
+     *
+     * @template V The type of data being returned.
+     */
+    get<V = any>(key: string): Promise<V | null>;
+    /**
+     * Parses the key and sets the value in JSON database.
+     *
+     * Type parameters:
+     *
+     * - `V` - The type of data being set.
+     * - `R` - The type of data being returned.
+     *
+     * @param {string} key The key in JSON database.
+     * @returns {Promise<R>} The data from JSON database.
+     *
+     * @template V The type of data being set.
+     * @template R The type of data being returned.
+     */
+    set<V = any, R = any>(key: string, value: V): Promise<R>;
+    /**
+     * Parses the key and deletes it from JSON database. If no key is provided, clears the database.
+     * @param {V} key The key in JSON database.
+     * @returns {Promise<boolean>} `true` if deleted successfully.
+     */
+    delete<V = any>(key?: V): Promise<boolean>;
+}
+
+export { Database, JSONDriver };