@upstash/redis 0.1.11 → 0.2.1

package/dist/main/index-cjs.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/main/index-cjs.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = __importDefault(require("./client"));
+const redis = (0, client_1.default)();
+module.exports = client_1.default;
+module.exports.auth = redis.auth;
+module.exports.append = redis.append;
+module.exports.decr = redis.decr;
+module.exports.decrby = redis.decrby;
+module.exports.get = redis.get;
+module.exports.getrange = redis.getrange;
+module.exports.getset = redis.getset;
+module.exports.incr = redis.incr;
+module.exports.incrby = redis.incrby;
+module.exports.incrbyfloat = redis.incrbyfloat;
+module.exports.mget = redis.mget;
+module.exports.mset = redis.mset;
+module.exports.msetnx = redis.msetnx;
+module.exports.psetex = redis.psetex;
+module.exports.set = redis.set;
+module.exports.setex = redis.setex;
+module.exports.setnx = redis.setnx;
+module.exports.setrange = redis.setrange;
+module.exports.strlen = redis.strlen;
+module.exports.bitcount = redis.bitcount;
+module.exports.bitop = redis.bitop;
+module.exports.bitpos = redis.bitpos;
+module.exports.getbit = redis.getbit;
+module.exports.setbit = redis.setbit;
+module.exports.echo = redis.echo;
+module.exports.ping = redis.ping;
+module.exports.hdel = redis.hdel;
+module.exports.hexists = redis.hexists;
+module.exports.hget = redis.hget;
+module.exports.hgetall = redis.hgetall;
+module.exports.hincrby = redis.hincrby;
+module.exports.hincrbyfloat = redis.hincrbyfloat;
+module.exports.hkeys = redis.hkeys;
+module.exports.hlen = redis.hlen;
+module.exports.hmget = redis.hmget;
+module.exports.hmset = redis.hmset;
+module.exports.hscan = redis.hscan;
+module.exports.hset = redis.hset;
+module.exports.hsetnx = redis.hsetnx;
+module.exports.hvals = redis.hvals;
+module.exports.del = redis.del;
+module.exports.exists = redis.exists;
+module.exports.expire = redis.expire;
+module.exports.expireat = redis.expireat;
+module.exports.keys = redis.keys;
+module.exports.persist = redis.persist;
+module.exports.pexpire = redis.pexpire;
+module.exports.pexpireat = redis.pexpireat;
+module.exports.pttl = redis.pttl;
+module.exports.randomkey = redis.randomkey;
+module.exports.rename = redis.rename;
+module.exports.renamenx = redis.renamenx;
+module.exports.scan = redis.scan;
+module.exports.touch = redis.touch;
+module.exports.ttl = redis.ttl;
+module.exports.type = redis.type;
+module.exports.unlink = redis.unlink;
+module.exports.lindex = redis.lindex;
+module.exports.linsert = redis.linsert;
+module.exports.llen = redis.llen;
+module.exports.lpop = redis.lpop;
+module.exports.lpush = redis.lpush;
+module.exports.lpushx = redis.lpushx;
+module.exports.lrange = redis.lrange;
+module.exports.lrem = redis.lrem;
+module.exports.lset = redis.lset;
+module.exports.ltrim = redis.ltrim;
+module.exports.rpop = redis.rpop;
+module.exports.rpoplpush = redis.rpoplpush;
+module.exports.rpush = redis.rpush;
+module.exports.rpushx = redis.rpushx;
+module.exports.dbsize = redis.dbsize;
+module.exports.flushall = redis.flushall;
+module.exports.flushdb = redis.flushdb;
+module.exports.info = redis.info;
+module.exports.time = redis.time;
+module.exports.sadd = redis.sadd;
+module.exports.scard = redis.scard;
+module.exports.sdiff = redis.sdiff;
+module.exports.sdiffstore = redis.sdiffstore;
+module.exports.sinter = redis.sinter;
+module.exports.sinterstore = redis.sinterstore;
+module.exports.sismember = redis.sismember;
+module.exports.smembers = redis.smembers;
+module.exports.smove = redis.smove;
+module.exports.spop = redis.spop;
+module.exports.srandmember = redis.srandmember;
+module.exports.srem = redis.srem;
+module.exports.sunion = redis.sunion;
+module.exports.sunionstore = redis.sunionstore;
+module.exports.zadd = redis.zadd;
+module.exports.zcard = redis.zcard;
+module.exports.zcount = redis.zcount;
+module.exports.zincrby = redis.zincrby;
+module.exports.zinterstore = redis.zinterstore;
+module.exports.zlexcount = redis.zlexcount;
+module.exports.zpopmax = redis.zpopmax;
+module.exports.zpopmin = redis.zpopmin;
+module.exports.zrange = redis.zrange;
+module.exports.zrangebylex = redis.zrangebylex;
+module.exports.zrangebyscore = redis.zrangebyscore;
+module.exports.zrank = redis.zrank;
+module.exports.zrem = redis.zrem;
+module.exports.zremrangebylex = redis.zremrangebylex;
+module.exports.zremrangebyrank = redis.zremrangebyrank;
+module.exports.zremrangebyscore = redis.zremrangebyscore;
+module.exports.zrevrange = redis.zrevrange;
+module.exports.zrevrangebylex = redis.zrevrangebylex;
+module.exports.zrevrangebyscore = redis.zrevrangebyscore;
+module.exports.zrevrank = redis.zrevrank;
+module.exports.zscore = redis.zscore;
+module.exports.zunionstore = redis.zunionstore;

package/dist/main/types.d.ts

@@ -0,0 +1,179 @@
+export declare type ClientObjectProps = {
+    url?: undefined | string;
+    token?: undefined | string;
+    requestOptions?: undefined | RequestInit;
+};
+export declare type ReturnType = {
+    data: string | number | [] | any;
+    error: string | null;
+};
+export declare type MethodReturn = Promise<ReturnType>;
+export declare type Part = string | boolean | number;
+export declare type Bit = 0 | 1;
+export declare type Infinities = '+inf' | '-inf';
+export declare type ZSetNumber = Infinities | number | string;
+declare type Auth1 = (options?: ClientObjectProps) => void;
+declare type Auth2 = (url?: string, token?: string) => void;
+declare type Auth3 = (url?: string | ClientObjectProps, token?: string) => void;
+declare type SET1 = (key: string, value: string | number) => MethodReturn;
+declare type SET2 = (key: string, value: string | number, timeType: 'EX' | 'PX', time: number | string) => MethodReturn;
+declare type BITCOUNT1 = (key: string) => MethodReturn;
+declare type BITCOUNT2 = (key: string, start: number | string, end: number | string) => MethodReturn;
+declare type BITPOS1 = (key: string, bit: Bit) => MethodReturn;
+declare type BITPOS2 = (key: string, bit: Bit, start: number) => MethodReturn;
+declare type BITPOS3 = (key: string, bit: Bit, start: number, end: number) => MethodReturn;
+declare type PING1 = () => MethodReturn;
+declare type PING2 = (message: string) => MethodReturn;
+declare type SCAN1 = (cursor: number | string) => MethodReturn;
+declare type SCAN2 = (cursor: number | string, match: 'MATCH', pattern: string) => MethodReturn;
+declare type SCAN3 = (cursor: number | string, count: 'COUNT', value: number | string) => MethodReturn;
+declare type SCAN4 = (cursor: number | string, match: 'MATCH', pattern: string, count: 'COUNT', value: number | string) => MethodReturn;
+declare type FLUSHALL1 = () => MethodReturn;
+declare type FLUSHALL2 = (mode: 'ASYNC') => MethodReturn;
+declare type FLUSHDB1 = () => MethodReturn;
+declare type FLUSHDB2 = (mode: 'ASYNC' | 'SYNC') => MethodReturn;
+declare type INFO1 = () => MethodReturn;
+declare type INFO2 = (section: string) => MethodReturn;
+declare type XSCAN1 = (key: string, cursor: number | string) => MethodReturn;
+declare type XSCAN2 = (key: string, cursor: number | string, match: 'MATCH', pattern: string) => MethodReturn;
+declare type XSCAN3 = (key: string, cursor: number | string, count: 'COUNT', value: number | string) => MethodReturn;
+declare type XSCAN4 = (key: string, cursor: number | string, match: 'MATCH', pattern: string, count: 'COUNT', value: number | string) => MethodReturn;
+declare type SPOP1 = (key: string) => MethodReturn;
+declare type SPOP2 = (key: string, count: number) => MethodReturn;
+declare type SRANDMEMBER1 = (key: string) => MethodReturn;
+declare type SRANDMEMBER2 = (key: string, count: number) => MethodReturn;
+declare type ZPOPMAX1 = (key: string) => MethodReturn;
+declare type ZPOPMAX2 = (key: string, count: number | string) => MethodReturn;
+declare type ZRANGE1 = (key: string, min: ZSetNumber, max: ZSetNumber) => MethodReturn;
+declare type ZRANGE2 = (key: string, min: ZSetNumber, max: ZSetNumber, withscores: 'WITHSCORES') => MethodReturn;
+declare type ZRANGEBYLEX1 = (key: string, min: ZSetNumber, max: ZSetNumber) => MethodReturn;
+declare type ZRANGEBYLEX2 = (key: string, min: ZSetNumber, max: ZSetNumber, limit: 'LIMIT', offset: number | string, count: number | string) => MethodReturn;
+declare type ZRANGEBYSCORE1 = (key: string, min: ZSetNumber, max: ZSetNumber) => MethodReturn;
+declare type ZRANGEBYSCORE2 = (key: string, min: ZSetNumber, max: ZSetNumber, withScores: 'WITHSCORES') => MethodReturn;
+declare type ZRANGEBYSCORE3 = (key: string, min: ZSetNumber, max: ZSetNumber, limit: 'LIMIT', offset: number | string, count: number | string) => MethodReturn;
+declare type ZRANGEBYSCORE4 = (key: string, min: ZSetNumber, max: ZSetNumber, withScores: 'WITHSCORES', limit: 'LIMIT', offset: number | string, count: number | string) => MethodReturn;
+declare type ZREVRANGEBYLEX1 = (key: string, max: ZSetNumber, min: ZSetNumber) => MethodReturn;
+declare type ZREVRANGEBYLEX2 = (key: string, max: ZSetNumber, min: ZSetNumber, limit: 'LIMIT', offset: number | string, count: number | string) => MethodReturn;
+declare type ZREVRANGEBYSCORE1 = (key: string, max: ZSetNumber, min: ZSetNumber) => MethodReturn;
+declare type ZREVRANGEBYSCORE2 = (key: string, max: ZSetNumber, min: ZSetNumber, withScores: 'WITHSCORES') => MethodReturn;
+declare type ZREVRANGEBYSCORE3 = (key: string, max: ZSetNumber, min: ZSetNumber, limit: 'LIMIT', offset: number | string, count: number | string) => MethodReturn;
+declare type ZREVRANGEBYSCORE4 = (key: string, max: ZSetNumber, min: ZSetNumber, withScores: 'WITHSCORES', limit: 'LIMIT', offset: number | string, count: number | string) => MethodReturn;
+declare type ZREVRANGE1 = (key: string, start: number | string, stop: number | string) => MethodReturn;
+declare type ZREVRANGE2 = (key: string, start: number | string, stop: number | string, withscores: 'WITHSCORES') => MethodReturn;
+export declare type Upstash = {
+    auth: Auth1 & Auth2 & Auth3;
+    append: (key: string, value: string) => MethodReturn;
+    decr: (key: string) => MethodReturn;
+    decrby: (key: string, decrement: number | string) => MethodReturn;
+    get: (key: string) => MethodReturn;
+    getrange: (key: string, start: number | string, end: number | string) => MethodReturn;
+    getset: (key: string, value: string) => MethodReturn;
+    incr: (key: string) => MethodReturn;
+    incrby: (key: string, increment: number | string) => MethodReturn;
+    incrbyfloat: (key: string, increment: number | string) => MethodReturn;
+    mget: (...key: any) => MethodReturn;
+    mset: (...keyValue: any) => MethodReturn;
+    msetnx: (...keyValue: any) => MethodReturn;
+    psetex: (key: string, miliseconds: number | string, value: string) => MethodReturn;
+    set: SET1 & SET2;
+    setex: (key: string, seconds: number | string, value: string) => MethodReturn;
+    setnx: (key: string, value: string) => MethodReturn;
+    setrange: (key: string, offset: number | string, value: string) => MethodReturn;
+    strlen: (key: string) => MethodReturn;
+    bitcount: BITCOUNT1 & BITCOUNT2;
+    bitop: (operation: 'AND' | 'OR' | 'XOR' | 'NOT', destKey: string, ...key: any) => MethodReturn;
+    bitpos: BITPOS1 & BITPOS2 & BITPOS3;
+    getbit: (key: string, offset: number | string) => MethodReturn;
+    setbit: (key: string, offset: number | string, value: Bit) => MethodReturn;
+    echo: (message: string) => MethodReturn;
+    ping: PING1 & PING2;
+    hdel: (key: string, ...field: any) => MethodReturn;
+    hexists: (key: string, field: string) => MethodReturn;
+    hget: (key: string, field: string) => MethodReturn;
+    hgetall: (key: string) => MethodReturn;
+    hincrby: (key: string, field: string, increment: number | string) => MethodReturn;
+    hincrbyfloat: (key: string, field: string, increment: number | string) => MethodReturn;
+    hkeys: (key: string) => MethodReturn;
+    hlen: (key: string) => MethodReturn;
+    hmget: (key: string, ...field: any) => MethodReturn;
+    hmset: (key: string, ...fieldValue: any) => MethodReturn;
+    hscan: XSCAN1 & XSCAN2 & XSCAN3 & XSCAN4;
+    hset: (key: string, ...fieldValue: any) => MethodReturn;
+    hsetnx: (key: string, field: string, value: string) => MethodReturn;
+    hvals: (key: string) => MethodReturn;
+    del: (...key: any) => MethodReturn;
+    exists: (...key: any) => MethodReturn;
+    expire: (key: string, seconds: number | string) => MethodReturn;
+    expireat: (key: string, timestamp: number | string) => MethodReturn;
+    keys: (pattern: string) => MethodReturn;
+    persist: (key: string) => MethodReturn;
+    pexpire: (key: string, miliseconds: number | string) => MethodReturn;
+    pexpireat: (key: string, milisecondsTimestamp: number | string) => MethodReturn;
+    pttl: (key: string) => MethodReturn;
+    randomkey: () => MethodReturn;
+    rename: (key: string, newKey: string) => MethodReturn;
+    renamenx: (key: string, newKey: string) => MethodReturn;
+    scan: SCAN1 & SCAN2 & SCAN3 & SCAN4;
+    touch: (...key: any) => MethodReturn;
+    ttl: (key: string) => MethodReturn;
+    type: (key: string) => MethodReturn;
+    unlink: (...key: any) => MethodReturn;
+    lindex: (key: string, index: number | string) => MethodReturn;
+    linsert: (key: string, option: 'BEFORE' | 'AFTER', pivot: string, element: string) => MethodReturn;
+    llen: (key: string) => MethodReturn;
+    lpop: (key: string) => MethodReturn;
+    lpush: (key: string, ...element: any) => MethodReturn;
+    lpushx: (key: string, ...element: any) => MethodReturn;
+    lrange: (key: string, start: number | string, stop: number | string) => MethodReturn;
+    lrem: (key: string, count: number | string, element: string) => MethodReturn;
+    lset: (key: string, index: number | string, element: string) => MethodReturn;
+    ltrim: (key: string, start: number | string, stop: number | string) => MethodReturn;
+    rpop: (key: string) => MethodReturn;
+    rpoplpush: (source: string, destination: string) => MethodReturn;
+    rpush: (key: string, ...element: any) => MethodReturn;
+    rpushx: (key: string, ...element: any) => MethodReturn;
+    dbsize: () => MethodReturn;
+    flushall: FLUSHALL1 & FLUSHALL2;
+    flushdb: FLUSHDB1 & FLUSHDB2;
+    info: INFO1 & INFO2;
+    time: () => MethodReturn;
+    sadd: (key: string, ...member: any) => MethodReturn;
+    scard: (key: string) => MethodReturn;
+    sdiff: (...key: any) => MethodReturn;
+    sdiffstore: (destination: string, ...key: any) => MethodReturn;
+    sinter: (...key: any) => MethodReturn;
+    sinterstore: (destination: string, ...key: any) => MethodReturn;
+    sismember: (key: string, member: string) => MethodReturn;
+    smembers: (key: string) => MethodReturn;
+    smove: (source: string, destination: string, member: string) => MethodReturn;
+    spop: SPOP1 & SPOP2;
+    srandmember: SRANDMEMBER1 & SRANDMEMBER2;
+    srem: (key: string, ...member: any) => MethodReturn;
+    sscan: XSCAN1 & XSCAN2 & XSCAN3 & XSCAN4;
+    sunion: (...key: any) => MethodReturn;
+    sunionstore: (destination: string, ...key: any) => MethodReturn;
+    zadd: (key: string, ...scoreMember: any) => MethodReturn;
+    zcard: (key: string) => MethodReturn;
+    zcount: (key: string, min: ZSetNumber, max: ZSetNumber) => MethodReturn;
+    zincrby: (key: string, increment: number | string, member: string) => MethodReturn;
+    zinterstore: (destination: string, numkeys: number | string, ...key: any) => MethodReturn;
+    zlexcount: (key: string, min: ZSetNumber, max: ZSetNumber) => MethodReturn;
+    zpopmax: ZPOPMAX1 & ZPOPMAX2;
+    zpopmin: ZPOPMAX1 & ZPOPMAX2;
+    zrange: ZRANGE1 & ZRANGE2;
+    zrangebylex: ZRANGEBYLEX1 & ZRANGEBYLEX2;
+    zrangebyscore: ZRANGEBYSCORE1 & ZRANGEBYSCORE2 & ZRANGEBYSCORE3 & ZRANGEBYSCORE4;
+    zrank: (key: string, member: string) => MethodReturn;
+    zrem: (key: string, ...member: any) => MethodReturn;
+    zremrangebylex: (key: string, min: ZSetNumber, max: ZSetNumber) => MethodReturn;
+    zremrangebyrank: (key: string, start: number | string, stop: number | string) => MethodReturn;
+    zremrangebyscore: (key: string, min: ZSetNumber, max: ZSetNumber) => MethodReturn;
+    zrevrange: ZREVRANGE1 & ZREVRANGE2;
+    zrevrangebylex: ZREVRANGEBYLEX1 & ZREVRANGEBYLEX2;
+    zrevrangebyscore: ZREVRANGEBYSCORE1 & ZREVRANGEBYSCORE2 & ZREVRANGEBYSCORE3 & ZREVRANGEBYSCORE4;
+    zrevrank: (key: string, member: string) => MethodReturn;
+    zscan: XSCAN1 & XSCAN2 & XSCAN3 & XSCAN4;
+    zscore: (key: string, member: string) => MethodReturn;
+    zunionstore: (destination: string, ...numkeys: any) => MethodReturn;
+};
+export {};

package/dist/main/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/module/client.d.ts

@@ -1,158 +1,21 @@
-export declare type ReturnType = {
-    data: string | number | [] | any;
-    error: string | null;
-};
-declare type MethodReturn = Promise<ReturnType>;
-declare type Callback = (res: ReturnType) => any;
-declare type Bit = 0 | 1;
-declare type Infinities = '+inf' | '-inf';
-declare type ZSetNumber = number | Infinities | string;
+import { ClientObjectProps, Upstash } from './types';
 /**
- * Upstash client
- * @param {string} url - database rest url
- * @param {string} token - database rest token
+ * Creates a Upstash Redis instance
+ *
+ * @constructor
+ * @param {Object} options
+ * @param {string} [options.url]
+ * @param {string} [options.token]
+ * @param {Object} [options.requestOptions]
+ *
+ * @example
+ * ```js
+ * import upstash from '@upstash/redis'
+ *
+ * const redis1 = upstash('url', token);
+ * const redis2 = upstash({ url: '', token: '', requestOptions: {} });
+ * ```
  */
-export default function client(url?: string, token?: string): {
-    auth: (url: string, token: string) => void;
-    append: (key: string, value: string, callback?: Callback | undefined) => MethodReturn;
-    decr: (key: string, callback?: Callback | undefined) => MethodReturn;
-    decrby: (key: string, decrement: number, callback?: Callback | undefined) => MethodReturn;
-    get: (key: string, callback?: Callback | undefined) => MethodReturn;
-    getrange: (key: string, start: number, end: number, callback?: Callback | undefined) => MethodReturn;
-    getset: (key: string, value: string, callback?: Callback | undefined) => MethodReturn;
-    incr: (key: string, callback?: Callback | undefined) => MethodReturn;
-    incrby: (key: string, value: number | string, callback?: Callback | undefined) => MethodReturn;
-    incrbyfloat: (key: string, value: number | string, callback?: Callback | undefined) => MethodReturn;
-    mget: (values: string[], callback?: Callback | undefined) => MethodReturn;
-    mset: (values: string[], callback?: Callback | undefined) => MethodReturn;
-    msetnx: (values: string[], callback?: Callback | undefined) => MethodReturn;
-    psetex: (key: string, miliseconds: number, value: string | number, callback?: Callback | undefined) => MethodReturn;
-    set: (key: string, value: string | number, callback?: Callback | undefined) => MethodReturn;
-    setex: (key: string, seconds: number, value: string | number, callback?: Callback | undefined) => MethodReturn;
-    setnx: (key: string, value: string, callback?: Callback | undefined) => MethodReturn;
-    setrange: (key: string, offset: number | string, value: string, callback?: Callback | undefined) => MethodReturn;
-    strlen: (key: string, callback?: Callback | undefined) => MethodReturn;
-    bitcount: (key: string, start?: number | undefined, end?: number | undefined, callback?: Callback | undefined) => MethodReturn;
-    bitop: (operation: 'AND' | 'OR' | 'XOR' | 'NOT', destinationKey: string, sourceKeys: string[], callback?: Callback | undefined) => MethodReturn;
-    bitpos: (key: string, bit: Bit, start?: number | undefined, end?: number | undefined, callback?: Callback | undefined) => MethodReturn;
-    getbit: (key: string, offset: number, callback?: Callback | undefined) => MethodReturn;
-    setbit: (key: string, offset: number, value: Bit, callback?: Callback | undefined) => MethodReturn;
-    echo: (value: string, callback?: Callback | undefined) => MethodReturn;
-    ping: (value?: string | undefined, callback?: Callback | undefined) => MethodReturn;
-    hdel: (key: string, fields: string[], callback?: Callback | undefined) => MethodReturn;
-    hexists: (key: string, field: string, callback?: Callback | undefined) => MethodReturn;
-    hget: (key: string, field: string, callback?: Callback | undefined) => MethodReturn;
-    hgetall: (key: string, callback?: Callback | undefined) => MethodReturn;
-    hincrby: (key: string, field: string, increment: number | string, callback?: Callback | undefined) => MethodReturn;
-    hincrbyfloat: (key: string, field: string, increment: number | string, callback?: Callback | undefined) => MethodReturn;
-    hkeys: (key: string, callback?: Callback | undefined) => MethodReturn;
-    hlen: (key: string, callback?: Callback | undefined) => MethodReturn;
-    hmget: (key: string, fields: string[], callback?: Callback | undefined) => MethodReturn;
-    hmset: (key: string, values: string[], callback?: Callback | undefined) => MethodReturn;
-    hset: (key: string, values: string[], callback?: Callback | undefined) => MethodReturn;
-    hsetnx: (key: string, field: string, value: string, callback?: Callback | undefined) => MethodReturn;
-    hvals: (key: string, callback?: Callback | undefined) => MethodReturn;
-    hscan: (key: string, cursor: number, options?: {
-        match?: string | number | undefined;
-        count?: string | number | undefined;
-    } | undefined, callback?: Callback | undefined) => MethodReturn;
-    del: (keys: string[], callback?: Callback | undefined) => MethodReturn;
-    exists: (keys: string[], callback?: Callback | undefined) => MethodReturn;
-    expire: (key: string, seconds: number, callback?: Callback | undefined) => MethodReturn;
-    expireat: (key: string, timestamp: number | string, callback?: Callback | undefined) => MethodReturn;
-    keys: (pattern: string, callback?: Callback | undefined) => MethodReturn;
-    persist: (key: string, callback?: Callback | undefined) => MethodReturn;
-    pexpire: (key: string, miliseconds: number, callback?: Callback | undefined) => MethodReturn;
-    pexpireat: (key: string, miliseconds: number, callback?: Callback | undefined) => MethodReturn;
-    pttl: (key: string, callback?: Callback | undefined) => MethodReturn;
-    randomkey: (callback?: Callback | undefined) => MethodReturn;
-    rename: (key: string, newkey: string, callback?: Callback | undefined) => MethodReturn;
-    renamenx: (key: string, newkey: string, callback?: Callback | undefined) => MethodReturn;
-    scan: (cursor: number, opitons?: {
-        match?: string | number | undefined;
-        count?: string | number | undefined;
-    } | undefined, callback?: Callback | undefined) => MethodReturn;
-    touch: (keys: string[], callback?: Callback | undefined) => MethodReturn;
-    ttl: (key: string, callback?: Callback | undefined) => MethodReturn;
-    type: (key: string, callback?: Callback | undefined) => MethodReturn;
-    unlink: (keys: string[], callback?: Callback | undefined) => MethodReturn;
-    lindex: (key: string, index: number, callback?: Callback | undefined) => MethodReturn;
-    linsert: (key: string, option: 'BEFORE' | 'AFTER', pivot: string, element: string, callback?: Callback | undefined) => MethodReturn;
-    llen: (key: string, callback?: Callback | undefined) => MethodReturn;
-    lpop: (key: string, callback?: Callback | undefined) => MethodReturn;
-    lpush: (key: string, elements: string[], callback?: Callback | undefined) => MethodReturn;
-    lpushx: (key: string, elements: string[], callback?: Callback | undefined) => MethodReturn;
-    lrange: (key: string, start: number, stop: number, callback?: Callback | undefined) => MethodReturn;
-    lrem: (key: string, count: number, element: string, callback?: Callback | undefined) => MethodReturn;
-    lset: (key: string, index: number, element: string, callback?: Callback | undefined) => MethodReturn;
-    ltrim: (key: string, start: number, stop: number, callback?: Callback | undefined) => MethodReturn;
-    rpop: (key: string, callback?: Callback | undefined) => MethodReturn;
-    rpoplpush: (source: string, destination: string, callback?: Callback | undefined) => MethodReturn;
-    rpush: (key: string, elements: string[], callback?: Callback | undefined) => MethodReturn;
-    rpushx: (key: string, elements: string[], callback?: Callback | undefined) => MethodReturn;
-    dbsize: (callback?: Callback | undefined) => MethodReturn;
-    flushall: (mode?: "ASYNC" | undefined, callback?: Callback | undefined) => MethodReturn;
-    flushdb: (mode?: "ASYNC" | undefined, callback?: Callback | undefined) => MethodReturn;
-    info: (callback?: Callback | undefined) => MethodReturn;
-    time: (callback?: Callback | undefined) => MethodReturn;
-    sadd: (key: string, members: string[], callback?: Callback | undefined) => MethodReturn;
-    scard: (key: string, callback?: Callback | undefined) => MethodReturn;
-    sdiff: (keys: string[], callback?: Callback | undefined) => MethodReturn;
-    sdiffstore: (destination: string, keys: string[], callback?: Callback | undefined) => MethodReturn;
-    sinter: (keys: string[], callback?: Callback | undefined) => MethodReturn;
-    sinterstore: (destination: string, keys: string[], callback?: Callback | undefined) => MethodReturn;
-    sismember: (key: string, member: string, callback?: Callback | undefined) => MethodReturn;
-    smembers: (key: string, callback?: Callback | undefined) => MethodReturn;
-    smove: (source: string, destination: string, member: string, callback?: Callback | undefined) => MethodReturn;
-    spop: (key: string, count?: number | undefined, callback?: Callback | undefined) => MethodReturn;
-    srandmember: (key: string, count?: number | undefined, callback?: Callback | undefined) => MethodReturn;
-    srem: (key: string, members: string[], callback?: Callback | undefined) => MethodReturn;
-    sunion: (keys: string[], callback?: Callback | undefined) => MethodReturn;
-    sunionstore: (destination: string, keys: string[], callback?: Callback | undefined) => MethodReturn;
-    zadd: (key: string, values: ZSetNumber[], options?: (({
-        xx?: boolean | undefined;
-    } | {
-        nx?: boolean | undefined;
-    }) & {
-        ch?: boolean | undefined;
-        incr: boolean;
-    }) | undefined, callback?: Callback | undefined) => MethodReturn;
-    zcard: (key: string, callback?: Callback | undefined) => MethodReturn;
-    zcount: (key: string, min: ZSetNumber, max: ZSetNumber, callback?: Callback | undefined) => MethodReturn;
-    zincrby: (key: string, increment: number | string, member: string, callback?: Callback | undefined) => MethodReturn;
-    zinterstore: (destination: string, keys: string[], options?: {
-        weights?: number[] | undefined;
-        aggregate?: "MIN" | "MAX" | "SUM" | undefined;
-    } | undefined, callback?: Callback | undefined) => MethodReturn;
-    zlexcount: (key: string, min: ZSetNumber, max: ZSetNumber, callback?: Callback | undefined) => MethodReturn;
-    zpopmax: (key: string, count?: number | undefined, callback?: Callback | undefined) => MethodReturn;
-    zpopmin: (key: string, count?: number | undefined, callback?: Callback | undefined) => MethodReturn;
-    zrange: (key: string, min: ZSetNumber, max: ZSetNumber, options?: {
-        withScores: boolean;
-    } | undefined, callback?: Callback | undefined) => MethodReturn;
-    zrangebylex: (key: string, min: ZSetNumber, max: ZSetNumber, offset?: number | undefined, count?: number | undefined, callback?: Callback | undefined) => MethodReturn;
-    zrangebyscore: (key: string, min: ZSetNumber, max: ZSetNumber, options?: {
-        withScores?: boolean | undefined;
-        limit?: {
-            offset: number;
-            count: number;
-        } | undefined;
-    } | undefined, callback?: Callback | undefined) => MethodReturn;
-    zrank: (key: string, member: string, callback?: Callback | undefined) => MethodReturn;
-    zrem: (key: string, members: string[], callback?: Callback | undefined) => MethodReturn;
-    zremrangebylex: (key: string, min: ZSetNumber, max: ZSetNumber, callback?: Callback | undefined) => MethodReturn;
-    zremrangebyrank: (key: string, start: number, stop: number, callback?: Callback | undefined) => MethodReturn;
-    zremrangebyscore: (key: string, min: ZSetNumber, max: ZSetNumber, callback?: Callback | undefined) => MethodReturn;
-    zrevrange: (key: string, start: number, stop: number, options?: {
-        withScores: boolean;
-    } | undefined, callback?: Callback | undefined) => MethodReturn;
-    zrevrangebylex: (key: string, max: ZSetNumber, min: ZSetNumber, offset?: number | undefined, count?: number | undefined, callback?: Callback | undefined) => MethodReturn;
-    zrevrangebyscore: (key: string, min: ZSetNumber, max: ZSetNumber, callback?: Callback | undefined) => MethodReturn;
-    zscore: (key: string, member: string, callback?: Callback | undefined) => MethodReturn;
-    zunionstore: (destination: string, keys: string[], options?: {
-        weights?: number[] | undefined;
-        aggregate?: "MIN" | "MAX" | "SUM" | undefined;
-    } | undefined, callback?: Callback | undefined) => MethodReturn;
-};
-export {};
-//# sourceMappingURL=client.d.ts.map
+declare function upstash(options?: ClientObjectProps): Upstash;
+declare function upstash(url?: string, token?: string): Upstash;
+export default upstash;