client

type Aggregate string

type Booler interface {
	// ToBooler converts a redis value to a bool.
	// In case the conversion is not supported a ConversionError is returned.
	ToBool() (bool, error)
}

type Cache struct {
	// contains filtered or unexported fields
}

type Clienttype string

type ClusterCommands interface {
	ClusterAddslots(slot []int64) Result
	ClusterBumpepoch() Result
	ClusterCountFailureReports(nodeId string) Result
	ClusterCountkeysinslot(slot int64) Result
	ClusterDelslots(slot []int64) Result
	ClusterFailover(force *bool) Result
	ClusterFlushslots() Result
	ClusterForget(nodeId string) Result
	ClusterGetkeysinslot(slot, count int64) Result
	ClusterInfo() Result
	ClusterKeyslot(key string) Result
	ClusterMeet(ip string, port int64) Result
	ClusterMyid() Result
	ClusterNodes() Result
	ClusterReplicas(nodeId string) Result
	ClusterReplicate(nodeId string) Result
	ClusterReset(hard *bool) Result
	ClusterSaveconfig() Result
	ClusterSetConfigEpoch(configEpoch int64) Result
	ClusterSetslotImporting(slot int64, sourceNodeId string) Result
	ClusterSetslotMigrating(slot int64, destNodeId string) Result
	ClusterSetslotNode(slot int64, nodeId string) Result
	ClusterSetslotStable(slot int64) Result
	ClusterSlaves(nodeId string) Result
	ClusterSlots() Result
	Readonly() Result
	Readwrite() Result
}

type Commands interface {
	ClusterCommands
	ConnectionCommands
	GenericCommands
	GeoCommands
	HashCommands
	HyperloglogCommands
	ListCommands
	PubsubCommands
	ScriptingCommands
	ServerCommands
	SetCommands
	SortedSetCommands
	StreamCommands
	StringCommands
	TransactionsCommands
}

type Conn interface {
	Commands
	Pipeline() Pipeline
	Close() error
}

type ConnectionCommands interface {
	AclCat(category *string) Result
	AclDeluser(username []string) Result
	AclGenpass() Result
	AclGetuser(username string) Result
	AclHelp() Result
	AclList() Result
	AclLoad() Result
	AclSave() Result
	AclSetuser(username string, rules []string) Result
	AclUsers() Result
	AclWhoami() Result
	Auth(username *string, password string) Result
	Echo(message string) Result
	Hello(version string, userPassword *UserPassword, clientName *string) Result
	Ping(message *string) Result
	Quit() Result
	Select(index int64) Result
	Swapdb(index1, index2 int64) Result
}

type ConversionError struct {
	To    string
	Value interface{}
}

type Converter interface {
	Stringer
	Int64er
	Float64er
	Booler

	Int64Slicer
	Slicer
	Slice2er
	StringMapSlicer
	StringSlicer
	Treer
	Xranger

	StringMapper
	StringInt64Mapper
	StringStringMapper
	Xreader

	StringSetter
}

type Decoder interface {
	Decode() (interface{}, error)
}

type Dialer struct {
	net.Dialer
	// TLS
	TLSConfig *tls.Config
	// Connection logging.
	Logger *log.Logger
	// Channel size for asynchronous result reader and handler.
	ChannelSize int
	// Duration to wait for async results before timeout.
	AsyncTimeout time.Duration
	// Redis authentication.
	User, Password string
	// Redis client name.
	ClientName string
	// Client cache.
	Cache *Cache
	// Monitor callback.
	MonitorCallback MonitorCallback
	// Callback function tracing Redis commands and results on RESP3 protocol level.
	// Direction dir is true for sent bytes b (commands), false for received bytes b (results).
	TraceCallback TraceCallback
	// Command interceptor (debugging).
	SendInterceptor SendInterceptor
}

type Encoder interface {
	Encode([]interface{}) error
	Flush() error
}

type FieldValue struct {
	Field interface{}
	Value interface{}
}

type Float64er interface {
	// ToFloat64 converts a redis value to a float64.
	// In case the conversion is not supported a ConversionError is returned.
	ToFloat64() (float64, error)
}

type GenericCommands interface {
	Del(key []interface{}) Result
	Do(v ...interface{}) Result
	Dump(key interface{}) Result
	Exists(key []interface{}) Result
	Expire(key interface{}, seconds int64) Result
	Expireat(key interface{}, timestamp int64) Result
	Keys(pattern string) Result
	Migrate(host, port string, key interface{}, destinationDb, timeout int64, copy, replace bool, auth *string, keys []interface{}) Result
	Move(key interface{}, db int64) Result
	ObjectEncoding(key interface{}) Result
	ObjectFreq(key interface{}) Result
	ObjectHelp() Result
	ObjectIdletime(key interface{}) Result
	ObjectRefcount(key interface{}) Result
	PTTL(key interface{}) Result
	Persist(key interface{}) Result
	Pexpire(key interface{}, milliseconds int64) Result
	Pexpireat(key interface{}, millisecondsTimestamp int64) Result
	Randomkey() Result
	Rename(key, newkey interface{}) Result
	RenameNx(key, newkey interface{}) Result
	Restore(key interface{}, ttl int64, serializedValue string, replace, absttl bool, idletime, freq *int64) Result
	Scan(cursor int64, match *string, count *int64, typ *string) Result
	Sort(key interface{}, by *string, limit *OffsetCount, get []string, asc *bool, sorting bool, store *interface{}) Result
	TTL(key interface{}) Result
	Touch(key []interface{}) Result
	Type(key interface{}) Result
	Unlink(key []interface{}) Result
	Wait(numreplicas, timeout int64) Result
}

type GeoCommands interface {
	Geoadd(key interface{}, longitudeLatitudeMember []LongitudeLatitudeMember) Result
	Geodist(key, member1, member2 interface{}, unit *Unit) Result
	Geohash(key interface{}, member []interface{}) Result
	Geopos(key interface{}, member []interface{}) Result
	Georadius(key interface{}, longitude, latitude, radius float64, unit Unit, withcoord, withdist, withhash bool, count *int64, asc *bool, store, storedist *interface{}) Result
	Georadiusbymember(key, member interface{}, radius float64, unit Unit, withcoord, withdist, withhash bool, count *int64, asc *bool, store, storedist *interface{}) Result
}

type GroupConsumer struct {
	Group    string
	Consumer string
}

type HashCommands interface {
	Hdel(key interface{}, field []interface{}) Result
	Hexists(key, field interface{}) Result
	Hget(key, field interface{}) Result
	Hgetall(key interface{}) Result
	Hincrby(key, field interface{}, increment int64) Result
	Hincrbyfloat(key, field interface{}, increment float64) Result
	Hkeys(key interface{}) Result
	Hlen(key interface{}) Result
	Hmget(key interface{}, field []interface{}) Result
	Hscan(key interface{}, cursor int64, match *string, count *int64) Result
	Hset(key interface{}, fieldValue []FieldValue) Result
	HsetNx(key, field, value interface{}) Result
	Hstrlen(key, field interface{}) Result
	Hvals(key interface{}) Result
}

type HyperloglogCommands interface {
	Pfadd(key interface{}, element []interface{}) Result
	Pfcount(key []interface{}) Result
	Pfmerge(destkey interface{}, sourcekey []interface{}) Result
}

type IDMap struct {
	ID  string
	Map map[string]string
}

type Int64Slicer interface {
	// ToInt64Slice returns a slice with values of type int64. In case value conversion to string is not possible
	// a ConversitionError is returned.
	ToInt64Slice() ([]int64, error)
}

type Int64er interface {
	// ToInt64 converts a redis value to an int64.
	// In case the conversion is not supported a ConversionError is returned.
	ToInt64() (int64, error)
}

type InvalidBigNumberError struct {
	Value string
}

type InvalidDoubleError struct {
	Value string
}

type InvalidNumberError struct {
	Value string
}

type InvalidTypeError struct {
	Value interface{}
}

type InvalidValueError struct {
	Name  string
	Value interface{}
}

type Key string

type KeyValue struct {
	Key   interface{}
	Value interface{}
}

type ListCommands interface {
	Blpop(key []interface{}, timeout int64) Result
	Brpop(key []interface{}, timeout int64) Result
	Brpoplpush(source, destination interface{}, timeout int64) Result
	Lindex(key interface{}, index int64) Result
	Linsert(key interface{}, before bool, pivot, element interface{}) Result
	Llen(key interface{}) Result
	Lpop(key interface{}) Result
	Lpush(key interface{}, element []interface{}) Result
	Lpushx(key interface{}, element []interface{}) Result
	Lrange(key interface{}, start, stop int64) Result
	Lrem(key interface{}, count int64, element interface{}) Result
	Lset(key interface{}, index int64, element interface{}) Result
	Ltrim(key interface{}, start, stop int64) Result
	Rpop(key interface{}) Result
	Rpoplpush(source, destination interface{}) Result
	Rpush(key interface{}, element []interface{}) Result
	Rpushx(key interface{}, element []interface{}) Result
}

type LongitudeLatitudeMember struct {
	Longitude float64
	Latitude  float64
	Member    interface{}
}

type Map []MapItem

type MapItem struct {
	Key   RedisValue
	Value RedisValue
}

type Mode string

type MonitorCallback func(time time.Time, db int64, addr string, cmds []string)

type MsgCallback func(pattern, channel, msg string)

type OffsetCount struct {
	Offset int64
	Count  int64
}

type Overflow string

type Pipeline interface {
	Commands
	Reset()
	Flush() error
}

type PubsubCommands interface {
	Psubscribe(pattern []string, cb MsgCallback) Result
	Publish(channel, message string) Result
	PubsubChannels(pattern *string) Result
	PubsubNumpat() Result
	PubsubNumsub(channel []string) Result
	Punsubscribe(pattern []string) Result
	Subscribe(channel []string, cb MsgCallback) Result
	Unsubscribe(channel []string) Result
}

type RedisError struct {
	Code string
	Msg  string
}

type RedisKind byte

type RedisValue interface {
	Kind() RedisKind
	Attr() *Map
	Converter
}

type ReplyMode string

type Result interface {
	// Attr returns the attribute of a Redis value if provided - <nil> otherwise.
	Attr() (*Map, error)
	// Err returns any of the following errors:
	// - <nil>: result received successfully.
	// - ErrNotFlushed: result not received yet (pipeline not flushed).
	// - ErrTimeout: timeout reached before result is available.
	// - RedisError: redis error message if a redis command was executed unsuccessfully.
	Err() error
	// IsNull returns <true> if the redis value is null.
	IsNull() (bool, error)
	// Kind returns the type of a Redis value.
	Kind() (RedisKind, error)
	// Value returns a Redis value.
	Value() (RedisValue, error)
	// VerbatimString returns a VerbatimString if the Redis type is a verbatim string.
	VerbatimString() (VerbatimString, error)
	// Map returns a Map if the Redis type is a map.
	Map() (Map, error)
	// Set returns a Set if the Redis type is a set.
	Set() (Set, error)
	// Slice returns a Slice if the Redis type is an array.
	Slice() (Slice, error)

	// Conversion methods.
	Converter
}

type ScoreMember struct {
	Score  float64
	Member interface{}
}

type ScriptingCommands interface {
	Eval(script string, numkeys int64, key, arg []interface{}) Result
	Evalsha(sha1 string, numkeys int64, key, arg []interface{}) Result
	ScriptDebug(mode Mode) Result
	ScriptExists(sha1 []string) Result
	ScriptFlush() Result
	ScriptKill() Result
	ScriptLoad(script string) Result
}

type SendInterceptor func(name string, values []interface{})

type ServerCommands interface {
	Bgrewriteaof() Result
	Bgsave() Result
	ClientGetname() Result
	ClientId() Result
	ClientKill(id *int64, typ *Clienttype, addr *string, skipme bool) Result
	ClientList(typ *Clienttype) Result
	ClientPause(timeout int64) Result
	ClientReply(replyMode ReplyMode) Result
	ClientSetname(connectionName string) Result
	ClientTracking(on bool, redirect *int64) Result
	ClientUnblock(clientId int64, timeout *bool) Result
	Command() Result
	CommandCount() Result
	CommandGetkeys(arg []interface{}) Result
	CommandInfo(commandName []string) Result
	ConfigGet(parameter string) Result
	ConfigResetstat() Result
	ConfigRewrite() Result
	ConfigSet(parameter, value string) Result
	Dbsize() Result
	DebugObject(key interface{}) Result
	DebugSegfault() Result
	Flushall(async bool) Result
	Flushdb(async bool) Result
	Info(section *string) Result
	Lastsave() Result
	LatencyDoctor() Result
	LatencyGraph(event string) Result
	LatencyHelp() Result
	LatencyHistory(event string) Result
	LatencyLatest() Result
	LatencyReset(event *string) Result
	Lolwut(version *int64) Result
	MemoryDoctor() Result
	MemoryHelp() Result
	MemoryMallocStats() Result
	MemoryPurge() Result
	MemoryStats() Result
	MemoryUsage(key interface{}, samples *int64) Result
	ModuleList() Result
	ModuleLoad(path string, arg []string) Result
	ModuleUnload(name string) Result
	Monitor() Result
	Psync(replicationid, offset int64) Result
	Replicaof(host, port string) Result
	Role() Result
	Save() Result
	Shutdown(nosave *bool) Result
	SlowlogGet(count *int64) Result
	SlowlogLen() Result
	SlowlogReset() Result
	Time() Result
}

type Set []RedisValue

type SetCommands interface {
	Sadd(key interface{}, member []interface{}) Result
	Scard(key interface{}) Result
	Sdiff(key []interface{}) Result
	Sdiffstore(destination interface{}, key []interface{}) Result
	Sinter(key []interface{}) Result
	Sinterstore(destination interface{}, key []interface{}) Result
	Sismember(key, member interface{}) Result
	Smembers(key interface{}) Result
	Smove(source, destination, member interface{}) Result
	Spop(key interface{}, count *int64) Result
	Srandmember(key interface{}, count *int64) Result
	Srem(key interface{}, member []interface{}) Result
	Sscan(key interface{}, cursor int64, match *string, count *int64) Result
	Sunion(key []interface{}) Result
	Sunionstore(destination interface{}, key []interface{}) Result
}

type Slice []RedisValue

type Slice2er interface {
	// ToSlice2 returns a slice with values of type []interface{}. In case value conversion to []interface{} is not possible
	// a ConversitionError is returned.
	ToSlice2() ([][]interface{}, error)
}

type Slicer interface {
	// ToSlice returns a slice with values of type interface{}.
	ToSlice() ([]interface{}, error)
}

type SortedSetCommands interface {
	Bzpopmax(key []interface{}, timeout int64) Result
	Bzpopmin(key []interface{}, timeout int64) Result
	Zadd(key interface{}, scoreMember []ScoreMember) Result
	ZaddCh(key interface{}, scoreMember []ScoreMember) Result
	ZaddNx(key interface{}, scoreMember []ScoreMember) Result
	ZaddXx(key interface{}, scoreMember []ScoreMember) Result
	ZaddXxCh(key interface{}, scoreMember []ScoreMember) Result
	Zcard(key interface{}) Result
	Zcount(key interface{}, min, max Zfloat64) Result
	Zincrby(key interface{}, increment float64, member interface{}) Result
	Zinterstore(destination interface{}, numkeys int64, key []interface{}, weights []int64, aggregate *Aggregate) Result
	Zlexcount(key interface{}, min, max string) Result
	Zpopmax(key interface{}, count *int64) Result
	Zpopmin(key interface{}, count *int64) Result
	Zrange(key interface{}, start, stop int64, withscores bool) Result
	Zrangebylex(key interface{}, min, max string, limit *OffsetCount) Result
	Zrangebyscore(key interface{}, min, max Zfloat64, withscores bool, limit *OffsetCount) Result
	Zrank(key, member interface{}) Result
	Zrem(key interface{}, member []interface{}) Result
	Zremrangebylex(key interface{}, min, max string) Result
	Zremrangebyrank(key interface{}, start, stop int64) Result
	Zremrangebyscore(key interface{}, min, max Zfloat64) Result
	Zrevrange(key interface{}, start, stop int64, withscores bool) Result
	Zrevrangebylex(key interface{}, max, min string, limit *OffsetCount) Result
	Zrevrangebyscore(key interface{}, max, min Zfloat64, withscores bool, limit *OffsetCount) Result
	Zrevrank(key, member interface{}) Result
	Zscan(key interface{}, cursor int64, match *string, count *int64) Result
	Zscore(key, member interface{}) Result
	Zunionstore(destination interface{}, numkeys int64, key []interface{}, weights []int64, aggregate *Aggregate) Result
}

type StartEnd struct {
	Start int64
	End   int64
}

type StartEndCount struct {
	Start string
	End   string
	Count int64
}

type StreamCommands interface {
	Xack(key interface{}, group string, id []string) Result
	Xadd(key interface{}, id string, fieldValue []FieldValue) Result
	Xclaim(key interface{}, group, consumer, minIdleTime string, id []string, idle, time, retrycount *int64, force, justid bool) Result
	Xdel(key interface{}, id []string) Result
	XgroupCreate(key interface{}, groupname, id string, mkstream bool) Result
	XgroupDelconsumer(key interface{}, groupname, consumername string) Result
	XgroupDestroy(key interface{}, groupname string) Result
	XgroupHelp() Result
	XgroupSetid(key interface{}, groupname, id string) Result
	XinfoConsumers(key interface{}, groupname string) Result
	XinfoGroups(key interface{}) Result
	XinfoHelp() Result
	XinfoStream(key interface{}) Result
	Xlen(key interface{}) Result
	Xpending(key interface{}, group string, startEndCount *StartEndCount, consumer *string) Result
	Xrange(key interface{}, start, end string, count *int64) Result
	Xread(count, block *int64, key []interface{}, id []string) Result
	Xreadgroup(group GroupConsumer, count, block *int64, noack bool, key []interface{}, id []string) Result
	Xrevrange(key interface{}, end, start string, count *int64) Result
	Xtrim(key interface{}, approx bool, count int64) Result
}

type StringCommands interface {
	Append(key, value interface{}) Result
	Bitcount(key interface{}, startEnd *StartEnd) Result
	Bitfield(key interface{}, operation []interface{}) Result
	BitopAnd(destkey interface{}, srckey []interface{}) Result
	BitopNot(destkey, srckey interface{}) Result
	BitopOr(destkey interface{}, srckey []interface{}) Result
	BitopXor(destkey interface{}, srckey []interface{}) Result
	Bitpos(key interface{}, bit int64, start, end *int64) Result
	Decr(key interface{}) Result
	Decrby(key interface{}, decrement int64) Result
	Get(key interface{}) Result
	Getbit(key interface{}, offset int64) Result
	Getrange(key interface{}, start, end int64) Result
	Getset(key, value interface{}) Result
	Incr(key interface{}) Result
	Incrby(key interface{}, increment int64) Result
	Incrbyfloat(key interface{}, increment float64) Result
	Mget(key []interface{}) Result
	Mset(keyValue []KeyValue) Result
	MsetNx(keyValue []KeyValue) Result
	Set(key, value interface{}) Result
	SetEx(key, value interface{}, seconds int64) Result
	SetExNx(key, value interface{}, seconds int64) Result
	SetExXx(key, value interface{}, seconds int64) Result
	SetNx(key, value interface{}) Result
	SetPx(key, value interface{}, milliseconds int64) Result
	SetPxNx(key, value interface{}, milliseconds int64) Result
	SetPxXx(key, value interface{}, milliseconds int64) Result
	SetXx(key, value interface{}) Result
	Setbit(key interface{}, offset, value int64) Result
	Setrange(key interface{}, offset int64, value interface{}) Result
	Strlen(key interface{}) Result
}

type StringInt64Mapper interface {
	// ToStringInt64Map returns a map with keys of type string and values of type int64. In case key or value conversion is not possible
	// a ConvertionError is returned.
	ToStringInt64Map() (map[string]int64, error)
}

type StringMapSlicer interface {
	// ToStringMapSlice returns a slice with values of type map[string]interfcae{}. In case value conversion to map[string]interface{} is not possible
	// a ConversitionError is returned.
	ToStringMapSlice() ([]map[string]interface{}, error)
}

type StringMapper interface {
	// ToStringMap returns a map with keys of type string. In case key conversion to string is not possible
	// a ConvertionError is returned.
	ToStringMap() (map[string]interface{}, error)
}

type StringSetter interface {
	// ToStringSet returns a map with keys of type string and boolean true values. In case key conversion to string is not possible
	// a ConvertionError is returned.
	ToStringSet() (map[string]bool, error)
}

type StringSlicer interface {
	// ToStringSlice returns a slice with values of type string. In case value conversion to string is not possible
	// a ConversitionError is returned.
	ToStringSlice() ([]string, error)
}

type StringStringMapper interface {
	// ToStringStringMap returns a map with keys and values of type string. In case key or value conversion to string is not possible
	// a ConvertionError is returned.
	ToStringStringMap() (map[string]string, error)
}

type Stringer interface {
	// ToString converts a redis value to a string.
	// In case the conversion is not supported a ConversionError is returned.
	ToString() (string, error)
}

type TraceCallback func(dir bool, b []byte)

type TransactionsCommands interface {
	Discard() Result
	Exec() Result
	Multi() Result
	Unwatch() Result
	Watch(key []interface{}) Result
}

type Treer interface {
	// ToTree returns a tree with nodes of type []interface{} and leaves of type interface{}. In case value conversion to []interface{} is not possible
	// a ConversitionError is returned.
	ToTree() ([]interface{}, error)
}

type TypeOffset struct {
	Type   string
	Offset int64
}

type TypeOffsetIncrement struct {
	Type      string
	Offset    int64
	Increment int64
}

type TypeOffsetValue struct {
	Type   string
	Offset int64
	Value  int64
}

type UnexpectedCharacterError struct {
	ActChar byte
	ExpChar byte
}

type Unit string

type UserPassword struct {
	User     string
	Password string
}

type VerbatimString string

type Xranger interface {
	// ToXrange returns a slice with values of type IdMap. In case the conversion is not possible
	// a ConversitionError is returned.
	ToXrange() ([]IDMap, error)
}

type Xreader interface {
	// ToXread returns a map[string] with values of type IdMap. In case the conversion is not possible
	// a ConversitionError is returned.
	ToXread() (map[string][]IDMap, error)
}

type Zclose float64

type Zfloat64 interface {
	String() string
	// contains filtered or unexported methods
}

type Zopen float64