@devvit/redis 0.11.16-next-2025-05-21-9df7afc74.0

package/types/redis.d.ts

@@ -0,0 +1,1514 @@
+import type { HScanResponse, ZScanResponse } from '@devvit/protos';
+export type TxClientLike = {
+    /**
+     * Executes all previously queued commands in a transaction and
+     * restores the connection state to normal. https://redis.io/commands/exec/
+     * @returns array, each element being the reply to each of the commands in the atomic transaction.
+     * @example
+     * ```ts
+     * async function execExample(context: Devvit.Context) {
+     *  await context.redis.set("karma", "32");
+     *
+     *  const txn = await context.redis.watch("quantity");
+     *
+     *  await txn.multi();  // Begin a transaction
+     *  await txn.incrby("karma", 10);
+     *  await txn.exec();   // Execute the commands in the transaction
+     * }
+     * ```
+     */
+    exec(): Promise<any[]>;
+    /**
+     * Marks the start of a transaction block. Subsequent commands will be
+     * queued for atomic execution using EXEC. https://redis.io/commands/multi/
+     * @example
+     * ```ts
+     * async function multiExample(context: Devvit.Context) {
+     *  await context.redis.set("karma", "32");
+     *
+     *  const txn = await context.redis.watch("quantity");
+     *
+     *  await txn.multi();  // Begin a transaction
+     *  await txn.incrby("karma", 10);
+     *  await txn.exec();   // Execute the commands in the transaction
+     * }
+     * ```
+     */
+    multi(): Promise<void>;
+    /**
+     * Flushes all previously queued commands in a transaction and restores the connection state to normal.
+     * If WATCH was used, DISCARD unwatches all keys watched by the connection. https://redis.io/docs/latest/commands/discard/
+     * @example
+     * ```ts
+     * async function discardExample(context: Devvit.Context) {
+     *  await context.redis.set("price", "25");
+     *
+     *  const txn = await context.redis.watch("price");
+     *
+     *  await txn.multi();     // Begin a transaction
+     *  await txn.incrby("price", 5);
+     *  await txn.discard();   // Discard the commands in the transaction
+     * }
+     * ```
+     */
+    discard(): Promise<void>;
+    /**
+     * Marks the given keys to be watched for conditional execution of a transaction.
+     * https://redis.io/commands/watch/
+     * @arg {} keys - given keys to be watched
+     * @example
+     * ```ts
+     * async function watchExample(context: Devvit.Context) {
+     *  await context.redis.set("karma", "32");
+     *
+     *  const txn = await context.redis.watch("quantity");
+     *
+     *  await txn.multi();  // Begin a transaction
+     *  await txn.incrby("karma", 10);
+     *  await txn.exec();   // Execute the commands in the transaction
+     * }
+     * ```
+     */
+    watch(...keys: string[]): Promise<TxClientLike>;
+    /**
+     * Flushes all the previously watched keys for a transaction.
+     * If you call EXEC or DISCARD, there's no need to manually call UNWATCH.
+     * https://redis.io/commands/unwatch/
+     * @example
+     * ```ts
+     * async function unwatchExample(context: Devvit.Context) {
+     *  await context.redis.set("gold", "50");
+     *
+     *  const txn = await context.redis.watch("gold");
+     *
+     *  await txn.multi();     // Begin a transaction
+     *  await txn.incrby("gold", 30);
+     *  await txn.unwatch();   // Unwatch "gold"
+     *
+     *  // Now that "gold" has been unwatched, we can increment its value
+     *  // outside the transaction without canceling the transaction
+     *  await context.redis.incrby("gold", -20);
+     *
+     *  await txn.exec();   // Execute the commands in the transaction
+     *
+     *  console.log("Gold value: " + await context.redis.get("gold")); // The value of 'gold' should be 50 + 30 - 20 = 60
+     * }
+     * ```
+     */
+    unwatch(): Promise<TxClientLike>;
+    /**
+     * Get the value of key. If the key does not exist the special value nil is returned.
+     * https://redis.io/commands/get/
+     * @arg {} key
+     * @returns value of key or null when key does not exist.
+     * @example
+     * ```ts
+     * async function getExample(context: Devvit.Context) {
+     *  await context.redis.set("quantity", "5");
+     *  const quantity : string | undefined = await context.redis.get("quantity");
+     *  console.log("Quantity: " + quantity);
+     * }
+     * ```
+     */
+    get(key: string): Promise<TxClientLike>;
+    /**
+     * Set key to hold the string value. If key already holds a value, it is overwritten
+     * https://redis.io/commands/set/
+     * @arg {} key
+     * @arg {} value
+     * @arg {} options
+     * @example
+     * ```ts
+     * async function setExample(context: Devvit.Context) {
+     *  await context.redis.set("quantity", "5");
+     * }
+     * ```
+     */
+    set(key: string, value: string, options?: SetOptions): Promise<TxClientLike>;
+    /**
+     * Removes the specified keys. A key is ignored if it does not exist.
+     * https://redis.io/commands/del/
+     * @arg {} keys
+     * @example
+     * ```ts
+     * async function delExample(context: Devvit.Context) {
+     *  await context.redis.set("quantity", "5");
+     *  await context.redis.del("quantity");
+     * }
+     * ```
+     */
+    del(...keys: string[]): Promise<TxClientLike>;
+    /**
+     * Increments the number stored at key by increment.
+     * https://redis.io/commands/incrby/
+     * @arg {} key
+     * @arg {} value
+     * @example
+     * ```ts
+     * async function incrByExample(context: Devvit.Context) {
+     *  await context.redis.set("totalPoints", "53")
+     *  const updatedPoints : number = await context.redis.incrby("totalPoints", 100);
+     *  console.log("Updated points: " + updatedPoints);
+     * }
+     * ```
+     */
+    incrby(key: string, value: number): Promise<TxClientLike>;
+    /**
+     * Returns the string representation of the type of the value stored at key
+     * https://redis.io/commands/type/
+     * @arg {} key
+     * @returns string representation of the type
+     * @example
+     * ```ts
+     * async function typeExample(context: Devvit.Context) {
+     *  await context.redis.set("quantity", "5");
+     *  const type : string = await context.redis.type("quantity");
+     *  console.log("Key type: " + type);
+     * }
+     * ```
+     */
+    type(key: string): Promise<TxClientLike>;
+    /**
+     * Returns the substring of the string value stored at key, determined by
+     * the offsets start and end (both are inclusive).
+     * https://redis.io/commands/getrange/
+     * @arg {} key
+     * @arg {} start
+     * @arg {} end
+     * @returns substring determined by offsets [start, end]
+     * @example
+     * ```ts
+     * async function getRangeExample(context: Devvit.Context) {
+     *  await context.redis.set("word", "tacocat");
+     *  const range : string = await context.redis.getrange("word", 0, 3)
+     *  console.log("Range from index 0 to 3: " + range);
+     * }
+     * ```
+     */
+    getrange(key: string, start: number, end: number): Promise<TxClientLike>;
+    /**
+     * Overwrites part of the string stored at key, starting at the
+     * specified offset, for the entire length of value.
+     * https://redis.io/commands/setrange/
+     * @arg {} key
+     * @arg {} offset
+     * @arg {} value
+     * @returns length of the string after it was modified by the command
+     * @example
+     * ```ts
+     * async function setRangeExample(context: Devvit.Context) {
+     *  await context.redis.set("word", "tacocat");
+     *  await context.redis.setrange("word", 0, "blue");
+     * }
+     * ```
+     */
+    setrange(key: string, offset: number, value: string): Promise<TxClientLike>;
+    /**
+     * Returns the length of the string value stored at key.
+     * An error is returned when key holds a non-string value.
+     * https://redis.io/commands/strlen/
+     * @arg {} key
+     * @returns length of the string stored at key
+     * @example
+     * ```ts
+     * async function strLenExample(context: Devvit.Context) {
+     *  await context.redis.set("word", "tacocat");
+     *  const length : number = await context.redis.strlen("word");
+     *  console.log("Length of word: " + length);
+     * }
+     * ```
+     */
+    strlen(key: string): Promise<TxClientLike>;
+    /**
+     * Returns the values of all specified keys.
+     * https://redis.io/commands/mget/
+     * @arg {} keys
+     * @returns list of values at the specified keys
+     * @example
+     * ```ts
+     * async function mGetExample(context: Devvit.Context) {
+     *  await context.redis.mset({"name": "Zeek", "occupation": "Developer"});
+     *  const result : (string | null)[] = await context.redis.mget(["name", "occupation"]);
+     *  result.forEach(x => {
+     *    console.log(x);
+     *  });
+     * }
+     * ```
+     */
+    mget(keys: string[]): Promise<TxClientLike>;
+    /**
+     * Sets the given keys to their respective values.
+     * https://redis.io/commands/mset/
+     * @arg {} keyValues
+     * @example
+     * ```ts
+     * async function mGetExample(context: Devvit.Context) {
+     *  await context.redis.mset({"name": "Zeek", "occupation": "Developer"});
+     *  const result : (string | null)[] = await context.redis.mget(["name", "occupation"]);
+     *  result.forEach(x => {
+     *    console.log(x);
+     *  });
+     * }
+     * ```
+     */
+    mset(keyValues: {
+        [key: string]: string;
+    }): Promise<TxClientLike>;
+    /**
+     * Set a timeout on key.
+     * https://redis.io/commands/expire/
+     * @arg {} key
+     * @arg {} seconds
+     * @example
+     * ```ts
+     * async function expireExample(context: Devvit.Context) {
+     *  await context.redis.set("product", "milk");
+     *  await context.redis.expire("product", 60);   // Set the product to expire in 60 seconds
+     * }
+     * ```
+     */
+    expire(key: string, seconds: number): Promise<TxClientLike>;
+    /**
+     * Returns the absolute Unix timestamp in seconds at which the given key will expire
+     * https://redis.io/commands/expiretime/
+     * @arg {} key
+     * @returns expiration Unix timestamp in seconds, or a negative value in order to signal an error
+     * @example
+     * async function expireTimeExample(context: Devvit.Context) {
+     *  await context.redis.set("product", "milk");
+     *  const expireTime : number = await context.redis.expiretime("product");
+     *  console.log("Expire time: " + expireTime);
+     * }
+     */
+    expiretime(key: string): Promise<TxClientLike>;
+    /**
+     * Adds all the specified members with the specified scores to the sorted set stored at key.
+     * https://redis.io/commands/zadd/
+     * @arg {} key
+     * @arg {} members
+     * @returns number of elements added to the sorted set
+     * @example
+     * ```ts
+     * async function zAddExample(context: Devvit.Context) {
+     *  const numMembersAdded : number = await context.redis.zadd("leaderboard",
+     *    {member: "louis", score: 37},
+     *    {member: "fernando", score: 10},
+     *    {member: "caesar", score: 20},
+     *    {member: "alexander", score: 25},
+     *  );
+     *  console.log("Number of members added: " + numMembersAdded);
+     * }
+     * ```
+     */
+    zadd(key: string, ...members: ZMember[]): Promise<TxClientLike>;
+    /**
+     * Returns the cardinality (number of elements) of the sorted set stored at key.
+     * https://redis.io/commands/zcard/
+     * @arg {} key
+     * @returns cardinality of the sorted set
+     * @example
+     * ```ts
+     * async function zCardExample(context: Devvit.Context) {
+     *  await context.redis.zadd("leaderboard",
+     *    {member: "louis", score: 37},
+     *    {member: "fernando", score: 10},
+     *    {member: "caesar", score: 20},
+     *    {member: "alexander", score: 25},
+     *  );
+     *  const cardinality : number = await context.redis.zcard("leaderboard");
+     *  console.log("Cardinality: " + cardinality);
+     * }
+     * ```
+     */
+    zcard(key: string): Promise<TxClientLike>;
+    /**
+     * Increments the score of member in the sorted set stored at key by value
+     * https://redis.io/commands/zincrby/
+     * @arg {} key
+     * @arg {} member
+     * @arg {} value
+     * @returns the new score of member as a double precision floating point number
+     * @example
+     * ```ts
+     * async function zIncrByExample(context: Devvit.Context) {
+     *  await context.redis.zadd("animals",
+     *    {member: "zebra", score: 92},
+     *    {member: "cat", score: 100},
+     *    {member: "dog", score: 95},
+     *    {member: "elephant", score: 97}
+     *  );
+     *  const updatedScore : number = await context.redis.zincrby("animals", "dog", 10);
+     *  console.log("Dog's updated score: " + updatedScore);
+     * }
+     * ```
+     */
+    zincrby(key: string, member: string, value: number): Promise<TxClientLike>;
+    /**
+     * Returns the rank of member in the sorted set stored at key
+     * https://redis.io/commands/zrank/
+     * @arg {} key
+     * @arg {} member
+     * @returns rank of the member. The rank (or index) is 0-based
+     * which means that the member with the lowest score has rank 0
+     * @example
+     * ```ts
+     * async function zRankExample(context: Devvit.Context) {
+     *  await context.redis.zadd("animals",
+     *    {member: "zebra", score: 92},
+     *    {member: "cat", score: 100},
+     *    {member: "dog", score: 95},
+     *    {member: "elephant", score: 97}
+     *  );
+     *  const rank : number = await context.redis.zrank("animals", "dog");
+     *  console.log("Dog's rank: " + rank);
+     * }
+     * ```
+     */
+    zrank(key: string, member: string): Promise<TxClientLike>;
+    /**
+     * Returns the score of member in the sorted set at key.
+     * https://redis.io/commands/zscore/
+     * @arg {} key
+     * @arg {} member
+     * @returns the score of the member (a double-precision floating point number).
+     * @example
+     * ```ts
+     * async function zScoreExample(context: Devvit.Context) {
+     *  await context.redis.zadd("leaderboard",
+     *    {member: "louis", score: 37},
+     *    {member: "fernando", score: 10},
+     *    {member: "caesar", score: 20},
+     *    {member: "alexander", score: 25},
+     *  );
+     *  const score : number | undefined = await context.redis.zscore("leaderboard", "caesar");
+     *  if(score !== undefined) {
+     *    console.log("Caesar's score: " + score);
+     *  }
+     * }
+     * ```
+     */
+    zscore(key: string, member: string): Promise<TxClientLike>;
+    /**
+     * Iterates elements of Sorted Set types and their associated scores.
+     * @arg {} key
+     * @arg {} cursor
+     * @arg {} pattern
+     * @arg {} count
+     * @example
+     * ```ts
+     * async function zScanExample(context: Devvit.Context) {
+     *  await context.redis.zadd("fruits",
+     *    {member: "kiwi", score: 0},
+     *    {member: "mango", score: 0},
+     *    {member: "banana", score: 0},
+     *    {member: "orange", score: 0},
+     *    {member: "apple", score: 0},
+     *  );
+     *  const zScanResponse = await context.redis.zscan("fruits", 0);
+     *  console.log("zScanResponse: " + JSON.stringify(zScanResponse));
+     * }
+     * ```
+     */
+    zscan(key: string, cursor: number, pattern?: string | undefined, count?: number | undefined): Promise<TxClientLike>;
+    /**
+     * Returns the specified range of elements in the sorted set stored at key.
+     * https://redis.io/commands/zrange/
+     *
+     * When using `by: 'lex'`, the start and stop inputs will be prepended with `[` by default, unless they already begin with `[`, `(` or are one of the special values `+` or `-`.
+     * @arg {} key
+     * @arg {} start
+     * @arg {} stop
+     * @arg {} options
+     * @returns list of elements in the specified range
+     * @example
+     * ```ts
+     * async function zRangeExample(context: Devvit.Context) {
+     *  await context.redis.zadd("leaderboard",
+     *    {member: "louis", score: 37},
+     *    {member: "fernando", score: 10},
+     *    {member: "caesar", score: 20},
+     *    {member: "alexander", score: 25},
+     *  );
+     *
+     *  // View elements with scores between 0 and 30 inclusive, sorted by score
+     *  const scores : {member : string, score : number}[] = await context.redis.zrange("leaderboard", 0, 30, { by: "score" });
+     *
+     *  scores.forEach(x => {
+     *    console.log("Member: " + x.member, ", Score: " + x.score);
+     *  });
+     * }
+     * ```
+     */
+    zrange(key: string, start: number | string, stop: number | string, options?: ZRangeOptions): Promise<TxClientLike>;
+    /**
+     * Removes the specified members from the sorted set stored at key.
+     * https://redis.io/commands/zrem/
+     * @arg {} key
+     * @arg {} members
+     * @returns number of members removed from the sorted set
+     * @example
+     * ```ts
+     * async function zRemExample(context: Devvit.Context) {
+     *  await context.redis.zadd("leaderboard",
+     *    {member: "louis", score: 37},
+     *    {member: "fernando", score: 10},
+     *    {member: "caesar", score: 20},
+     *    {member: "alexander", score: 25},
+     *  );
+     *  const numberOfMembersRemoved : number = await context.redis.zrem("leaderboard", ["fernando", "alexander"]);
+     *  console.log("Number of members removed: " + numberOfMembersRemoved);
+     * }
+     * ```
+     */
+    zrem(key: string, members: string[]): Promise<TxClientLike>;
+    /**
+     * removes all elements in the sorted set stored at key between the
+     * lexicographical range specified by min and max
+     * https://redis.io/commands/zremrangebylex/
+     * @arg {} key
+     * @arg {} min
+     * @arg {} max
+     * @returns number of members removed from the sorted set
+     * @example
+     * ```ts
+     * async function zRemRangeByLexExample(context: Devvit.Context) {
+     *  await context.redis.zadd("fruits",
+     *    {member: "kiwi", score: 0},
+     *    {member: "mango", score: 0},
+     *    {member: "banana", score: 0},
+     *    {member: "orange", score: 0},
+     *    {member: "apple", score: 0},
+     *  );
+     *
+     *  // Remove fruits alphabetically ordered between 'kiwi' inclusive and 'orange' exclusive
+     *  // Note: The symbols '[' and '(' indicate inclusive or exclusive, respectively. These must be included in the call to zremrangebylex().
+     *  const numFieldsRemoved : number = await context.redis.zremrangebylex("fruits", "[kiwi", "(orange");
+     *  console.log("Number of fields removed: " + numFieldsRemoved);
+     * }
+     * ```
+     */
+    zremrangebylex(key: string, min: string, max: string): Promise<TxClientLike>;
+    /**
+     * Removes all elements in the sorted set stored at key with rank between start and stop.
+     * https://redis.io/commands/zremrangebyrank/
+     * @arg {} key
+     * @arg {} start
+     * @arg {} stop
+     * @returns number of members removed from the sorted set
+     * @example
+     * ```
+     * async function zRemRangeByRankExample(context: Devvit.Context) {
+     *  await context.redis.zadd("fruits",
+     *    {member: "kiwi", score: 10},
+     *    {member: "mango", score: 20},
+     *    {member: "banana", score: 30},
+     *    {member: "orange", score: 40},
+     *    {member: "apple", score: 50},
+     *  );
+  
+     *  // Remove fruits ranked 1 through 3 inclusive
+     *  const numFieldsRemoved : number = await context.redis.zremrangebyrank("fruits", 1, 3);
+     *  console.log("Number of fields removed: " + numFieldsRemoved);
+     * }
+     * ```
+     */
+    zremrangebyrank(key: string, start: number, stop: number): Promise<TxClientLike>;
+    /**
+     * Removes all elements in the sorted set stored at key with a score between min and max
+     * https://redis.io/commands/zremrangebyscore/
+     * @arg {} key
+     * @arg {} min
+     * @arg {} max
+     * @returns number of members removed from the sorted set
+     * @example
+     * ```ts
+     * async function zRemRangeByScoreExample(context: Devvit.Context) {
+     *  await context.redis.zadd("fruits",
+     *    {member: "kiwi", score: 10},
+     *    {member: "mango", score: 20},
+     *    {member: "banana", score: 30},
+     *    {member: "orange", score: 40},
+     *    {member: "apple", score: 50},
+     *  );
+     *  // Remove fruits scored between 30 and 50 inclusive
+     *  const numFieldsRemoved : number = await context.redis.zremrangebyscore("fruits", 30, 50);
+     *  console.log("Number of fields removed: " + numFieldsRemoved);
+     * }
+     * ```
+     */
+    zremrangebyscore(key: string, min: number, max: number): Promise<TxClientLike>;
+    /**
+     * Sets the specified fields to their respective values in the hash stored at key.
+     * https://redis.io/commands/hset
+     * @arg {} key
+     * @arg {} fieldValues
+     * @returns number of fields that were added
+     * @example
+     * ```ts
+     * async function hSetExample(context: Devvit.Context) {
+     *  const numFieldsAdded = await context.redis.hset("fruits", {"apple": "5", "orange": "7", "kiwi": "9"});
+     *  console.log("Number of fields added: " + numFieldsAdded);
+     * }
+     * ```
+     */
+    hset(key: string, fieldValues: {
+        [field: string]: string;
+    }): Promise<TxClientLike>;
+    /**
+     * Returns the value associated with field in the hash stored at key.
+     * https://redis.io/commands/hget
+     * @arg {} key
+     * @arg {} field
+     * @returns value associated with field
+     * @example
+     * ```ts
+     * async function hGetExample(context: Devvit.Context) {
+     *  await context.redis.hset("fruits", {"apple": "5", "orange": "7", "kiwi": "9"});
+     *  const result : string | undefined = await context.redis.hget("fruits", "orange");
+     *  console.log("Value of orange: " + result);
+     * }
+     * ```
+     */
+    hget(key: string, field: string): Promise<TxClientLike>;
+    /**
+     * Returns the values associated with fields in the hash stored at key.
+     * https://redis.io/commands/hmget
+     * @arg {} key
+     * @arg {} fields
+     * @returns values associated with each field in the order they appear in fields
+     * @example
+     * ```ts
+     * async function hMGetExample(context: Devvit.Context) {
+     *  await context.redis.hset("fruits", {"apple": "5", "orange": "7", "kiwi": "9"});
+     *  const result : string[] | undefined = await context.redis.hmget("fruits", ["orange", "grape", "apple"]);
+     *  console.log("Value of fields: " + result); // "Value of fields: ["7", undefined, "5"]
+     * }
+     * ```
+     */
+    hmget(key: string, fields: string[]): Promise<TxClientLike>;
+    /**
+     * Returns all fields and values of the hash stored at key
+     * https://redis.io/commands/hgetall
+     * @arg {} key
+     * @returns a map of fields and their values stored in the hash,
+     * @example
+     * ```
+     * async function hGetAllExample(context: Devvit.Context) {
+     *  await context.redis.hset("groceryList", {
+     *   "eggs": "12",
+     *   "apples": "3",
+     *   "milk": "1"
+     *  });
+     *
+     *  const record : Record<string, string> | undefined = await context.redis.hgetall("groceryList");
+     *
+     *  if (record != undefined) {
+     *   console.log("Eggs: " + record.eggs + ", Apples: " + record.apples + ", Milk: " + record.milk);
+     *  }
+     * }
+     * ```
+     */
+    hgetall(key: string): Promise<TxClientLike>;
+    /**
+     * Removes the specified fields from the hash stored at key.
+     * https://redis.io/commands/hdel/
+     * @arg {} key
+     * @arg {} fields
+     * @returns number of fields that were removed from the hash
+     * ```ts
+     * async function hDelExample(context: Devvit.Context) {
+     *  await context.redis.hset("fruits", {"apple": "5", "orange": "7", "kiwi": "9"});
+     *  const numFieldsRemoved = await context.redis.hdel("fruits", ["apple", "kiwi"]);
+     *  console.log("Number of fields removed: " + numFieldsRemoved);
+     * }
+     * ```
+     */
+    hdel(key: string, fields: string[]): Promise<TxClientLike>;
+    /**
+     * Iterates fields of Hash types and their associated values.
+     * @arg {} key
+     * @arg {} cursor
+     * @arg {} pattern
+     * @arg {} count
+     * @example
+     * ```ts
+     * async function hScanExample(context: Devvit.Context) {
+     *  await context.redis.hset("userInfo", {
+     *    "name": "Bob",
+     *    "startDate": "01-05-20",
+     *    "totalAwards": "12"
+     *  });
+     *
+     *  const hScanResponse = await context.redis.hscan("userInfo", 0);
+     *
+     *  hScanResponse.fieldValues.forEach(x => {
+     *    console.log("Field: '" + x.field + "', Value: '" + x.value + "'");
+     *  });
+     * }
+     * ```
+     */
+    hscan(key: string, cursor: number, pattern?: string | undefined, count?: number | undefined): Promise<TxClientLike>;
+    /**
+     * Returns all field names in the hash stored at key.
+     * @arg {} key
+     * @example
+     * ```ts
+     * async function hKeysExample(context: Devvit.Context) {
+     *  await context.redis.hset("prices", {
+     *    "chair": "48",
+     *    "desk": "95",
+     *    "whiteboard": "23"
+     *  });
+     *  const keys : string[] = await context.redis.hkeys("prices");
+     *  console.log("Keys: " + keys);
+     * }
+     * ```
+     */
+    hkeys(key: string): Promise<TxClientLike>;
+    /**
+     * Increments the number stored at field in the hash stored at key by increment.
+     * https://redis.io/commands/hincrby/
+     * @arg {} key
+     * @arg {} field
+     * @arg {} value
+     * @returns value of key after the increment
+     * @example
+     * ```ts
+     * async function hIncrByExample(context: Devvit.Context) {
+     *  await context.redis.hset("user123", { "karma": "100" });
+     *  await context.redis.hincrby("user123", "karma", 5);
+     * }
+     * ```
+     */
+    hincrby(key: string, field: string, value: number): Promise<TxClientLike>;
+    /**
+     * Returns the number of fields contained in the hash stored at key.
+     * @arg {} key
+     * @returns the number of fields in the hash, or 0 when the key does not exist.
+     * @example
+     * ```ts
+     * async function hLenExample(context: Devvit.Context) {
+     *  await context.redis.hset("supplies", {
+     *    "paperclips": "25",
+     *    "pencils": "10",
+     *    "erasers": "5",
+     *    "pens": "7"
+     *  });
+     *  const numberOfFields : number = await context.redis.hlen("supplies");
+     *  console.log("Number of fields: " + numberOfFields);
+     * }
+     * ```
+     */
+    hlen(key: string): Promise<TxClientLike>;
+};
+export type RedisClient = {
+    /**
+     * Marks the given keys to be watched for conditional execution of a transaction.
+     * https://redis.io/commands/watch/
+     * @arg {} keys - given keys to be watched
+     * @example
+     * ```ts
+     * async function watchExample(context: Devvit.Context) {
+     *  await context.redis.set("karma", "32");
+     *
+     *  const txn = await context.redis.watch("quantity");
+     *
+     *  await txn.multi();  // Begin a transaction
+     *  await txn.incrBy("karma", 10);
+     *  await txn.exec();   // Execute the commands in the transaction
+     * }
+     * ```
+     */
+    watch(...keys: string[]): Promise<TxClientLike>;
+    /**
+     * Get the value of key. If the key does not exist the special value nil is returned.
+     * An exception will be raised if the value of key is not a valid utf-8 encoding.
+     * https://redis.io/commands/get/
+     * @arg {} key
+     * @returns value of key or null when key does not exist.
+     * @example
+     * ```ts
+     * async function getExample(context: Devvit.Context) {
+     *  await context.redis.set("quantity", "5");
+     *  const quantity : string | undefined = await context.redis.get("quantity");
+     *  console.log("Quantity: " + quantity);
+     * }
+     * ```
+     */
+    get(key: string): Promise<string | undefined>;
+    /**
+     * Get the value of key and return it as a buffer.
+     * Use getBytes instead of get if you need to tolerate values that are not valid utf-8.
+     * If the key does not exist the special value nil is returned.
+     * https://redis.io/commands/get/
+     * @arg {} key
+     * @returns value of key or null when key does not exist.
+     * @example
+     * ```ts
+     * async function getExample(context: Devvit.Context) {
+     *  await context.redis.bitfield("nonutf8", "set", "u8", "0", "192");
+     *  const buf : string | undefined = await context.redis.getbuffer("nonutf8");
+     *  console.log("Bytes: " + JSON.stringify(buf));
+     * }
+     * ```
+     */
+    getbuffer(key: string): Promise<Buffer | undefined>;
+    /**
+     * Set key to hold the string value. If key already holds a value, it is overwritten
+     * https://redis.io/commands/set/
+     * @arg {} key
+     * @arg {} value
+     * @arg {} options
+     * @example
+     * ```ts
+     * async function setExample(context: Devvit.Context) {
+     *  await context.redis.set("quantity", "5");
+     * }
+     * ```
+     */
+    set(key: string, value: string, options?: SetOptions): Promise<string>;
+    /**
+     * Returns number of given keys that exists
+     * https://redis.io/commands/exists/
+     * @arg {} keys Keys to check for existence
+     * @returns number of keys in the list of keys that exist (note: double counts if an existing key is passed twice)
+     * @example
+     * ```ts
+     * async function existsExample(context: Devvit.Context) {
+     *  const exists : number = await context.redis.exists("someKey");
+     *  console.log("Exists: " + exists); // 0
+     *
+     *  await context.redis.set("someKey", "someValue");
+     *  const exists2 : number = await context.redis.exists("someKey", "someOtherKey");
+     *  console.log("Exists2: " + exists2); // 1
+     *
+     *  await context.redis.set("someOtherKey", "someOtherValue");
+     *  const exists3 : number = await context.redis.exists("someKey", "someKey", "someOtherKey");
+     *  console.log("Exists3: " + exists3); // 3, since "someKey" is counted twice
+     * }
+     * ```
+     */
+    exists(...keys: string[]): Promise<number>;
+    /**
+     * Removes the specified keys. A key is ignored if it does not exist.
+     * https://redis.io/commands/del/
+     * @arg {} keys
+     * @example
+     * ```ts
+     * async function delExample(context: Devvit.Context) {
+     *  await context.redis.set("quantity", "5");
+     *  await context.redis.del("quantity");
+     * }
+     * ```
+     */
+    del(...keys: string[]): Promise<void>;
+    /**
+     * Returns the string representation of the type of the value stored at key
+     * https://redis.io/commands/type/
+     * @arg {} key
+     * @returns string representation of the type
+     * @example
+     * ```ts
+     * async function typeExample(context: Devvit.Context) {
+     *  await context.redis.set("quantity", "5");
+     *  const type : string = await context.redis.type("quantity");
+     *  console.log("Key type: " + type);
+     * }
+     * ```
+     */
+    type(key: string): Promise<string>;
+    /**
+     * Renames key to newKey. It returns an error when key does not exist.
+     * https://redis.io/commands/rename/
+     * @arg {} key key to be renamed
+     * @arg {} newKey new key name
+     * @returns string returns "OK" if the key was renamed successfully
+     * @example
+     * ```ts
+     * async function renameExample(context: Devvit.Context) {
+     *  await context.redis.set("quantity", "5");
+     *  await context.redis.rename("quantity", "amount");
+     *  const value : string = await context.redis.get("amount");
+     *  console.log("Value: " + value);
+     * }
+     * ```
+     */
+    rename(key: string, newKey: string): Promise<string>;
+    /**
+     * Returns the substring of the string value stored at key, determined by
+     * the offsets start and end (both are inclusive).
+     * https://redis.io/commands/getrange/
+     * @arg {} key
+     * @arg {} start
+     * @arg {} end
+     * @returns substring determined by offsets [start, end]
+     * @example
+     * ```ts
+     * async function getRangeExample(context: Devvit.Context) {
+     *  await context.redis.set("word", "tacocat");
+     *  const range : string = await context.redis.getrange("word", 0, 3)
+     *  console.log("Range from index 0 to 3: " + range);
+     * }
+     * ```
+     */
+    getrange(key: string, start: number, end: number): Promise<string>;
+    /**
+     * Overwrites part of the string stored at key, starting at the
+     * specified offset, for the entire length of value.
+     * https://redis.io/commands/setrange/
+     * @arg {} key
+     * @arg {} offset
+     * @arg {} value
+     * @returns length of the string after it was modified by the command
+     * @example
+     * ```ts
+     * async function setRangeExample(context: Devvit.Context) {
+     *  await context.redis.set("word", "tacocat");
+     *  await context.redis.setrange("word", 0, "blue");
+     * }
+     * ```
+     */
+    setrange(key: string, offset: number, value: string): Promise<number>;
+    /**
+     * Returns the length of the string value stored at key.
+     * An error is returned when key holds a non-string value.
+     * https://redis.io/commands/strlen/
+     * @arg {} key
+     * @returns length of the string stored at key
+     * @example
+     * ```ts
+     * async function strLenExample(context: Devvit.Context) {
+     *  await context.redis.set("word", "tacocat");
+     *  const length : number = await context.redis.strlen("word");
+     *  console.log("Length of word: " + length);
+     * }
+     * ```
+     */
+    strlen(key: string): Promise<number>;
+    /**
+     * Increments the number stored at key by increment.
+     * https://redis.io/commands/incrby/
+     * @arg {} key
+     * @arg {} value
+     * @returns value of key after the increment
+     * @example
+     * ```ts
+     * async function incrByExample(context: Devvit.Context) {
+     *  await context.redis.set("totalPoints", "53")
+     *  const updatedPoints : number = await context.redis.incrby("totalPoints", 100);
+     *  console.log("Updated points: " + updatedPoints);
+     * }
+     * ```
+     */
+    incrby(key: string, value: number): Promise<number>;
+    /**
+     * Returns the values of all specified keys.
+     * https://redis.io/commands/mget/
+     * @arg {} keys
+     * @returns list of values at the specified keys
+     * @example
+     * ```ts
+     * async function mGetExample(context: Devvit.Context) {
+     *  await context.redis.mset({"name": "Zeek", "occupation": "Developer"});
+     *  const result : (string | null)[] = await context.redis.mget(["name", "occupation"]);
+     *  result.forEach(x => {
+     *    console.log(x);
+     *  });
+     * }
+     * ```
+     */
+    mget(keys: string[]): Promise<(string | null)[]>;
+    /**
+     * Sets the given keys to their respective values.
+     * https://redis.io/commands/mset/
+     * @arg {} keyValues
+     * @example
+     * ```ts
+     * async function mSetExample(context: Devvit.Context) {
+     *  await context.redis.mset({"name": "Zeek", "occupation": "Developer"});
+     * }
+     * ```
+     */
+    mset(keyValues: {
+        [key: string]: string;
+    }): Promise<void>;
+    /**
+     * Set a timeout on key.
+     * https://redis.io/commands/expire/
+     * @arg {} key
+     * @arg {} seconds
+     * @example
+     * ```ts
+     * async function expireExample(context: Devvit.Context) {
+     *  await context.redis.set("product", "milk");
+     *  await context.redis.expire("product", 60);   // Set the product to expire in 60 seconds
+     * }
+     * ```
+     */
+    expire(key: string, seconds: number): Promise<void>;
+    /**
+     * Returns the absolute Unix timestamp in seconds at which the given key will expire
+     * https://redis.io/commands/expiretime/
+     * @arg {} key
+     * @returns expiration Unix timestamp in seconds, or a negative value in order to signal an error
+     * @example
+     * async function expireTimeExample(context: Devvit.Context) {
+     *  await context.redis.set("product", "milk");
+     *  const expireTime : number = await context.redis.expiretime("product");
+     *  console.log("Expire time: " + expireTime);
+     * }
+     */
+    expiretime(key: string): Promise<number>;
+    /**
+     * Adds all the specified members with the specified scores to the sorted set stored at key.
+     * https://redis.io/commands/zadd/
+     * @arg {} key
+     * @arg {} members
+     * @returns number of elements added to the sorted set
+     * @example
+     * ```ts
+     * async function zAddExample(context: Devvit.Context) {
+     *  const numMembersAdded : number = await context.redis.zadd("leaderboard",
+     *    {member: "louis", score: 37},
+     *    {member: "fernando", score: 10},
+     *    {member: "caesar", score: 20},
+     *    {member: "alexander", score: 25},
+     *  );
+     *  console.log("Number of members added: " + numMembersAdded);
+     * }
+     * ```
+     */
+    zadd(key: string, ...members: ZMember[]): Promise<number>;
+    /**
+     * Returns the cardinality (number of elements) of the sorted set stored at key.
+     * https://redis.io/commands/zcard/
+     * @arg {} key
+     * @returns cardinality of the sorted set
+     * @example
+     * ```ts
+     * async function zCardExample(context: Devvit.Context) {
+     *  await context.redis.zadd("leaderboard",
+     *    {member: "louis", score: 37},
+     *    {member: "fernando", score: 10},
+     *    {member: "caesar", score: 20},
+     *    {member: "alexander", score: 25},
+     *  );
+     *  const cardinality : number = await context.redis.zcard("leaderboard");
+     *  console.log("Cardinality: " + cardinality);
+     * }
+     * ```
+     */
+    zcard(key: string): Promise<number>;
+    /**
+     * Returns the score of member in the sorted set at key.
+     * https://redis.io/commands/zscore/
+     * @arg {} key
+     * @arg {} member
+     * @returns the score of the member (a double-precision floating point number).
+     * @example
+     * ```ts
+     * async function zScoreExample(context: Devvit.Context) {
+     *  await context.redis.zadd("leaderboard",
+     *    {member: "louis", score: 37},
+     *    {member: "fernando", score: 10},
+     *    {member: "caesar", score: 20},
+     *    {member: "alexander", score: 25},
+     *  );
+     *  const score : number = await context.redis.zscore("leaderboard", "caesar");
+     *  console.log("Caesar's score: " + score);
+     * }
+     * ```
+     */
+    zscore(key: string, member: string): Promise<number | undefined>;
+    /**
+     * Returns the rank of member in the sorted set stored at key
+     * https://redis.io/commands/zrank/
+     * @arg {} key
+     * @arg {} member
+     * @returns rank of the member if opts is undefined or opts.withScore = false,
+     * or returns { rank, score } of the member if opts.withScore = true. The rank (or index)
+     * is 0-based which means that the member with the lowest score has rank 0
+     * @example
+     * ```ts
+     * async function zRankExample(context: Devvit.Context) {
+     *  await context.redis.zadd("animals",
+     *    {member: "zebra", score: 92},
+     *    {member: "cat", score: 100},
+     *    {member: "dog", score: 95},
+     *    {member: "elephant", score: 97}
+     *  );
+     *  const rank : number | undefined = await context.redis.zrank("animals", "dog");
+     *  if(rank !== undefined) {
+     *    console.log("Dog's rank: " + rank);
+     *  }
+     * }
+     * ```
+     */
+    zrank(key: string, member: string): Promise<number | undefined>;
+    /**
+     * Increments the score of member in the sorted set stored at key by value
+     * https://redis.io/commands/zincrby/
+     * @arg {} key
+     * @arg {} member
+     * @arg {} value
+     * @returns the new score of member as a double precision floating point number
+     * @example
+     * ```ts
+     * async function zIncrByExample(context: Devvit.Context) {
+     *  await context.redis.zadd("animals",
+     *    {member: "zebra", score: 92},
+     *    {member: "cat", score: 100},
+     *    {member: "dog", score: 95},
+     *    {member: "elephant", score: 97}
+     *  );
+     *  const updatedScore : number = await context.redis.zincrby("animals", "dog", 10);
+     *  console.log("Dog's updated score: " + updatedScore);
+     * }
+     * ```
+     */
+    zincrby(key: string, member: string, value: number): Promise<number>;
+    /**
+     * Returns the specified range of elements in the sorted set stored at key.
+     * https://redis.io/commands/zrange/
+     *
+     * When using `by: 'lex'`, the start and stop inputs will be prepended with `[` by default, unless they already begin with `[`, `(` or are one of the special values `+` or `-`.
+     * @arg {} key
+     * @arg {} start
+     * @arg {} stop
+     * @arg {} options
+     * @returns list of elements in the specified range
+     * @example
+     * ```ts
+     * async function zRangeExample(context: Devvit.Context) {
+     *  await context.redis.zadd("leaderboard",
+     *    {member: "louis", score: 37},
+     *    {member: "fernando", score: 10},
+     *    {member: "caesar", score: 20},
+     *    {member: "alexander", score: 25},
+     *  );
+     *
+     *  // View elements with scores between 0 and 30 inclusive, sorted by score
+     *  const scores : {member : string, score : number}[] = await context.redis.zrange("leaderboard", 0, 30, { by: "score" });
+     *
+     *  scores.forEach(x => {
+     *    console.log("Member: " + x.member, ", Score: " + x.score);
+     *  });
+     * }
+     * ```
+     */
+    zrange(key: string, start: number | string, stop: number | string, options?: ZRangeOptions): Promise<{
+        member: string;
+        score: number;
+    }[]>;
+    /**
+     * Removes the specified members from the sorted set stored at key.
+     * https://redis.io/commands/zrem/
+     * @arg {} key
+     * @arg {} members
+     * @returns number of members removed from the sorted set
+     * @example
+     * ```ts
+     * async function zRemExample(context: Devvit.Context) {
+     *  await context.redis.zadd("leaderboard",
+     *    {member: "louis", score: 37},
+     *    {member: "fernando", score: 10},
+     *    {member: "caesar", score: 20},
+     *    {member: "alexander", score: 25},
+     *  );
+     *  const numberOfMembersRemoved : number = await context.redis.zrem("leaderboard", ["fernando", "alexander"]);
+     *  console.log("Number of members removed: " + numberOfMembersRemoved);
+     * }
+     * ```
+     */
+    zrem(key: string, members: string[]): Promise<number>;
+    /**
+     * removes all elements in the sorted set stored at key between the
+     * lexicographical range specified by min and max
+     * https://redis.io/commands/zremrangebylex/
+     * @arg {} key
+     * @arg {} min
+     * @arg {} max
+     * @returns number of members removed from the sorted set
+     * @example
+     * ```ts
+     * async function zRemRangeByLexExample(context: Devvit.Context) {
+     *  await context.redis.zadd("fruits",
+     *    {member: "kiwi", score: 0},
+     *    {member: "mango", score: 0},
+     *    {member: "banana", score: 0},
+     *    {member: "orange", score: 0},
+     *    {member: "apple", score: 0},
+     *  );
+     *
+     *  // Remove fruits alphabetically ordered between 'kiwi' inclusive and 'orange' exclusive
+     *  // Note: The symbols '[' and '(' indicate inclusive or exclusive, respectively. These must be included in the call to zRemRangeByLex().
+     *  const numFieldsRemoved : number = await context.redis.zremrangebylex("fruits", "[kiwi", "(orange");
+     *  console.log("Number of fields removed: " + numFieldsRemoved);
+     * }
+     * ```
+     */
+    zremrangebylex(key: string, min: string, max: string): Promise<number>;
+    /**
+     * Removes all elements in the sorted set stored at key with rank between start and stop.
+     * https://redis.io/commands/zremrangebyrank/
+     * @arg {} key
+     * @arg {} start
+     * @arg {} stop
+     * @returns number of members removed from the sorted set
+     * @example
+     * ```
+     * async function zRemRangeByRankExample(context: Devvit.Context) {
+     *  await context.redis.zadd("fruits",
+     *    {member: "kiwi", score: 10},
+     *    {member: "mango", score: 20},
+     *    {member: "banana", score: 30},
+     *    {member: "orange", score: 40},
+     *    {member: "apple", score: 50},
+     *  );
+  
+     *  // Remove fruits ranked 1 through 3 inclusive
+     *  const numFieldsRemoved : number = await context.redis.zremrangebyrank("fruits", 1, 3);
+     *  console.log("Number of fields removed: " + numFieldsRemoved);
+     * }
+     * ```
+     */
+    zremrangebyrank(key: string, start: number, stop: number): Promise<number>;
+    /**
+     * Removes all elements in the sorted set stored at key with a score between min and max
+     * https://redis.io/commands/zremrangebyscore/
+     * @arg {} key
+     * @arg {} min
+     * @arg {} max
+     * @returns number of members removed from the sorted set
+     * @example
+     * ```ts
+     * async function zRemRangeByScoreExample(context: Devvit.Context) {
+     *  await context.redis.zadd("fruits",
+     *    {member: "kiwi", score: 10},
+     *    {member: "mango", score: 20},
+     *    {member: "banana", score: 30},
+     *    {member: "orange", score: 40},
+     *    {member: "apple", score: 50},
+     *  );
+     *  // Remove fruits scored between 30 and 50 inclusive
+     *  const numFieldsRemoved : number = await context.redis.zremrangebyscore("fruits", 30, 50);
+     *  console.log("Number of fields removed: " + numFieldsRemoved);
+     * }
+     * ```
+     */
+    zremrangebyscore(key: string, min: number, max: number): Promise<number>;
+    /**
+     * Iterates elements of Sorted Set types and their associated scores.
+     * @arg {} key
+     * @arg {} cursor
+     * @arg {} pattern
+     * @arg {} count
+     * @example
+     * ```ts
+     * async function zScanExample(context: Devvit.Context) {
+     *  await context.redis.zadd("fruits",
+     *    {member: "kiwi", score: 0},
+     *    {member: "mango", score: 0},
+     *    {member: "banana", score: 0},
+     *    {member: "orange", score: 0},
+     *    {member: "apple", score: 0},
+     *  );
+     *  const zScanResponse = await context.redis.zscan("fruits", 0);
+     *  console.log("zScanResponse: " + JSON.stringify(zScanResponse));
+     * }
+     * ```
+     */
+    zscan(key: string, cursor: number, pattern?: string | undefined, count?: number | undefined): Promise<ZScanResponse>;
+    /**
+     * Sets the specified fields to their respective values in the hash stored at key.
+     * https://redis.io/commands/hset
+     * @arg {} key
+     * @arg {} fieldValues
+     * @returns number of fields that were added
+     * @example
+     * ```ts
+     * async function hSetExample(context: Devvit.Context) {
+     *  const numFieldsAdded = await context.redis.hset("fruits", {"apple": "5", "orange": "7", "kiwi": "9"});
+     *  console.log("Number of fields added: " + numFieldsAdded);
+     * }
+     * ```
+     */
+    hset(key: string, fieldValues: {
+        [field: string]: string;
+    }): Promise<number>;
+    /**
+     * Sets field in the hash stored at key to value, only if field does not yet exist.
+     * https://redis.io/commands/hsetnx/
+     * @returns 1 if field is a new field in the hash and value was set, 0 if field already exists in the hash and no operation was performed.
+     * @example
+     * ```ts
+     * async function hSetNXExample(context: Devvit.Context) {
+     *  const result : number = await context.redis.hsetnx("myhash", "field1", "value1");
+     *  console.log("HSETNX result: " + result);
+     * }
+     * ```
+     */
+    hsetnx(key: string, field: string, value: string): Promise<number>;
+    /**
+     * Returns the value associated with field in the hash stored at key.
+     * https://redis.io/commands/hget
+     * @arg {} key
+     * @arg {} field
+     * @returns value associated with field
+     * @example
+     * ```ts
+     * async function hGetExample(context: Devvit.Context) {
+     *  await context.redis.hset("fruits", {"apple": "5", "orange": "7", "kiwi": "9"});
+     *  const result : string | undefined = await context.redis.hget("fruits", "orange");
+     *  console.log("Value of orange: " + result);
+     * }
+     * ```
+     */
+    hget(key: string, field: string): Promise<string | undefined>;
+    /**
+     * Returns the values associated with fields in the hash stored at key.
+     * https://redis.io/commands/hmget
+     * @arg {} key
+     * @arg {} fields
+     * @returns values associated with each field in the order they appear in fields
+     * @example
+     * ```ts
+     * async function hMGetExample(context: Devvit.Context) {
+     *  await context.redis.hset("fruits", {"apple": "5", "orange": "7", "kiwi": "9"});
+     *  const result : string[] | undefined = await context.redis.hmget("fruits", ["orange", "grape", "apple"]);
+     *  console.log("Value of fields: " + result); // "Value of fields: ["7", undefined, "5"]
+     * }
+     * ```
+     */
+    hmget(key: string, fields: string[]): Promise<(string | null)[]>;
+    /**
+     * Returns all fields and values of the hash stored at key
+     * https://redis.io/commands/hgetall
+     * @arg {} key
+     * @returns a map of fields and their values stored in the hash,
+     * @example
+     * ```
+     * async function hGetAllExample(context: Devvit.Context) {
+     *  await context.redis.hset("groceryList", {
+     *   "eggs": "12",
+     *   "apples": "3",
+     *   "milk": "1"
+     *  });
+     *
+     *  const record : Record<string, string> = await context.redis.hgetall("groceryList");
+     *
+     *  if (record.eggs !== undefined) {
+     *   console.log(`Eggs: ${record.eggs}`);
+     *  }
+     * }
+     * ```
+     */
+    hgetall(key: string): Promise<Record<string, string>>;
+    /**
+     * Removes the specified fields from the hash stored at key.
+     * https://redis.io/commands/hdel/
+     * @arg {} key
+     * @arg {} fields
+     * @returns number of fields that were removed from the hash
+     * @example
+     * ```ts
+     * async function hDelExample(context: Devvit.Context) {
+     *  await context.redis.hset("fruits", {"apple": "5", "orange": "7", "kiwi": "9"});
+     *  const numFieldsRemoved = await context.redis.hdel("fruits", ["apple", "kiwi"]);
+     *  console.log("Number of fields removed: " + numFieldsRemoved);
+     * }
+     * ```
+     */
+    hdel(key: string, fields: string[]): Promise<number>;
+    /**
+     * Iterates fields of Hash types and their associated values.
+     * @arg {} key
+     * @arg {} cursor
+     * @arg {} pattern
+     * @arg {} count
+     * @example
+     * ```ts
+     * async function hScanExample(context: Devvit.Context) {
+     *  await context.redis.hset("userInfo", {
+     *    "name": "Bob",
+     *    "startDate": "01-05-20",
+     *    "totalAwards": "12"
+     *  });
+     *
+     *  const hScanResponse = await context.redis.hscan("userInfo", 0);
+     *
+     *  hScanResponse.fieldValues.forEach(x => {
+     *    console.log("Field: '" + x.field + "', Value: '" + x.value + "'");
+     *  });
+     * }
+     * ```
+     */
+    hscan(key: string, cursor: number, pattern?: string | undefined, count?: number | undefined): Promise<HScanResponse>;
+    /**
+     * Returns all field names in the hash stored at key.
+     * @arg {} key
+     * @example
+     * ```ts
+     * async function hKeysExample(context: Devvit.Context) {
+     *  await context.redis.hset("prices", {
+     *    "chair": "48",
+     *    "desk": "95",
+     *    "whiteboard": "23"
+     *  });
+     *  const keys : string[] = await context.redis.hkeys("prices");
+     *  console.log("Keys: " + keys);
+     * }
+     * ```
+     */
+    hkeys(key: string): Promise<string[]>;
+    /**
+     * Increments the number stored at field in the hash stored at key by increment.
+     * https://redis.io/commands/hincrby/
+     * @arg {} key
+     * @arg {} field
+     * @arg {} value
+     * @returns value of key after the increment
+     * @example
+     * ```ts
+     * async function hIncrByExample(context: Devvit.Context) {
+     *  await context.redis.hset("user123", { "karma": "100" });
+     *  await context.redis.hincrby("user123", "karma", 5);
+     * }
+     * ```
+     */
+    hincrby(key: string, field: string, value: number): Promise<number>;
+    /**
+     * Returns the number of fields contained in the hash stored at key.
+     * @arg {} key
+     * @returns the number of fields in the hash, or 0 when the key does not exist.
+     * @example
+     * ```ts
+     * async function hLenExample(context: Devvit.Context) {
+     *  await context.redis.hset("supplies", {
+     *    "paperclips": "25",
+     *    "pencils": "10",
+     *    "erasers": "5",
+     *    "pens": "7"
+     *  });
+     *  const numberOfFields : number = await context.redis.hlen("supplies");
+     *  console.log("Number of fields: " + numberOfFields);
+     * }
+     * ```
+     */
+    hlen(key: string): Promise<number>;
+    /**
+     * Performs operations on a redis string treating it as an array of bits.
+     * Operations available:
+     *   - get <encoding> <offset> -- Returns the specified bit field.
+     *   - set <encoding> <offset> <value> -- Sets the specified bit field and returns its old value.
+     *   - incrBy <encoding> <offset> <increment> -- Increments or decrements (if a negative increment is given) the specified bit field and returns the new value.
+     *   - overflow [wrap|sat|fail] -- Alters the overflow behavior of subsequent set's and incrBy's until the next overflow command
+     * https://redis.io/docs/latest/commands/bitfield/
+     * @arg {} key the redis key containing the string to operate on
+     * @arg {} cmds the commands to perform on the string
+     * @returns an array with the result of each command, in order
+     * @example
+     * ```ts
+     * async function bitfieldExample(context: Devvit.Context) {
+     *  const fooResults : number[] =
+     *    await context.redis.bitfield('foo', 'incrBy', 'i5', 100, 1, 'get', 'u4', 0);
+     *  console.log("fooResults: " + fooResults); // [1, 0]
+     *
+     *  const barResults : number[] =
+     *    await context.redis.bitfield('bar',
+     *      'set', 'u2', 0, 3,
+     *      'get', 'u2', 0,
+     *      'incrBy', 'u2', 0, 1,
+     *      'overflow', 'sat',
+     *      'get', 'u2', 0,
+     *      'set', 'u2', 0, 3,
+     *      'incrBy', 'u2', 0, 1);
+     *  console.log("barResults: " + barResults); // [0, 3, 0, 0, 3, 3]
+     * }
+     * ```
+     */
+    bitfield(key: string, ...cmds: [] | BitfieldCommand | [...BitfieldCommand, ...BitfieldCommand] | [...BitfieldCommand, ...BitfieldCommand, ...BitfieldCommand, ...(number | string)[]]): Promise<number[]>;
+    /**
+     * Allows read/write operations to global keys in Redis
+     * Global redis enables apps to persist and access state across subreddit installations
+     */
+    global: Omit<RedisClient, 'global'>;
+};
+export type SetOptions = {
+    /** Only set the key if it does not already exist. */
+    nx?: boolean;
+    /** Only set the key if it already exists. */
+    xx?: boolean;
+    expiration?: Date;
+};
+export type ZMember = {
+    score: number;
+    member: string;
+};
+export type ZRangeOptions = {
+    /**
+     * Reverses the sorted set, with index 0 as the element with the highest
+     * score.
+     */
+    reverse?: boolean;
+    by: 'score' | 'lex' | 'rank';
+    limit?: {
+        offset: number;
+        count: number;
+    };
+};
+export type ZRangeByScoreOptions = {
+    withScores?: boolean;
+    limit?: {
+        offset: number;
+        count: number;
+    };
+};
+export type BitfieldCommand = BitfieldGet | BitfieldSet | BitfieldIncrBy | BitfieldOverflow;
+/**
+ * Represents a 'get' operation in a bitfield command
+ */
+type BitfieldGet = [get: 'get', encoding: BitfieldEncoding, offset: BitfieldOffset];
+/**
+ * Represents a 'set' operation in a bitfield command
+ */
+type BitfieldSet = [
+    set: 'set',
+    encoding: BitfieldEncoding,
+    offset: BitfieldOffset,
+    /**
+     * Value to set the bitfield to
+     */
+    value: number | `${number}`
+];
+/**
+ * Represents an 'incrBy' operation in a bitfield command
+ */
+type BitfieldIncrBy = [
+    incrBy: 'incrBy',
+    encoding: BitfieldEncoding,
+    offset: BitfieldOffset,
+    /**
+     * Value to increment (or decrement if given a negative increment) the bitfield by
+     */
+    increment: number | `${number}`
+];
+/**
+ * Represents an 'overflow' operation in a bitfield command
+ */
+type BitfieldOverflow = [overflow: 'overflow', behavior: 'wrap' | 'sat' | 'fail'];
+/**
+ * Encoding for operations in a bitfield command
+ * Prefix with 'u' to encode as unsigned integers (e.g. 'u4' is a 4-bit unsigned integer)
+ * Prefix with 'i' to encode as signed integers (e.g. 'i6' is a 6-bit signed integer)
+ * Up to 64 bits for signed integers, and up to 63 bits for unsigned integers
+ */
+type BitfieldEncoding = `${'i' | 'u'}${number}`;
+/**
+ * Offset to operate on for an operation in a bitfield command
+ * If given a number without any prefix, it is used just as a zero based bit offset inside the string
+ * if given a number prefixed with a # character, the specified offset is multiplied by the integer encoding's width
+ */
+type BitfieldOffset = number | string | `#${number}`;
+export {};
+//# sourceMappingURL=redis.d.ts.map