# typed: true
# frozen_string_literal: true

class Redis
  class Error < StandardError
  end

  class CommandError < Error
  end

  class Future
    sig { returns(T.untyped) }
    def value; end
  end

  sig { params(options: T::Hash[Symbol, T.untyped]).void }
  def initialize(options); end

  sig { params(block: T.proc.params(arg0: String).void).void }
  def monitor(&block); end

  sig { void }
  def flushdb; end

  sig { params(block: T.proc.params(arg0: Redis::PipelinedConnection).void).returns(T::Array[T.untyped]) }
  def pipelined(&block); end

  sig { params(block: T.proc.params(arg0: Redis::PipelinedConnection).void).returns(T::Array[T.untyped]) }
  def multi(&block); end

  sig { params(script: String, keys: T::Array[String], argv: T::Array[String]).returns(T.untyped) }
  def eval(script, keys: [], argv: []); end

  sig { params(script_sha: String, keys: T::Array[String], argv: T::Array[String]).returns(T.untyped) }
  def evalsha(script_sha, keys: [], argv: []); end

  sig { params(action: Symbol, script: String).returns(String) }
  def script(action, script); end

  sig { params(key: String).returns(String) }
  def get(key); end

  sig { params(keys: String).void }
  def del(*keys); end

  sig { params(keys: String).returns(T::Array[T.nilable(String)]) }
  def mget(*keys); end

  sig { params(key: String, value: T.untyped).void }
  def set(key, value); end

  sig { params(key: String, value: T.untyped).returns(T::Boolean) }
  def setnx(key, value); end

  sig { params(key_value_pairs: T.untyped).returns(T::Boolean) }
  def mset(*key_value_pairs); end

  sig { params(key_value_pairs: T.untyped).returns(T::Boolean) }
  def msetnx(*key_value_pairs); end

  sig { params(key: String).returns(Integer) }
  def incr(key); end

  sig { params(key: String, value: T.untyped).void }
  def lpush(key, value); end

  sig { params(key: String, start: Integer, stop: Integer).void }
  def lrange(key, start, stop); end

  sig { params(key: String, value: T.untyped).returns(T.untyped) }
  def sadd(key, value); end

  sig { params(key: String, value: T.untyped).returns(T::Boolean) }
  def srem(key, value); end

  sig { params(key: String, amount: Integer).returns(Integer) }
  def incrby(key, amount); end

  def xadd(key, value); end
  def xack(stream_key, group_name, *entry_ids); end
  def xgroup(*); end
  def xpending(*); end
  def xreadgroup(*); end
  def xclaim(*); end
  def xinfo(*); end
end

class Redis::PipelinedConnection
  sig { params(key: String, value: T.untyped).returns(T.untyped) }
  def sadd(key, value); end

  sig { params(key: String, amount: Integer).returns(Integer) }
  def incrby(key, amount); end

  sig { params(key: String, value: T.untyped).returns(T::Boolean) }
  def srem(key, value); end

  sig { params(keys: String).void }
  def del(*keys); end

  sig { params(key: String, start: Integer, stop: Integer).void }
  def lrange(key, start, stop); end

  def xack(stream_key, group_name, *entry_ids); end
  def xadd(key, value); end
end