minitest-distributed 0.2.8 → 0.2.9

data/sorbet/rbi/gems/redis-client.rbi

@@ -0,0 +1,311 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/redis-client/all/redis-client.rbi
+#
+# redis-client-0.11.2
+
+class RedisClient
+  def blocking_call(timeout, *command, **kwargs); end
+  def blocking_call_v(timeout, command); end
+  def build_transaction; end
+  def call(*command, **kwargs); end
+  def call_once(*command, **kwargs); end
+  def call_once_v(command); end
+  def call_v(command); end
+  def close; end
+  def connect; end
+  def connected?; end
+  def ensure_connected(retryable: nil); end
+  def hscan(key, *args, **kwargs, &block); end
+  def initialize(config, **); end
+  def inspect; end
+  def multi(watch: nil, &block); end
+  def pipelined; end
+  def pubsub; end
+  def raw_connection; end
+  def read_timeout=(timeout); end
+  def scan(*args, **kwargs, &block); end
+  def scan_list(cursor_index, command, &block); end
+  def scan_pairs(cursor_index, command); end
+  def self.config(**kwargs); end
+  def self.default_driver; end
+  def self.default_driver=(name); end
+  def self.driver(name); end
+  def self.new(arg = nil, **kwargs); end
+  def self.register(middleware); end
+  def self.register_driver(name, &block); end
+  def self.sentinel(**kwargs); end
+  def size; end
+  def sscan(key, *args, **kwargs, &block); end
+  def then(_options = nil); end
+  def timeout=(timeout); end
+  def with(_options = nil); end
+  def write_timeout=(timeout); end
+  def zscan(key, *args, **kwargs, &block); end
+  include RedisClient::Common
+end
+module RedisClient::CommandBuilder
+  def generate(args, kwargs = nil); end
+  extend RedisClient::CommandBuilder
+end
+class RedisClient::Config
+  def host; end
+  def initialize(url: nil, host: nil, port: nil, path: nil, **kwargs); end
+  def path; end
+  def port; end
+  include RedisClient::Config::Common
+end
+module RedisClient::Config::Common
+  def build_connection_prelude; end
+  def command_builder; end
+  def connect_timeout; end
+  def connection_prelude; end
+  def custom; end
+  def db; end
+  def driver; end
+  def id; end
+  def inherit_socket; end
+  def initialize(username: nil, password: nil, db: nil, id: nil, timeout: nil, read_timeout: nil, write_timeout: nil, connect_timeout: nil, ssl: nil, custom: nil, ssl_params: nil, driver: nil, protocol: nil, client_implementation: nil, command_builder: nil, inherit_socket: nil, reconnect_attempts: nil, middlewares: nil); end
+  def middlewares_stack; end
+  def new_client(**kwargs); end
+  def new_pool(**kwargs); end
+  def password; end
+  def protocol; end
+  def read_timeout; end
+  def retry_connecting?(attempt, _error); end
+  def sentinel?; end
+  def server_url; end
+  def ssl; end
+  def ssl?; end
+  def ssl_context; end
+  def ssl_params; end
+  def username; end
+  def write_timeout; end
+end
+class RedisClient::SentinelConfig
+  def check_role!(role); end
+  def config; end
+  def each_sentinel; end
+  def host; end
+  def initialize(name:, sentinels:, role: nil, **client_config); end
+  def path; end
+  def port; end
+  def reset; end
+  def resolve_master; end
+  def resolve_replica; end
+  def retry_connecting?(attempt, error); end
+  def sentinel?; end
+  def sentinel_client(sentinel_config); end
+  def sentinels; end
+  include RedisClient::Config::Common
+end
+class RedisClient::BasicMiddleware
+  def call(command, _config); end
+  def call_pipelined(command, _config); end
+  def client; end
+  def connect(_config); end
+  def initialize(client); end
+end
+class RedisClient::Middlewares < RedisClient::BasicMiddleware
+end
+class RedisClient::Pooled
+  def blocking_call(*args, **, &block); end
+  def blocking_call_v(*args, **, &block); end
+  def call(*args, **, &block); end
+  def call_once(*args, **, &block); end
+  def call_once_v(*args, **, &block); end
+  def call_v(*args, **, &block); end
+  def close; end
+  def hscan(*args, **, &block); end
+  def initialize(config, id: nil, connect_timeout: nil, read_timeout: nil, write_timeout: nil, **kwargs); end
+  def multi(*args, **, &block); end
+  def new_pool; end
+  def pipelined(*args, **, &block); end
+  def pool; end
+  def pubsub(*args, **, &block); end
+  def scan(*args, **, &block); end
+  def size; end
+  def sscan(*args, **, &block); end
+  def then(options = nil); end
+  def with(options = nil); end
+  def zscan(*args, **, &block); end
+  include RedisClient::Common
+end
+module RedisClient::ConnectionMixin
+  def call(command, timeout); end
+  def call_pipelined(commands, timeouts); end
+  def initialize; end
+  def revalidate; end
+end
+class RedisClient::RubyConnection
+  def close; end
+  def connected?; end
+  def initialize(config, connect_timeout:, read_timeout:, write_timeout:); end
+  def read(timeout = nil); end
+  def read_timeout=(timeout); end
+  def self.ssl_context(ssl_params); end
+  def write(command); end
+  def write_multi(commands); end
+  def write_timeout=(timeout); end
+  include RedisClient::ConnectionMixin
+end
+class RedisClient::RubyConnection::BufferedIO
+  def close; end
+  def closed?; end
+  def ensure_remaining(bytes); end
+  def eof?; end
+  def fill_buffer(strict, size = nil); end
+  def getbyte; end
+  def gets_chomp; end
+  def initialize(io, read_timeout:, write_timeout:, chunk_size: nil); end
+  def read_chomp(bytes); end
+  def read_timeout; end
+  def read_timeout=(arg0); end
+  def skip(offset); end
+  def with_timeout(new_timeout); end
+  def write(string); end
+  def write_timeout; end
+  def write_timeout=(arg0); end
+end
+module RedisClient::RESP3
+  def dump(command, buffer = nil); end
+  def dump_any(object, buffer); end
+  def dump_array(array, buffer); end
+  def dump_hash(hash, buffer); end
+  def dump_numeric(numeric, buffer); end
+  def dump_set(set, buffer); end
+  def dump_string(string, buffer); end
+  def dump_symbol(symbol, buffer); end
+  def load(io); end
+  def new_buffer; end
+  def parse(io); end
+  def parse_array(io); end
+  def parse_blob(io); end
+  def parse_boolean(io); end
+  def parse_double(io); end
+  def parse_error(io); end
+  def parse_integer(io); end
+  def parse_map(io); end
+  def parse_null(io); end
+  def parse_push(io); end
+  def parse_sequence(io, size); end
+  def parse_set(io); end
+  def parse_string(io); end
+  def parse_verbatim_string(io); end
+  def self.dump(command, buffer = nil); end
+  def self.dump_any(object, buffer); end
+  def self.dump_array(array, buffer); end
+  def self.dump_hash(hash, buffer); end
+  def self.dump_numeric(numeric, buffer); end
+  def self.dump_set(set, buffer); end
+  def self.dump_string(string, buffer); end
+  def self.dump_symbol(symbol, buffer); end
+  def self.load(io); end
+  def self.new_buffer; end
+  def self.parse(io); end
+  def self.parse_array(io); end
+  def self.parse_blob(io); end
+  def self.parse_boolean(io); end
+  def self.parse_double(io); end
+  def self.parse_error(io); end
+  def self.parse_integer(io); end
+  def self.parse_map(io); end
+  def self.parse_null(io); end
+  def self.parse_push(io); end
+  def self.parse_sequence(io, size); end
+  def self.parse_set(io); end
+  def self.parse_string(io); end
+  def self.parse_verbatim_string(io); end
+end
+class RedisClient::RESP3::Error < RedisClient::Error
+end
+class RedisClient::RESP3::UnknownType < RedisClient::RESP3::Error
+end
+class RedisClient::RESP3::SyntaxError < RedisClient::RESP3::Error
+end
+module RedisClient::Common
+  def config; end
+  def connect_timeout; end
+  def connect_timeout=(arg0); end
+  def id; end
+  def initialize(config, id: nil, connect_timeout: nil, read_timeout: nil, write_timeout: nil); end
+  def read_timeout; end
+  def read_timeout=(arg0); end
+  def timeout=(timeout); end
+  def write_timeout; end
+  def write_timeout=(arg0); end
+end
+class RedisClient::Error < StandardError
+end
+class RedisClient::ProtocolError < RedisClient::Error
+end
+class RedisClient::UnsupportedServer < RedisClient::Error
+end
+class RedisClient::ConnectionError < RedisClient::Error
+end
+class RedisClient::CannotConnectError < RedisClient::ConnectionError
+end
+class RedisClient::FailoverError < RedisClient::ConnectionError
+end
+class RedisClient::TimeoutError < RedisClient::ConnectionError
+end
+class RedisClient::ReadTimeoutError < RedisClient::TimeoutError
+end
+class RedisClient::WriteTimeoutError < RedisClient::TimeoutError
+end
+class RedisClient::CheckoutTimeoutError < RedisClient::TimeoutError
+end
+module RedisClient::HasCommand
+  def _set_command(command); end
+  def command; end
+end
+class RedisClient::CommandError < RedisClient::Error
+  def self.parse(error_message); end
+  include RedisClient::HasCommand
+end
+class RedisClient::AuthenticationError < RedisClient::CommandError
+end
+class RedisClient::PermissionError < RedisClient::CommandError
+end
+class RedisClient::WrongTypeError < RedisClient::CommandError
+end
+class RedisClient::OutOfMemoryError < RedisClient::CommandError
+end
+class RedisClient::ReadOnlyError < RedisClient::ConnectionError
+  include RedisClient::HasCommand
+end
+class RedisClient::PubSub
+  def call(*command, **kwargs); end
+  def call_v(command); end
+  def close; end
+  def initialize(raw_connection, command_builder); end
+  def next_event(timeout = nil); end
+  def raw_connection; end
+end
+class RedisClient::Multi
+  def _blocks; end
+  def _coerce!(results); end
+  def _commands; end
+  def _empty?; end
+  def _retryable?; end
+  def _size; end
+  def _timeouts; end
+  def call(*command, **kwargs, &block); end
+  def call_once(*command, **kwargs, &block); end
+  def call_once_v(command, &block); end
+  def call_v(command, &block); end
+  def initialize(command_builder); end
+end
+class RedisClient::Pipeline < RedisClient::Multi
+  def _coerce!(results); end
+  def _empty?; end
+  def _timeouts; end
+  def blocking_call(timeout, *command, **kwargs, &block); end
+  def blocking_call_v(timeout, command, &block); end
+  def initialize(_command_builder); end
+end

data/sorbet/rbi/gems/redis.rbi

@@ -0,0 +1,409 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/redis/all/redis.rbi
+#
+# redis-5.0.6
+
+class Redis
+  def _client; end
+  def _subscription(method, timeout, channels, block); end
+  def close; end
+  def connected?; end
+  def connection; end
+  def disconnect!; end
+  def dup; end
+  def id; end
+  def initialize(options = nil); end
+  def initialize_client(options); end
+  def inspect; end
+  def pipelined; end
+  def self.deprecate!(message); end
+  def self.raise_deprecations; end
+  def self.raise_deprecations=(arg0); end
+  def self.silence_deprecations; end
+  def self.silence_deprecations=(arg0); end
+  def send_blocking_command(command, timeout, &block); end
+  def send_command(command, &block); end
+  def synchronize; end
+  def with; end
+  def without_reconnect(&block); end
+  include Redis::Commands
+end
+class Redis::BaseError < StandardError
+end
+class Redis::ProtocolError < Redis::BaseError
+  def initialize(reply_type); end
+end
+class Redis::CommandError < Redis::BaseError
+end
+class Redis::PermissionError < Redis::CommandError
+end
+class Redis::WrongTypeError < Redis::CommandError
+end
+class Redis::OutOfMemoryError < Redis::CommandError
+end
+class Redis::BaseConnectionError < Redis::BaseError
+end
+class Redis::CannotConnectError < Redis::BaseConnectionError
+end
+class Redis::ConnectionError < Redis::BaseConnectionError
+end
+class Redis::TimeoutError < Redis::BaseConnectionError
+end
+class Redis::InheritedError < Redis::BaseConnectionError
+end
+class Redis::ReadOnlyError < Redis::BaseConnectionError
+end
+class Redis::InvalidClientOptionError < Redis::BaseError
+end
+class Redis::SubscriptionError < Redis::BaseError
+end
+module Redis::Commands
+  def call(*command); end
+  def method_missing(*command); end
+  def sentinel(subcommand, *args); end
+  include Redis::Commands::Bitmaps
+  include Redis::Commands::Cluster
+  include Redis::Commands::Connection
+  include Redis::Commands::Geo
+  include Redis::Commands::Hashes
+  include Redis::Commands::HyperLogLog
+  include Redis::Commands::Keys
+  include Redis::Commands::Lists
+  include Redis::Commands::Pubsub
+  include Redis::Commands::Scripting
+  include Redis::Commands::Server
+  include Redis::Commands::Sets
+  include Redis::Commands::SortedSets
+  include Redis::Commands::Streams
+  include Redis::Commands::Strings
+  include Redis::Commands::Transactions
+end
+module Redis::Commands::Bitmaps
+  def bitcount(key, start = nil, stop = nil); end
+  def bitop(operation, destkey, *keys); end
+  def bitpos(key, bit, start = nil, stop = nil); end
+  def getbit(key, offset); end
+  def setbit(key, offset, value); end
+end
+module Redis::Commands::Cluster
+  def asking; end
+  def cluster(subcommand, *args); end
+end
+module Redis::Commands::Connection
+  def auth(*args); end
+  def echo(value); end
+  def ping(message = nil); end
+  def quit; end
+  def select(db); end
+end
+module Redis::Commands::Geo
+  def _geoarguments(*args, options: nil, sort: nil, count: nil); end
+  def geoadd(key, *member); end
+  def geodist(key, member1, member2, unit = nil); end
+  def geohash(key, member); end
+  def geopos(key, member); end
+  def georadius(*args, **geoptions); end
+  def georadiusbymember(*args, **geoptions); end
+end
+module Redis::Commands::Hashes
+  def hdel(key, *fields); end
+  def hexists(key, field); end
+  def hget(key, field); end
+  def hgetall(key); end
+  def hincrby(key, field, increment); end
+  def hincrbyfloat(key, field, increment); end
+  def hkeys(key); end
+  def hlen(key); end
+  def hmget(key, *fields, &blk); end
+  def hmset(key, *attrs); end
+  def hrandfield(key, count = nil, withvalues: nil, with_values: nil); end
+  def hscan(key, cursor, **options); end
+  def hscan_each(key, **options, &block); end
+  def hset(key, *attrs); end
+  def hsetnx(key, field, value); end
+  def hvals(key); end
+  def mapped_hmget(key, *fields); end
+  def mapped_hmset(key, hash); end
+end
+module Redis::Commands::HyperLogLog
+  def pfadd(key, member); end
+  def pfcount(*keys); end
+  def pfmerge(dest_key, *source_key); end
+end
+module Redis::Commands::Keys
+  def _scan(command, cursor, args, match: nil, count: nil, type: nil, &block); end
+  def copy(source, destination, db: nil, replace: nil); end
+  def del(*keys); end
+  def dump(key); end
+  def exists(*keys); end
+  def exists?(*keys); end
+  def expire(key, seconds, nx: nil, xx: nil, gt: nil, lt: nil); end
+  def expireat(key, unix_time, nx: nil, xx: nil, gt: nil, lt: nil); end
+  def keys(pattern = nil); end
+  def migrate(key, options); end
+  def move(key, db); end
+  def object(*args); end
+  def persist(key); end
+  def pexpire(key, milliseconds, nx: nil, xx: nil, gt: nil, lt: nil); end
+  def pexpireat(key, ms_unix_time, nx: nil, xx: nil, gt: nil, lt: nil); end
+  def pttl(key); end
+  def randomkey; end
+  def rename(old_name, new_name); end
+  def renamenx(old_name, new_name); end
+  def restore(key, ttl, serialized_value, replace: nil); end
+  def scan(cursor, **options); end
+  def scan_each(**options, &block); end
+  def sort(key, by: nil, limit: nil, get: nil, order: nil, store: nil); end
+  def ttl(key); end
+  def type(key); end
+  def unlink(*keys); end
+end
+module Redis::Commands::Lists
+  def _bpop(cmd, args, &blk); end
+  def _normalize_move_wheres(where_source, where_destination); end
+  def blmove(source, destination, where_source, where_destination, timeout: nil); end
+  def blpop(*args); end
+  def brpop(*args); end
+  def brpoplpush(source, destination, timeout: nil); end
+  def lindex(key, index); end
+  def linsert(key, where, pivot, value); end
+  def llen(key); end
+  def lmove(source, destination, where_source, where_destination); end
+  def lpop(key, count = nil); end
+  def lpush(key, value); end
+  def lpushx(key, value); end
+  def lrange(key, start, stop); end
+  def lrem(key, count, value); end
+  def lset(key, index, value); end
+  def ltrim(key, start, stop); end
+  def rpop(key, count = nil); end
+  def rpoplpush(source, destination); end
+  def rpush(key, value); end
+  def rpushx(key, value); end
+end
+module Redis::Commands::Pubsub
+  def psubscribe(*channels, &block); end
+  def psubscribe_with_timeout(timeout, *channels, &block); end
+  def publish(channel, message); end
+  def pubsub(subcommand, *args); end
+  def punsubscribe(*channels); end
+  def subscribe(*channels, &block); end
+  def subscribe_with_timeout(timeout, *channels, &block); end
+  def subscribed?; end
+  def unsubscribe(*channels); end
+end
+module Redis::Commands::Scripting
+  def _eval(cmd, args); end
+  def eval(*args); end
+  def evalsha(*args); end
+  def script(subcommand, *args); end
+end
+module Redis::Commands::Server
+  def bgrewriteaof; end
+  def bgsave; end
+  def client(subcommand, *args); end
+  def config(action, *args); end
+  def dbsize; end
+  def debug(*args); end
+  def flushall(options = nil); end
+  def flushdb(options = nil); end
+  def info(cmd = nil); end
+  def lastsave; end
+  def monitor; end
+  def save; end
+  def shutdown; end
+  def slaveof(host, port); end
+  def slowlog(subcommand, length = nil); end
+  def sync; end
+  def time; end
+end
+module Redis::Commands::Sets
+  def sadd(key, *members); end
+  def sadd?(key, *members); end
+  def scard(key); end
+  def sdiff(*keys); end
+  def sdiffstore(destination, *keys); end
+  def sinter(*keys); end
+  def sinterstore(destination, *keys); end
+  def sismember(key, member); end
+  def smembers(key); end
+  def smismember(key, *members); end
+  def smove(source, destination, member); end
+  def spop(key, count = nil); end
+  def srandmember(key, count = nil); end
+  def srem(key, *members); end
+  def srem?(key, *members); end
+  def sscan(key, cursor, **options); end
+  def sscan_each(key, **options, &block); end
+  def sunion(*keys); end
+  def sunionstore(destination, *keys); end
+end
+module Redis::Commands::SortedSets
+  def _zsets_operation(cmd, *keys, weights: nil, aggregate: nil, with_scores: nil); end
+  def _zsets_operation_store(cmd, destination, keys, weights: nil, aggregate: nil); end
+  def bzpopmax(*args); end
+  def bzpopmin(*args); end
+  def zadd(key, *args, nx: nil, xx: nil, lt: nil, gt: nil, ch: nil, incr: nil); end
+  def zcard(key); end
+  def zcount(key, min, max); end
+  def zdiff(*keys, with_scores: nil); end
+  def zdiffstore(*args, **); end
+  def zincrby(key, increment, member); end
+  def zinter(*args, **); end
+  def zinterstore(*args, **); end
+  def zlexcount(key, min, max); end
+  def zmscore(key, *members); end
+  def zpopmax(key, count = nil); end
+  def zpopmin(key, count = nil); end
+  def zrandmember(key, count = nil, withscores: nil, with_scores: nil); end
+  def zrange(key, start, stop, byscore: nil, by_score: nil, bylex: nil, by_lex: nil, rev: nil, limit: nil, withscores: nil, with_scores: nil); end
+  def zrangebylex(key, min, max, limit: nil); end
+  def zrangebyscore(key, min, max, withscores: nil, with_scores: nil, limit: nil); end
+  def zrangestore(dest_key, src_key, start, stop, byscore: nil, by_score: nil, bylex: nil, by_lex: nil, rev: nil, limit: nil); end
+  def zrank(key, member); end
+  def zrem(key, member); end
+  def zremrangebyrank(key, start, stop); end
+  def zremrangebyscore(key, min, max); end
+  def zrevrange(key, start, stop, withscores: nil, with_scores: nil); end
+  def zrevrangebylex(key, max, min, limit: nil); end
+  def zrevrangebyscore(key, max, min, withscores: nil, with_scores: nil, limit: nil); end
+  def zrevrank(key, member); end
+  def zscan(key, cursor, **options); end
+  def zscan_each(key, **options, &block); end
+  def zscore(key, member); end
+  def zunion(*args, **); end
+  def zunionstore(*args, **); end
+end
+module Redis::Commands::Streams
+  def _xread(args, keys, ids, blocking_timeout_msec); end
+  def xack(key, group, *ids); end
+  def xadd(key, entry, approximate: nil, maxlen: nil, nomkstream: nil, id: nil); end
+  def xautoclaim(key, group, consumer, min_idle_time, start, count: nil, justid: nil); end
+  def xclaim(key, group, consumer, min_idle_time, *ids, **opts); end
+  def xdel(key, *ids); end
+  def xgroup(subcommand, key, group, id_or_consumer = nil, mkstream: nil); end
+  def xinfo(subcommand, key, group = nil); end
+  def xlen(key); end
+  def xpending(key, group, *args, idle: nil); end
+  def xrange(key, start = nil, range_end = nil, count: nil); end
+  def xread(keys, ids, count: nil, block: nil); end
+  def xreadgroup(group, consumer, keys, ids, count: nil, block: nil, noack: nil); end
+  def xrevrange(key, range_end = nil, start = nil, count: nil); end
+  def xtrim(key, len_or_id, strategy: nil, approximate: nil, limit: nil); end
+end
+module Redis::Commands::Strings
+  def append(key, value); end
+  def decr(key); end
+  def decrby(key, decrement); end
+  def get(key); end
+  def getdel(key); end
+  def getex(key, ex: nil, px: nil, exat: nil, pxat: nil, persist: nil); end
+  def getrange(key, start, stop); end
+  def getset(key, value); end
+  def incr(key); end
+  def incrby(key, increment); end
+  def incrbyfloat(key, increment); end
+  def mapped_mget(*keys); end
+  def mapped_mset(hash); end
+  def mapped_msetnx(hash); end
+  def mget(*keys, &blk); end
+  def mset(*args); end
+  def msetnx(*args); end
+  def psetex(key, ttl, value); end
+  def set(key, value, ex: nil, px: nil, exat: nil, pxat: nil, nx: nil, xx: nil, keepttl: nil, get: nil); end
+  def setex(key, ttl, value); end
+  def setnx(key, value); end
+  def setrange(key, offset, value); end
+  def strlen(key); end
+end
+module Redis::Commands::Transactions
+  def discard; end
+  def exec; end
+  def multi; end
+  def unwatch; end
+  def watch(*keys); end
+end
+class Redis::Client < RedisClient
+  def blocking_call_v(timeout, command, &block); end
+  def call_v(command, &block); end
+  def db; end
+  def disable_reconnection(&block); end
+  def host; end
+  def id; end
+  def inherit_socket!; end
+  def multi; end
+  def password; end
+  def path; end
+  def pipelined; end
+  def port; end
+  def self.config(**kwargs); end
+  def self.sentinel(**kwargs); end
+  def server_url; end
+  def timeout; end
+  def translate_error!(error); end
+  def translate_error_class(error_class); end
+  def username; end
+end
+class Redis::PipelinedConnection
+  def db; end
+  def db=(arg0); end
+  def initialize(pipeline, futures = nil); end
+  def multi; end
+  def pipelined; end
+  def send_blocking_command(command, timeout, &block); end
+  def send_command(command, &block); end
+  def synchronize; end
+  include Redis::Commands
+end
+class Redis::MultiConnection < Redis::PipelinedConnection
+  def multi; end
+  def send_blocking_command(command, _timeout, &block); end
+end
+class Redis::FutureNotReady < RuntimeError
+  def initialize; end
+end
+class Redis::Future < BasicObject
+  def _set(object); end
+  def class; end
+  def initialize(command, coerce); end
+  def inspect; end
+  def is_a?(other); end
+  def value; end
+end
+class Redis::MultiFuture < Redis::Future
+  def _set(replies); end
+  def initialize(futures); end
+end
+class Redis::SubscribedClient
+  def call_v(command); end
+  def close; end
+  def initialize(client); end
+  def psubscribe(*channels, &block); end
+  def psubscribe_with_timeout(timeout, *channels, &block); end
+  def punsubscribe(*channels); end
+  def subscribe(*channels, &block); end
+  def subscribe_with_timeout(timeout, *channels, &block); end
+  def subscription(start, stop, channels, block, timeout = nil); end
+  def unsubscribe(*channels); end
+end
+class Redis::Subscription
+  def callbacks; end
+  def initialize; end
+  def message(&block); end
+  def pmessage(&block); end
+  def psubscribe(&block); end
+  def punsubscribe(&block); end
+  def subscribe(&block); end
+  def unsubscribe(&block); end
+end
+class Redis::Deprecated < StandardError
+end
+module Redis::Connection
+  def self.drivers; end
+end