Answer from what is in this file:--A key-value database that can be used to store and retrieve data. Data is stored as key-value pairs, where the key is a Deno.KvKey and the value is an arbitrary structured-serializable JavaScript value. Keys are ordered lexicographically as described in the documentation for Deno.KvKey. Keys are unique within a database, and the last value set for a given key is the one that is returned when reading the key. Keys can be deleted from the database, in which case they will no longer be returned when reading keys. Values can be any structured-serializable JavaScript value (objects, arrays, strings, numbers, etc.). The special value Deno.KvU64 can be used to store 64-bit unsigned integers in the database. This special value can not be nested within other objects or arrays. In addition to the regular database mutation operations, the unsigned 64-bit integer value also supports sum, max, and min mutations. Keys are versioned on write by assigning the key an ever-increasing "versionstamp". The versionstamp represents the version of a key-value pair in the database at some point in time, and can be used to perform transactional operations on the database without requiring any locking. This is enabled by atomic operations, which can have conditions that ensure that the operation only succeeds if the versionstamp of the key-value pair matches an expected versionstamp. Keys have a maximum length of 2048 bytes after serialization. Values have a maximum length of 64 KiB after serialization. Serialization of both keys and values is somewhat opaque, but one can usually assume that the serialization of any value is about the same length as the resulting string of a JSON serialization of that same value. If theses limits are exceeded, an exception will be thrown. Methods atomic(): AtomicOperation Create a new Deno.AtomicOperation object which can be used to perform an atomic transaction on the database. This does not perform any operations on the database - the atomic transaction must be committed explicitly using the Deno.AtomicOperation.commit method once all checks and mutations have been added to the operation. close(): void Close the database connection. This will prevent any further operations from being performed on the database, and interrupt any in-flight operations immediately. delete(key: KvKey): Promise<void> Delete the value for the given key from the database. If no value exists for the key, this operation is a no-op. const db = await Deno.openKv(); await db.delete(["foo"]); enqueue(value: unknown, options?: { delay?: number; keysIfUndelivered?: Deno.KvKey[]; }): Promise<KvCommitResult> Add a value into the database queue to be delivered to the queue listener via Deno.Kv.listenQueue. const db = await Deno.openKv(); await db.enqueue("bar"); The delay option can be used to specify the delay (in milliseconds) of the value delivery. The default delay is 0, which means immediate delivery. const db = await Deno.openKv(); await db.enqueue("bar", { delay: 60000 }); The keysIfUndelivered option can be used to specify the keys to be set if the value is not successfully delivered to the queue listener after several attempts. The values are set to the value of the queued message. const db = await Deno.openKv(); await db.enqueue("bar", { keysIfUndelivered: [["foo", "bar"]] }); get<T = unknown>(key: KvKey, options?: { consistency?: KvConsistencyLevel; }): Promise<KvEntryMaybe<T>> Retrieve the value and versionstamp for the given key from the database in the form of a Deno.KvEntryMaybe. If no value exists for the key, the returned entry will have a null value and versionstamp. const db = await Deno.openKv(); const result = await db.get(["foo"]); result.key; // ["foo"] result.value; // "bar" result.versionstamp; // "00000000000000010000" The consistency option can be used to specify the consistency level for the read operation. The default consistency level is "strong". Some use cases can benefit from using a weaker consistency level. For more information on consistency levels, see the documentation for Deno.KvConsistencyLevel. getMany<T extends readonly unknown[]>(keys: readonly [...[K in keyof T]: KvKey], options?: { consistency?: KvConsistencyLevel; }): Promise<[K in keyof T]: KvEntryMaybe<T[K]>> Retrieve multiple values and versionstamps from the database in the form of an array of Deno.KvEntryMaybe objects. The returned array will have the same length as the keys array, and the entries will be in the same order as the keys. If no value exists for a given key, the returned entry will have a null value and versionstamp. const db = await Deno.openKv(); const result = await db.getMany([["foo"], ["baz"]]); result[0].key; // ["foo"] result[0].value; // "bar" result[0].versionstamp; // "00000000000000010000" result[1].key; // ["baz"] result[1].value; // null result[1].versionstamp; // null The consistency option can be used to specify the consistency level for the read operation.