diff --git a/go.mod b/go.mod index 3302796..5857187 100644 --- a/go.mod +++ b/go.mod @@ -44,7 +44,7 @@ require ( github.com/bitly/go-simplejson v0.5.0 // indirect github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869 // indirect github.com/certifi/gocertifi v0.0.0-20170727155124-3fd9e1adb12b // indirect - github.com/cespare/xxhash/v2 v2.1.2 // indirect + github.com/cespare/xxhash/v2 v2.2.0 // indirect github.com/customerio/gospec v0.0.0-20130710230057-a5cc0e48aa39 // indirect github.com/davecgh/go-spew v1.1.1 // indirect github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect @@ -54,6 +54,8 @@ require ( github.com/fsnotify/fsnotify v1.5.4 // indirect github.com/garyburd/redigo v1.6.0 // indirect github.com/go-ini/ini v1.35.0 // indirect + github.com/go-logr/logr v1.4.1 // indirect + github.com/go-logr/stdr v1.2.2 // indirect github.com/go-sql-driver/mysql v1.5.0 // indirect github.com/golang/protobuf v1.5.2 // indirect github.com/golang/snappy v0.0.4 // indirect @@ -88,6 +90,9 @@ require ( github.com/pkg/errors v0.9.1 // indirect github.com/poy/onpar v1.0.1 // indirect github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 // indirect + github.com/redis/go-redis/extra/rediscmd/v9 v9.7.0 // indirect + github.com/redis/go-redis/extra/redisotel/v9 v9.7.0 // indirect + github.com/redis/go-redis/v9 v9.7.0 // indirect github.com/smartystreets/goconvey v1.6.4 // indirect github.com/spf13/afero v1.8.2 // indirect github.com/spf13/cast v1.5.0 // indirect @@ -98,10 +103,13 @@ require ( github.com/valyala/bytebufferpool v1.0.0 // indirect github.com/valyala/fasttemplate v0.0.0-20170224212429-dcecefd839c4 // indirect github.com/ziutek/mymysql v1.5.4 // indirect + go.opentelemetry.io/otel v1.22.0 // indirect + go.opentelemetry.io/otel/metric v1.22.0 // indirect + go.opentelemetry.io/otel/trace v1.22.0 // indirect go.uber.org/atomic v1.7.0 // indirect golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa // indirect golang.org/x/net v0.0.0-20220927171203-f486391704dc // indirect - golang.org/x/sys v0.0.0-20220909162455-aba9fc2a8ff2 // indirect + golang.org/x/sys v0.16.0 // indirect golang.org/x/text v0.3.7 // indirect google.golang.org/appengine v1.6.7 // indirect google.golang.org/genproto v0.0.0-20220519153652-3a47de7e79bd // indirect diff --git a/go.sum b/go.sum index a02c246..36156d4 100644 --- a/go.sum +++ b/go.sum @@ -112,6 +112,8 @@ github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghf github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE= github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44= +github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= @@ -200,6 +202,11 @@ github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A= github.com/go-logfmt/logfmt v0.5.1/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs= +github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ= +github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/go-pg/pg v6.15.1+incompatible h1:vO4P9WoCi+i4qomgcBXWlKgDk4GcHAqDAOIfkEpi7B4= github.com/go-pg/pg v6.15.1+incompatible/go.mod h1:a2oXow+aFOrvwcKs3eIA0lNFmMilrxK2sOkB5NWe0vA= github.com/go-redis/redis v6.13.2+incompatible h1:kfEWSpgBs4XmuzGg7nYPqhQejjzU9eKdIL0PmE2TtRY= @@ -528,6 +535,12 @@ github.com/prometheus/procfs v0.8.0/go.mod h1:z7EfXMXOkbkqb9IINtpCn86r/to3BnA0ua github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU= github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 h1:N/ElC8H3+5XpJzTSTfLsJV/mx9Q9g7kxmchpfZyxgzM= github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= +github.com/redis/go-redis/extra/rediscmd/v9 v9.7.0 h1:BIx9TNZH/Jsr4l1i7VVxnV0JPiwYj8qyrHyuL0fGZrk= +github.com/redis/go-redis/extra/rediscmd/v9 v9.7.0/go.mod h1:eTg/YQtGYAZD5r3DlGlJptJ45AHA+/G+2NPn30PKzik= +github.com/redis/go-redis/extra/redisotel/v9 v9.7.0 h1:bQk8xiVFw+3ln4pfELVktpWgYdFpgLLU+quwSoeIof0= +github.com/redis/go-redis/extra/redisotel/v9 v9.7.0/go.mod h1:0LyN+GHLIJmKtjYRPF7nHyTTMV6E91YngoOopNifQRo= +github.com/redis/go-redis/v9 v9.7.0 h1:HhLSs+B6O021gwzl+locl0zEDnyNkxMtf/Z3NNBMa9E= +github.com/redis/go-redis/v9 v9.7.0/go.mod h1:f6zhXITC7JUJIlPEiBOTXxJgPLdZcA93GewI7inzyWw= github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg= github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= @@ -621,6 +634,12 @@ go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk= go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E= +go.opentelemetry.io/otel v1.22.0 h1:xS7Ku+7yTFvDfDraDIJVpw7XPyuHlB9MCiqqX5mcJ6Y= +go.opentelemetry.io/otel v1.22.0/go.mod h1:eoV4iAi3Ea8LkAEI9+GFT44O6T/D0GWAVFyZVCC6pMI= +go.opentelemetry.io/otel/metric v1.22.0 h1:lypMQnGyJYeuYPhOM/bgjbFM6WE44W1/T45er4d8Hhg= +go.opentelemetry.io/otel/metric v1.22.0/go.mod h1:evJGjVpZv0mQ5QBRJoBF64yMuOf4xCWdXjK8pzFvliY= +go.opentelemetry.io/otel/trace v1.22.0 h1:Hg6pPujv0XG9QaVbGOBVHunyuLcCC3jN7WEhPx83XD0= +go.opentelemetry.io/otel/trace v1.22.0/go.mod h1:RbbHXVqKES9QhzZq/fE5UnOSILqRt40a21sPw2He1xo= go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw= @@ -863,6 +882,7 @@ golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220909162455-aba9fc2a8ff2 h1:wM1k/lXfpc5HdkJJyW9GELpd8ERGdnh8sMGL6Gzq3Ho= golang.org/x/sys v0.0.0-20220909162455-aba9fc2a8ff2/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/term v0.0.0-20220526004731-065cf7ba2467/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= diff --git a/redis/cluster/mocks/pipeliner.go b/redis/cluster/mocks/pipeliner.go new file mode 100644 index 0000000..0980e06 --- /dev/null +++ b/redis/cluster/mocks/pipeliner.go @@ -0,0 +1,7887 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: redis/experimental/interfaces/pipeliner.go + +// Package mocks is a generated GoMock package. +package mocks + +import ( + context "context" + reflect "reflect" + time "time" + + gomock "github.com/golang/mock/gomock" + redis "github.com/redis/go-redis/v9" +) + +// MockPipeliner is a mock of Pipeliner interface. +type MockPipeliner struct { + ctrl *gomock.Controller + recorder *MockPipelinerMockRecorder +} + +// MockPipelinerMockRecorder is the mock recorder for MockPipeliner. +type MockPipelinerMockRecorder struct { + mock *MockPipeliner +} + +// NewMockPipeliner creates a new mock instance. +func NewMockPipeliner(ctrl *gomock.Controller) *MockPipeliner { + mock := &MockPipeliner{ctrl: ctrl} + mock.recorder = &MockPipelinerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockPipeliner) EXPECT() *MockPipelinerMockRecorder { + return m.recorder +} + +// ACLDryRun mocks base method. +func (m *MockPipeliner) ACLDryRun(ctx context.Context, username string, command ...interface{}) *redis.StringCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, username} + for _, a := range command { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ACLDryRun", varargs...) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ACLDryRun indicates an expected call of ACLDryRun. +func (mr *MockPipelinerMockRecorder) ACLDryRun(ctx, username interface{}, command ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, username}, command...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLDryRun", reflect.TypeOf((*MockPipeliner)(nil).ACLDryRun), varargs...) +} + +// ACLLog mocks base method. +func (m *MockPipeliner) ACLLog(ctx context.Context, count int64) *redis.ACLLogCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ACLLog", ctx, count) + ret0, _ := ret[0].(*redis.ACLLogCmd) + return ret0 +} + +// ACLLog indicates an expected call of ACLLog. +func (mr *MockPipelinerMockRecorder) ACLLog(ctx, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLog", reflect.TypeOf((*MockPipeliner)(nil).ACLLog), ctx, count) +} + +// ACLLogReset mocks base method. +func (m *MockPipeliner) ACLLogReset(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ACLLogReset", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ACLLogReset indicates an expected call of ACLLogReset. +func (mr *MockPipelinerMockRecorder) ACLLogReset(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLogReset", reflect.TypeOf((*MockPipeliner)(nil).ACLLogReset), ctx) +} + +// Append mocks base method. +func (m *MockPipeliner) Append(ctx context.Context, key, value string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Append", ctx, key, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Append indicates an expected call of Append. +func (mr *MockPipelinerMockRecorder) Append(ctx, key, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Append", reflect.TypeOf((*MockPipeliner)(nil).Append), ctx, key, value) +} + +// Auth mocks base method. +func (m *MockPipeliner) Auth(ctx context.Context, password string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Auth", ctx, password) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Auth indicates an expected call of Auth. +func (mr *MockPipelinerMockRecorder) Auth(ctx, password interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Auth", reflect.TypeOf((*MockPipeliner)(nil).Auth), ctx, password) +} + +// AuthACL mocks base method. +func (m *MockPipeliner) AuthACL(ctx context.Context, username, password string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AuthACL", ctx, username, password) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// AuthACL indicates an expected call of AuthACL. +func (mr *MockPipelinerMockRecorder) AuthACL(ctx, username, password interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthACL", reflect.TypeOf((*MockPipeliner)(nil).AuthACL), ctx, username, password) +} + +// BFAdd mocks base method. +func (m *MockPipeliner) BFAdd(ctx context.Context, key string, element interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFAdd", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// BFAdd indicates an expected call of BFAdd. +func (mr *MockPipelinerMockRecorder) BFAdd(ctx, key, element interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFAdd", reflect.TypeOf((*MockPipeliner)(nil).BFAdd), ctx, key, element) +} + +// BFCard mocks base method. +func (m *MockPipeliner) BFCard(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFCard", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BFCard indicates an expected call of BFCard. +func (mr *MockPipelinerMockRecorder) BFCard(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFCard", reflect.TypeOf((*MockPipeliner)(nil).BFCard), ctx, key) +} + +// BFExists mocks base method. +func (m *MockPipeliner) BFExists(ctx context.Context, key string, element interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFExists", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// BFExists indicates an expected call of BFExists. +func (mr *MockPipelinerMockRecorder) BFExists(ctx, key, element interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFExists", reflect.TypeOf((*MockPipeliner)(nil).BFExists), ctx, key, element) +} + +// BFInfo mocks base method. +func (m *MockPipeliner) BFInfo(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfo", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfo indicates an expected call of BFInfo. +func (mr *MockPipelinerMockRecorder) BFInfo(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfo", reflect.TypeOf((*MockPipeliner)(nil).BFInfo), ctx, key) +} + +// BFInfoArg mocks base method. +func (m *MockPipeliner) BFInfoArg(ctx context.Context, key, option string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoArg", ctx, key, option) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoArg indicates an expected call of BFInfoArg. +func (mr *MockPipelinerMockRecorder) BFInfoArg(ctx, key, option interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoArg", reflect.TypeOf((*MockPipeliner)(nil).BFInfoArg), ctx, key, option) +} + +// BFInfoCapacity mocks base method. +func (m *MockPipeliner) BFInfoCapacity(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoCapacity", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoCapacity indicates an expected call of BFInfoCapacity. +func (mr *MockPipelinerMockRecorder) BFInfoCapacity(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoCapacity", reflect.TypeOf((*MockPipeliner)(nil).BFInfoCapacity), ctx, key) +} + +// BFInfoExpansion mocks base method. +func (m *MockPipeliner) BFInfoExpansion(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoExpansion", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoExpansion indicates an expected call of BFInfoExpansion. +func (mr *MockPipelinerMockRecorder) BFInfoExpansion(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoExpansion", reflect.TypeOf((*MockPipeliner)(nil).BFInfoExpansion), ctx, key) +} + +// BFInfoFilters mocks base method. +func (m *MockPipeliner) BFInfoFilters(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoFilters", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoFilters indicates an expected call of BFInfoFilters. +func (mr *MockPipelinerMockRecorder) BFInfoFilters(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoFilters", reflect.TypeOf((*MockPipeliner)(nil).BFInfoFilters), ctx, key) +} + +// BFInfoItems mocks base method. +func (m *MockPipeliner) BFInfoItems(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoItems", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoItems indicates an expected call of BFInfoItems. +func (mr *MockPipelinerMockRecorder) BFInfoItems(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoItems", reflect.TypeOf((*MockPipeliner)(nil).BFInfoItems), ctx, key) +} + +// BFInfoSize mocks base method. +func (m *MockPipeliner) BFInfoSize(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoSize", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoSize indicates an expected call of BFInfoSize. +func (mr *MockPipelinerMockRecorder) BFInfoSize(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoSize", reflect.TypeOf((*MockPipeliner)(nil).BFInfoSize), ctx, key) +} + +// BFInsert mocks base method. +func (m *MockPipeliner) BFInsert(ctx context.Context, key string, options *redis.BFInsertOptions, elements ...interface{}) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, options} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BFInsert", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// BFInsert indicates an expected call of BFInsert. +func (mr *MockPipelinerMockRecorder) BFInsert(ctx, key, options interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, options}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInsert", reflect.TypeOf((*MockPipeliner)(nil).BFInsert), varargs...) +} + +// BFLoadChunk mocks base method. +func (m *MockPipeliner) BFLoadChunk(ctx context.Context, key string, iterator int64, data interface{}) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFLoadChunk", ctx, key, iterator, data) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFLoadChunk indicates an expected call of BFLoadChunk. +func (mr *MockPipelinerMockRecorder) BFLoadChunk(ctx, key, iterator, data interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFLoadChunk", reflect.TypeOf((*MockPipeliner)(nil).BFLoadChunk), ctx, key, iterator, data) +} + +// BFMAdd mocks base method. +func (m *MockPipeliner) BFMAdd(ctx context.Context, key string, elements ...interface{}) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BFMAdd", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// BFMAdd indicates an expected call of BFMAdd. +func (mr *MockPipelinerMockRecorder) BFMAdd(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFMAdd", reflect.TypeOf((*MockPipeliner)(nil).BFMAdd), varargs...) +} + +// BFMExists mocks base method. +func (m *MockPipeliner) BFMExists(ctx context.Context, key string, elements ...interface{}) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BFMExists", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// BFMExists indicates an expected call of BFMExists. +func (mr *MockPipelinerMockRecorder) BFMExists(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFMExists", reflect.TypeOf((*MockPipeliner)(nil).BFMExists), varargs...) +} + +// BFReserve mocks base method. +func (m *MockPipeliner) BFReserve(ctx context.Context, key string, errorRate float64, capacity int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserve", ctx, key, errorRate, capacity) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserve indicates an expected call of BFReserve. +func (mr *MockPipelinerMockRecorder) BFReserve(ctx, key, errorRate, capacity interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserve", reflect.TypeOf((*MockPipeliner)(nil).BFReserve), ctx, key, errorRate, capacity) +} + +// BFReserveExpansion mocks base method. +func (m *MockPipeliner) BFReserveExpansion(ctx context.Context, key string, errorRate float64, capacity, expansion int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserveExpansion", ctx, key, errorRate, capacity, expansion) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserveExpansion indicates an expected call of BFReserveExpansion. +func (mr *MockPipelinerMockRecorder) BFReserveExpansion(ctx, key, errorRate, capacity, expansion interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveExpansion", reflect.TypeOf((*MockPipeliner)(nil).BFReserveExpansion), ctx, key, errorRate, capacity, expansion) +} + +// BFReserveNonScaling mocks base method. +func (m *MockPipeliner) BFReserveNonScaling(ctx context.Context, key string, errorRate float64, capacity int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserveNonScaling", ctx, key, errorRate, capacity) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserveNonScaling indicates an expected call of BFReserveNonScaling. +func (mr *MockPipelinerMockRecorder) BFReserveNonScaling(ctx, key, errorRate, capacity interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveNonScaling", reflect.TypeOf((*MockPipeliner)(nil).BFReserveNonScaling), ctx, key, errorRate, capacity) +} + +// BFReserveWithArgs mocks base method. +func (m *MockPipeliner) BFReserveWithArgs(ctx context.Context, key string, options *redis.BFReserveOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserveWithArgs", ctx, key, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserveWithArgs indicates an expected call of BFReserveWithArgs. +func (mr *MockPipelinerMockRecorder) BFReserveWithArgs(ctx, key, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveWithArgs", reflect.TypeOf((*MockPipeliner)(nil).BFReserveWithArgs), ctx, key, options) +} + +// BFScanDump mocks base method. +func (m *MockPipeliner) BFScanDump(ctx context.Context, key string, iterator int64) *redis.ScanDumpCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFScanDump", ctx, key, iterator) + ret0, _ := ret[0].(*redis.ScanDumpCmd) + return ret0 +} + +// BFScanDump indicates an expected call of BFScanDump. +func (mr *MockPipelinerMockRecorder) BFScanDump(ctx, key, iterator interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFScanDump", reflect.TypeOf((*MockPipeliner)(nil).BFScanDump), ctx, key, iterator) +} + +// BLMPop mocks base method. +func (m *MockPipeliner) BLMPop(ctx context.Context, timeout time.Duration, direction string, count int64, keys ...string) *redis.KeyValuesCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, timeout, direction, count} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BLMPop", varargs...) + ret0, _ := ret[0].(*redis.KeyValuesCmd) + return ret0 +} + +// BLMPop indicates an expected call of BLMPop. +func (mr *MockPipelinerMockRecorder) BLMPop(ctx, timeout, direction, count interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, timeout, direction, count}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLMPop", reflect.TypeOf((*MockPipeliner)(nil).BLMPop), varargs...) +} + +// BLMove mocks base method. +func (m *MockPipeliner) BLMove(ctx context.Context, source, destination, srcpos, destpos string, timeout time.Duration) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BLMove", ctx, source, destination, srcpos, destpos, timeout) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// BLMove indicates an expected call of BLMove. +func (mr *MockPipelinerMockRecorder) BLMove(ctx, source, destination, srcpos, destpos, timeout interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLMove", reflect.TypeOf((*MockPipeliner)(nil).BLMove), ctx, source, destination, srcpos, destpos, timeout) +} + +// BLPop mocks base method. +func (m *MockPipeliner) BLPop(ctx context.Context, timeout time.Duration, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, timeout} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BLPop", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// BLPop indicates an expected call of BLPop. +func (mr *MockPipelinerMockRecorder) BLPop(ctx, timeout interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, timeout}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLPop", reflect.TypeOf((*MockPipeliner)(nil).BLPop), varargs...) +} + +// BRPop mocks base method. +func (m *MockPipeliner) BRPop(ctx context.Context, timeout time.Duration, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, timeout} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BRPop", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// BRPop indicates an expected call of BRPop. +func (mr *MockPipelinerMockRecorder) BRPop(ctx, timeout interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, timeout}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BRPop", reflect.TypeOf((*MockPipeliner)(nil).BRPop), varargs...) +} + +// BRPopLPush mocks base method. +func (m *MockPipeliner) BRPopLPush(ctx context.Context, source, destination string, timeout time.Duration) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BRPopLPush", ctx, source, destination, timeout) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// BRPopLPush indicates an expected call of BRPopLPush. +func (mr *MockPipelinerMockRecorder) BRPopLPush(ctx, source, destination, timeout interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BRPopLPush", reflect.TypeOf((*MockPipeliner)(nil).BRPopLPush), ctx, source, destination, timeout) +} + +// BZMPop mocks base method. +func (m *MockPipeliner) BZMPop(ctx context.Context, timeout time.Duration, order string, count int64, keys ...string) *redis.ZSliceWithKeyCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, timeout, order, count} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BZMPop", varargs...) + ret0, _ := ret[0].(*redis.ZSliceWithKeyCmd) + return ret0 +} + +// BZMPop indicates an expected call of BZMPop. +func (mr *MockPipelinerMockRecorder) BZMPop(ctx, timeout, order, count interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, timeout, order, count}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZMPop", reflect.TypeOf((*MockPipeliner)(nil).BZMPop), varargs...) +} + +// BZPopMax mocks base method. +func (m *MockPipeliner) BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) *redis.ZWithKeyCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, timeout} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BZPopMax", varargs...) + ret0, _ := ret[0].(*redis.ZWithKeyCmd) + return ret0 +} + +// BZPopMax indicates an expected call of BZPopMax. +func (mr *MockPipelinerMockRecorder) BZPopMax(ctx, timeout interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, timeout}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZPopMax", reflect.TypeOf((*MockPipeliner)(nil).BZPopMax), varargs...) +} + +// BZPopMin mocks base method. +func (m *MockPipeliner) BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) *redis.ZWithKeyCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, timeout} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BZPopMin", varargs...) + ret0, _ := ret[0].(*redis.ZWithKeyCmd) + return ret0 +} + +// BZPopMin indicates an expected call of BZPopMin. +func (mr *MockPipelinerMockRecorder) BZPopMin(ctx, timeout interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, timeout}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZPopMin", reflect.TypeOf((*MockPipeliner)(nil).BZPopMin), varargs...) +} + +// BgRewriteAOF mocks base method. +func (m *MockPipeliner) BgRewriteAOF(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BgRewriteAOF", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BgRewriteAOF indicates an expected call of BgRewriteAOF. +func (mr *MockPipelinerMockRecorder) BgRewriteAOF(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BgRewriteAOF", reflect.TypeOf((*MockPipeliner)(nil).BgRewriteAOF), ctx) +} + +// BgSave mocks base method. +func (m *MockPipeliner) BgSave(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BgSave", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BgSave indicates an expected call of BgSave. +func (mr *MockPipelinerMockRecorder) BgSave(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BgSave", reflect.TypeOf((*MockPipeliner)(nil).BgSave), ctx) +} + +// BitCount mocks base method. +func (m *MockPipeliner) BitCount(ctx context.Context, key string, bitCount *redis.BitCount) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BitCount", ctx, key, bitCount) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitCount indicates an expected call of BitCount. +func (mr *MockPipelinerMockRecorder) BitCount(ctx, key, bitCount interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitCount", reflect.TypeOf((*MockPipeliner)(nil).BitCount), ctx, key, bitCount) +} + +// BitField mocks base method. +func (m *MockPipeliner) BitField(ctx context.Context, key string, values ...interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitField", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// BitField indicates an expected call of BitField. +func (mr *MockPipelinerMockRecorder) BitField(ctx, key interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitField", reflect.TypeOf((*MockPipeliner)(nil).BitField), varargs...) +} + +// BitFieldRO mocks base method. +func (m *MockPipeliner) BitFieldRO(ctx context.Context, key string, values ...interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitFieldRO", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// BitFieldRO indicates an expected call of BitFieldRO. +func (mr *MockPipelinerMockRecorder) BitFieldRO(ctx, key interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitFieldRO", reflect.TypeOf((*MockPipeliner)(nil).BitFieldRO), varargs...) +} + +// BitOpAnd mocks base method. +func (m *MockPipeliner) BitOpAnd(ctx context.Context, destKey string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, destKey} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitOpAnd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitOpAnd indicates an expected call of BitOpAnd. +func (mr *MockPipelinerMockRecorder) BitOpAnd(ctx, destKey interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, destKey}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpAnd", reflect.TypeOf((*MockPipeliner)(nil).BitOpAnd), varargs...) +} + +// BitOpNot mocks base method. +func (m *MockPipeliner) BitOpNot(ctx context.Context, destKey, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BitOpNot", ctx, destKey, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitOpNot indicates an expected call of BitOpNot. +func (mr *MockPipelinerMockRecorder) BitOpNot(ctx, destKey, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpNot", reflect.TypeOf((*MockPipeliner)(nil).BitOpNot), ctx, destKey, key) +} + +// BitOpOr mocks base method. +func (m *MockPipeliner) BitOpOr(ctx context.Context, destKey string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, destKey} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitOpOr", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitOpOr indicates an expected call of BitOpOr. +func (mr *MockPipelinerMockRecorder) BitOpOr(ctx, destKey interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, destKey}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpOr", reflect.TypeOf((*MockPipeliner)(nil).BitOpOr), varargs...) +} + +// BitOpXor mocks base method. +func (m *MockPipeliner) BitOpXor(ctx context.Context, destKey string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, destKey} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitOpXor", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitOpXor indicates an expected call of BitOpXor. +func (mr *MockPipelinerMockRecorder) BitOpXor(ctx, destKey interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, destKey}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpXor", reflect.TypeOf((*MockPipeliner)(nil).BitOpXor), varargs...) +} + +// BitPos mocks base method. +func (m *MockPipeliner) BitPos(ctx context.Context, key string, bit int64, pos ...int64) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, bit} + for _, a := range pos { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitPos", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitPos indicates an expected call of BitPos. +func (mr *MockPipelinerMockRecorder) BitPos(ctx, key, bit interface{}, pos ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, bit}, pos...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitPos", reflect.TypeOf((*MockPipeliner)(nil).BitPos), varargs...) +} + +// BitPosSpan mocks base method. +func (m *MockPipeliner) BitPosSpan(ctx context.Context, key string, bit int8, start, end int64, span string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BitPosSpan", ctx, key, bit, start, end, span) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitPosSpan indicates an expected call of BitPosSpan. +func (mr *MockPipelinerMockRecorder) BitPosSpan(ctx, key, bit, start, end, span interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitPosSpan", reflect.TypeOf((*MockPipeliner)(nil).BitPosSpan), ctx, key, bit, start, end, span) +} + +// CFAdd mocks base method. +func (m *MockPipeliner) CFAdd(ctx context.Context, key string, element interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFAdd", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// CFAdd indicates an expected call of CFAdd. +func (mr *MockPipelinerMockRecorder) CFAdd(ctx, key, element interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAdd", reflect.TypeOf((*MockPipeliner)(nil).CFAdd), ctx, key, element) +} + +// CFAddNX mocks base method. +func (m *MockPipeliner) CFAddNX(ctx context.Context, key string, element interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFAddNX", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// CFAddNX indicates an expected call of CFAddNX. +func (mr *MockPipelinerMockRecorder) CFAddNX(ctx, key, element interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAddNX", reflect.TypeOf((*MockPipeliner)(nil).CFAddNX), ctx, key, element) +} + +// CFCount mocks base method. +func (m *MockPipeliner) CFCount(ctx context.Context, key string, element interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFCount", ctx, key, element) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// CFCount indicates an expected call of CFCount. +func (mr *MockPipelinerMockRecorder) CFCount(ctx, key, element interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFCount", reflect.TypeOf((*MockPipeliner)(nil).CFCount), ctx, key, element) +} + +// CFDel mocks base method. +func (m *MockPipeliner) CFDel(ctx context.Context, key string, element interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFDel", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// CFDel indicates an expected call of CFDel. +func (mr *MockPipelinerMockRecorder) CFDel(ctx, key, element interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFDel", reflect.TypeOf((*MockPipeliner)(nil).CFDel), ctx, key, element) +} + +// CFExists mocks base method. +func (m *MockPipeliner) CFExists(ctx context.Context, key string, element interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFExists", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// CFExists indicates an expected call of CFExists. +func (mr *MockPipelinerMockRecorder) CFExists(ctx, key, element interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFExists", reflect.TypeOf((*MockPipeliner)(nil).CFExists), ctx, key, element) +} + +// CFInfo mocks base method. +func (m *MockPipeliner) CFInfo(ctx context.Context, key string) *redis.CFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFInfo", ctx, key) + ret0, _ := ret[0].(*redis.CFInfoCmd) + return ret0 +} + +// CFInfo indicates an expected call of CFInfo. +func (mr *MockPipelinerMockRecorder) CFInfo(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInfo", reflect.TypeOf((*MockPipeliner)(nil).CFInfo), ctx, key) +} + +// CFInsert mocks base method. +func (m *MockPipeliner) CFInsert(ctx context.Context, key string, options *redis.CFInsertOptions, elements ...interface{}) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, options} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CFInsert", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// CFInsert indicates an expected call of CFInsert. +func (mr *MockPipelinerMockRecorder) CFInsert(ctx, key, options interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, options}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInsert", reflect.TypeOf((*MockPipeliner)(nil).CFInsert), varargs...) +} + +// CFInsertNX mocks base method. +func (m *MockPipeliner) CFInsertNX(ctx context.Context, key string, options *redis.CFInsertOptions, elements ...interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, options} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CFInsertNX", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// CFInsertNX indicates an expected call of CFInsertNX. +func (mr *MockPipelinerMockRecorder) CFInsertNX(ctx, key, options interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, options}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInsertNX", reflect.TypeOf((*MockPipeliner)(nil).CFInsertNX), varargs...) +} + +// CFLoadChunk mocks base method. +func (m *MockPipeliner) CFLoadChunk(ctx context.Context, key string, iterator int64, data interface{}) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFLoadChunk", ctx, key, iterator, data) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFLoadChunk indicates an expected call of CFLoadChunk. +func (mr *MockPipelinerMockRecorder) CFLoadChunk(ctx, key, iterator, data interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFLoadChunk", reflect.TypeOf((*MockPipeliner)(nil).CFLoadChunk), ctx, key, iterator, data) +} + +// CFMExists mocks base method. +func (m *MockPipeliner) CFMExists(ctx context.Context, key string, elements ...interface{}) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CFMExists", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// CFMExists indicates an expected call of CFMExists. +func (mr *MockPipelinerMockRecorder) CFMExists(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFMExists", reflect.TypeOf((*MockPipeliner)(nil).CFMExists), varargs...) +} + +// CFReserve mocks base method. +func (m *MockPipeliner) CFReserve(ctx context.Context, key string, capacity int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserve", ctx, key, capacity) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserve indicates an expected call of CFReserve. +func (mr *MockPipelinerMockRecorder) CFReserve(ctx, key, capacity interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserve", reflect.TypeOf((*MockPipeliner)(nil).CFReserve), ctx, key, capacity) +} + +// CFReserveBucketSize mocks base method. +func (m *MockPipeliner) CFReserveBucketSize(ctx context.Context, key string, capacity, bucketsize int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveBucketSize", ctx, key, capacity, bucketsize) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveBucketSize indicates an expected call of CFReserveBucketSize. +func (mr *MockPipelinerMockRecorder) CFReserveBucketSize(ctx, key, capacity, bucketsize interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveBucketSize", reflect.TypeOf((*MockPipeliner)(nil).CFReserveBucketSize), ctx, key, capacity, bucketsize) +} + +// CFReserveExpansion mocks base method. +func (m *MockPipeliner) CFReserveExpansion(ctx context.Context, key string, capacity, expansion int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveExpansion", ctx, key, capacity, expansion) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveExpansion indicates an expected call of CFReserveExpansion. +func (mr *MockPipelinerMockRecorder) CFReserveExpansion(ctx, key, capacity, expansion interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveExpansion", reflect.TypeOf((*MockPipeliner)(nil).CFReserveExpansion), ctx, key, capacity, expansion) +} + +// CFReserveMaxIterations mocks base method. +func (m *MockPipeliner) CFReserveMaxIterations(ctx context.Context, key string, capacity, maxiterations int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveMaxIterations", ctx, key, capacity, maxiterations) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveMaxIterations indicates an expected call of CFReserveMaxIterations. +func (mr *MockPipelinerMockRecorder) CFReserveMaxIterations(ctx, key, capacity, maxiterations interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveMaxIterations", reflect.TypeOf((*MockPipeliner)(nil).CFReserveMaxIterations), ctx, key, capacity, maxiterations) +} + +// CFReserveWithArgs mocks base method. +func (m *MockPipeliner) CFReserveWithArgs(ctx context.Context, key string, options *redis.CFReserveOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveWithArgs", ctx, key, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveWithArgs indicates an expected call of CFReserveWithArgs. +func (mr *MockPipelinerMockRecorder) CFReserveWithArgs(ctx, key, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveWithArgs", reflect.TypeOf((*MockPipeliner)(nil).CFReserveWithArgs), ctx, key, options) +} + +// CFScanDump mocks base method. +func (m *MockPipeliner) CFScanDump(ctx context.Context, key string, iterator int64) *redis.ScanDumpCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFScanDump", ctx, key, iterator) + ret0, _ := ret[0].(*redis.ScanDumpCmd) + return ret0 +} + +// CFScanDump indicates an expected call of CFScanDump. +func (mr *MockPipelinerMockRecorder) CFScanDump(ctx, key, iterator interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFScanDump", reflect.TypeOf((*MockPipeliner)(nil).CFScanDump), ctx, key, iterator) +} + +// CMSIncrBy mocks base method. +func (m *MockPipeliner) CMSIncrBy(ctx context.Context, key string, elements ...interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CMSIncrBy", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// CMSIncrBy indicates an expected call of CMSIncrBy. +func (mr *MockPipelinerMockRecorder) CMSIncrBy(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSIncrBy", reflect.TypeOf((*MockPipeliner)(nil).CMSIncrBy), varargs...) +} + +// CMSInfo mocks base method. +func (m *MockPipeliner) CMSInfo(ctx context.Context, key string) *redis.CMSInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CMSInfo", ctx, key) + ret0, _ := ret[0].(*redis.CMSInfoCmd) + return ret0 +} + +// CMSInfo indicates an expected call of CMSInfo. +func (mr *MockPipelinerMockRecorder) CMSInfo(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInfo", reflect.TypeOf((*MockPipeliner)(nil).CMSInfo), ctx, key) +} + +// CMSInitByDim mocks base method. +func (m *MockPipeliner) CMSInitByDim(ctx context.Context, key string, width, height int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CMSInitByDim", ctx, key, width, height) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CMSInitByDim indicates an expected call of CMSInitByDim. +func (mr *MockPipelinerMockRecorder) CMSInitByDim(ctx, key, width, height interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInitByDim", reflect.TypeOf((*MockPipeliner)(nil).CMSInitByDim), ctx, key, width, height) +} + +// CMSInitByProb mocks base method. +func (m *MockPipeliner) CMSInitByProb(ctx context.Context, key string, errorRate, probability float64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CMSInitByProb", ctx, key, errorRate, probability) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CMSInitByProb indicates an expected call of CMSInitByProb. +func (mr *MockPipelinerMockRecorder) CMSInitByProb(ctx, key, errorRate, probability interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInitByProb", reflect.TypeOf((*MockPipeliner)(nil).CMSInitByProb), ctx, key, errorRate, probability) +} + +// CMSMerge mocks base method. +func (m *MockPipeliner) CMSMerge(ctx context.Context, destKey string, sourceKeys ...string) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, destKey} + for _, a := range sourceKeys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CMSMerge", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CMSMerge indicates an expected call of CMSMerge. +func (mr *MockPipelinerMockRecorder) CMSMerge(ctx, destKey interface{}, sourceKeys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, destKey}, sourceKeys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSMerge", reflect.TypeOf((*MockPipeliner)(nil).CMSMerge), varargs...) +} + +// CMSMergeWithWeight mocks base method. +func (m *MockPipeliner) CMSMergeWithWeight(ctx context.Context, destKey string, sourceKeys map[string]int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CMSMergeWithWeight", ctx, destKey, sourceKeys) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CMSMergeWithWeight indicates an expected call of CMSMergeWithWeight. +func (mr *MockPipelinerMockRecorder) CMSMergeWithWeight(ctx, destKey, sourceKeys interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSMergeWithWeight", reflect.TypeOf((*MockPipeliner)(nil).CMSMergeWithWeight), ctx, destKey, sourceKeys) +} + +// CMSQuery mocks base method. +func (m *MockPipeliner) CMSQuery(ctx context.Context, key string, elements ...interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CMSQuery", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// CMSQuery indicates an expected call of CMSQuery. +func (mr *MockPipelinerMockRecorder) CMSQuery(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSQuery", reflect.TypeOf((*MockPipeliner)(nil).CMSQuery), varargs...) +} + +// ClientGetName mocks base method. +func (m *MockPipeliner) ClientGetName(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientGetName", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClientGetName indicates an expected call of ClientGetName. +func (mr *MockPipelinerMockRecorder) ClientGetName(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientGetName", reflect.TypeOf((*MockPipeliner)(nil).ClientGetName), ctx) +} + +// ClientID mocks base method. +func (m *MockPipeliner) ClientID(ctx context.Context) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientID", ctx) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClientID indicates an expected call of ClientID. +func (mr *MockPipelinerMockRecorder) ClientID(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientID", reflect.TypeOf((*MockPipeliner)(nil).ClientID), ctx) +} + +// ClientInfo mocks base method. +func (m *MockPipeliner) ClientInfo(ctx context.Context) *redis.ClientInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientInfo", ctx) + ret0, _ := ret[0].(*redis.ClientInfoCmd) + return ret0 +} + +// ClientInfo indicates an expected call of ClientInfo. +func (mr *MockPipelinerMockRecorder) ClientInfo(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientInfo", reflect.TypeOf((*MockPipeliner)(nil).ClientInfo), ctx) +} + +// ClientKill mocks base method. +func (m *MockPipeliner) ClientKill(ctx context.Context, ipPort string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientKill", ctx, ipPort) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClientKill indicates an expected call of ClientKill. +func (mr *MockPipelinerMockRecorder) ClientKill(ctx, ipPort interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientKill", reflect.TypeOf((*MockPipeliner)(nil).ClientKill), ctx, ipPort) +} + +// ClientKillByFilter mocks base method. +func (m *MockPipeliner) ClientKillByFilter(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ClientKillByFilter", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClientKillByFilter indicates an expected call of ClientKillByFilter. +func (mr *MockPipelinerMockRecorder) ClientKillByFilter(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientKillByFilter", reflect.TypeOf((*MockPipeliner)(nil).ClientKillByFilter), varargs...) +} + +// ClientList mocks base method. +func (m *MockPipeliner) ClientList(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientList", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClientList indicates an expected call of ClientList. +func (mr *MockPipelinerMockRecorder) ClientList(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientList", reflect.TypeOf((*MockPipeliner)(nil).ClientList), ctx) +} + +// ClientPause mocks base method. +func (m *MockPipeliner) ClientPause(ctx context.Context, dur time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientPause", ctx, dur) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ClientPause indicates an expected call of ClientPause. +func (mr *MockPipelinerMockRecorder) ClientPause(ctx, dur interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientPause", reflect.TypeOf((*MockPipeliner)(nil).ClientPause), ctx, dur) +} + +// ClientSetInfo mocks base method. +func (m *MockPipeliner) ClientSetInfo(ctx context.Context, info redis.LibraryInfo) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientSetInfo", ctx, info) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClientSetInfo indicates an expected call of ClientSetInfo. +func (mr *MockPipelinerMockRecorder) ClientSetInfo(ctx, info interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientSetInfo", reflect.TypeOf((*MockPipeliner)(nil).ClientSetInfo), ctx, info) +} + +// ClientSetName mocks base method. +func (m *MockPipeliner) ClientSetName(ctx context.Context, name string) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientSetName", ctx, name) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ClientSetName indicates an expected call of ClientSetName. +func (mr *MockPipelinerMockRecorder) ClientSetName(ctx, name interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientSetName", reflect.TypeOf((*MockPipeliner)(nil).ClientSetName), ctx, name) +} + +// ClientUnblock mocks base method. +func (m *MockPipeliner) ClientUnblock(ctx context.Context, id int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientUnblock", ctx, id) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClientUnblock indicates an expected call of ClientUnblock. +func (mr *MockPipelinerMockRecorder) ClientUnblock(ctx, id interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblock", reflect.TypeOf((*MockPipeliner)(nil).ClientUnblock), ctx, id) +} + +// ClientUnblockWithError mocks base method. +func (m *MockPipeliner) ClientUnblockWithError(ctx context.Context, id int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientUnblockWithError", ctx, id) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClientUnblockWithError indicates an expected call of ClientUnblockWithError. +func (mr *MockPipelinerMockRecorder) ClientUnblockWithError(ctx, id interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblockWithError", reflect.TypeOf((*MockPipeliner)(nil).ClientUnblockWithError), ctx, id) +} + +// ClientUnpause mocks base method. +func (m *MockPipeliner) ClientUnpause(ctx context.Context) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientUnpause", ctx) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ClientUnpause indicates an expected call of ClientUnpause. +func (mr *MockPipelinerMockRecorder) ClientUnpause(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnpause", reflect.TypeOf((*MockPipeliner)(nil).ClientUnpause), ctx) +} + +// ClusterAddSlots mocks base method. +func (m *MockPipeliner) ClusterAddSlots(ctx context.Context, slots ...int) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range slots { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ClusterAddSlots", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterAddSlots indicates an expected call of ClusterAddSlots. +func (mr *MockPipelinerMockRecorder) ClusterAddSlots(ctx interface{}, slots ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, slots...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterAddSlots", reflect.TypeOf((*MockPipeliner)(nil).ClusterAddSlots), varargs...) +} + +// ClusterAddSlotsRange mocks base method. +func (m *MockPipeliner) ClusterAddSlotsRange(ctx context.Context, min, max int) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterAddSlotsRange", ctx, min, max) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterAddSlotsRange indicates an expected call of ClusterAddSlotsRange. +func (mr *MockPipelinerMockRecorder) ClusterAddSlotsRange(ctx, min, max interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterAddSlotsRange", reflect.TypeOf((*MockPipeliner)(nil).ClusterAddSlotsRange), ctx, min, max) +} + +// ClusterCountFailureReports mocks base method. +func (m *MockPipeliner) ClusterCountFailureReports(ctx context.Context, nodeID string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterCountFailureReports", ctx, nodeID) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClusterCountFailureReports indicates an expected call of ClusterCountFailureReports. +func (mr *MockPipelinerMockRecorder) ClusterCountFailureReports(ctx, nodeID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountFailureReports", reflect.TypeOf((*MockPipeliner)(nil).ClusterCountFailureReports), ctx, nodeID) +} + +// ClusterCountKeysInSlot mocks base method. +func (m *MockPipeliner) ClusterCountKeysInSlot(ctx context.Context, slot int) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterCountKeysInSlot", ctx, slot) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClusterCountKeysInSlot indicates an expected call of ClusterCountKeysInSlot. +func (mr *MockPipelinerMockRecorder) ClusterCountKeysInSlot(ctx, slot interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountKeysInSlot", reflect.TypeOf((*MockPipeliner)(nil).ClusterCountKeysInSlot), ctx, slot) +} + +// ClusterDelSlots mocks base method. +func (m *MockPipeliner) ClusterDelSlots(ctx context.Context, slots ...int) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range slots { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ClusterDelSlots", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterDelSlots indicates an expected call of ClusterDelSlots. +func (mr *MockPipelinerMockRecorder) ClusterDelSlots(ctx interface{}, slots ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, slots...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterDelSlots", reflect.TypeOf((*MockPipeliner)(nil).ClusterDelSlots), varargs...) +} + +// ClusterDelSlotsRange mocks base method. +func (m *MockPipeliner) ClusterDelSlotsRange(ctx context.Context, min, max int) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterDelSlotsRange", ctx, min, max) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterDelSlotsRange indicates an expected call of ClusterDelSlotsRange. +func (mr *MockPipelinerMockRecorder) ClusterDelSlotsRange(ctx, min, max interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterDelSlotsRange", reflect.TypeOf((*MockPipeliner)(nil).ClusterDelSlotsRange), ctx, min, max) +} + +// ClusterFailover mocks base method. +func (m *MockPipeliner) ClusterFailover(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterFailover", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterFailover indicates an expected call of ClusterFailover. +func (mr *MockPipelinerMockRecorder) ClusterFailover(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterFailover", reflect.TypeOf((*MockPipeliner)(nil).ClusterFailover), ctx) +} + +// ClusterForget mocks base method. +func (m *MockPipeliner) ClusterForget(ctx context.Context, nodeID string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterForget", ctx, nodeID) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterForget indicates an expected call of ClusterForget. +func (mr *MockPipelinerMockRecorder) ClusterForget(ctx, nodeID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterForget", reflect.TypeOf((*MockPipeliner)(nil).ClusterForget), ctx, nodeID) +} + +// ClusterGetKeysInSlot mocks base method. +func (m *MockPipeliner) ClusterGetKeysInSlot(ctx context.Context, slot, count int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterGetKeysInSlot", ctx, slot, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ClusterGetKeysInSlot indicates an expected call of ClusterGetKeysInSlot. +func (mr *MockPipelinerMockRecorder) ClusterGetKeysInSlot(ctx, slot, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterGetKeysInSlot", reflect.TypeOf((*MockPipeliner)(nil).ClusterGetKeysInSlot), ctx, slot, count) +} + +// ClusterInfo mocks base method. +func (m *MockPipeliner) ClusterInfo(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterInfo", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClusterInfo indicates an expected call of ClusterInfo. +func (mr *MockPipelinerMockRecorder) ClusterInfo(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterInfo", reflect.TypeOf((*MockPipeliner)(nil).ClusterInfo), ctx) +} + +// ClusterKeySlot mocks base method. +func (m *MockPipeliner) ClusterKeySlot(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterKeySlot", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClusterKeySlot indicates an expected call of ClusterKeySlot. +func (mr *MockPipelinerMockRecorder) ClusterKeySlot(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterKeySlot", reflect.TypeOf((*MockPipeliner)(nil).ClusterKeySlot), ctx, key) +} + +// ClusterLinks mocks base method. +func (m *MockPipeliner) ClusterLinks(ctx context.Context) *redis.ClusterLinksCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterLinks", ctx) + ret0, _ := ret[0].(*redis.ClusterLinksCmd) + return ret0 +} + +// ClusterLinks indicates an expected call of ClusterLinks. +func (mr *MockPipelinerMockRecorder) ClusterLinks(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterLinks", reflect.TypeOf((*MockPipeliner)(nil).ClusterLinks), ctx) +} + +// ClusterMeet mocks base method. +func (m *MockPipeliner) ClusterMeet(ctx context.Context, host, port string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterMeet", ctx, host, port) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterMeet indicates an expected call of ClusterMeet. +func (mr *MockPipelinerMockRecorder) ClusterMeet(ctx, host, port interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMeet", reflect.TypeOf((*MockPipeliner)(nil).ClusterMeet), ctx, host, port) +} + +// ClusterMyShardID mocks base method. +func (m *MockPipeliner) ClusterMyShardID(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterMyShardID", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClusterMyShardID indicates an expected call of ClusterMyShardID. +func (mr *MockPipelinerMockRecorder) ClusterMyShardID(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMyShardID", reflect.TypeOf((*MockPipeliner)(nil).ClusterMyShardID), ctx) +} + +// ClusterNodes mocks base method. +func (m *MockPipeliner) ClusterNodes(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterNodes", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClusterNodes indicates an expected call of ClusterNodes. +func (mr *MockPipelinerMockRecorder) ClusterNodes(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterNodes", reflect.TypeOf((*MockPipeliner)(nil).ClusterNodes), ctx) +} + +// ClusterReplicate mocks base method. +func (m *MockPipeliner) ClusterReplicate(ctx context.Context, nodeID string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterReplicate", ctx, nodeID) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterReplicate indicates an expected call of ClusterReplicate. +func (mr *MockPipelinerMockRecorder) ClusterReplicate(ctx, nodeID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterReplicate", reflect.TypeOf((*MockPipeliner)(nil).ClusterReplicate), ctx, nodeID) +} + +// ClusterResetHard mocks base method. +func (m *MockPipeliner) ClusterResetHard(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterResetHard", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterResetHard indicates an expected call of ClusterResetHard. +func (mr *MockPipelinerMockRecorder) ClusterResetHard(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetHard", reflect.TypeOf((*MockPipeliner)(nil).ClusterResetHard), ctx) +} + +// ClusterResetSoft mocks base method. +func (m *MockPipeliner) ClusterResetSoft(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterResetSoft", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterResetSoft indicates an expected call of ClusterResetSoft. +func (mr *MockPipelinerMockRecorder) ClusterResetSoft(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetSoft", reflect.TypeOf((*MockPipeliner)(nil).ClusterResetSoft), ctx) +} + +// ClusterSaveConfig mocks base method. +func (m *MockPipeliner) ClusterSaveConfig(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterSaveConfig", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterSaveConfig indicates an expected call of ClusterSaveConfig. +func (mr *MockPipelinerMockRecorder) ClusterSaveConfig(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSaveConfig", reflect.TypeOf((*MockPipeliner)(nil).ClusterSaveConfig), ctx) +} + +// ClusterShards mocks base method. +func (m *MockPipeliner) ClusterShards(ctx context.Context) *redis.ClusterShardsCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterShards", ctx) + ret0, _ := ret[0].(*redis.ClusterShardsCmd) + return ret0 +} + +// ClusterShards indicates an expected call of ClusterShards. +func (mr *MockPipelinerMockRecorder) ClusterShards(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterShards", reflect.TypeOf((*MockPipeliner)(nil).ClusterShards), ctx) +} + +// ClusterSlaves mocks base method. +func (m *MockPipeliner) ClusterSlaves(ctx context.Context, nodeID string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterSlaves", ctx, nodeID) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ClusterSlaves indicates an expected call of ClusterSlaves. +func (mr *MockPipelinerMockRecorder) ClusterSlaves(ctx, nodeID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlaves", reflect.TypeOf((*MockPipeliner)(nil).ClusterSlaves), ctx, nodeID) +} + +// ClusterSlots mocks base method. +func (m *MockPipeliner) ClusterSlots(ctx context.Context) *redis.ClusterSlotsCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterSlots", ctx) + ret0, _ := ret[0].(*redis.ClusterSlotsCmd) + return ret0 +} + +// ClusterSlots indicates an expected call of ClusterSlots. +func (mr *MockPipelinerMockRecorder) ClusterSlots(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlots", reflect.TypeOf((*MockPipeliner)(nil).ClusterSlots), ctx) +} + +// Command mocks base method. +func (m *MockPipeliner) Command(ctx context.Context) *redis.CommandsInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Command", ctx) + ret0, _ := ret[0].(*redis.CommandsInfoCmd) + return ret0 +} + +// Command indicates an expected call of Command. +func (mr *MockPipelinerMockRecorder) Command(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Command", reflect.TypeOf((*MockPipeliner)(nil).Command), ctx) +} + +// CommandGetKeys mocks base method. +func (m *MockPipeliner) CommandGetKeys(ctx context.Context, commands ...interface{}) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range commands { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CommandGetKeys", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// CommandGetKeys indicates an expected call of CommandGetKeys. +func (mr *MockPipelinerMockRecorder) CommandGetKeys(ctx interface{}, commands ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, commands...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandGetKeys", reflect.TypeOf((*MockPipeliner)(nil).CommandGetKeys), varargs...) +} + +// CommandGetKeysAndFlags mocks base method. +func (m *MockPipeliner) CommandGetKeysAndFlags(ctx context.Context, commands ...interface{}) *redis.KeyFlagsCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range commands { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CommandGetKeysAndFlags", varargs...) + ret0, _ := ret[0].(*redis.KeyFlagsCmd) + return ret0 +} + +// CommandGetKeysAndFlags indicates an expected call of CommandGetKeysAndFlags. +func (mr *MockPipelinerMockRecorder) CommandGetKeysAndFlags(ctx interface{}, commands ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, commands...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandGetKeysAndFlags", reflect.TypeOf((*MockPipeliner)(nil).CommandGetKeysAndFlags), varargs...) +} + +// CommandList mocks base method. +func (m *MockPipeliner) CommandList(ctx context.Context, filter *redis.FilterBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CommandList", ctx, filter) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// CommandList indicates an expected call of CommandList. +func (mr *MockPipelinerMockRecorder) CommandList(ctx, filter interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandList", reflect.TypeOf((*MockPipeliner)(nil).CommandList), ctx, filter) +} + +// ConfigGet mocks base method. +func (m *MockPipeliner) ConfigGet(ctx context.Context, parameter string) *redis.MapStringStringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigGet", ctx, parameter) + ret0, _ := ret[0].(*redis.MapStringStringCmd) + return ret0 +} + +// ConfigGet indicates an expected call of ConfigGet. +func (mr *MockPipelinerMockRecorder) ConfigGet(ctx, parameter interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigGet", reflect.TypeOf((*MockPipeliner)(nil).ConfigGet), ctx, parameter) +} + +// ConfigResetStat mocks base method. +func (m *MockPipeliner) ConfigResetStat(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigResetStat", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ConfigResetStat indicates an expected call of ConfigResetStat. +func (mr *MockPipelinerMockRecorder) ConfigResetStat(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigResetStat", reflect.TypeOf((*MockPipeliner)(nil).ConfigResetStat), ctx) +} + +// ConfigRewrite mocks base method. +func (m *MockPipeliner) ConfigRewrite(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigRewrite", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ConfigRewrite indicates an expected call of ConfigRewrite. +func (mr *MockPipelinerMockRecorder) ConfigRewrite(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigRewrite", reflect.TypeOf((*MockPipeliner)(nil).ConfigRewrite), ctx) +} + +// ConfigSet mocks base method. +func (m *MockPipeliner) ConfigSet(ctx context.Context, parameter, value string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigSet", ctx, parameter, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ConfigSet indicates an expected call of ConfigSet. +func (mr *MockPipelinerMockRecorder) ConfigSet(ctx, parameter, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigSet", reflect.TypeOf((*MockPipeliner)(nil).ConfigSet), ctx, parameter, value) +} + +// Copy mocks base method. +func (m *MockPipeliner) Copy(ctx context.Context, sourceKey, destKey string, db int, replace bool) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Copy", ctx, sourceKey, destKey, db, replace) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Copy indicates an expected call of Copy. +func (mr *MockPipelinerMockRecorder) Copy(ctx, sourceKey, destKey, db, replace interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Copy", reflect.TypeOf((*MockPipeliner)(nil).Copy), ctx, sourceKey, destKey, db, replace) +} + +// DBSize mocks base method. +func (m *MockPipeliner) DBSize(ctx context.Context) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DBSize", ctx) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// DBSize indicates an expected call of DBSize. +func (mr *MockPipelinerMockRecorder) DBSize(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DBSize", reflect.TypeOf((*MockPipeliner)(nil).DBSize), ctx) +} + +// DebugObject mocks base method. +func (m *MockPipeliner) DebugObject(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DebugObject", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// DebugObject indicates an expected call of DebugObject. +func (mr *MockPipelinerMockRecorder) DebugObject(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugObject", reflect.TypeOf((*MockPipeliner)(nil).DebugObject), ctx, key) +} + +// Decr mocks base method. +func (m *MockPipeliner) Decr(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Decr", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Decr indicates an expected call of Decr. +func (mr *MockPipelinerMockRecorder) Decr(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decr", reflect.TypeOf((*MockPipeliner)(nil).Decr), ctx, key) +} + +// DecrBy mocks base method. +func (m *MockPipeliner) DecrBy(ctx context.Context, key string, decrement int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DecrBy", ctx, key, decrement) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// DecrBy indicates an expected call of DecrBy. +func (mr *MockPipelinerMockRecorder) DecrBy(ctx, key, decrement interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecrBy", reflect.TypeOf((*MockPipeliner)(nil).DecrBy), ctx, key, decrement) +} + +// Del mocks base method. +func (m *MockPipeliner) Del(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Del", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Del indicates an expected call of Del. +func (mr *MockPipelinerMockRecorder) Del(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Del", reflect.TypeOf((*MockPipeliner)(nil).Del), varargs...) +} + +// Discard mocks base method. +func (m *MockPipeliner) Discard() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "Discard") +} + +// Discard indicates an expected call of Discard. +func (mr *MockPipelinerMockRecorder) Discard() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Discard", reflect.TypeOf((*MockPipeliner)(nil).Discard)) +} + +// Do mocks base method. +func (m *MockPipeliner) Do(ctx context.Context, args ...interface{}) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Do", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// Do indicates an expected call of Do. +func (mr *MockPipelinerMockRecorder) Do(ctx interface{}, args ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Do", reflect.TypeOf((*MockPipeliner)(nil).Do), varargs...) +} + +// Dump mocks base method. +func (m *MockPipeliner) Dump(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Dump", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// Dump indicates an expected call of Dump. +func (mr *MockPipelinerMockRecorder) Dump(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Dump", reflect.TypeOf((*MockPipeliner)(nil).Dump), ctx, key) +} + +// Echo mocks base method. +func (m *MockPipeliner) Echo(ctx context.Context, message interface{}) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Echo", ctx, message) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// Echo indicates an expected call of Echo. +func (mr *MockPipelinerMockRecorder) Echo(ctx, message interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Echo", reflect.TypeOf((*MockPipeliner)(nil).Echo), ctx, message) +} + +// Eval mocks base method. +func (m *MockPipeliner) Eval(ctx context.Context, script string, keys []string, args ...interface{}) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, script, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Eval", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// Eval indicates an expected call of Eval. +func (mr *MockPipelinerMockRecorder) Eval(ctx, script, keys interface{}, args ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, script, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eval", reflect.TypeOf((*MockPipeliner)(nil).Eval), varargs...) +} + +// EvalRO mocks base method. +func (m *MockPipeliner) EvalRO(ctx context.Context, script string, keys []string, args ...interface{}) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, script, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EvalRO", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// EvalRO indicates an expected call of EvalRO. +func (mr *MockPipelinerMockRecorder) EvalRO(ctx, script, keys interface{}, args ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, script, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalRO", reflect.TypeOf((*MockPipeliner)(nil).EvalRO), varargs...) +} + +// EvalSha mocks base method. +func (m *MockPipeliner) EvalSha(ctx context.Context, sha1 string, keys []string, args ...interface{}) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, sha1, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EvalSha", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// EvalSha indicates an expected call of EvalSha. +func (mr *MockPipelinerMockRecorder) EvalSha(ctx, sha1, keys interface{}, args ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, sha1, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalSha", reflect.TypeOf((*MockPipeliner)(nil).EvalSha), varargs...) +} + +// EvalShaRO mocks base method. +func (m *MockPipeliner) EvalShaRO(ctx context.Context, sha1 string, keys []string, args ...interface{}) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, sha1, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EvalShaRO", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// EvalShaRO indicates an expected call of EvalShaRO. +func (mr *MockPipelinerMockRecorder) EvalShaRO(ctx, sha1, keys interface{}, args ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, sha1, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalShaRO", reflect.TypeOf((*MockPipeliner)(nil).EvalShaRO), varargs...) +} + +// Exec mocks base method. +func (m *MockPipeliner) Exec(ctx context.Context) ([]redis.Cmder, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Exec", ctx) + ret0, _ := ret[0].([]redis.Cmder) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Exec indicates an expected call of Exec. +func (mr *MockPipelinerMockRecorder) Exec(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockPipeliner)(nil).Exec), ctx) +} + +// Exists mocks base method. +func (m *MockPipeliner) Exists(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Exists", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Exists indicates an expected call of Exists. +func (mr *MockPipelinerMockRecorder) Exists(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockPipeliner)(nil).Exists), varargs...) +} + +// Expire mocks base method. +func (m *MockPipeliner) Expire(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Expire", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// Expire indicates an expected call of Expire. +func (mr *MockPipelinerMockRecorder) Expire(ctx, key, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expire", reflect.TypeOf((*MockPipeliner)(nil).Expire), ctx, key, expiration) +} + +// ExpireAt mocks base method. +func (m *MockPipeliner) ExpireAt(ctx context.Context, key string, tm time.Time) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireAt", ctx, key, tm) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireAt indicates an expected call of ExpireAt. +func (mr *MockPipelinerMockRecorder) ExpireAt(ctx, key, tm interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireAt", reflect.TypeOf((*MockPipeliner)(nil).ExpireAt), ctx, key, tm) +} + +// ExpireGT mocks base method. +func (m *MockPipeliner) ExpireGT(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireGT", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireGT indicates an expected call of ExpireGT. +func (mr *MockPipelinerMockRecorder) ExpireGT(ctx, key, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireGT", reflect.TypeOf((*MockPipeliner)(nil).ExpireGT), ctx, key, expiration) +} + +// ExpireLT mocks base method. +func (m *MockPipeliner) ExpireLT(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireLT", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireLT indicates an expected call of ExpireLT. +func (mr *MockPipelinerMockRecorder) ExpireLT(ctx, key, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireLT", reflect.TypeOf((*MockPipeliner)(nil).ExpireLT), ctx, key, expiration) +} + +// ExpireNX mocks base method. +func (m *MockPipeliner) ExpireNX(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireNX", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireNX indicates an expected call of ExpireNX. +func (mr *MockPipelinerMockRecorder) ExpireNX(ctx, key, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireNX", reflect.TypeOf((*MockPipeliner)(nil).ExpireNX), ctx, key, expiration) +} + +// ExpireTime mocks base method. +func (m *MockPipeliner) ExpireTime(ctx context.Context, key string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireTime", ctx, key) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// ExpireTime indicates an expected call of ExpireTime. +func (mr *MockPipelinerMockRecorder) ExpireTime(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireTime", reflect.TypeOf((*MockPipeliner)(nil).ExpireTime), ctx, key) +} + +// ExpireXX mocks base method. +func (m *MockPipeliner) ExpireXX(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireXX", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireXX indicates an expected call of ExpireXX. +func (mr *MockPipelinerMockRecorder) ExpireXX(ctx, key, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireXX", reflect.TypeOf((*MockPipeliner)(nil).ExpireXX), ctx, key, expiration) +} + +// FCall mocks base method. +func (m *MockPipeliner) FCall(ctx context.Context, function string, keys []string, args ...interface{}) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, function, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FCall", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// FCall indicates an expected call of FCall. +func (mr *MockPipelinerMockRecorder) FCall(ctx, function, keys interface{}, args ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, function, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCall", reflect.TypeOf((*MockPipeliner)(nil).FCall), varargs...) +} + +// FCallRO mocks base method. +func (m *MockPipeliner) FCallRO(ctx context.Context, function string, keys []string, args ...interface{}) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, function, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FCallRO", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// FCallRO indicates an expected call of FCallRO. +func (mr *MockPipelinerMockRecorder) FCallRO(ctx, function, keys interface{}, args ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, function, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCallRO", reflect.TypeOf((*MockPipeliner)(nil).FCallRO), varargs...) +} + +// FCallRo mocks base method. +func (m *MockPipeliner) FCallRo(ctx context.Context, function string, keys []string, args ...interface{}) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, function, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FCallRo", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// FCallRo indicates an expected call of FCallRo. +func (mr *MockPipelinerMockRecorder) FCallRo(ctx, function, keys interface{}, args ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, function, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCallRo", reflect.TypeOf((*MockPipeliner)(nil).FCallRo), varargs...) +} + +// FTAggregate mocks base method. +func (m *MockPipeliner) FTAggregate(ctx context.Context, index, query string) *redis.MapStringInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTAggregate", ctx, index, query) + ret0, _ := ret[0].(*redis.MapStringInterfaceCmd) + return ret0 +} + +// FTAggregate indicates an expected call of FTAggregate. +func (mr *MockPipelinerMockRecorder) FTAggregate(ctx, index, query interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAggregate", reflect.TypeOf((*MockPipeliner)(nil).FTAggregate), ctx, index, query) +} + +// FTAggregateWithArgs mocks base method. +func (m *MockPipeliner) FTAggregateWithArgs(ctx context.Context, index, query string, options *redis.FTAggregateOptions) *redis.AggregateCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTAggregateWithArgs", ctx, index, query, options) + ret0, _ := ret[0].(*redis.AggregateCmd) + return ret0 +} + +// FTAggregateWithArgs indicates an expected call of FTAggregateWithArgs. +func (mr *MockPipelinerMockRecorder) FTAggregateWithArgs(ctx, index, query, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAggregateWithArgs", reflect.TypeOf((*MockPipeliner)(nil).FTAggregateWithArgs), ctx, index, query, options) +} + +// FTAliasAdd mocks base method. +func (m *MockPipeliner) FTAliasAdd(ctx context.Context, index, alias string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTAliasAdd", ctx, index, alias) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTAliasAdd indicates an expected call of FTAliasAdd. +func (mr *MockPipelinerMockRecorder) FTAliasAdd(ctx, index, alias interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAliasAdd", reflect.TypeOf((*MockPipeliner)(nil).FTAliasAdd), ctx, index, alias) +} + +// FTAliasDel mocks base method. +func (m *MockPipeliner) FTAliasDel(ctx context.Context, alias string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTAliasDel", ctx, alias) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTAliasDel indicates an expected call of FTAliasDel. +func (mr *MockPipelinerMockRecorder) FTAliasDel(ctx, alias interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAliasDel", reflect.TypeOf((*MockPipeliner)(nil).FTAliasDel), ctx, alias) +} + +// FTAliasUpdate mocks base method. +func (m *MockPipeliner) FTAliasUpdate(ctx context.Context, index, alias string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTAliasUpdate", ctx, index, alias) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTAliasUpdate indicates an expected call of FTAliasUpdate. +func (mr *MockPipelinerMockRecorder) FTAliasUpdate(ctx, index, alias interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAliasUpdate", reflect.TypeOf((*MockPipeliner)(nil).FTAliasUpdate), ctx, index, alias) +} + +// FTAlter mocks base method. +func (m *MockPipeliner) FTAlter(ctx context.Context, index string, skipInitialScan bool, definition []interface{}) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTAlter", ctx, index, skipInitialScan, definition) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTAlter indicates an expected call of FTAlter. +func (mr *MockPipelinerMockRecorder) FTAlter(ctx, index, skipInitialScan, definition interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAlter", reflect.TypeOf((*MockPipeliner)(nil).FTAlter), ctx, index, skipInitialScan, definition) +} + +// FTConfigGet mocks base method. +func (m *MockPipeliner) FTConfigGet(ctx context.Context, option string) *redis.MapMapStringInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTConfigGet", ctx, option) + ret0, _ := ret[0].(*redis.MapMapStringInterfaceCmd) + return ret0 +} + +// FTConfigGet indicates an expected call of FTConfigGet. +func (mr *MockPipelinerMockRecorder) FTConfigGet(ctx, option interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTConfigGet", reflect.TypeOf((*MockPipeliner)(nil).FTConfigGet), ctx, option) +} + +// FTConfigSet mocks base method. +func (m *MockPipeliner) FTConfigSet(ctx context.Context, option string, value interface{}) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTConfigSet", ctx, option, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTConfigSet indicates an expected call of FTConfigSet. +func (mr *MockPipelinerMockRecorder) FTConfigSet(ctx, option, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTConfigSet", reflect.TypeOf((*MockPipeliner)(nil).FTConfigSet), ctx, option, value) +} + +// FTCreate mocks base method. +func (m *MockPipeliner) FTCreate(ctx context.Context, index string, options *redis.FTCreateOptions, schema ...*redis.FieldSchema) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, index, options} + for _, a := range schema { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FTCreate", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTCreate indicates an expected call of FTCreate. +func (mr *MockPipelinerMockRecorder) FTCreate(ctx, index, options interface{}, schema ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, index, options}, schema...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTCreate", reflect.TypeOf((*MockPipeliner)(nil).FTCreate), varargs...) +} + +// FTCursorDel mocks base method. +func (m *MockPipeliner) FTCursorDel(ctx context.Context, index string, cursorId int) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTCursorDel", ctx, index, cursorId) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTCursorDel indicates an expected call of FTCursorDel. +func (mr *MockPipelinerMockRecorder) FTCursorDel(ctx, index, cursorId interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTCursorDel", reflect.TypeOf((*MockPipeliner)(nil).FTCursorDel), ctx, index, cursorId) +} + +// FTCursorRead mocks base method. +func (m *MockPipeliner) FTCursorRead(ctx context.Context, index string, cursorId, count int) *redis.MapStringInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTCursorRead", ctx, index, cursorId, count) + ret0, _ := ret[0].(*redis.MapStringInterfaceCmd) + return ret0 +} + +// FTCursorRead indicates an expected call of FTCursorRead. +func (mr *MockPipelinerMockRecorder) FTCursorRead(ctx, index, cursorId, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTCursorRead", reflect.TypeOf((*MockPipeliner)(nil).FTCursorRead), ctx, index, cursorId, count) +} + +// FTDictAdd mocks base method. +func (m *MockPipeliner) FTDictAdd(ctx context.Context, dict string, term ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, dict} + for _, a := range term { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FTDictAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// FTDictAdd indicates an expected call of FTDictAdd. +func (mr *MockPipelinerMockRecorder) FTDictAdd(ctx, dict interface{}, term ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, dict}, term...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDictAdd", reflect.TypeOf((*MockPipeliner)(nil).FTDictAdd), varargs...) +} + +// FTDictDel mocks base method. +func (m *MockPipeliner) FTDictDel(ctx context.Context, dict string, term ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, dict} + for _, a := range term { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FTDictDel", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// FTDictDel indicates an expected call of FTDictDel. +func (mr *MockPipelinerMockRecorder) FTDictDel(ctx, dict interface{}, term ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, dict}, term...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDictDel", reflect.TypeOf((*MockPipeliner)(nil).FTDictDel), varargs...) +} + +// FTDictDump mocks base method. +func (m *MockPipeliner) FTDictDump(ctx context.Context, dict string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTDictDump", ctx, dict) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// FTDictDump indicates an expected call of FTDictDump. +func (mr *MockPipelinerMockRecorder) FTDictDump(ctx, dict interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDictDump", reflect.TypeOf((*MockPipeliner)(nil).FTDictDump), ctx, dict) +} + +// FTDropIndex mocks base method. +func (m *MockPipeliner) FTDropIndex(ctx context.Context, index string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTDropIndex", ctx, index) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTDropIndex indicates an expected call of FTDropIndex. +func (mr *MockPipelinerMockRecorder) FTDropIndex(ctx, index interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDropIndex", reflect.TypeOf((*MockPipeliner)(nil).FTDropIndex), ctx, index) +} + +// FTDropIndexWithArgs mocks base method. +func (m *MockPipeliner) FTDropIndexWithArgs(ctx context.Context, index string, options *redis.FTDropIndexOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTDropIndexWithArgs", ctx, index, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTDropIndexWithArgs indicates an expected call of FTDropIndexWithArgs. +func (mr *MockPipelinerMockRecorder) FTDropIndexWithArgs(ctx, index, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDropIndexWithArgs", reflect.TypeOf((*MockPipeliner)(nil).FTDropIndexWithArgs), ctx, index, options) +} + +// FTExplain mocks base method. +func (m *MockPipeliner) FTExplain(ctx context.Context, index, query string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTExplain", ctx, index, query) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FTExplain indicates an expected call of FTExplain. +func (mr *MockPipelinerMockRecorder) FTExplain(ctx, index, query interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTExplain", reflect.TypeOf((*MockPipeliner)(nil).FTExplain), ctx, index, query) +} + +// FTExplainWithArgs mocks base method. +func (m *MockPipeliner) FTExplainWithArgs(ctx context.Context, index, query string, options *redis.FTExplainOptions) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTExplainWithArgs", ctx, index, query, options) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FTExplainWithArgs indicates an expected call of FTExplainWithArgs. +func (mr *MockPipelinerMockRecorder) FTExplainWithArgs(ctx, index, query, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTExplainWithArgs", reflect.TypeOf((*MockPipeliner)(nil).FTExplainWithArgs), ctx, index, query, options) +} + +// FTInfo mocks base method. +func (m *MockPipeliner) FTInfo(ctx context.Context, index string) *redis.FTInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTInfo", ctx, index) + ret0, _ := ret[0].(*redis.FTInfoCmd) + return ret0 +} + +// FTInfo indicates an expected call of FTInfo. +func (mr *MockPipelinerMockRecorder) FTInfo(ctx, index interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTInfo", reflect.TypeOf((*MockPipeliner)(nil).FTInfo), ctx, index) +} + +// FTSearch mocks base method. +func (m *MockPipeliner) FTSearch(ctx context.Context, index, query string) *redis.FTSearchCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTSearch", ctx, index, query) + ret0, _ := ret[0].(*redis.FTSearchCmd) + return ret0 +} + +// FTSearch indicates an expected call of FTSearch. +func (mr *MockPipelinerMockRecorder) FTSearch(ctx, index, query interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSearch", reflect.TypeOf((*MockPipeliner)(nil).FTSearch), ctx, index, query) +} + +// FTSearchWithArgs mocks base method. +func (m *MockPipeliner) FTSearchWithArgs(ctx context.Context, index, query string, options *redis.FTSearchOptions) *redis.FTSearchCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTSearchWithArgs", ctx, index, query, options) + ret0, _ := ret[0].(*redis.FTSearchCmd) + return ret0 +} + +// FTSearchWithArgs indicates an expected call of FTSearchWithArgs. +func (mr *MockPipelinerMockRecorder) FTSearchWithArgs(ctx, index, query, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSearchWithArgs", reflect.TypeOf((*MockPipeliner)(nil).FTSearchWithArgs), ctx, index, query, options) +} + +// FTSpellCheck mocks base method. +func (m *MockPipeliner) FTSpellCheck(ctx context.Context, index, query string) *redis.FTSpellCheckCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTSpellCheck", ctx, index, query) + ret0, _ := ret[0].(*redis.FTSpellCheckCmd) + return ret0 +} + +// FTSpellCheck indicates an expected call of FTSpellCheck. +func (mr *MockPipelinerMockRecorder) FTSpellCheck(ctx, index, query interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSpellCheck", reflect.TypeOf((*MockPipeliner)(nil).FTSpellCheck), ctx, index, query) +} + +// FTSpellCheckWithArgs mocks base method. +func (m *MockPipeliner) FTSpellCheckWithArgs(ctx context.Context, index, query string, options *redis.FTSpellCheckOptions) *redis.FTSpellCheckCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTSpellCheckWithArgs", ctx, index, query, options) + ret0, _ := ret[0].(*redis.FTSpellCheckCmd) + return ret0 +} + +// FTSpellCheckWithArgs indicates an expected call of FTSpellCheckWithArgs. +func (mr *MockPipelinerMockRecorder) FTSpellCheckWithArgs(ctx, index, query, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSpellCheckWithArgs", reflect.TypeOf((*MockPipeliner)(nil).FTSpellCheckWithArgs), ctx, index, query, options) +} + +// FTSynDump mocks base method. +func (m *MockPipeliner) FTSynDump(ctx context.Context, index string) *redis.FTSynDumpCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTSynDump", ctx, index) + ret0, _ := ret[0].(*redis.FTSynDumpCmd) + return ret0 +} + +// FTSynDump indicates an expected call of FTSynDump. +func (mr *MockPipelinerMockRecorder) FTSynDump(ctx, index interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSynDump", reflect.TypeOf((*MockPipeliner)(nil).FTSynDump), ctx, index) +} + +// FTSynUpdate mocks base method. +func (m *MockPipeliner) FTSynUpdate(ctx context.Context, index string, synGroupId interface{}, terms []interface{}) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTSynUpdate", ctx, index, synGroupId, terms) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTSynUpdate indicates an expected call of FTSynUpdate. +func (mr *MockPipelinerMockRecorder) FTSynUpdate(ctx, index, synGroupId, terms interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSynUpdate", reflect.TypeOf((*MockPipeliner)(nil).FTSynUpdate), ctx, index, synGroupId, terms) +} + +// FTSynUpdateWithArgs mocks base method. +func (m *MockPipeliner) FTSynUpdateWithArgs(ctx context.Context, index string, synGroupId interface{}, options *redis.FTSynUpdateOptions, terms []interface{}) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTSynUpdateWithArgs", ctx, index, synGroupId, options, terms) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTSynUpdateWithArgs indicates an expected call of FTSynUpdateWithArgs. +func (mr *MockPipelinerMockRecorder) FTSynUpdateWithArgs(ctx, index, synGroupId, options, terms interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSynUpdateWithArgs", reflect.TypeOf((*MockPipeliner)(nil).FTSynUpdateWithArgs), ctx, index, synGroupId, options, terms) +} + +// FTTagVals mocks base method. +func (m *MockPipeliner) FTTagVals(ctx context.Context, index, field string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTTagVals", ctx, index, field) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// FTTagVals indicates an expected call of FTTagVals. +func (mr *MockPipelinerMockRecorder) FTTagVals(ctx, index, field interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTTagVals", reflect.TypeOf((*MockPipeliner)(nil).FTTagVals), ctx, index, field) +} + +// FT_List mocks base method. +func (m *MockPipeliner) FT_List(ctx context.Context) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FT_List", ctx) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// FT_List indicates an expected call of FT_List. +func (mr *MockPipelinerMockRecorder) FT_List(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FT_List", reflect.TypeOf((*MockPipeliner)(nil).FT_List), ctx) +} + +// FlushAll mocks base method. +func (m *MockPipeliner) FlushAll(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlushAll", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FlushAll indicates an expected call of FlushAll. +func (mr *MockPipelinerMockRecorder) FlushAll(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAll", reflect.TypeOf((*MockPipeliner)(nil).FlushAll), ctx) +} + +// FlushAllAsync mocks base method. +func (m *MockPipeliner) FlushAllAsync(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlushAllAsync", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FlushAllAsync indicates an expected call of FlushAllAsync. +func (mr *MockPipelinerMockRecorder) FlushAllAsync(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAllAsync", reflect.TypeOf((*MockPipeliner)(nil).FlushAllAsync), ctx) +} + +// FlushDB mocks base method. +func (m *MockPipeliner) FlushDB(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlushDB", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FlushDB indicates an expected call of FlushDB. +func (mr *MockPipelinerMockRecorder) FlushDB(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDB", reflect.TypeOf((*MockPipeliner)(nil).FlushDB), ctx) +} + +// FlushDBAsync mocks base method. +func (m *MockPipeliner) FlushDBAsync(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlushDBAsync", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FlushDBAsync indicates an expected call of FlushDBAsync. +func (mr *MockPipelinerMockRecorder) FlushDBAsync(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDBAsync", reflect.TypeOf((*MockPipeliner)(nil).FlushDBAsync), ctx) +} + +// FunctionDelete mocks base method. +func (m *MockPipeliner) FunctionDelete(ctx context.Context, libName string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionDelete", ctx, libName) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionDelete indicates an expected call of FunctionDelete. +func (mr *MockPipelinerMockRecorder) FunctionDelete(ctx, libName interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDelete", reflect.TypeOf((*MockPipeliner)(nil).FunctionDelete), ctx, libName) +} + +// FunctionDump mocks base method. +func (m *MockPipeliner) FunctionDump(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionDump", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionDump indicates an expected call of FunctionDump. +func (mr *MockPipelinerMockRecorder) FunctionDump(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDump", reflect.TypeOf((*MockPipeliner)(nil).FunctionDump), ctx) +} + +// FunctionFlush mocks base method. +func (m *MockPipeliner) FunctionFlush(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionFlush", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionFlush indicates an expected call of FunctionFlush. +func (mr *MockPipelinerMockRecorder) FunctionFlush(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlush", reflect.TypeOf((*MockPipeliner)(nil).FunctionFlush), ctx) +} + +// FunctionFlushAsync mocks base method. +func (m *MockPipeliner) FunctionFlushAsync(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionFlushAsync", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionFlushAsync indicates an expected call of FunctionFlushAsync. +func (mr *MockPipelinerMockRecorder) FunctionFlushAsync(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlushAsync", reflect.TypeOf((*MockPipeliner)(nil).FunctionFlushAsync), ctx) +} + +// FunctionKill mocks base method. +func (m *MockPipeliner) FunctionKill(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionKill", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionKill indicates an expected call of FunctionKill. +func (mr *MockPipelinerMockRecorder) FunctionKill(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionKill", reflect.TypeOf((*MockPipeliner)(nil).FunctionKill), ctx) +} + +// FunctionList mocks base method. +func (m *MockPipeliner) FunctionList(ctx context.Context, q redis.FunctionListQuery) *redis.FunctionListCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionList", ctx, q) + ret0, _ := ret[0].(*redis.FunctionListCmd) + return ret0 +} + +// FunctionList indicates an expected call of FunctionList. +func (mr *MockPipelinerMockRecorder) FunctionList(ctx, q interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionList", reflect.TypeOf((*MockPipeliner)(nil).FunctionList), ctx, q) +} + +// FunctionLoad mocks base method. +func (m *MockPipeliner) FunctionLoad(ctx context.Context, code string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionLoad", ctx, code) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionLoad indicates an expected call of FunctionLoad. +func (mr *MockPipelinerMockRecorder) FunctionLoad(ctx, code interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoad", reflect.TypeOf((*MockPipeliner)(nil).FunctionLoad), ctx, code) +} + +// FunctionLoadReplace mocks base method. +func (m *MockPipeliner) FunctionLoadReplace(ctx context.Context, code string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionLoadReplace", ctx, code) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionLoadReplace indicates an expected call of FunctionLoadReplace. +func (mr *MockPipelinerMockRecorder) FunctionLoadReplace(ctx, code interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoadReplace", reflect.TypeOf((*MockPipeliner)(nil).FunctionLoadReplace), ctx, code) +} + +// FunctionRestore mocks base method. +func (m *MockPipeliner) FunctionRestore(ctx context.Context, libDump string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionRestore", ctx, libDump) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionRestore indicates an expected call of FunctionRestore. +func (mr *MockPipelinerMockRecorder) FunctionRestore(ctx, libDump interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionRestore", reflect.TypeOf((*MockPipeliner)(nil).FunctionRestore), ctx, libDump) +} + +// FunctionStats mocks base method. +func (m *MockPipeliner) FunctionStats(ctx context.Context) *redis.FunctionStatsCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionStats", ctx) + ret0, _ := ret[0].(*redis.FunctionStatsCmd) + return ret0 +} + +// FunctionStats indicates an expected call of FunctionStats. +func (mr *MockPipelinerMockRecorder) FunctionStats(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionStats", reflect.TypeOf((*MockPipeliner)(nil).FunctionStats), ctx) +} + +// GeoAdd mocks base method. +func (m *MockPipeliner) GeoAdd(ctx context.Context, key string, geoLocation ...*redis.GeoLocation) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range geoLocation { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GeoAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GeoAdd indicates an expected call of GeoAdd. +func (mr *MockPipelinerMockRecorder) GeoAdd(ctx, key interface{}, geoLocation ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, geoLocation...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoAdd", reflect.TypeOf((*MockPipeliner)(nil).GeoAdd), varargs...) +} + +// GeoDist mocks base method. +func (m *MockPipeliner) GeoDist(ctx context.Context, key, member1, member2, unit string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoDist", ctx, key, member1, member2, unit) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// GeoDist indicates an expected call of GeoDist. +func (mr *MockPipelinerMockRecorder) GeoDist(ctx, key, member1, member2, unit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoDist", reflect.TypeOf((*MockPipeliner)(nil).GeoDist), ctx, key, member1, member2, unit) +} + +// GeoHash mocks base method. +func (m *MockPipeliner) GeoHash(ctx context.Context, key string, members ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GeoHash", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// GeoHash indicates an expected call of GeoHash. +func (mr *MockPipelinerMockRecorder) GeoHash(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoHash", reflect.TypeOf((*MockPipeliner)(nil).GeoHash), varargs...) +} + +// GeoPos mocks base method. +func (m *MockPipeliner) GeoPos(ctx context.Context, key string, members ...string) *redis.GeoPosCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GeoPos", varargs...) + ret0, _ := ret[0].(*redis.GeoPosCmd) + return ret0 +} + +// GeoPos indicates an expected call of GeoPos. +func (mr *MockPipelinerMockRecorder) GeoPos(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoPos", reflect.TypeOf((*MockPipeliner)(nil).GeoPos), varargs...) +} + +// GeoRadius mocks base method. +func (m *MockPipeliner) GeoRadius(ctx context.Context, key string, longitude, latitude float64, query *redis.GeoRadiusQuery) *redis.GeoLocationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoRadius", ctx, key, longitude, latitude, query) + ret0, _ := ret[0].(*redis.GeoLocationCmd) + return ret0 +} + +// GeoRadius indicates an expected call of GeoRadius. +func (mr *MockPipelinerMockRecorder) GeoRadius(ctx, key, longitude, latitude, query interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadius", reflect.TypeOf((*MockPipeliner)(nil).GeoRadius), ctx, key, longitude, latitude, query) +} + +// GeoRadiusByMember mocks base method. +func (m *MockPipeliner) GeoRadiusByMember(ctx context.Context, key, member string, query *redis.GeoRadiusQuery) *redis.GeoLocationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoRadiusByMember", ctx, key, member, query) + ret0, _ := ret[0].(*redis.GeoLocationCmd) + return ret0 +} + +// GeoRadiusByMember indicates an expected call of GeoRadiusByMember. +func (mr *MockPipelinerMockRecorder) GeoRadiusByMember(ctx, key, member, query interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMember", reflect.TypeOf((*MockPipeliner)(nil).GeoRadiusByMember), ctx, key, member, query) +} + +// GeoRadiusByMemberStore mocks base method. +func (m *MockPipeliner) GeoRadiusByMemberStore(ctx context.Context, key, member string, query *redis.GeoRadiusQuery) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoRadiusByMemberStore", ctx, key, member, query) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GeoRadiusByMemberStore indicates an expected call of GeoRadiusByMemberStore. +func (mr *MockPipelinerMockRecorder) GeoRadiusByMemberStore(ctx, key, member, query interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMemberStore", reflect.TypeOf((*MockPipeliner)(nil).GeoRadiusByMemberStore), ctx, key, member, query) +} + +// GeoRadiusStore mocks base method. +func (m *MockPipeliner) GeoRadiusStore(ctx context.Context, key string, longitude, latitude float64, query *redis.GeoRadiusQuery) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoRadiusStore", ctx, key, longitude, latitude, query) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GeoRadiusStore indicates an expected call of GeoRadiusStore. +func (mr *MockPipelinerMockRecorder) GeoRadiusStore(ctx, key, longitude, latitude, query interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusStore", reflect.TypeOf((*MockPipeliner)(nil).GeoRadiusStore), ctx, key, longitude, latitude, query) +} + +// GeoSearch mocks base method. +func (m *MockPipeliner) GeoSearch(ctx context.Context, key string, q *redis.GeoSearchQuery) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoSearch", ctx, key, q) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// GeoSearch indicates an expected call of GeoSearch. +func (mr *MockPipelinerMockRecorder) GeoSearch(ctx, key, q interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearch", reflect.TypeOf((*MockPipeliner)(nil).GeoSearch), ctx, key, q) +} + +// GeoSearchLocation mocks base method. +func (m *MockPipeliner) GeoSearchLocation(ctx context.Context, key string, q *redis.GeoSearchLocationQuery) *redis.GeoSearchLocationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoSearchLocation", ctx, key, q) + ret0, _ := ret[0].(*redis.GeoSearchLocationCmd) + return ret0 +} + +// GeoSearchLocation indicates an expected call of GeoSearchLocation. +func (mr *MockPipelinerMockRecorder) GeoSearchLocation(ctx, key, q interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchLocation", reflect.TypeOf((*MockPipeliner)(nil).GeoSearchLocation), ctx, key, q) +} + +// GeoSearchStore mocks base method. +func (m *MockPipeliner) GeoSearchStore(ctx context.Context, key, store string, q *redis.GeoSearchStoreQuery) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoSearchStore", ctx, key, store, q) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GeoSearchStore indicates an expected call of GeoSearchStore. +func (mr *MockPipelinerMockRecorder) GeoSearchStore(ctx, key, store, q interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchStore", reflect.TypeOf((*MockPipeliner)(nil).GeoSearchStore), ctx, key, store, q) +} + +// Get mocks base method. +func (m *MockPipeliner) Get(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Get", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// Get indicates an expected call of Get. +func (mr *MockPipelinerMockRecorder) Get(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockPipeliner)(nil).Get), ctx, key) +} + +// GetBit mocks base method. +func (m *MockPipeliner) GetBit(ctx context.Context, key string, offset int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetBit", ctx, key, offset) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GetBit indicates an expected call of GetBit. +func (mr *MockPipelinerMockRecorder) GetBit(ctx, key, offset interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBit", reflect.TypeOf((*MockPipeliner)(nil).GetBit), ctx, key, offset) +} + +// GetDel mocks base method. +func (m *MockPipeliner) GetDel(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetDel", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// GetDel indicates an expected call of GetDel. +func (mr *MockPipelinerMockRecorder) GetDel(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDel", reflect.TypeOf((*MockPipeliner)(nil).GetDel), ctx, key) +} + +// GetEx mocks base method. +func (m *MockPipeliner) GetEx(ctx context.Context, key string, expiration time.Duration) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetEx", ctx, key, expiration) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// GetEx indicates an expected call of GetEx. +func (mr *MockPipelinerMockRecorder) GetEx(ctx, key, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEx", reflect.TypeOf((*MockPipeliner)(nil).GetEx), ctx, key, expiration) +} + +// GetRange mocks base method. +func (m *MockPipeliner) GetRange(ctx context.Context, key string, start, end int64) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRange", ctx, key, start, end) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// GetRange indicates an expected call of GetRange. +func (mr *MockPipelinerMockRecorder) GetRange(ctx, key, start, end interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRange", reflect.TypeOf((*MockPipeliner)(nil).GetRange), ctx, key, start, end) +} + +// GetSet mocks base method. +func (m *MockPipeliner) GetSet(ctx context.Context, key string, value interface{}) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSet", ctx, key, value) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// GetSet indicates an expected call of GetSet. +func (mr *MockPipelinerMockRecorder) GetSet(ctx, key, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSet", reflect.TypeOf((*MockPipeliner)(nil).GetSet), ctx, key, value) +} + +// HDel mocks base method. +func (m *MockPipeliner) HDel(ctx context.Context, key string, fields ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HDel", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// HDel indicates an expected call of HDel. +func (mr *MockPipelinerMockRecorder) HDel(ctx, key interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HDel", reflect.TypeOf((*MockPipeliner)(nil).HDel), varargs...) +} + +// HExists mocks base method. +func (m *MockPipeliner) HExists(ctx context.Context, key, field string) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HExists", ctx, key, field) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// HExists indicates an expected call of HExists. +func (mr *MockPipelinerMockRecorder) HExists(ctx, key, field interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExists", reflect.TypeOf((*MockPipeliner)(nil).HExists), ctx, key, field) +} + +// HExpire mocks base method. +func (m *MockPipeliner) HExpire(ctx context.Context, key string, expiration time.Duration, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, expiration} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HExpire", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HExpire indicates an expected call of HExpire. +func (mr *MockPipelinerMockRecorder) HExpire(ctx, key, expiration interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, expiration}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpire", reflect.TypeOf((*MockPipeliner)(nil).HExpire), varargs...) +} + +// HExpireAt mocks base method. +func (m *MockPipeliner) HExpireAt(ctx context.Context, key string, tm time.Time, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, tm} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HExpireAt", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HExpireAt indicates an expected call of HExpireAt. +func (mr *MockPipelinerMockRecorder) HExpireAt(ctx, key, tm interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, tm}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireAt", reflect.TypeOf((*MockPipeliner)(nil).HExpireAt), varargs...) +} + +// HExpireAtWithArgs mocks base method. +func (m *MockPipeliner) HExpireAtWithArgs(ctx context.Context, key string, tm time.Time, expirationArgs redis.HExpireArgs, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, tm, expirationArgs} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HExpireAtWithArgs", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HExpireAtWithArgs indicates an expected call of HExpireAtWithArgs. +func (mr *MockPipelinerMockRecorder) HExpireAtWithArgs(ctx, key, tm, expirationArgs interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, tm, expirationArgs}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireAtWithArgs", reflect.TypeOf((*MockPipeliner)(nil).HExpireAtWithArgs), varargs...) +} + +// HExpireTime mocks base method. +func (m *MockPipeliner) HExpireTime(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HExpireTime", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HExpireTime indicates an expected call of HExpireTime. +func (mr *MockPipelinerMockRecorder) HExpireTime(ctx, key interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireTime", reflect.TypeOf((*MockPipeliner)(nil).HExpireTime), varargs...) +} + +// HExpireWithArgs mocks base method. +func (m *MockPipeliner) HExpireWithArgs(ctx context.Context, key string, expiration time.Duration, expirationArgs redis.HExpireArgs, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, expiration, expirationArgs} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HExpireWithArgs", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HExpireWithArgs indicates an expected call of HExpireWithArgs. +func (mr *MockPipelinerMockRecorder) HExpireWithArgs(ctx, key, expiration, expirationArgs interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, expiration, expirationArgs}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireWithArgs", reflect.TypeOf((*MockPipeliner)(nil).HExpireWithArgs), varargs...) +} + +// HGet mocks base method. +func (m *MockPipeliner) HGet(ctx context.Context, key, field string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HGet", ctx, key, field) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// HGet indicates an expected call of HGet. +func (mr *MockPipelinerMockRecorder) HGet(ctx, key, field interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGet", reflect.TypeOf((*MockPipeliner)(nil).HGet), ctx, key, field) +} + +// HGetAll mocks base method. +func (m *MockPipeliner) HGetAll(ctx context.Context, key string) *redis.MapStringStringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HGetAll", ctx, key) + ret0, _ := ret[0].(*redis.MapStringStringCmd) + return ret0 +} + +// HGetAll indicates an expected call of HGetAll. +func (mr *MockPipelinerMockRecorder) HGetAll(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGetAll", reflect.TypeOf((*MockPipeliner)(nil).HGetAll), ctx, key) +} + +// HIncrBy mocks base method. +func (m *MockPipeliner) HIncrBy(ctx context.Context, key, field string, incr int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HIncrBy", ctx, key, field, incr) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// HIncrBy indicates an expected call of HIncrBy. +func (mr *MockPipelinerMockRecorder) HIncrBy(ctx, key, field, incr interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrBy", reflect.TypeOf((*MockPipeliner)(nil).HIncrBy), ctx, key, field, incr) +} + +// HIncrByFloat mocks base method. +func (m *MockPipeliner) HIncrByFloat(ctx context.Context, key, field string, incr float64) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HIncrByFloat", ctx, key, field, incr) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// HIncrByFloat indicates an expected call of HIncrByFloat. +func (mr *MockPipelinerMockRecorder) HIncrByFloat(ctx, key, field, incr interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrByFloat", reflect.TypeOf((*MockPipeliner)(nil).HIncrByFloat), ctx, key, field, incr) +} + +// HKeys mocks base method. +func (m *MockPipeliner) HKeys(ctx context.Context, key string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HKeys", ctx, key) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// HKeys indicates an expected call of HKeys. +func (mr *MockPipelinerMockRecorder) HKeys(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HKeys", reflect.TypeOf((*MockPipeliner)(nil).HKeys), ctx, key) +} + +// HLen mocks base method. +func (m *MockPipeliner) HLen(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HLen", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// HLen indicates an expected call of HLen. +func (mr *MockPipelinerMockRecorder) HLen(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HLen", reflect.TypeOf((*MockPipeliner)(nil).HLen), ctx, key) +} + +// HMGet mocks base method. +func (m *MockPipeliner) HMGet(ctx context.Context, key string, fields ...string) *redis.SliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HMGet", varargs...) + ret0, _ := ret[0].(*redis.SliceCmd) + return ret0 +} + +// HMGet indicates an expected call of HMGet. +func (mr *MockPipelinerMockRecorder) HMGet(ctx, key interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HMGet", reflect.TypeOf((*MockPipeliner)(nil).HMGet), varargs...) +} + +// HMSet mocks base method. +func (m *MockPipeliner) HMSet(ctx context.Context, key string, values ...interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HMSet", varargs...) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// HMSet indicates an expected call of HMSet. +func (mr *MockPipelinerMockRecorder) HMSet(ctx, key interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HMSet", reflect.TypeOf((*MockPipeliner)(nil).HMSet), varargs...) +} + +// HPExpire mocks base method. +func (m *MockPipeliner) HPExpire(ctx context.Context, key string, expiration time.Duration, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, expiration} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HPExpire", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HPExpire indicates an expected call of HPExpire. +func (mr *MockPipelinerMockRecorder) HPExpire(ctx, key, expiration interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, expiration}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpire", reflect.TypeOf((*MockPipeliner)(nil).HPExpire), varargs...) +} + +// HPExpireAt mocks base method. +func (m *MockPipeliner) HPExpireAt(ctx context.Context, key string, tm time.Time, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, tm} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HPExpireAt", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HPExpireAt indicates an expected call of HPExpireAt. +func (mr *MockPipelinerMockRecorder) HPExpireAt(ctx, key, tm interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, tm}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireAt", reflect.TypeOf((*MockPipeliner)(nil).HPExpireAt), varargs...) +} + +// HPExpireAtWithArgs mocks base method. +func (m *MockPipeliner) HPExpireAtWithArgs(ctx context.Context, key string, tm time.Time, expirationArgs redis.HExpireArgs, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, tm, expirationArgs} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HPExpireAtWithArgs", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HPExpireAtWithArgs indicates an expected call of HPExpireAtWithArgs. +func (mr *MockPipelinerMockRecorder) HPExpireAtWithArgs(ctx, key, tm, expirationArgs interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, tm, expirationArgs}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireAtWithArgs", reflect.TypeOf((*MockPipeliner)(nil).HPExpireAtWithArgs), varargs...) +} + +// HPExpireTime mocks base method. +func (m *MockPipeliner) HPExpireTime(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HPExpireTime", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HPExpireTime indicates an expected call of HPExpireTime. +func (mr *MockPipelinerMockRecorder) HPExpireTime(ctx, key interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireTime", reflect.TypeOf((*MockPipeliner)(nil).HPExpireTime), varargs...) +} + +// HPExpireWithArgs mocks base method. +func (m *MockPipeliner) HPExpireWithArgs(ctx context.Context, key string, expiration time.Duration, expirationArgs redis.HExpireArgs, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, expiration, expirationArgs} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HPExpireWithArgs", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HPExpireWithArgs indicates an expected call of HPExpireWithArgs. +func (mr *MockPipelinerMockRecorder) HPExpireWithArgs(ctx, key, expiration, expirationArgs interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, expiration, expirationArgs}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireWithArgs", reflect.TypeOf((*MockPipeliner)(nil).HPExpireWithArgs), varargs...) +} + +// HPTTL mocks base method. +func (m *MockPipeliner) HPTTL(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HPTTL", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HPTTL indicates an expected call of HPTTL. +func (mr *MockPipelinerMockRecorder) HPTTL(ctx, key interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPTTL", reflect.TypeOf((*MockPipeliner)(nil).HPTTL), varargs...) +} + +// HPersist mocks base method. +func (m *MockPipeliner) HPersist(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HPersist", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HPersist indicates an expected call of HPersist. +func (mr *MockPipelinerMockRecorder) HPersist(ctx, key interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPersist", reflect.TypeOf((*MockPipeliner)(nil).HPersist), varargs...) +} + +// HRandField mocks base method. +func (m *MockPipeliner) HRandField(ctx context.Context, key string, count int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HRandField", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// HRandField indicates an expected call of HRandField. +func (mr *MockPipelinerMockRecorder) HRandField(ctx, key, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandField", reflect.TypeOf((*MockPipeliner)(nil).HRandField), ctx, key, count) +} + +// HRandFieldWithValues mocks base method. +func (m *MockPipeliner) HRandFieldWithValues(ctx context.Context, key string, count int) *redis.KeyValueSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HRandFieldWithValues", ctx, key, count) + ret0, _ := ret[0].(*redis.KeyValueSliceCmd) + return ret0 +} + +// HRandFieldWithValues indicates an expected call of HRandFieldWithValues. +func (mr *MockPipelinerMockRecorder) HRandFieldWithValues(ctx, key, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandFieldWithValues", reflect.TypeOf((*MockPipeliner)(nil).HRandFieldWithValues), ctx, key, count) +} + +// HScan mocks base method. +func (m *MockPipeliner) HScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HScan", ctx, key, cursor, match, count) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// HScan indicates an expected call of HScan. +func (mr *MockPipelinerMockRecorder) HScan(ctx, key, cursor, match, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HScan", reflect.TypeOf((*MockPipeliner)(nil).HScan), ctx, key, cursor, match, count) +} + +// HScanNoValues mocks base method. +func (m *MockPipeliner) HScanNoValues(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HScanNoValues", ctx, key, cursor, match, count) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// HScanNoValues indicates an expected call of HScanNoValues. +func (mr *MockPipelinerMockRecorder) HScanNoValues(ctx, key, cursor, match, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HScanNoValues", reflect.TypeOf((*MockPipeliner)(nil).HScanNoValues), ctx, key, cursor, match, count) +} + +// HSet mocks base method. +func (m *MockPipeliner) HSet(ctx context.Context, key string, values ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HSet", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// HSet indicates an expected call of HSet. +func (mr *MockPipelinerMockRecorder) HSet(ctx, key interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSet", reflect.TypeOf((*MockPipeliner)(nil).HSet), varargs...) +} + +// HSetNX mocks base method. +func (m *MockPipeliner) HSetNX(ctx context.Context, key, field string, value interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HSetNX", ctx, key, field, value) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// HSetNX indicates an expected call of HSetNX. +func (mr *MockPipelinerMockRecorder) HSetNX(ctx, key, field, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSetNX", reflect.TypeOf((*MockPipeliner)(nil).HSetNX), ctx, key, field, value) +} + +// HTTL mocks base method. +func (m *MockPipeliner) HTTL(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HTTL", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HTTL indicates an expected call of HTTL. +func (mr *MockPipelinerMockRecorder) HTTL(ctx, key interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HTTL", reflect.TypeOf((*MockPipeliner)(nil).HTTL), varargs...) +} + +// HVals mocks base method. +func (m *MockPipeliner) HVals(ctx context.Context, key string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HVals", ctx, key) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// HVals indicates an expected call of HVals. +func (mr *MockPipelinerMockRecorder) HVals(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HVals", reflect.TypeOf((*MockPipeliner)(nil).HVals), ctx, key) +} + +// Hello mocks base method. +func (m *MockPipeliner) Hello(ctx context.Context, ver int, username, password, clientName string) *redis.MapStringInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Hello", ctx, ver, username, password, clientName) + ret0, _ := ret[0].(*redis.MapStringInterfaceCmd) + return ret0 +} + +// Hello indicates an expected call of Hello. +func (mr *MockPipelinerMockRecorder) Hello(ctx, ver, username, password, clientName interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Hello", reflect.TypeOf((*MockPipeliner)(nil).Hello), ctx, ver, username, password, clientName) +} + +// Incr mocks base method. +func (m *MockPipeliner) Incr(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Incr", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Incr indicates an expected call of Incr. +func (mr *MockPipelinerMockRecorder) Incr(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Incr", reflect.TypeOf((*MockPipeliner)(nil).Incr), ctx, key) +} + +// IncrBy mocks base method. +func (m *MockPipeliner) IncrBy(ctx context.Context, key string, value int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IncrBy", ctx, key, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// IncrBy indicates an expected call of IncrBy. +func (mr *MockPipelinerMockRecorder) IncrBy(ctx, key, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrBy", reflect.TypeOf((*MockPipeliner)(nil).IncrBy), ctx, key, value) +} + +// IncrByFloat mocks base method. +func (m *MockPipeliner) IncrByFloat(ctx context.Context, key string, value float64) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IncrByFloat", ctx, key, value) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// IncrByFloat indicates an expected call of IncrByFloat. +func (mr *MockPipelinerMockRecorder) IncrByFloat(ctx, key, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrByFloat", reflect.TypeOf((*MockPipeliner)(nil).IncrByFloat), ctx, key, value) +} + +// Info mocks base method. +func (m *MockPipeliner) Info(ctx context.Context, section ...string) *redis.StringCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range section { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Info", varargs...) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// Info indicates an expected call of Info. +func (mr *MockPipelinerMockRecorder) Info(ctx interface{}, section ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, section...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockPipeliner)(nil).Info), varargs...) +} + +// JSONArrAppend mocks base method. +func (m *MockPipeliner) JSONArrAppend(ctx context.Context, key, path string, values ...interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, path} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONArrAppend", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// JSONArrAppend indicates an expected call of JSONArrAppend. +func (mr *MockPipelinerMockRecorder) JSONArrAppend(ctx, key, path interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, path}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrAppend", reflect.TypeOf((*MockPipeliner)(nil).JSONArrAppend), varargs...) +} + +// JSONArrIndex mocks base method. +func (m *MockPipeliner) JSONArrIndex(ctx context.Context, key, path string, value ...interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, path} + for _, a := range value { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONArrIndex", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// JSONArrIndex indicates an expected call of JSONArrIndex. +func (mr *MockPipelinerMockRecorder) JSONArrIndex(ctx, key, path interface{}, value ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, path}, value...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrIndex", reflect.TypeOf((*MockPipeliner)(nil).JSONArrIndex), varargs...) +} + +// JSONArrIndexWithArgs mocks base method. +func (m *MockPipeliner) JSONArrIndexWithArgs(ctx context.Context, key, path string, options *redis.JSONArrIndexArgs, value ...interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, path, options} + for _, a := range value { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONArrIndexWithArgs", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// JSONArrIndexWithArgs indicates an expected call of JSONArrIndexWithArgs. +func (mr *MockPipelinerMockRecorder) JSONArrIndexWithArgs(ctx, key, path, options interface{}, value ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, path, options}, value...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrIndexWithArgs", reflect.TypeOf((*MockPipeliner)(nil).JSONArrIndexWithArgs), varargs...) +} + +// JSONArrInsert mocks base method. +func (m *MockPipeliner) JSONArrInsert(ctx context.Context, key, path string, index int64, values ...interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, path, index} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONArrInsert", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// JSONArrInsert indicates an expected call of JSONArrInsert. +func (mr *MockPipelinerMockRecorder) JSONArrInsert(ctx, key, path, index interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, path, index}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrInsert", reflect.TypeOf((*MockPipeliner)(nil).JSONArrInsert), varargs...) +} + +// JSONArrLen mocks base method. +func (m *MockPipeliner) JSONArrLen(ctx context.Context, key, path string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONArrLen", ctx, key, path) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// JSONArrLen indicates an expected call of JSONArrLen. +func (mr *MockPipelinerMockRecorder) JSONArrLen(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrLen", reflect.TypeOf((*MockPipeliner)(nil).JSONArrLen), ctx, key, path) +} + +// JSONArrPop mocks base method. +func (m *MockPipeliner) JSONArrPop(ctx context.Context, key, path string, index int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONArrPop", ctx, key, path, index) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// JSONArrPop indicates an expected call of JSONArrPop. +func (mr *MockPipelinerMockRecorder) JSONArrPop(ctx, key, path, index interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrPop", reflect.TypeOf((*MockPipeliner)(nil).JSONArrPop), ctx, key, path, index) +} + +// JSONArrTrim mocks base method. +func (m *MockPipeliner) JSONArrTrim(ctx context.Context, key, path string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONArrTrim", ctx, key, path) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// JSONArrTrim indicates an expected call of JSONArrTrim. +func (mr *MockPipelinerMockRecorder) JSONArrTrim(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrTrim", reflect.TypeOf((*MockPipeliner)(nil).JSONArrTrim), ctx, key, path) +} + +// JSONArrTrimWithArgs mocks base method. +func (m *MockPipeliner) JSONArrTrimWithArgs(ctx context.Context, key, path string, options *redis.JSONArrTrimArgs) *redis.IntSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONArrTrimWithArgs", ctx, key, path, options) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// JSONArrTrimWithArgs indicates an expected call of JSONArrTrimWithArgs. +func (mr *MockPipelinerMockRecorder) JSONArrTrimWithArgs(ctx, key, path, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrTrimWithArgs", reflect.TypeOf((*MockPipeliner)(nil).JSONArrTrimWithArgs), ctx, key, path, options) +} + +// JSONClear mocks base method. +func (m *MockPipeliner) JSONClear(ctx context.Context, key, path string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONClear", ctx, key, path) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// JSONClear indicates an expected call of JSONClear. +func (mr *MockPipelinerMockRecorder) JSONClear(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONClear", reflect.TypeOf((*MockPipeliner)(nil).JSONClear), ctx, key, path) +} + +// JSONDebugMemory mocks base method. +func (m *MockPipeliner) JSONDebugMemory(ctx context.Context, key, path string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONDebugMemory", ctx, key, path) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// JSONDebugMemory indicates an expected call of JSONDebugMemory. +func (mr *MockPipelinerMockRecorder) JSONDebugMemory(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONDebugMemory", reflect.TypeOf((*MockPipeliner)(nil).JSONDebugMemory), ctx, key, path) +} + +// JSONDel mocks base method. +func (m *MockPipeliner) JSONDel(ctx context.Context, key, path string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONDel", ctx, key, path) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// JSONDel indicates an expected call of JSONDel. +func (mr *MockPipelinerMockRecorder) JSONDel(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONDel", reflect.TypeOf((*MockPipeliner)(nil).JSONDel), ctx, key, path) +} + +// JSONForget mocks base method. +func (m *MockPipeliner) JSONForget(ctx context.Context, key, path string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONForget", ctx, key, path) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// JSONForget indicates an expected call of JSONForget. +func (mr *MockPipelinerMockRecorder) JSONForget(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONForget", reflect.TypeOf((*MockPipeliner)(nil).JSONForget), ctx, key, path) +} + +// JSONGet mocks base method. +func (m *MockPipeliner) JSONGet(ctx context.Context, key string, paths ...string) *redis.JSONCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range paths { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONGet", varargs...) + ret0, _ := ret[0].(*redis.JSONCmd) + return ret0 +} + +// JSONGet indicates an expected call of JSONGet. +func (mr *MockPipelinerMockRecorder) JSONGet(ctx, key interface{}, paths ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, paths...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONGet", reflect.TypeOf((*MockPipeliner)(nil).JSONGet), varargs...) +} + +// JSONGetWithArgs mocks base method. +func (m *MockPipeliner) JSONGetWithArgs(ctx context.Context, key string, options *redis.JSONGetArgs, paths ...string) *redis.JSONCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, options} + for _, a := range paths { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONGetWithArgs", varargs...) + ret0, _ := ret[0].(*redis.JSONCmd) + return ret0 +} + +// JSONGetWithArgs indicates an expected call of JSONGetWithArgs. +func (mr *MockPipelinerMockRecorder) JSONGetWithArgs(ctx, key, options interface{}, paths ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, options}, paths...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONGetWithArgs", reflect.TypeOf((*MockPipeliner)(nil).JSONGetWithArgs), varargs...) +} + +// JSONMGet mocks base method. +func (m *MockPipeliner) JSONMGet(ctx context.Context, path string, keys ...string) *redis.JSONSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, path} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONMGet", varargs...) + ret0, _ := ret[0].(*redis.JSONSliceCmd) + return ret0 +} + +// JSONMGet indicates an expected call of JSONMGet. +func (mr *MockPipelinerMockRecorder) JSONMGet(ctx, path interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, path}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMGet", reflect.TypeOf((*MockPipeliner)(nil).JSONMGet), varargs...) +} + +// JSONMSet mocks base method. +func (m *MockPipeliner) JSONMSet(ctx context.Context, params ...interface{}) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range params { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONMSet", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// JSONMSet indicates an expected call of JSONMSet. +func (mr *MockPipelinerMockRecorder) JSONMSet(ctx interface{}, params ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, params...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMSet", reflect.TypeOf((*MockPipeliner)(nil).JSONMSet), varargs...) +} + +// JSONMSetArgs mocks base method. +func (m *MockPipeliner) JSONMSetArgs(ctx context.Context, docs []redis.JSONSetArgs) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONMSetArgs", ctx, docs) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// JSONMSetArgs indicates an expected call of JSONMSetArgs. +func (mr *MockPipelinerMockRecorder) JSONMSetArgs(ctx, docs interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMSetArgs", reflect.TypeOf((*MockPipeliner)(nil).JSONMSetArgs), ctx, docs) +} + +// JSONMerge mocks base method. +func (m *MockPipeliner) JSONMerge(ctx context.Context, key, path, value string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONMerge", ctx, key, path, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// JSONMerge indicates an expected call of JSONMerge. +func (mr *MockPipelinerMockRecorder) JSONMerge(ctx, key, path, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMerge", reflect.TypeOf((*MockPipeliner)(nil).JSONMerge), ctx, key, path, value) +} + +// JSONNumIncrBy mocks base method. +func (m *MockPipeliner) JSONNumIncrBy(ctx context.Context, key, path string, value float64) *redis.JSONCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONNumIncrBy", ctx, key, path, value) + ret0, _ := ret[0].(*redis.JSONCmd) + return ret0 +} + +// JSONNumIncrBy indicates an expected call of JSONNumIncrBy. +func (mr *MockPipelinerMockRecorder) JSONNumIncrBy(ctx, key, path, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONNumIncrBy", reflect.TypeOf((*MockPipeliner)(nil).JSONNumIncrBy), ctx, key, path, value) +} + +// JSONObjKeys mocks base method. +func (m *MockPipeliner) JSONObjKeys(ctx context.Context, key, path string) *redis.SliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONObjKeys", ctx, key, path) + ret0, _ := ret[0].(*redis.SliceCmd) + return ret0 +} + +// JSONObjKeys indicates an expected call of JSONObjKeys. +func (mr *MockPipelinerMockRecorder) JSONObjKeys(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONObjKeys", reflect.TypeOf((*MockPipeliner)(nil).JSONObjKeys), ctx, key, path) +} + +// JSONObjLen mocks base method. +func (m *MockPipeliner) JSONObjLen(ctx context.Context, key, path string) *redis.IntPointerSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONObjLen", ctx, key, path) + ret0, _ := ret[0].(*redis.IntPointerSliceCmd) + return ret0 +} + +// JSONObjLen indicates an expected call of JSONObjLen. +func (mr *MockPipelinerMockRecorder) JSONObjLen(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONObjLen", reflect.TypeOf((*MockPipeliner)(nil).JSONObjLen), ctx, key, path) +} + +// JSONSet mocks base method. +func (m *MockPipeliner) JSONSet(ctx context.Context, key, path string, value interface{}) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONSet", ctx, key, path, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// JSONSet indicates an expected call of JSONSet. +func (mr *MockPipelinerMockRecorder) JSONSet(ctx, key, path, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONSet", reflect.TypeOf((*MockPipeliner)(nil).JSONSet), ctx, key, path, value) +} + +// JSONSetMode mocks base method. +func (m *MockPipeliner) JSONSetMode(ctx context.Context, key, path string, value interface{}, mode string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONSetMode", ctx, key, path, value, mode) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// JSONSetMode indicates an expected call of JSONSetMode. +func (mr *MockPipelinerMockRecorder) JSONSetMode(ctx, key, path, value, mode interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONSetMode", reflect.TypeOf((*MockPipeliner)(nil).JSONSetMode), ctx, key, path, value, mode) +} + +// JSONStrAppend mocks base method. +func (m *MockPipeliner) JSONStrAppend(ctx context.Context, key, path, value string) *redis.IntPointerSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONStrAppend", ctx, key, path, value) + ret0, _ := ret[0].(*redis.IntPointerSliceCmd) + return ret0 +} + +// JSONStrAppend indicates an expected call of JSONStrAppend. +func (mr *MockPipelinerMockRecorder) JSONStrAppend(ctx, key, path, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONStrAppend", reflect.TypeOf((*MockPipeliner)(nil).JSONStrAppend), ctx, key, path, value) +} + +// JSONStrLen mocks base method. +func (m *MockPipeliner) JSONStrLen(ctx context.Context, key, path string) *redis.IntPointerSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONStrLen", ctx, key, path) + ret0, _ := ret[0].(*redis.IntPointerSliceCmd) + return ret0 +} + +// JSONStrLen indicates an expected call of JSONStrLen. +func (mr *MockPipelinerMockRecorder) JSONStrLen(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONStrLen", reflect.TypeOf((*MockPipeliner)(nil).JSONStrLen), ctx, key, path) +} + +// JSONToggle mocks base method. +func (m *MockPipeliner) JSONToggle(ctx context.Context, key, path string) *redis.IntPointerSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONToggle", ctx, key, path) + ret0, _ := ret[0].(*redis.IntPointerSliceCmd) + return ret0 +} + +// JSONToggle indicates an expected call of JSONToggle. +func (mr *MockPipelinerMockRecorder) JSONToggle(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONToggle", reflect.TypeOf((*MockPipeliner)(nil).JSONToggle), ctx, key, path) +} + +// JSONType mocks base method. +func (m *MockPipeliner) JSONType(ctx context.Context, key, path string) *redis.JSONSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONType", ctx, key, path) + ret0, _ := ret[0].(*redis.JSONSliceCmd) + return ret0 +} + +// JSONType indicates an expected call of JSONType. +func (mr *MockPipelinerMockRecorder) JSONType(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONType", reflect.TypeOf((*MockPipeliner)(nil).JSONType), ctx, key, path) +} + +// Keys mocks base method. +func (m *MockPipeliner) Keys(ctx context.Context, pattern string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Keys", ctx, pattern) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// Keys indicates an expected call of Keys. +func (mr *MockPipelinerMockRecorder) Keys(ctx, pattern interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Keys", reflect.TypeOf((*MockPipeliner)(nil).Keys), ctx, pattern) +} + +// LCS mocks base method. +func (m *MockPipeliner) LCS(ctx context.Context, q *redis.LCSQuery) *redis.LCSCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LCS", ctx, q) + ret0, _ := ret[0].(*redis.LCSCmd) + return ret0 +} + +// LCS indicates an expected call of LCS. +func (mr *MockPipelinerMockRecorder) LCS(ctx, q interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LCS", reflect.TypeOf((*MockPipeliner)(nil).LCS), ctx, q) +} + +// LIndex mocks base method. +func (m *MockPipeliner) LIndex(ctx context.Context, key string, index int64) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LIndex", ctx, key, index) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// LIndex indicates an expected call of LIndex. +func (mr *MockPipelinerMockRecorder) LIndex(ctx, key, index interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LIndex", reflect.TypeOf((*MockPipeliner)(nil).LIndex), ctx, key, index) +} + +// LInsert mocks base method. +func (m *MockPipeliner) LInsert(ctx context.Context, key, op string, pivot, value interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LInsert", ctx, key, op, pivot, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LInsert indicates an expected call of LInsert. +func (mr *MockPipelinerMockRecorder) LInsert(ctx, key, op, pivot, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsert", reflect.TypeOf((*MockPipeliner)(nil).LInsert), ctx, key, op, pivot, value) +} + +// LInsertAfter mocks base method. +func (m *MockPipeliner) LInsertAfter(ctx context.Context, key string, pivot, value interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LInsertAfter", ctx, key, pivot, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LInsertAfter indicates an expected call of LInsertAfter. +func (mr *MockPipelinerMockRecorder) LInsertAfter(ctx, key, pivot, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertAfter", reflect.TypeOf((*MockPipeliner)(nil).LInsertAfter), ctx, key, pivot, value) +} + +// LInsertBefore mocks base method. +func (m *MockPipeliner) LInsertBefore(ctx context.Context, key string, pivot, value interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LInsertBefore", ctx, key, pivot, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LInsertBefore indicates an expected call of LInsertBefore. +func (mr *MockPipelinerMockRecorder) LInsertBefore(ctx, key, pivot, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertBefore", reflect.TypeOf((*MockPipeliner)(nil).LInsertBefore), ctx, key, pivot, value) +} + +// LLen mocks base method. +func (m *MockPipeliner) LLen(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LLen", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LLen indicates an expected call of LLen. +func (mr *MockPipelinerMockRecorder) LLen(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LLen", reflect.TypeOf((*MockPipeliner)(nil).LLen), ctx, key) +} + +// LMPop mocks base method. +func (m *MockPipeliner) LMPop(ctx context.Context, direction string, count int64, keys ...string) *redis.KeyValuesCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, direction, count} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "LMPop", varargs...) + ret0, _ := ret[0].(*redis.KeyValuesCmd) + return ret0 +} + +// LMPop indicates an expected call of LMPop. +func (mr *MockPipelinerMockRecorder) LMPop(ctx, direction, count interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, direction, count}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LMPop", reflect.TypeOf((*MockPipeliner)(nil).LMPop), varargs...) +} + +// LMove mocks base method. +func (m *MockPipeliner) LMove(ctx context.Context, source, destination, srcpos, destpos string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LMove", ctx, source, destination, srcpos, destpos) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// LMove indicates an expected call of LMove. +func (mr *MockPipelinerMockRecorder) LMove(ctx, source, destination, srcpos, destpos interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LMove", reflect.TypeOf((*MockPipeliner)(nil).LMove), ctx, source, destination, srcpos, destpos) +} + +// LPop mocks base method. +func (m *MockPipeliner) LPop(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LPop", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// LPop indicates an expected call of LPop. +func (mr *MockPipelinerMockRecorder) LPop(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPop", reflect.TypeOf((*MockPipeliner)(nil).LPop), ctx, key) +} + +// LPopCount mocks base method. +func (m *MockPipeliner) LPopCount(ctx context.Context, key string, count int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LPopCount", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// LPopCount indicates an expected call of LPopCount. +func (mr *MockPipelinerMockRecorder) LPopCount(ctx, key, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPopCount", reflect.TypeOf((*MockPipeliner)(nil).LPopCount), ctx, key, count) +} + +// LPos mocks base method. +func (m *MockPipeliner) LPos(ctx context.Context, key, value string, args redis.LPosArgs) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LPos", ctx, key, value, args) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LPos indicates an expected call of LPos. +func (mr *MockPipelinerMockRecorder) LPos(ctx, key, value, args interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPos", reflect.TypeOf((*MockPipeliner)(nil).LPos), ctx, key, value, args) +} + +// LPosCount mocks base method. +func (m *MockPipeliner) LPosCount(ctx context.Context, key, value string, count int64, args redis.LPosArgs) *redis.IntSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LPosCount", ctx, key, value, count, args) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// LPosCount indicates an expected call of LPosCount. +func (mr *MockPipelinerMockRecorder) LPosCount(ctx, key, value, count, args interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPosCount", reflect.TypeOf((*MockPipeliner)(nil).LPosCount), ctx, key, value, count, args) +} + +// LPush mocks base method. +func (m *MockPipeliner) LPush(ctx context.Context, key string, values ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "LPush", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LPush indicates an expected call of LPush. +func (mr *MockPipelinerMockRecorder) LPush(ctx, key interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPush", reflect.TypeOf((*MockPipeliner)(nil).LPush), varargs...) +} + +// LPushX mocks base method. +func (m *MockPipeliner) LPushX(ctx context.Context, key string, values ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "LPushX", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LPushX indicates an expected call of LPushX. +func (mr *MockPipelinerMockRecorder) LPushX(ctx, key interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPushX", reflect.TypeOf((*MockPipeliner)(nil).LPushX), varargs...) +} + +// LRange mocks base method. +func (m *MockPipeliner) LRange(ctx context.Context, key string, start, stop int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LRange", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// LRange indicates an expected call of LRange. +func (mr *MockPipelinerMockRecorder) LRange(ctx, key, start, stop interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRange", reflect.TypeOf((*MockPipeliner)(nil).LRange), ctx, key, start, stop) +} + +// LRem mocks base method. +func (m *MockPipeliner) LRem(ctx context.Context, key string, count int64, value interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LRem", ctx, key, count, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LRem indicates an expected call of LRem. +func (mr *MockPipelinerMockRecorder) LRem(ctx, key, count, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRem", reflect.TypeOf((*MockPipeliner)(nil).LRem), ctx, key, count, value) +} + +// LSet mocks base method. +func (m *MockPipeliner) LSet(ctx context.Context, key string, index int64, value interface{}) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LSet", ctx, key, index, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// LSet indicates an expected call of LSet. +func (mr *MockPipelinerMockRecorder) LSet(ctx, key, index, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LSet", reflect.TypeOf((*MockPipeliner)(nil).LSet), ctx, key, index, value) +} + +// LTrim mocks base method. +func (m *MockPipeliner) LTrim(ctx context.Context, key string, start, stop int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LTrim", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// LTrim indicates an expected call of LTrim. +func (mr *MockPipelinerMockRecorder) LTrim(ctx, key, start, stop interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LTrim", reflect.TypeOf((*MockPipeliner)(nil).LTrim), ctx, key, start, stop) +} + +// LastSave mocks base method. +func (m *MockPipeliner) LastSave(ctx context.Context) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LastSave", ctx) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LastSave indicates an expected call of LastSave. +func (mr *MockPipelinerMockRecorder) LastSave(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastSave", reflect.TypeOf((*MockPipeliner)(nil).LastSave), ctx) +} + +// Len mocks base method. +func (m *MockPipeliner) Len() int { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Len") + ret0, _ := ret[0].(int) + return ret0 +} + +// Len indicates an expected call of Len. +func (mr *MockPipelinerMockRecorder) Len() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Len", reflect.TypeOf((*MockPipeliner)(nil).Len)) +} + +// MGet mocks base method. +func (m *MockPipeliner) MGet(ctx context.Context, keys ...string) *redis.SliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MGet", varargs...) + ret0, _ := ret[0].(*redis.SliceCmd) + return ret0 +} + +// MGet indicates an expected call of MGet. +func (mr *MockPipelinerMockRecorder) MGet(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGet", reflect.TypeOf((*MockPipeliner)(nil).MGet), varargs...) +} + +// MSet mocks base method. +func (m *MockPipeliner) MSet(ctx context.Context, values ...interface{}) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MSet", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// MSet indicates an expected call of MSet. +func (mr *MockPipelinerMockRecorder) MSet(ctx interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MSet", reflect.TypeOf((*MockPipeliner)(nil).MSet), varargs...) +} + +// MSetNX mocks base method. +func (m *MockPipeliner) MSetNX(ctx context.Context, values ...interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MSetNX", varargs...) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// MSetNX indicates an expected call of MSetNX. +func (mr *MockPipelinerMockRecorder) MSetNX(ctx interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MSetNX", reflect.TypeOf((*MockPipeliner)(nil).MSetNX), varargs...) +} + +// MemoryUsage mocks base method. +func (m *MockPipeliner) MemoryUsage(ctx context.Context, key string, samples ...int) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range samples { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MemoryUsage", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// MemoryUsage indicates an expected call of MemoryUsage. +func (mr *MockPipelinerMockRecorder) MemoryUsage(ctx, key interface{}, samples ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, samples...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MemoryUsage", reflect.TypeOf((*MockPipeliner)(nil).MemoryUsage), varargs...) +} + +// Migrate mocks base method. +func (m *MockPipeliner) Migrate(ctx context.Context, host, port, key string, db int, timeout time.Duration) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Migrate", ctx, host, port, key, db, timeout) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Migrate indicates an expected call of Migrate. +func (mr *MockPipelinerMockRecorder) Migrate(ctx, host, port, key, db, timeout interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Migrate", reflect.TypeOf((*MockPipeliner)(nil).Migrate), ctx, host, port, key, db, timeout) +} + +// ModuleLoadex mocks base method. +func (m *MockPipeliner) ModuleLoadex(ctx context.Context, conf *redis.ModuleLoadexConfig) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModuleLoadex", ctx, conf) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ModuleLoadex indicates an expected call of ModuleLoadex. +func (mr *MockPipelinerMockRecorder) ModuleLoadex(ctx, conf interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModuleLoadex", reflect.TypeOf((*MockPipeliner)(nil).ModuleLoadex), ctx, conf) +} + +// Move mocks base method. +func (m *MockPipeliner) Move(ctx context.Context, key string, db int) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Move", ctx, key, db) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// Move indicates an expected call of Move. +func (mr *MockPipelinerMockRecorder) Move(ctx, key, db interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Move", reflect.TypeOf((*MockPipeliner)(nil).Move), ctx, key, db) +} + +// ObjectEncoding mocks base method. +func (m *MockPipeliner) ObjectEncoding(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ObjectEncoding", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ObjectEncoding indicates an expected call of ObjectEncoding. +func (mr *MockPipelinerMockRecorder) ObjectEncoding(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectEncoding", reflect.TypeOf((*MockPipeliner)(nil).ObjectEncoding), ctx, key) +} + +// ObjectFreq mocks base method. +func (m *MockPipeliner) ObjectFreq(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ObjectFreq", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ObjectFreq indicates an expected call of ObjectFreq. +func (mr *MockPipelinerMockRecorder) ObjectFreq(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectFreq", reflect.TypeOf((*MockPipeliner)(nil).ObjectFreq), ctx, key) +} + +// ObjectIdleTime mocks base method. +func (m *MockPipeliner) ObjectIdleTime(ctx context.Context, key string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ObjectIdleTime", ctx, key) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// ObjectIdleTime indicates an expected call of ObjectIdleTime. +func (mr *MockPipelinerMockRecorder) ObjectIdleTime(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectIdleTime", reflect.TypeOf((*MockPipeliner)(nil).ObjectIdleTime), ctx, key) +} + +// ObjectRefCount mocks base method. +func (m *MockPipeliner) ObjectRefCount(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ObjectRefCount", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ObjectRefCount indicates an expected call of ObjectRefCount. +func (mr *MockPipelinerMockRecorder) ObjectRefCount(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectRefCount", reflect.TypeOf((*MockPipeliner)(nil).ObjectRefCount), ctx, key) +} + +// PExpire mocks base method. +func (m *MockPipeliner) PExpire(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PExpire", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// PExpire indicates an expected call of PExpire. +func (mr *MockPipelinerMockRecorder) PExpire(ctx, key, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpire", reflect.TypeOf((*MockPipeliner)(nil).PExpire), ctx, key, expiration) +} + +// PExpireAt mocks base method. +func (m *MockPipeliner) PExpireAt(ctx context.Context, key string, tm time.Time) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PExpireAt", ctx, key, tm) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// PExpireAt indicates an expected call of PExpireAt. +func (mr *MockPipelinerMockRecorder) PExpireAt(ctx, key, tm interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpireAt", reflect.TypeOf((*MockPipeliner)(nil).PExpireAt), ctx, key, tm) +} + +// PExpireTime mocks base method. +func (m *MockPipeliner) PExpireTime(ctx context.Context, key string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PExpireTime", ctx, key) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// PExpireTime indicates an expected call of PExpireTime. +func (mr *MockPipelinerMockRecorder) PExpireTime(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpireTime", reflect.TypeOf((*MockPipeliner)(nil).PExpireTime), ctx, key) +} + +// PFAdd mocks base method. +func (m *MockPipeliner) PFAdd(ctx context.Context, key string, els ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range els { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PFAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// PFAdd indicates an expected call of PFAdd. +func (mr *MockPipelinerMockRecorder) PFAdd(ctx, key interface{}, els ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, els...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFAdd", reflect.TypeOf((*MockPipeliner)(nil).PFAdd), varargs...) +} + +// PFCount mocks base method. +func (m *MockPipeliner) PFCount(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PFCount", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// PFCount indicates an expected call of PFCount. +func (mr *MockPipelinerMockRecorder) PFCount(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFCount", reflect.TypeOf((*MockPipeliner)(nil).PFCount), varargs...) +} + +// PFMerge mocks base method. +func (m *MockPipeliner) PFMerge(ctx context.Context, dest string, keys ...string) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, dest} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PFMerge", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// PFMerge indicates an expected call of PFMerge. +func (mr *MockPipelinerMockRecorder) PFMerge(ctx, dest interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, dest}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFMerge", reflect.TypeOf((*MockPipeliner)(nil).PFMerge), varargs...) +} + +// PTTL mocks base method. +func (m *MockPipeliner) PTTL(ctx context.Context, key string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PTTL", ctx, key) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// PTTL indicates an expected call of PTTL. +func (mr *MockPipelinerMockRecorder) PTTL(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PTTL", reflect.TypeOf((*MockPipeliner)(nil).PTTL), ctx, key) +} + +// Persist mocks base method. +func (m *MockPipeliner) Persist(ctx context.Context, key string) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Persist", ctx, key) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// Persist indicates an expected call of Persist. +func (mr *MockPipelinerMockRecorder) Persist(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Persist", reflect.TypeOf((*MockPipeliner)(nil).Persist), ctx, key) +} + +// Ping mocks base method. +func (m *MockPipeliner) Ping(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Ping", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Ping indicates an expected call of Ping. +func (mr *MockPipelinerMockRecorder) Ping(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockPipeliner)(nil).Ping), ctx) +} + +// Pipeline mocks base method. +func (m *MockPipeliner) Pipeline() redis.Pipeliner { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Pipeline") + ret0, _ := ret[0].(redis.Pipeliner) + return ret0 +} + +// Pipeline indicates an expected call of Pipeline. +func (mr *MockPipelinerMockRecorder) Pipeline() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipeline", reflect.TypeOf((*MockPipeliner)(nil).Pipeline)) +} + +// Pipelined mocks base method. +func (m *MockPipeliner) Pipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Pipelined", ctx, fn) + ret0, _ := ret[0].([]redis.Cmder) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Pipelined indicates an expected call of Pipelined. +func (mr *MockPipelinerMockRecorder) Pipelined(ctx, fn interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipelined", reflect.TypeOf((*MockPipeliner)(nil).Pipelined), ctx, fn) +} + +// Process mocks base method. +func (m *MockPipeliner) Process(ctx context.Context, cmd redis.Cmder) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Process", ctx, cmd) + ret0, _ := ret[0].(error) + return ret0 +} + +// Process indicates an expected call of Process. +func (mr *MockPipelinerMockRecorder) Process(ctx, cmd interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Process", reflect.TypeOf((*MockPipeliner)(nil).Process), ctx, cmd) +} + +// PubSubChannels mocks base method. +func (m *MockPipeliner) PubSubChannels(ctx context.Context, pattern string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PubSubChannels", ctx, pattern) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// PubSubChannels indicates an expected call of PubSubChannels. +func (mr *MockPipelinerMockRecorder) PubSubChannels(ctx, pattern interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubChannels", reflect.TypeOf((*MockPipeliner)(nil).PubSubChannels), ctx, pattern) +} + +// PubSubNumPat mocks base method. +func (m *MockPipeliner) PubSubNumPat(ctx context.Context) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PubSubNumPat", ctx) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// PubSubNumPat indicates an expected call of PubSubNumPat. +func (mr *MockPipelinerMockRecorder) PubSubNumPat(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubNumPat", reflect.TypeOf((*MockPipeliner)(nil).PubSubNumPat), ctx) +} + +// PubSubNumSub mocks base method. +func (m *MockPipeliner) PubSubNumSub(ctx context.Context, channels ...string) *redis.MapStringIntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range channels { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PubSubNumSub", varargs...) + ret0, _ := ret[0].(*redis.MapStringIntCmd) + return ret0 +} + +// PubSubNumSub indicates an expected call of PubSubNumSub. +func (mr *MockPipelinerMockRecorder) PubSubNumSub(ctx interface{}, channels ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, channels...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubNumSub", reflect.TypeOf((*MockPipeliner)(nil).PubSubNumSub), varargs...) +} + +// PubSubShardChannels mocks base method. +func (m *MockPipeliner) PubSubShardChannels(ctx context.Context, pattern string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PubSubShardChannels", ctx, pattern) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// PubSubShardChannels indicates an expected call of PubSubShardChannels. +func (mr *MockPipelinerMockRecorder) PubSubShardChannels(ctx, pattern interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubShardChannels", reflect.TypeOf((*MockPipeliner)(nil).PubSubShardChannels), ctx, pattern) +} + +// PubSubShardNumSub mocks base method. +func (m *MockPipeliner) PubSubShardNumSub(ctx context.Context, channels ...string) *redis.MapStringIntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range channels { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PubSubShardNumSub", varargs...) + ret0, _ := ret[0].(*redis.MapStringIntCmd) + return ret0 +} + +// PubSubShardNumSub indicates an expected call of PubSubShardNumSub. +func (mr *MockPipelinerMockRecorder) PubSubShardNumSub(ctx interface{}, channels ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, channels...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubShardNumSub", reflect.TypeOf((*MockPipeliner)(nil).PubSubShardNumSub), varargs...) +} + +// Publish mocks base method. +func (m *MockPipeliner) Publish(ctx context.Context, channel string, message interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Publish", ctx, channel, message) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Publish indicates an expected call of Publish. +func (mr *MockPipelinerMockRecorder) Publish(ctx, channel, message interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Publish", reflect.TypeOf((*MockPipeliner)(nil).Publish), ctx, channel, message) +} + +// Quit mocks base method. +func (m *MockPipeliner) Quit(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Quit", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Quit indicates an expected call of Quit. +func (mr *MockPipelinerMockRecorder) Quit(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Quit", reflect.TypeOf((*MockPipeliner)(nil).Quit), ctx) +} + +// RPop mocks base method. +func (m *MockPipeliner) RPop(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RPop", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// RPop indicates an expected call of RPop. +func (mr *MockPipelinerMockRecorder) RPop(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPop", reflect.TypeOf((*MockPipeliner)(nil).RPop), ctx, key) +} + +// RPopCount mocks base method. +func (m *MockPipeliner) RPopCount(ctx context.Context, key string, count int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RPopCount", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// RPopCount indicates an expected call of RPopCount. +func (mr *MockPipelinerMockRecorder) RPopCount(ctx, key, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopCount", reflect.TypeOf((*MockPipeliner)(nil).RPopCount), ctx, key, count) +} + +// RPopLPush mocks base method. +func (m *MockPipeliner) RPopLPush(ctx context.Context, source, destination string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RPopLPush", ctx, source, destination) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// RPopLPush indicates an expected call of RPopLPush. +func (mr *MockPipelinerMockRecorder) RPopLPush(ctx, source, destination interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopLPush", reflect.TypeOf((*MockPipeliner)(nil).RPopLPush), ctx, source, destination) +} + +// RPush mocks base method. +func (m *MockPipeliner) RPush(ctx context.Context, key string, values ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RPush", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// RPush indicates an expected call of RPush. +func (mr *MockPipelinerMockRecorder) RPush(ctx, key interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPush", reflect.TypeOf((*MockPipeliner)(nil).RPush), varargs...) +} + +// RPushX mocks base method. +func (m *MockPipeliner) RPushX(ctx context.Context, key string, values ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RPushX", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// RPushX indicates an expected call of RPushX. +func (mr *MockPipelinerMockRecorder) RPushX(ctx, key interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPushX", reflect.TypeOf((*MockPipeliner)(nil).RPushX), varargs...) +} + +// RandomKey mocks base method. +func (m *MockPipeliner) RandomKey(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RandomKey", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// RandomKey indicates an expected call of RandomKey. +func (mr *MockPipelinerMockRecorder) RandomKey(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RandomKey", reflect.TypeOf((*MockPipeliner)(nil).RandomKey), ctx) +} + +// ReadOnly mocks base method. +func (m *MockPipeliner) ReadOnly(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadOnly", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ReadOnly indicates an expected call of ReadOnly. +func (mr *MockPipelinerMockRecorder) ReadOnly(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadOnly", reflect.TypeOf((*MockPipeliner)(nil).ReadOnly), ctx) +} + +// ReadWrite mocks base method. +func (m *MockPipeliner) ReadWrite(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadWrite", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ReadWrite indicates an expected call of ReadWrite. +func (mr *MockPipelinerMockRecorder) ReadWrite(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadWrite", reflect.TypeOf((*MockPipeliner)(nil).ReadWrite), ctx) +} + +// Rename mocks base method. +func (m *MockPipeliner) Rename(ctx context.Context, key, newkey string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Rename", ctx, key, newkey) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Rename indicates an expected call of Rename. +func (mr *MockPipelinerMockRecorder) Rename(ctx, key, newkey interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rename", reflect.TypeOf((*MockPipeliner)(nil).Rename), ctx, key, newkey) +} + +// RenameNX mocks base method. +func (m *MockPipeliner) RenameNX(ctx context.Context, key, newkey string) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RenameNX", ctx, key, newkey) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// RenameNX indicates an expected call of RenameNX. +func (mr *MockPipelinerMockRecorder) RenameNX(ctx, key, newkey interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameNX", reflect.TypeOf((*MockPipeliner)(nil).RenameNX), ctx, key, newkey) +} + +// Restore mocks base method. +func (m *MockPipeliner) Restore(ctx context.Context, key string, ttl time.Duration, value string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Restore", ctx, key, ttl, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Restore indicates an expected call of Restore. +func (mr *MockPipelinerMockRecorder) Restore(ctx, key, ttl, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Restore", reflect.TypeOf((*MockPipeliner)(nil).Restore), ctx, key, ttl, value) +} + +// RestoreReplace mocks base method. +func (m *MockPipeliner) RestoreReplace(ctx context.Context, key string, ttl time.Duration, value string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RestoreReplace", ctx, key, ttl, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// RestoreReplace indicates an expected call of RestoreReplace. +func (mr *MockPipelinerMockRecorder) RestoreReplace(ctx, key, ttl, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreReplace", reflect.TypeOf((*MockPipeliner)(nil).RestoreReplace), ctx, key, ttl, value) +} + +// SAdd mocks base method. +func (m *MockPipeliner) SAdd(ctx context.Context, key string, members ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SAdd indicates an expected call of SAdd. +func (mr *MockPipelinerMockRecorder) SAdd(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SAdd", reflect.TypeOf((*MockPipeliner)(nil).SAdd), varargs...) +} + +// SCard mocks base method. +func (m *MockPipeliner) SCard(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SCard", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SCard indicates an expected call of SCard. +func (mr *MockPipelinerMockRecorder) SCard(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SCard", reflect.TypeOf((*MockPipeliner)(nil).SCard), ctx, key) +} + +// SDiff mocks base method. +func (m *MockPipeliner) SDiff(ctx context.Context, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SDiff", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SDiff indicates an expected call of SDiff. +func (mr *MockPipelinerMockRecorder) SDiff(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SDiff", reflect.TypeOf((*MockPipeliner)(nil).SDiff), varargs...) +} + +// SDiffStore mocks base method. +func (m *MockPipeliner) SDiffStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, destination} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SDiffStore", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SDiffStore indicates an expected call of SDiffStore. +func (mr *MockPipelinerMockRecorder) SDiffStore(ctx, destination interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, destination}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SDiffStore", reflect.TypeOf((*MockPipeliner)(nil).SDiffStore), varargs...) +} + +// SInter mocks base method. +func (m *MockPipeliner) SInter(ctx context.Context, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SInter", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SInter indicates an expected call of SInter. +func (mr *MockPipelinerMockRecorder) SInter(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInter", reflect.TypeOf((*MockPipeliner)(nil).SInter), varargs...) +} + +// SInterCard mocks base method. +func (m *MockPipeliner) SInterCard(ctx context.Context, limit int64, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, limit} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SInterCard", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SInterCard indicates an expected call of SInterCard. +func (mr *MockPipelinerMockRecorder) SInterCard(ctx, limit interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, limit}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInterCard", reflect.TypeOf((*MockPipeliner)(nil).SInterCard), varargs...) +} + +// SInterStore mocks base method. +func (m *MockPipeliner) SInterStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, destination} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SInterStore", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SInterStore indicates an expected call of SInterStore. +func (mr *MockPipelinerMockRecorder) SInterStore(ctx, destination interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, destination}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInterStore", reflect.TypeOf((*MockPipeliner)(nil).SInterStore), varargs...) +} + +// SIsMember mocks base method. +func (m *MockPipeliner) SIsMember(ctx context.Context, key string, member interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SIsMember", ctx, key, member) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// SIsMember indicates an expected call of SIsMember. +func (mr *MockPipelinerMockRecorder) SIsMember(ctx, key, member interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SIsMember", reflect.TypeOf((*MockPipeliner)(nil).SIsMember), ctx, key, member) +} + +// SMIsMember mocks base method. +func (m *MockPipeliner) SMIsMember(ctx context.Context, key string, members ...interface{}) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SMIsMember", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// SMIsMember indicates an expected call of SMIsMember. +func (mr *MockPipelinerMockRecorder) SMIsMember(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMIsMember", reflect.TypeOf((*MockPipeliner)(nil).SMIsMember), varargs...) +} + +// SMembers mocks base method. +func (m *MockPipeliner) SMembers(ctx context.Context, key string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SMembers", ctx, key) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SMembers indicates an expected call of SMembers. +func (mr *MockPipelinerMockRecorder) SMembers(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembers", reflect.TypeOf((*MockPipeliner)(nil).SMembers), ctx, key) +} + +// SMembersMap mocks base method. +func (m *MockPipeliner) SMembersMap(ctx context.Context, key string) *redis.StringStructMapCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SMembersMap", ctx, key) + ret0, _ := ret[0].(*redis.StringStructMapCmd) + return ret0 +} + +// SMembersMap indicates an expected call of SMembersMap. +func (mr *MockPipelinerMockRecorder) SMembersMap(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembersMap", reflect.TypeOf((*MockPipeliner)(nil).SMembersMap), ctx, key) +} + +// SMove mocks base method. +func (m *MockPipeliner) SMove(ctx context.Context, source, destination string, member interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SMove", ctx, source, destination, member) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// SMove indicates an expected call of SMove. +func (mr *MockPipelinerMockRecorder) SMove(ctx, source, destination, member interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMove", reflect.TypeOf((*MockPipeliner)(nil).SMove), ctx, source, destination, member) +} + +// SPop mocks base method. +func (m *MockPipeliner) SPop(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SPop", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// SPop indicates an expected call of SPop. +func (mr *MockPipelinerMockRecorder) SPop(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPop", reflect.TypeOf((*MockPipeliner)(nil).SPop), ctx, key) +} + +// SPopN mocks base method. +func (m *MockPipeliner) SPopN(ctx context.Context, key string, count int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SPopN", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SPopN indicates an expected call of SPopN. +func (mr *MockPipelinerMockRecorder) SPopN(ctx, key, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPopN", reflect.TypeOf((*MockPipeliner)(nil).SPopN), ctx, key, count) +} + +// SPublish mocks base method. +func (m *MockPipeliner) SPublish(ctx context.Context, channel string, message interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SPublish", ctx, channel, message) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SPublish indicates an expected call of SPublish. +func (mr *MockPipelinerMockRecorder) SPublish(ctx, channel, message interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPublish", reflect.TypeOf((*MockPipeliner)(nil).SPublish), ctx, channel, message) +} + +// SRandMember mocks base method. +func (m *MockPipeliner) SRandMember(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SRandMember", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// SRandMember indicates an expected call of SRandMember. +func (mr *MockPipelinerMockRecorder) SRandMember(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMember", reflect.TypeOf((*MockPipeliner)(nil).SRandMember), ctx, key) +} + +// SRandMemberN mocks base method. +func (m *MockPipeliner) SRandMemberN(ctx context.Context, key string, count int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SRandMemberN", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SRandMemberN indicates an expected call of SRandMemberN. +func (mr *MockPipelinerMockRecorder) SRandMemberN(ctx, key, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMemberN", reflect.TypeOf((*MockPipeliner)(nil).SRandMemberN), ctx, key, count) +} + +// SRem mocks base method. +func (m *MockPipeliner) SRem(ctx context.Context, key string, members ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SRem", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SRem indicates an expected call of SRem. +func (mr *MockPipelinerMockRecorder) SRem(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRem", reflect.TypeOf((*MockPipeliner)(nil).SRem), varargs...) +} + +// SScan mocks base method. +func (m *MockPipeliner) SScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SScan", ctx, key, cursor, match, count) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// SScan indicates an expected call of SScan. +func (mr *MockPipelinerMockRecorder) SScan(ctx, key, cursor, match, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SScan", reflect.TypeOf((*MockPipeliner)(nil).SScan), ctx, key, cursor, match, count) +} + +// SUnion mocks base method. +func (m *MockPipeliner) SUnion(ctx context.Context, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SUnion", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SUnion indicates an expected call of SUnion. +func (mr *MockPipelinerMockRecorder) SUnion(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnion", reflect.TypeOf((*MockPipeliner)(nil).SUnion), varargs...) +} + +// SUnionStore mocks base method. +func (m *MockPipeliner) SUnionStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, destination} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SUnionStore", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SUnionStore indicates an expected call of SUnionStore. +func (mr *MockPipelinerMockRecorder) SUnionStore(ctx, destination interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, destination}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnionStore", reflect.TypeOf((*MockPipeliner)(nil).SUnionStore), varargs...) +} + +// Save mocks base method. +func (m *MockPipeliner) Save(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Save", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Save indicates an expected call of Save. +func (mr *MockPipelinerMockRecorder) Save(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockPipeliner)(nil).Save), ctx) +} + +// Scan mocks base method. +func (m *MockPipeliner) Scan(ctx context.Context, cursor uint64, match string, count int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Scan", ctx, cursor, match, count) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// Scan indicates an expected call of Scan. +func (mr *MockPipelinerMockRecorder) Scan(ctx, cursor, match, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockPipeliner)(nil).Scan), ctx, cursor, match, count) +} + +// ScanType mocks base method. +func (m *MockPipeliner) ScanType(ctx context.Context, cursor uint64, match string, count int64, keyType string) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScanType", ctx, cursor, match, count, keyType) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// ScanType indicates an expected call of ScanType. +func (mr *MockPipelinerMockRecorder) ScanType(ctx, cursor, match, count, keyType interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanType", reflect.TypeOf((*MockPipeliner)(nil).ScanType), ctx, cursor, match, count, keyType) +} + +// ScriptExists mocks base method. +func (m *MockPipeliner) ScriptExists(ctx context.Context, hashes ...string) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range hashes { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ScriptExists", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// ScriptExists indicates an expected call of ScriptExists. +func (mr *MockPipelinerMockRecorder) ScriptExists(ctx interface{}, hashes ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, hashes...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptExists", reflect.TypeOf((*MockPipeliner)(nil).ScriptExists), varargs...) +} + +// ScriptFlush mocks base method. +func (m *MockPipeliner) ScriptFlush(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScriptFlush", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ScriptFlush indicates an expected call of ScriptFlush. +func (mr *MockPipelinerMockRecorder) ScriptFlush(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptFlush", reflect.TypeOf((*MockPipeliner)(nil).ScriptFlush), ctx) +} + +// ScriptKill mocks base method. +func (m *MockPipeliner) ScriptKill(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScriptKill", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ScriptKill indicates an expected call of ScriptKill. +func (mr *MockPipelinerMockRecorder) ScriptKill(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptKill", reflect.TypeOf((*MockPipeliner)(nil).ScriptKill), ctx) +} + +// ScriptLoad mocks base method. +func (m *MockPipeliner) ScriptLoad(ctx context.Context, script string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScriptLoad", ctx, script) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ScriptLoad indicates an expected call of ScriptLoad. +func (mr *MockPipelinerMockRecorder) ScriptLoad(ctx, script interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptLoad", reflect.TypeOf((*MockPipeliner)(nil).ScriptLoad), ctx, script) +} + +// Select mocks base method. +func (m *MockPipeliner) Select(ctx context.Context, index int) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Select", ctx, index) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Select indicates an expected call of Select. +func (mr *MockPipelinerMockRecorder) Select(ctx, index interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Select", reflect.TypeOf((*MockPipeliner)(nil).Select), ctx, index) +} + +// Set mocks base method. +func (m *MockPipeliner) Set(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Set", ctx, key, value, expiration) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Set indicates an expected call of Set. +func (mr *MockPipelinerMockRecorder) Set(ctx, key, value, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockPipeliner)(nil).Set), ctx, key, value, expiration) +} + +// SetArgs mocks base method. +func (m *MockPipeliner) SetArgs(ctx context.Context, key string, value interface{}, a redis.SetArgs) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetArgs", ctx, key, value, a) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// SetArgs indicates an expected call of SetArgs. +func (mr *MockPipelinerMockRecorder) SetArgs(ctx, key, value, a interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetArgs", reflect.TypeOf((*MockPipeliner)(nil).SetArgs), ctx, key, value, a) +} + +// SetBit mocks base method. +func (m *MockPipeliner) SetBit(ctx context.Context, key string, offset int64, value int) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetBit", ctx, key, offset, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SetBit indicates an expected call of SetBit. +func (mr *MockPipelinerMockRecorder) SetBit(ctx, key, offset, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBit", reflect.TypeOf((*MockPipeliner)(nil).SetBit), ctx, key, offset, value) +} + +// SetEx mocks base method. +func (m *MockPipeliner) SetEx(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetEx", ctx, key, value, expiration) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// SetEx indicates an expected call of SetEx. +func (mr *MockPipelinerMockRecorder) SetEx(ctx, key, value, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEx", reflect.TypeOf((*MockPipeliner)(nil).SetEx), ctx, key, value, expiration) +} + +// SetNX mocks base method. +func (m *MockPipeliner) SetNX(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetNX", ctx, key, value, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// SetNX indicates an expected call of SetNX. +func (mr *MockPipelinerMockRecorder) SetNX(ctx, key, value, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNX", reflect.TypeOf((*MockPipeliner)(nil).SetNX), ctx, key, value, expiration) +} + +// SetRange mocks base method. +func (m *MockPipeliner) SetRange(ctx context.Context, key string, offset int64, value string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetRange", ctx, key, offset, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SetRange indicates an expected call of SetRange. +func (mr *MockPipelinerMockRecorder) SetRange(ctx, key, offset, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRange", reflect.TypeOf((*MockPipeliner)(nil).SetRange), ctx, key, offset, value) +} + +// SetXX mocks base method. +func (m *MockPipeliner) SetXX(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetXX", ctx, key, value, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// SetXX indicates an expected call of SetXX. +func (mr *MockPipelinerMockRecorder) SetXX(ctx, key, value, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetXX", reflect.TypeOf((*MockPipeliner)(nil).SetXX), ctx, key, value, expiration) +} + +// Shutdown mocks base method. +func (m *MockPipeliner) Shutdown(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Shutdown", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Shutdown indicates an expected call of Shutdown. +func (mr *MockPipelinerMockRecorder) Shutdown(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockPipeliner)(nil).Shutdown), ctx) +} + +// ShutdownNoSave mocks base method. +func (m *MockPipeliner) ShutdownNoSave(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ShutdownNoSave", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ShutdownNoSave indicates an expected call of ShutdownNoSave. +func (mr *MockPipelinerMockRecorder) ShutdownNoSave(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownNoSave", reflect.TypeOf((*MockPipeliner)(nil).ShutdownNoSave), ctx) +} + +// ShutdownSave mocks base method. +func (m *MockPipeliner) ShutdownSave(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ShutdownSave", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ShutdownSave indicates an expected call of ShutdownSave. +func (mr *MockPipelinerMockRecorder) ShutdownSave(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownSave", reflect.TypeOf((*MockPipeliner)(nil).ShutdownSave), ctx) +} + +// SlaveOf mocks base method. +func (m *MockPipeliner) SlaveOf(ctx context.Context, host, port string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SlaveOf", ctx, host, port) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// SlaveOf indicates an expected call of SlaveOf. +func (mr *MockPipelinerMockRecorder) SlaveOf(ctx, host, port interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlaveOf", reflect.TypeOf((*MockPipeliner)(nil).SlaveOf), ctx, host, port) +} + +// SlowLogGet mocks base method. +func (m *MockPipeliner) SlowLogGet(ctx context.Context, num int64) *redis.SlowLogCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SlowLogGet", ctx, num) + ret0, _ := ret[0].(*redis.SlowLogCmd) + return ret0 +} + +// SlowLogGet indicates an expected call of SlowLogGet. +func (mr *MockPipelinerMockRecorder) SlowLogGet(ctx, num interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlowLogGet", reflect.TypeOf((*MockPipeliner)(nil).SlowLogGet), ctx, num) +} + +// Sort mocks base method. +func (m *MockPipeliner) Sort(ctx context.Context, key string, sort *redis.Sort) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Sort", ctx, key, sort) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// Sort indicates an expected call of Sort. +func (mr *MockPipelinerMockRecorder) Sort(ctx, key, sort interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sort", reflect.TypeOf((*MockPipeliner)(nil).Sort), ctx, key, sort) +} + +// SortInterfaces mocks base method. +func (m *MockPipeliner) SortInterfaces(ctx context.Context, key string, sort *redis.Sort) *redis.SliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SortInterfaces", ctx, key, sort) + ret0, _ := ret[0].(*redis.SliceCmd) + return ret0 +} + +// SortInterfaces indicates an expected call of SortInterfaces. +func (mr *MockPipelinerMockRecorder) SortInterfaces(ctx, key, sort interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortInterfaces", reflect.TypeOf((*MockPipeliner)(nil).SortInterfaces), ctx, key, sort) +} + +// SortRO mocks base method. +func (m *MockPipeliner) SortRO(ctx context.Context, key string, sort *redis.Sort) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SortRO", ctx, key, sort) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SortRO indicates an expected call of SortRO. +func (mr *MockPipelinerMockRecorder) SortRO(ctx, key, sort interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortRO", reflect.TypeOf((*MockPipeliner)(nil).SortRO), ctx, key, sort) +} + +// SortStore mocks base method. +func (m *MockPipeliner) SortStore(ctx context.Context, key, store string, sort *redis.Sort) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SortStore", ctx, key, store, sort) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SortStore indicates an expected call of SortStore. +func (mr *MockPipelinerMockRecorder) SortStore(ctx, key, store, sort interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortStore", reflect.TypeOf((*MockPipeliner)(nil).SortStore), ctx, key, store, sort) +} + +// StrLen mocks base method. +func (m *MockPipeliner) StrLen(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StrLen", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// StrLen indicates an expected call of StrLen. +func (mr *MockPipelinerMockRecorder) StrLen(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StrLen", reflect.TypeOf((*MockPipeliner)(nil).StrLen), ctx, key) +} + +// SwapDB mocks base method. +func (m *MockPipeliner) SwapDB(ctx context.Context, index1, index2 int) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SwapDB", ctx, index1, index2) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// SwapDB indicates an expected call of SwapDB. +func (mr *MockPipelinerMockRecorder) SwapDB(ctx, index1, index2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwapDB", reflect.TypeOf((*MockPipeliner)(nil).SwapDB), ctx, index1, index2) +} + +// TDigestAdd mocks base method. +func (m *MockPipeliner) TDigestAdd(ctx context.Context, key string, elements ...float64) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestAdd", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestAdd indicates an expected call of TDigestAdd. +func (mr *MockPipelinerMockRecorder) TDigestAdd(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestAdd", reflect.TypeOf((*MockPipeliner)(nil).TDigestAdd), varargs...) +} + +// TDigestByRank mocks base method. +func (m *MockPipeliner) TDigestByRank(ctx context.Context, key string, rank ...uint64) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range rank { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestByRank", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// TDigestByRank indicates an expected call of TDigestByRank. +func (mr *MockPipelinerMockRecorder) TDigestByRank(ctx, key interface{}, rank ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, rank...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestByRank", reflect.TypeOf((*MockPipeliner)(nil).TDigestByRank), varargs...) +} + +// TDigestByRevRank mocks base method. +func (m *MockPipeliner) TDigestByRevRank(ctx context.Context, key string, rank ...uint64) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range rank { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestByRevRank", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// TDigestByRevRank indicates an expected call of TDigestByRevRank. +func (mr *MockPipelinerMockRecorder) TDigestByRevRank(ctx, key interface{}, rank ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, rank...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestByRevRank", reflect.TypeOf((*MockPipeliner)(nil).TDigestByRevRank), varargs...) +} + +// TDigestCDF mocks base method. +func (m *MockPipeliner) TDigestCDF(ctx context.Context, key string, elements ...float64) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestCDF", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// TDigestCDF indicates an expected call of TDigestCDF. +func (mr *MockPipelinerMockRecorder) TDigestCDF(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCDF", reflect.TypeOf((*MockPipeliner)(nil).TDigestCDF), varargs...) +} + +// TDigestCreate mocks base method. +func (m *MockPipeliner) TDigestCreate(ctx context.Context, key string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestCreate", ctx, key) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestCreate indicates an expected call of TDigestCreate. +func (mr *MockPipelinerMockRecorder) TDigestCreate(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCreate", reflect.TypeOf((*MockPipeliner)(nil).TDigestCreate), ctx, key) +} + +// TDigestCreateWithCompression mocks base method. +func (m *MockPipeliner) TDigestCreateWithCompression(ctx context.Context, key string, compression int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestCreateWithCompression", ctx, key, compression) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestCreateWithCompression indicates an expected call of TDigestCreateWithCompression. +func (mr *MockPipelinerMockRecorder) TDigestCreateWithCompression(ctx, key, compression interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCreateWithCompression", reflect.TypeOf((*MockPipeliner)(nil).TDigestCreateWithCompression), ctx, key, compression) +} + +// TDigestInfo mocks base method. +func (m *MockPipeliner) TDigestInfo(ctx context.Context, key string) *redis.TDigestInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestInfo", ctx, key) + ret0, _ := ret[0].(*redis.TDigestInfoCmd) + return ret0 +} + +// TDigestInfo indicates an expected call of TDigestInfo. +func (mr *MockPipelinerMockRecorder) TDigestInfo(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestInfo", reflect.TypeOf((*MockPipeliner)(nil).TDigestInfo), ctx, key) +} + +// TDigestMax mocks base method. +func (m *MockPipeliner) TDigestMax(ctx context.Context, key string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestMax", ctx, key) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// TDigestMax indicates an expected call of TDigestMax. +func (mr *MockPipelinerMockRecorder) TDigestMax(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMax", reflect.TypeOf((*MockPipeliner)(nil).TDigestMax), ctx, key) +} + +// TDigestMerge mocks base method. +func (m *MockPipeliner) TDigestMerge(ctx context.Context, destKey string, options *redis.TDigestMergeOptions, sourceKeys ...string) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, destKey, options} + for _, a := range sourceKeys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestMerge", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestMerge indicates an expected call of TDigestMerge. +func (mr *MockPipelinerMockRecorder) TDigestMerge(ctx, destKey, options interface{}, sourceKeys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, destKey, options}, sourceKeys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMerge", reflect.TypeOf((*MockPipeliner)(nil).TDigestMerge), varargs...) +} + +// TDigestMin mocks base method. +func (m *MockPipeliner) TDigestMin(ctx context.Context, key string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestMin", ctx, key) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// TDigestMin indicates an expected call of TDigestMin. +func (mr *MockPipelinerMockRecorder) TDigestMin(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMin", reflect.TypeOf((*MockPipeliner)(nil).TDigestMin), ctx, key) +} + +// TDigestQuantile mocks base method. +func (m *MockPipeliner) TDigestQuantile(ctx context.Context, key string, elements ...float64) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestQuantile", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// TDigestQuantile indicates an expected call of TDigestQuantile. +func (mr *MockPipelinerMockRecorder) TDigestQuantile(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestQuantile", reflect.TypeOf((*MockPipeliner)(nil).TDigestQuantile), varargs...) +} + +// TDigestRank mocks base method. +func (m *MockPipeliner) TDigestRank(ctx context.Context, key string, values ...float64) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestRank", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// TDigestRank indicates an expected call of TDigestRank. +func (mr *MockPipelinerMockRecorder) TDigestRank(ctx, key interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestRank", reflect.TypeOf((*MockPipeliner)(nil).TDigestRank), varargs...) +} + +// TDigestReset mocks base method. +func (m *MockPipeliner) TDigestReset(ctx context.Context, key string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestReset", ctx, key) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestReset indicates an expected call of TDigestReset. +func (mr *MockPipelinerMockRecorder) TDigestReset(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestReset", reflect.TypeOf((*MockPipeliner)(nil).TDigestReset), ctx, key) +} + +// TDigestRevRank mocks base method. +func (m *MockPipeliner) TDigestRevRank(ctx context.Context, key string, values ...float64) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestRevRank", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// TDigestRevRank indicates an expected call of TDigestRevRank. +func (mr *MockPipelinerMockRecorder) TDigestRevRank(ctx, key interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestRevRank", reflect.TypeOf((*MockPipeliner)(nil).TDigestRevRank), varargs...) +} + +// TDigestTrimmedMean mocks base method. +func (m *MockPipeliner) TDigestTrimmedMean(ctx context.Context, key string, lowCutQuantile, highCutQuantile float64) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestTrimmedMean", ctx, key, lowCutQuantile, highCutQuantile) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// TDigestTrimmedMean indicates an expected call of TDigestTrimmedMean. +func (mr *MockPipelinerMockRecorder) TDigestTrimmedMean(ctx, key, lowCutQuantile, highCutQuantile interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestTrimmedMean", reflect.TypeOf((*MockPipeliner)(nil).TDigestTrimmedMean), ctx, key, lowCutQuantile, highCutQuantile) +} + +// TFCall mocks base method. +func (m *MockPipeliner) TFCall(ctx context.Context, libName, funcName string, numKeys int) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCall", ctx, libName, funcName, numKeys) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCall indicates an expected call of TFCall. +func (mr *MockPipelinerMockRecorder) TFCall(ctx, libName, funcName, numKeys interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCall", reflect.TypeOf((*MockPipeliner)(nil).TFCall), ctx, libName, funcName, numKeys) +} + +// TFCallASYNC mocks base method. +func (m *MockPipeliner) TFCallASYNC(ctx context.Context, libName, funcName string, numKeys int) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCallASYNC", ctx, libName, funcName, numKeys) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCallASYNC indicates an expected call of TFCallASYNC. +func (mr *MockPipelinerMockRecorder) TFCallASYNC(ctx, libName, funcName, numKeys interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallASYNC", reflect.TypeOf((*MockPipeliner)(nil).TFCallASYNC), ctx, libName, funcName, numKeys) +} + +// TFCallASYNCArgs mocks base method. +func (m *MockPipeliner) TFCallASYNCArgs(ctx context.Context, libName, funcName string, numKeys int, options *redis.TFCallOptions) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCallASYNCArgs", ctx, libName, funcName, numKeys, options) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCallASYNCArgs indicates an expected call of TFCallASYNCArgs. +func (mr *MockPipelinerMockRecorder) TFCallASYNCArgs(ctx, libName, funcName, numKeys, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallASYNCArgs", reflect.TypeOf((*MockPipeliner)(nil).TFCallASYNCArgs), ctx, libName, funcName, numKeys, options) +} + +// TFCallArgs mocks base method. +func (m *MockPipeliner) TFCallArgs(ctx context.Context, libName, funcName string, numKeys int, options *redis.TFCallOptions) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCallArgs", ctx, libName, funcName, numKeys, options) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCallArgs indicates an expected call of TFCallArgs. +func (mr *MockPipelinerMockRecorder) TFCallArgs(ctx, libName, funcName, numKeys, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallArgs", reflect.TypeOf((*MockPipeliner)(nil).TFCallArgs), ctx, libName, funcName, numKeys, options) +} + +// TFunctionDelete mocks base method. +func (m *MockPipeliner) TFunctionDelete(ctx context.Context, libName string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionDelete", ctx, libName) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TFunctionDelete indicates an expected call of TFunctionDelete. +func (mr *MockPipelinerMockRecorder) TFunctionDelete(ctx, libName interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionDelete", reflect.TypeOf((*MockPipeliner)(nil).TFunctionDelete), ctx, libName) +} + +// TFunctionList mocks base method. +func (m *MockPipeliner) TFunctionList(ctx context.Context) *redis.MapStringInterfaceSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionList", ctx) + ret0, _ := ret[0].(*redis.MapStringInterfaceSliceCmd) + return ret0 +} + +// TFunctionList indicates an expected call of TFunctionList. +func (mr *MockPipelinerMockRecorder) TFunctionList(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionList", reflect.TypeOf((*MockPipeliner)(nil).TFunctionList), ctx) +} + +// TFunctionListArgs mocks base method. +func (m *MockPipeliner) TFunctionListArgs(ctx context.Context, options *redis.TFunctionListOptions) *redis.MapStringInterfaceSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionListArgs", ctx, options) + ret0, _ := ret[0].(*redis.MapStringInterfaceSliceCmd) + return ret0 +} + +// TFunctionListArgs indicates an expected call of TFunctionListArgs. +func (mr *MockPipelinerMockRecorder) TFunctionListArgs(ctx, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionListArgs", reflect.TypeOf((*MockPipeliner)(nil).TFunctionListArgs), ctx, options) +} + +// TFunctionLoad mocks base method. +func (m *MockPipeliner) TFunctionLoad(ctx context.Context, lib string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionLoad", ctx, lib) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TFunctionLoad indicates an expected call of TFunctionLoad. +func (mr *MockPipelinerMockRecorder) TFunctionLoad(ctx, lib interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionLoad", reflect.TypeOf((*MockPipeliner)(nil).TFunctionLoad), ctx, lib) +} + +// TFunctionLoadArgs mocks base method. +func (m *MockPipeliner) TFunctionLoadArgs(ctx context.Context, lib string, options *redis.TFunctionLoadOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionLoadArgs", ctx, lib, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TFunctionLoadArgs indicates an expected call of TFunctionLoadArgs. +func (mr *MockPipelinerMockRecorder) TFunctionLoadArgs(ctx, lib, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionLoadArgs", reflect.TypeOf((*MockPipeliner)(nil).TFunctionLoadArgs), ctx, lib, options) +} + +// TSAdd mocks base method. +func (m *MockPipeliner) TSAdd(ctx context.Context, key string, timestamp interface{}, value float64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSAdd", ctx, key, timestamp, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// TSAdd indicates an expected call of TSAdd. +func (mr *MockPipelinerMockRecorder) TSAdd(ctx, key, timestamp, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSAdd", reflect.TypeOf((*MockPipeliner)(nil).TSAdd), ctx, key, timestamp, value) +} + +// TSAddWithArgs mocks base method. +func (m *MockPipeliner) TSAddWithArgs(ctx context.Context, key string, timestamp interface{}, value float64, options *redis.TSOptions) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSAddWithArgs", ctx, key, timestamp, value, options) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// TSAddWithArgs indicates an expected call of TSAddWithArgs. +func (mr *MockPipelinerMockRecorder) TSAddWithArgs(ctx, key, timestamp, value, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSAddWithArgs", reflect.TypeOf((*MockPipeliner)(nil).TSAddWithArgs), ctx, key, timestamp, value, options) +} + +// TSAlter mocks base method. +func (m *MockPipeliner) TSAlter(ctx context.Context, key string, options *redis.TSAlterOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSAlter", ctx, key, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TSAlter indicates an expected call of TSAlter. +func (mr *MockPipelinerMockRecorder) TSAlter(ctx, key, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSAlter", reflect.TypeOf((*MockPipeliner)(nil).TSAlter), ctx, key, options) +} + +// TSCreate mocks base method. +func (m *MockPipeliner) TSCreate(ctx context.Context, key string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSCreate", ctx, key) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TSCreate indicates an expected call of TSCreate. +func (mr *MockPipelinerMockRecorder) TSCreate(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreate", reflect.TypeOf((*MockPipeliner)(nil).TSCreate), ctx, key) +} + +// TSCreateRule mocks base method. +func (m *MockPipeliner) TSCreateRule(ctx context.Context, sourceKey, destKey string, aggregator redis.Aggregator, bucketDuration int) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSCreateRule", ctx, sourceKey, destKey, aggregator, bucketDuration) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TSCreateRule indicates an expected call of TSCreateRule. +func (mr *MockPipelinerMockRecorder) TSCreateRule(ctx, sourceKey, destKey, aggregator, bucketDuration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreateRule", reflect.TypeOf((*MockPipeliner)(nil).TSCreateRule), ctx, sourceKey, destKey, aggregator, bucketDuration) +} + +// TSCreateRuleWithArgs mocks base method. +func (m *MockPipeliner) TSCreateRuleWithArgs(ctx context.Context, sourceKey, destKey string, aggregator redis.Aggregator, bucketDuration int, options *redis.TSCreateRuleOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSCreateRuleWithArgs", ctx, sourceKey, destKey, aggregator, bucketDuration, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TSCreateRuleWithArgs indicates an expected call of TSCreateRuleWithArgs. +func (mr *MockPipelinerMockRecorder) TSCreateRuleWithArgs(ctx, sourceKey, destKey, aggregator, bucketDuration, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreateRuleWithArgs", reflect.TypeOf((*MockPipeliner)(nil).TSCreateRuleWithArgs), ctx, sourceKey, destKey, aggregator, bucketDuration, options) +} + +// TSCreateWithArgs mocks base method. +func (m *MockPipeliner) TSCreateWithArgs(ctx context.Context, key string, options *redis.TSOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSCreateWithArgs", ctx, key, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TSCreateWithArgs indicates an expected call of TSCreateWithArgs. +func (mr *MockPipelinerMockRecorder) TSCreateWithArgs(ctx, key, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreateWithArgs", reflect.TypeOf((*MockPipeliner)(nil).TSCreateWithArgs), ctx, key, options) +} + +// TSDecrBy mocks base method. +func (m *MockPipeliner) TSDecrBy(ctx context.Context, Key string, timestamp float64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSDecrBy", ctx, Key, timestamp) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// TSDecrBy indicates an expected call of TSDecrBy. +func (mr *MockPipelinerMockRecorder) TSDecrBy(ctx, Key, timestamp interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDecrBy", reflect.TypeOf((*MockPipeliner)(nil).TSDecrBy), ctx, Key, timestamp) +} + +// TSDecrByWithArgs mocks base method. +func (m *MockPipeliner) TSDecrByWithArgs(ctx context.Context, key string, timestamp float64, options *redis.TSIncrDecrOptions) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSDecrByWithArgs", ctx, key, timestamp, options) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// TSDecrByWithArgs indicates an expected call of TSDecrByWithArgs. +func (mr *MockPipelinerMockRecorder) TSDecrByWithArgs(ctx, key, timestamp, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDecrByWithArgs", reflect.TypeOf((*MockPipeliner)(nil).TSDecrByWithArgs), ctx, key, timestamp, options) +} + +// TSDel mocks base method. +func (m *MockPipeliner) TSDel(ctx context.Context, Key string, fromTimestamp, toTimestamp int) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSDel", ctx, Key, fromTimestamp, toTimestamp) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// TSDel indicates an expected call of TSDel. +func (mr *MockPipelinerMockRecorder) TSDel(ctx, Key, fromTimestamp, toTimestamp interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDel", reflect.TypeOf((*MockPipeliner)(nil).TSDel), ctx, Key, fromTimestamp, toTimestamp) +} + +// TSDeleteRule mocks base method. +func (m *MockPipeliner) TSDeleteRule(ctx context.Context, sourceKey, destKey string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSDeleteRule", ctx, sourceKey, destKey) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TSDeleteRule indicates an expected call of TSDeleteRule. +func (mr *MockPipelinerMockRecorder) TSDeleteRule(ctx, sourceKey, destKey interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDeleteRule", reflect.TypeOf((*MockPipeliner)(nil).TSDeleteRule), ctx, sourceKey, destKey) +} + +// TSGet mocks base method. +func (m *MockPipeliner) TSGet(ctx context.Context, key string) *redis.TSTimestampValueCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSGet", ctx, key) + ret0, _ := ret[0].(*redis.TSTimestampValueCmd) + return ret0 +} + +// TSGet indicates an expected call of TSGet. +func (mr *MockPipelinerMockRecorder) TSGet(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSGet", reflect.TypeOf((*MockPipeliner)(nil).TSGet), ctx, key) +} + +// TSGetWithArgs mocks base method. +func (m *MockPipeliner) TSGetWithArgs(ctx context.Context, key string, options *redis.TSGetOptions) *redis.TSTimestampValueCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSGetWithArgs", ctx, key, options) + ret0, _ := ret[0].(*redis.TSTimestampValueCmd) + return ret0 +} + +// TSGetWithArgs indicates an expected call of TSGetWithArgs. +func (mr *MockPipelinerMockRecorder) TSGetWithArgs(ctx, key, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSGetWithArgs", reflect.TypeOf((*MockPipeliner)(nil).TSGetWithArgs), ctx, key, options) +} + +// TSIncrBy mocks base method. +func (m *MockPipeliner) TSIncrBy(ctx context.Context, Key string, timestamp float64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSIncrBy", ctx, Key, timestamp) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// TSIncrBy indicates an expected call of TSIncrBy. +func (mr *MockPipelinerMockRecorder) TSIncrBy(ctx, Key, timestamp interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSIncrBy", reflect.TypeOf((*MockPipeliner)(nil).TSIncrBy), ctx, Key, timestamp) +} + +// TSIncrByWithArgs mocks base method. +func (m *MockPipeliner) TSIncrByWithArgs(ctx context.Context, key string, timestamp float64, options *redis.TSIncrDecrOptions) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSIncrByWithArgs", ctx, key, timestamp, options) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// TSIncrByWithArgs indicates an expected call of TSIncrByWithArgs. +func (mr *MockPipelinerMockRecorder) TSIncrByWithArgs(ctx, key, timestamp, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSIncrByWithArgs", reflect.TypeOf((*MockPipeliner)(nil).TSIncrByWithArgs), ctx, key, timestamp, options) +} + +// TSInfo mocks base method. +func (m *MockPipeliner) TSInfo(ctx context.Context, key string) *redis.MapStringInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSInfo", ctx, key) + ret0, _ := ret[0].(*redis.MapStringInterfaceCmd) + return ret0 +} + +// TSInfo indicates an expected call of TSInfo. +func (mr *MockPipelinerMockRecorder) TSInfo(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSInfo", reflect.TypeOf((*MockPipeliner)(nil).TSInfo), ctx, key) +} + +// TSInfoWithArgs mocks base method. +func (m *MockPipeliner) TSInfoWithArgs(ctx context.Context, key string, options *redis.TSInfoOptions) *redis.MapStringInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSInfoWithArgs", ctx, key, options) + ret0, _ := ret[0].(*redis.MapStringInterfaceCmd) + return ret0 +} + +// TSInfoWithArgs indicates an expected call of TSInfoWithArgs. +func (mr *MockPipelinerMockRecorder) TSInfoWithArgs(ctx, key, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSInfoWithArgs", reflect.TypeOf((*MockPipeliner)(nil).TSInfoWithArgs), ctx, key, options) +} + +// TSMAdd mocks base method. +func (m *MockPipeliner) TSMAdd(ctx context.Context, ktvSlices [][]interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSMAdd", ctx, ktvSlices) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// TSMAdd indicates an expected call of TSMAdd. +func (mr *MockPipelinerMockRecorder) TSMAdd(ctx, ktvSlices interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMAdd", reflect.TypeOf((*MockPipeliner)(nil).TSMAdd), ctx, ktvSlices) +} + +// TSMGet mocks base method. +func (m *MockPipeliner) TSMGet(ctx context.Context, filters []string) *redis.MapStringSliceInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSMGet", ctx, filters) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) + return ret0 +} + +// TSMGet indicates an expected call of TSMGet. +func (mr *MockPipelinerMockRecorder) TSMGet(ctx, filters interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMGet", reflect.TypeOf((*MockPipeliner)(nil).TSMGet), ctx, filters) +} + +// TSMGetWithArgs mocks base method. +func (m *MockPipeliner) TSMGetWithArgs(ctx context.Context, filters []string, options *redis.TSMGetOptions) *redis.MapStringSliceInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSMGetWithArgs", ctx, filters, options) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) + return ret0 +} + +// TSMGetWithArgs indicates an expected call of TSMGetWithArgs. +func (mr *MockPipelinerMockRecorder) TSMGetWithArgs(ctx, filters, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMGetWithArgs", reflect.TypeOf((*MockPipeliner)(nil).TSMGetWithArgs), ctx, filters, options) +} + +// TSMRange mocks base method. +func (m *MockPipeliner) TSMRange(ctx context.Context, fromTimestamp, toTimestamp int, filterExpr []string) *redis.MapStringSliceInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSMRange", ctx, fromTimestamp, toTimestamp, filterExpr) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) + return ret0 +} + +// TSMRange indicates an expected call of TSMRange. +func (mr *MockPipelinerMockRecorder) TSMRange(ctx, fromTimestamp, toTimestamp, filterExpr interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRange", reflect.TypeOf((*MockPipeliner)(nil).TSMRange), ctx, fromTimestamp, toTimestamp, filterExpr) +} + +// TSMRangeWithArgs mocks base method. +func (m *MockPipeliner) TSMRangeWithArgs(ctx context.Context, fromTimestamp, toTimestamp int, filterExpr []string, options *redis.TSMRangeOptions) *redis.MapStringSliceInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSMRangeWithArgs", ctx, fromTimestamp, toTimestamp, filterExpr, options) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) + return ret0 +} + +// TSMRangeWithArgs indicates an expected call of TSMRangeWithArgs. +func (mr *MockPipelinerMockRecorder) TSMRangeWithArgs(ctx, fromTimestamp, toTimestamp, filterExpr, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRangeWithArgs", reflect.TypeOf((*MockPipeliner)(nil).TSMRangeWithArgs), ctx, fromTimestamp, toTimestamp, filterExpr, options) +} + +// TSMRevRange mocks base method. +func (m *MockPipeliner) TSMRevRange(ctx context.Context, fromTimestamp, toTimestamp int, filterExpr []string) *redis.MapStringSliceInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSMRevRange", ctx, fromTimestamp, toTimestamp, filterExpr) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) + return ret0 +} + +// TSMRevRange indicates an expected call of TSMRevRange. +func (mr *MockPipelinerMockRecorder) TSMRevRange(ctx, fromTimestamp, toTimestamp, filterExpr interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRevRange", reflect.TypeOf((*MockPipeliner)(nil).TSMRevRange), ctx, fromTimestamp, toTimestamp, filterExpr) +} + +// TSMRevRangeWithArgs mocks base method. +func (m *MockPipeliner) TSMRevRangeWithArgs(ctx context.Context, fromTimestamp, toTimestamp int, filterExpr []string, options *redis.TSMRevRangeOptions) *redis.MapStringSliceInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSMRevRangeWithArgs", ctx, fromTimestamp, toTimestamp, filterExpr, options) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) + return ret0 +} + +// TSMRevRangeWithArgs indicates an expected call of TSMRevRangeWithArgs. +func (mr *MockPipelinerMockRecorder) TSMRevRangeWithArgs(ctx, fromTimestamp, toTimestamp, filterExpr, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRevRangeWithArgs", reflect.TypeOf((*MockPipeliner)(nil).TSMRevRangeWithArgs), ctx, fromTimestamp, toTimestamp, filterExpr, options) +} + +// TSQueryIndex mocks base method. +func (m *MockPipeliner) TSQueryIndex(ctx context.Context, filterExpr []string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSQueryIndex", ctx, filterExpr) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// TSQueryIndex indicates an expected call of TSQueryIndex. +func (mr *MockPipelinerMockRecorder) TSQueryIndex(ctx, filterExpr interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSQueryIndex", reflect.TypeOf((*MockPipeliner)(nil).TSQueryIndex), ctx, filterExpr) +} + +// TSRange mocks base method. +func (m *MockPipeliner) TSRange(ctx context.Context, key string, fromTimestamp, toTimestamp int) *redis.TSTimestampValueSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSRange", ctx, key, fromTimestamp, toTimestamp) + ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd) + return ret0 +} + +// TSRange indicates an expected call of TSRange. +func (mr *MockPipelinerMockRecorder) TSRange(ctx, key, fromTimestamp, toTimestamp interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRange", reflect.TypeOf((*MockPipeliner)(nil).TSRange), ctx, key, fromTimestamp, toTimestamp) +} + +// TSRangeWithArgs mocks base method. +func (m *MockPipeliner) TSRangeWithArgs(ctx context.Context, key string, fromTimestamp, toTimestamp int, options *redis.TSRangeOptions) *redis.TSTimestampValueSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSRangeWithArgs", ctx, key, fromTimestamp, toTimestamp, options) + ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd) + return ret0 +} + +// TSRangeWithArgs indicates an expected call of TSRangeWithArgs. +func (mr *MockPipelinerMockRecorder) TSRangeWithArgs(ctx, key, fromTimestamp, toTimestamp, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRangeWithArgs", reflect.TypeOf((*MockPipeliner)(nil).TSRangeWithArgs), ctx, key, fromTimestamp, toTimestamp, options) +} + +// TSRevRange mocks base method. +func (m *MockPipeliner) TSRevRange(ctx context.Context, key string, fromTimestamp, toTimestamp int) *redis.TSTimestampValueSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSRevRange", ctx, key, fromTimestamp, toTimestamp) + ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd) + return ret0 +} + +// TSRevRange indicates an expected call of TSRevRange. +func (mr *MockPipelinerMockRecorder) TSRevRange(ctx, key, fromTimestamp, toTimestamp interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRevRange", reflect.TypeOf((*MockPipeliner)(nil).TSRevRange), ctx, key, fromTimestamp, toTimestamp) +} + +// TSRevRangeWithArgs mocks base method. +func (m *MockPipeliner) TSRevRangeWithArgs(ctx context.Context, key string, fromTimestamp, toTimestamp int, options *redis.TSRevRangeOptions) *redis.TSTimestampValueSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSRevRangeWithArgs", ctx, key, fromTimestamp, toTimestamp, options) + ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd) + return ret0 +} + +// TSRevRangeWithArgs indicates an expected call of TSRevRangeWithArgs. +func (mr *MockPipelinerMockRecorder) TSRevRangeWithArgs(ctx, key, fromTimestamp, toTimestamp, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRevRangeWithArgs", reflect.TypeOf((*MockPipeliner)(nil).TSRevRangeWithArgs), ctx, key, fromTimestamp, toTimestamp, options) +} + +// TTL mocks base method. +func (m *MockPipeliner) TTL(ctx context.Context, key string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TTL", ctx, key) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// TTL indicates an expected call of TTL. +func (mr *MockPipelinerMockRecorder) TTL(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TTL", reflect.TypeOf((*MockPipeliner)(nil).TTL), ctx, key) +} + +// Time mocks base method. +func (m *MockPipeliner) Time(ctx context.Context) *redis.TimeCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Time", ctx) + ret0, _ := ret[0].(*redis.TimeCmd) + return ret0 +} + +// Time indicates an expected call of Time. +func (mr *MockPipelinerMockRecorder) Time(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Time", reflect.TypeOf((*MockPipeliner)(nil).Time), ctx) +} + +// TopKAdd mocks base method. +func (m *MockPipeliner) TopKAdd(ctx context.Context, key string, elements ...interface{}) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TopKAdd", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// TopKAdd indicates an expected call of TopKAdd. +func (mr *MockPipelinerMockRecorder) TopKAdd(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKAdd", reflect.TypeOf((*MockPipeliner)(nil).TopKAdd), varargs...) +} + +// TopKCount mocks base method. +func (m *MockPipeliner) TopKCount(ctx context.Context, key string, elements ...interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TopKCount", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// TopKCount indicates an expected call of TopKCount. +func (mr *MockPipelinerMockRecorder) TopKCount(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKCount", reflect.TypeOf((*MockPipeliner)(nil).TopKCount), varargs...) +} + +// TopKIncrBy mocks base method. +func (m *MockPipeliner) TopKIncrBy(ctx context.Context, key string, elements ...interface{}) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TopKIncrBy", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// TopKIncrBy indicates an expected call of TopKIncrBy. +func (mr *MockPipelinerMockRecorder) TopKIncrBy(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKIncrBy", reflect.TypeOf((*MockPipeliner)(nil).TopKIncrBy), varargs...) +} + +// TopKInfo mocks base method. +func (m *MockPipeliner) TopKInfo(ctx context.Context, key string) *redis.TopKInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKInfo", ctx, key) + ret0, _ := ret[0].(*redis.TopKInfoCmd) + return ret0 +} + +// TopKInfo indicates an expected call of TopKInfo. +func (mr *MockPipelinerMockRecorder) TopKInfo(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKInfo", reflect.TypeOf((*MockPipeliner)(nil).TopKInfo), ctx, key) +} + +// TopKList mocks base method. +func (m *MockPipeliner) TopKList(ctx context.Context, key string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKList", ctx, key) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// TopKList indicates an expected call of TopKList. +func (mr *MockPipelinerMockRecorder) TopKList(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKList", reflect.TypeOf((*MockPipeliner)(nil).TopKList), ctx, key) +} + +// TopKListWithCount mocks base method. +func (m *MockPipeliner) TopKListWithCount(ctx context.Context, key string) *redis.MapStringIntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKListWithCount", ctx, key) + ret0, _ := ret[0].(*redis.MapStringIntCmd) + return ret0 +} + +// TopKListWithCount indicates an expected call of TopKListWithCount. +func (mr *MockPipelinerMockRecorder) TopKListWithCount(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKListWithCount", reflect.TypeOf((*MockPipeliner)(nil).TopKListWithCount), ctx, key) +} + +// TopKQuery mocks base method. +func (m *MockPipeliner) TopKQuery(ctx context.Context, key string, elements ...interface{}) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TopKQuery", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// TopKQuery indicates an expected call of TopKQuery. +func (mr *MockPipelinerMockRecorder) TopKQuery(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKQuery", reflect.TypeOf((*MockPipeliner)(nil).TopKQuery), varargs...) +} + +// TopKReserve mocks base method. +func (m *MockPipeliner) TopKReserve(ctx context.Context, key string, k int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKReserve", ctx, key, k) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TopKReserve indicates an expected call of TopKReserve. +func (mr *MockPipelinerMockRecorder) TopKReserve(ctx, key, k interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKReserve", reflect.TypeOf((*MockPipeliner)(nil).TopKReserve), ctx, key, k) +} + +// TopKReserveWithOptions mocks base method. +func (m *MockPipeliner) TopKReserveWithOptions(ctx context.Context, key string, k, width, depth int64, decay float64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKReserveWithOptions", ctx, key, k, width, depth, decay) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TopKReserveWithOptions indicates an expected call of TopKReserveWithOptions. +func (mr *MockPipelinerMockRecorder) TopKReserveWithOptions(ctx, key, k, width, depth, decay interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKReserveWithOptions", reflect.TypeOf((*MockPipeliner)(nil).TopKReserveWithOptions), ctx, key, k, width, depth, decay) +} + +// Touch mocks base method. +func (m *MockPipeliner) Touch(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Touch", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Touch indicates an expected call of Touch. +func (mr *MockPipelinerMockRecorder) Touch(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Touch", reflect.TypeOf((*MockPipeliner)(nil).Touch), varargs...) +} + +// TxPipeline mocks base method. +func (m *MockPipeliner) TxPipeline() redis.Pipeliner { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TxPipeline") + ret0, _ := ret[0].(redis.Pipeliner) + return ret0 +} + +// TxPipeline indicates an expected call of TxPipeline. +func (mr *MockPipelinerMockRecorder) TxPipeline() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipeline", reflect.TypeOf((*MockPipeliner)(nil).TxPipeline)) +} + +// TxPipelined mocks base method. +func (m *MockPipeliner) TxPipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TxPipelined", ctx, fn) + ret0, _ := ret[0].([]redis.Cmder) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TxPipelined indicates an expected call of TxPipelined. +func (mr *MockPipelinerMockRecorder) TxPipelined(ctx, fn interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipelined", reflect.TypeOf((*MockPipeliner)(nil).TxPipelined), ctx, fn) +} + +// Type mocks base method. +func (m *MockPipeliner) Type(ctx context.Context, key string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Type", ctx, key) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Type indicates an expected call of Type. +func (mr *MockPipelinerMockRecorder) Type(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockPipeliner)(nil).Type), ctx, key) +} + +// Unlink mocks base method. +func (m *MockPipeliner) Unlink(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Unlink", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Unlink indicates an expected call of Unlink. +func (mr *MockPipelinerMockRecorder) Unlink(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unlink", reflect.TypeOf((*MockPipeliner)(nil).Unlink), varargs...) +} + +// XAck mocks base method. +func (m *MockPipeliner) XAck(ctx context.Context, stream, group string, ids ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, stream, group} + for _, a := range ids { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "XAck", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XAck indicates an expected call of XAck. +func (mr *MockPipelinerMockRecorder) XAck(ctx, stream, group interface{}, ids ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, stream, group}, ids...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAck", reflect.TypeOf((*MockPipeliner)(nil).XAck), varargs...) +} + +// XAdd mocks base method. +func (m *MockPipeliner) XAdd(ctx context.Context, a *redis.XAddArgs) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XAdd", ctx, a) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// XAdd indicates an expected call of XAdd. +func (mr *MockPipelinerMockRecorder) XAdd(ctx, a interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAdd", reflect.TypeOf((*MockPipeliner)(nil).XAdd), ctx, a) +} + +// XAutoClaim mocks base method. +func (m *MockPipeliner) XAutoClaim(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XAutoClaim", ctx, a) + ret0, _ := ret[0].(*redis.XAutoClaimCmd) + return ret0 +} + +// XAutoClaim indicates an expected call of XAutoClaim. +func (mr *MockPipelinerMockRecorder) XAutoClaim(ctx, a interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaim", reflect.TypeOf((*MockPipeliner)(nil).XAutoClaim), ctx, a) +} + +// XAutoClaimJustID mocks base method. +func (m *MockPipeliner) XAutoClaimJustID(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimJustIDCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XAutoClaimJustID", ctx, a) + ret0, _ := ret[0].(*redis.XAutoClaimJustIDCmd) + return ret0 +} + +// XAutoClaimJustID indicates an expected call of XAutoClaimJustID. +func (mr *MockPipelinerMockRecorder) XAutoClaimJustID(ctx, a interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaimJustID", reflect.TypeOf((*MockPipeliner)(nil).XAutoClaimJustID), ctx, a) +} + +// XClaim mocks base method. +func (m *MockPipeliner) XClaim(ctx context.Context, a *redis.XClaimArgs) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XClaim", ctx, a) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XClaim indicates an expected call of XClaim. +func (mr *MockPipelinerMockRecorder) XClaim(ctx, a interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaim", reflect.TypeOf((*MockPipeliner)(nil).XClaim), ctx, a) +} + +// XClaimJustID mocks base method. +func (m *MockPipeliner) XClaimJustID(ctx context.Context, a *redis.XClaimArgs) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XClaimJustID", ctx, a) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// XClaimJustID indicates an expected call of XClaimJustID. +func (mr *MockPipelinerMockRecorder) XClaimJustID(ctx, a interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaimJustID", reflect.TypeOf((*MockPipeliner)(nil).XClaimJustID), ctx, a) +} + +// XDel mocks base method. +func (m *MockPipeliner) XDel(ctx context.Context, stream string, ids ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, stream} + for _, a := range ids { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "XDel", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XDel indicates an expected call of XDel. +func (mr *MockPipelinerMockRecorder) XDel(ctx, stream interface{}, ids ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, stream}, ids...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XDel", reflect.TypeOf((*MockPipeliner)(nil).XDel), varargs...) +} + +// XGroupCreate mocks base method. +func (m *MockPipeliner) XGroupCreate(ctx context.Context, stream, group, start string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupCreate", ctx, stream, group, start) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// XGroupCreate indicates an expected call of XGroupCreate. +func (mr *MockPipelinerMockRecorder) XGroupCreate(ctx, stream, group, start interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreate", reflect.TypeOf((*MockPipeliner)(nil).XGroupCreate), ctx, stream, group, start) +} + +// XGroupCreateConsumer mocks base method. +func (m *MockPipeliner) XGroupCreateConsumer(ctx context.Context, stream, group, consumer string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupCreateConsumer", ctx, stream, group, consumer) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XGroupCreateConsumer indicates an expected call of XGroupCreateConsumer. +func (mr *MockPipelinerMockRecorder) XGroupCreateConsumer(ctx, stream, group, consumer interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreateConsumer", reflect.TypeOf((*MockPipeliner)(nil).XGroupCreateConsumer), ctx, stream, group, consumer) +} + +// XGroupCreateMkStream mocks base method. +func (m *MockPipeliner) XGroupCreateMkStream(ctx context.Context, stream, group, start string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupCreateMkStream", ctx, stream, group, start) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// XGroupCreateMkStream indicates an expected call of XGroupCreateMkStream. +func (mr *MockPipelinerMockRecorder) XGroupCreateMkStream(ctx, stream, group, start interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreateMkStream", reflect.TypeOf((*MockPipeliner)(nil).XGroupCreateMkStream), ctx, stream, group, start) +} + +// XGroupDelConsumer mocks base method. +func (m *MockPipeliner) XGroupDelConsumer(ctx context.Context, stream, group, consumer string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupDelConsumer", ctx, stream, group, consumer) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XGroupDelConsumer indicates an expected call of XGroupDelConsumer. +func (mr *MockPipelinerMockRecorder) XGroupDelConsumer(ctx, stream, group, consumer interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDelConsumer", reflect.TypeOf((*MockPipeliner)(nil).XGroupDelConsumer), ctx, stream, group, consumer) +} + +// XGroupDestroy mocks base method. +func (m *MockPipeliner) XGroupDestroy(ctx context.Context, stream, group string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupDestroy", ctx, stream, group) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XGroupDestroy indicates an expected call of XGroupDestroy. +func (mr *MockPipelinerMockRecorder) XGroupDestroy(ctx, stream, group interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDestroy", reflect.TypeOf((*MockPipeliner)(nil).XGroupDestroy), ctx, stream, group) +} + +// XGroupSetID mocks base method. +func (m *MockPipeliner) XGroupSetID(ctx context.Context, stream, group, start string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupSetID", ctx, stream, group, start) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// XGroupSetID indicates an expected call of XGroupSetID. +func (mr *MockPipelinerMockRecorder) XGroupSetID(ctx, stream, group, start interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupSetID", reflect.TypeOf((*MockPipeliner)(nil).XGroupSetID), ctx, stream, group, start) +} + +// XInfoConsumers mocks base method. +func (m *MockPipeliner) XInfoConsumers(ctx context.Context, key, group string) *redis.XInfoConsumersCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XInfoConsumers", ctx, key, group) + ret0, _ := ret[0].(*redis.XInfoConsumersCmd) + return ret0 +} + +// XInfoConsumers indicates an expected call of XInfoConsumers. +func (mr *MockPipelinerMockRecorder) XInfoConsumers(ctx, key, group interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoConsumers", reflect.TypeOf((*MockPipeliner)(nil).XInfoConsumers), ctx, key, group) +} + +// XInfoGroups mocks base method. +func (m *MockPipeliner) XInfoGroups(ctx context.Context, key string) *redis.XInfoGroupsCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XInfoGroups", ctx, key) + ret0, _ := ret[0].(*redis.XInfoGroupsCmd) + return ret0 +} + +// XInfoGroups indicates an expected call of XInfoGroups. +func (mr *MockPipelinerMockRecorder) XInfoGroups(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoGroups", reflect.TypeOf((*MockPipeliner)(nil).XInfoGroups), ctx, key) +} + +// XInfoStream mocks base method. +func (m *MockPipeliner) XInfoStream(ctx context.Context, key string) *redis.XInfoStreamCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XInfoStream", ctx, key) + ret0, _ := ret[0].(*redis.XInfoStreamCmd) + return ret0 +} + +// XInfoStream indicates an expected call of XInfoStream. +func (mr *MockPipelinerMockRecorder) XInfoStream(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoStream", reflect.TypeOf((*MockPipeliner)(nil).XInfoStream), ctx, key) +} + +// XInfoStreamFull mocks base method. +func (m *MockPipeliner) XInfoStreamFull(ctx context.Context, key string, count int) *redis.XInfoStreamFullCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XInfoStreamFull", ctx, key, count) + ret0, _ := ret[0].(*redis.XInfoStreamFullCmd) + return ret0 +} + +// XInfoStreamFull indicates an expected call of XInfoStreamFull. +func (mr *MockPipelinerMockRecorder) XInfoStreamFull(ctx, key, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoStreamFull", reflect.TypeOf((*MockPipeliner)(nil).XInfoStreamFull), ctx, key, count) +} + +// XLen mocks base method. +func (m *MockPipeliner) XLen(ctx context.Context, stream string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XLen", ctx, stream) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XLen indicates an expected call of XLen. +func (mr *MockPipelinerMockRecorder) XLen(ctx, stream interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XLen", reflect.TypeOf((*MockPipeliner)(nil).XLen), ctx, stream) +} + +// XPending mocks base method. +func (m *MockPipeliner) XPending(ctx context.Context, stream, group string) *redis.XPendingCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XPending", ctx, stream, group) + ret0, _ := ret[0].(*redis.XPendingCmd) + return ret0 +} + +// XPending indicates an expected call of XPending. +func (mr *MockPipelinerMockRecorder) XPending(ctx, stream, group interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPending", reflect.TypeOf((*MockPipeliner)(nil).XPending), ctx, stream, group) +} + +// XPendingExt mocks base method. +func (m *MockPipeliner) XPendingExt(ctx context.Context, a *redis.XPendingExtArgs) *redis.XPendingExtCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XPendingExt", ctx, a) + ret0, _ := ret[0].(*redis.XPendingExtCmd) + return ret0 +} + +// XPendingExt indicates an expected call of XPendingExt. +func (mr *MockPipelinerMockRecorder) XPendingExt(ctx, a interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPendingExt", reflect.TypeOf((*MockPipeliner)(nil).XPendingExt), ctx, a) +} + +// XRange mocks base method. +func (m *MockPipeliner) XRange(ctx context.Context, stream, start, stop string) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRange", ctx, stream, start, stop) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XRange indicates an expected call of XRange. +func (mr *MockPipelinerMockRecorder) XRange(ctx, stream, start, stop interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRange", reflect.TypeOf((*MockPipeliner)(nil).XRange), ctx, stream, start, stop) +} + +// XRangeN mocks base method. +func (m *MockPipeliner) XRangeN(ctx context.Context, stream, start, stop string, count int64) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRangeN", ctx, stream, start, stop, count) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XRangeN indicates an expected call of XRangeN. +func (mr *MockPipelinerMockRecorder) XRangeN(ctx, stream, start, stop, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRangeN", reflect.TypeOf((*MockPipeliner)(nil).XRangeN), ctx, stream, start, stop, count) +} + +// XRead mocks base method. +func (m *MockPipeliner) XRead(ctx context.Context, a *redis.XReadArgs) *redis.XStreamSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRead", ctx, a) + ret0, _ := ret[0].(*redis.XStreamSliceCmd) + return ret0 +} + +// XRead indicates an expected call of XRead. +func (mr *MockPipelinerMockRecorder) XRead(ctx, a interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRead", reflect.TypeOf((*MockPipeliner)(nil).XRead), ctx, a) +} + +// XReadGroup mocks base method. +func (m *MockPipeliner) XReadGroup(ctx context.Context, a *redis.XReadGroupArgs) *redis.XStreamSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XReadGroup", ctx, a) + ret0, _ := ret[0].(*redis.XStreamSliceCmd) + return ret0 +} + +// XReadGroup indicates an expected call of XReadGroup. +func (mr *MockPipelinerMockRecorder) XReadGroup(ctx, a interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XReadGroup", reflect.TypeOf((*MockPipeliner)(nil).XReadGroup), ctx, a) +} + +// XReadStreams mocks base method. +func (m *MockPipeliner) XReadStreams(ctx context.Context, streams ...string) *redis.XStreamSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range streams { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "XReadStreams", varargs...) + ret0, _ := ret[0].(*redis.XStreamSliceCmd) + return ret0 +} + +// XReadStreams indicates an expected call of XReadStreams. +func (mr *MockPipelinerMockRecorder) XReadStreams(ctx interface{}, streams ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, streams...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XReadStreams", reflect.TypeOf((*MockPipeliner)(nil).XReadStreams), varargs...) +} + +// XRevRange mocks base method. +func (m *MockPipeliner) XRevRange(ctx context.Context, stream, start, stop string) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRevRange", ctx, stream, start, stop) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XRevRange indicates an expected call of XRevRange. +func (mr *MockPipelinerMockRecorder) XRevRange(ctx, stream, start, stop interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRevRange", reflect.TypeOf((*MockPipeliner)(nil).XRevRange), ctx, stream, start, stop) +} + +// XRevRangeN mocks base method. +func (m *MockPipeliner) XRevRangeN(ctx context.Context, stream, start, stop string, count int64) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRevRangeN", ctx, stream, start, stop, count) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XRevRangeN indicates an expected call of XRevRangeN. +func (mr *MockPipelinerMockRecorder) XRevRangeN(ctx, stream, start, stop, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRevRangeN", reflect.TypeOf((*MockPipeliner)(nil).XRevRangeN), ctx, stream, start, stop, count) +} + +// XTrimMaxLen mocks base method. +func (m *MockPipeliner) XTrimMaxLen(ctx context.Context, key string, maxLen int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XTrimMaxLen", ctx, key, maxLen) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XTrimMaxLen indicates an expected call of XTrimMaxLen. +func (mr *MockPipelinerMockRecorder) XTrimMaxLen(ctx, key, maxLen interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLen", reflect.TypeOf((*MockPipeliner)(nil).XTrimMaxLen), ctx, key, maxLen) +} + +// XTrimMaxLenApprox mocks base method. +func (m *MockPipeliner) XTrimMaxLenApprox(ctx context.Context, key string, maxLen, limit int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XTrimMaxLenApprox", ctx, key, maxLen, limit) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XTrimMaxLenApprox indicates an expected call of XTrimMaxLenApprox. +func (mr *MockPipelinerMockRecorder) XTrimMaxLenApprox(ctx, key, maxLen, limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLenApprox", reflect.TypeOf((*MockPipeliner)(nil).XTrimMaxLenApprox), ctx, key, maxLen, limit) +} + +// XTrimMinID mocks base method. +func (m *MockPipeliner) XTrimMinID(ctx context.Context, key, minID string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XTrimMinID", ctx, key, minID) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XTrimMinID indicates an expected call of XTrimMinID. +func (mr *MockPipelinerMockRecorder) XTrimMinID(ctx, key, minID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinID", reflect.TypeOf((*MockPipeliner)(nil).XTrimMinID), ctx, key, minID) +} + +// XTrimMinIDApprox mocks base method. +func (m *MockPipeliner) XTrimMinIDApprox(ctx context.Context, key, minID string, limit int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XTrimMinIDApprox", ctx, key, minID, limit) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XTrimMinIDApprox indicates an expected call of XTrimMinIDApprox. +func (mr *MockPipelinerMockRecorder) XTrimMinIDApprox(ctx, key, minID, limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinIDApprox", reflect.TypeOf((*MockPipeliner)(nil).XTrimMinIDApprox), ctx, key, minID, limit) +} + +// ZAdd mocks base method. +func (m *MockPipeliner) ZAdd(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAdd indicates an expected call of ZAdd. +func (mr *MockPipelinerMockRecorder) ZAdd(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAdd", reflect.TypeOf((*MockPipeliner)(nil).ZAdd), varargs...) +} + +// ZAddArgs mocks base method. +func (m *MockPipeliner) ZAddArgs(ctx context.Context, key string, args redis.ZAddArgs) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZAddArgs", ctx, key, args) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddArgs indicates an expected call of ZAddArgs. +func (mr *MockPipelinerMockRecorder) ZAddArgs(ctx, key, args interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgs", reflect.TypeOf((*MockPipeliner)(nil).ZAddArgs), ctx, key, args) +} + +// ZAddArgsIncr mocks base method. +func (m *MockPipeliner) ZAddArgsIncr(ctx context.Context, key string, args redis.ZAddArgs) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZAddArgsIncr", ctx, key, args) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// ZAddArgsIncr indicates an expected call of ZAddArgsIncr. +func (mr *MockPipelinerMockRecorder) ZAddArgsIncr(ctx, key, args interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgsIncr", reflect.TypeOf((*MockPipeliner)(nil).ZAddArgsIncr), ctx, key, args) +} + +// ZAddGT mocks base method. +func (m *MockPipeliner) ZAddGT(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAddGT", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddGT indicates an expected call of ZAddGT. +func (mr *MockPipelinerMockRecorder) ZAddGT(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddGT", reflect.TypeOf((*MockPipeliner)(nil).ZAddGT), varargs...) +} + +// ZAddLT mocks base method. +func (m *MockPipeliner) ZAddLT(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAddLT", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddLT indicates an expected call of ZAddLT. +func (mr *MockPipelinerMockRecorder) ZAddLT(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddLT", reflect.TypeOf((*MockPipeliner)(nil).ZAddLT), varargs...) +} + +// ZAddNX mocks base method. +func (m *MockPipeliner) ZAddNX(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAddNX", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddNX indicates an expected call of ZAddNX. +func (mr *MockPipelinerMockRecorder) ZAddNX(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddNX", reflect.TypeOf((*MockPipeliner)(nil).ZAddNX), varargs...) +} + +// ZAddXX mocks base method. +func (m *MockPipeliner) ZAddXX(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAddXX", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddXX indicates an expected call of ZAddXX. +func (mr *MockPipelinerMockRecorder) ZAddXX(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddXX", reflect.TypeOf((*MockPipeliner)(nil).ZAddXX), varargs...) +} + +// ZCard mocks base method. +func (m *MockPipeliner) ZCard(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZCard", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZCard indicates an expected call of ZCard. +func (mr *MockPipelinerMockRecorder) ZCard(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZCard", reflect.TypeOf((*MockPipeliner)(nil).ZCard), ctx, key) +} + +// ZCount mocks base method. +func (m *MockPipeliner) ZCount(ctx context.Context, key, min, max string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZCount", ctx, key, min, max) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZCount indicates an expected call of ZCount. +func (mr *MockPipelinerMockRecorder) ZCount(ctx, key, min, max interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZCount", reflect.TypeOf((*MockPipeliner)(nil).ZCount), ctx, key, min, max) +} + +// ZDiff mocks base method. +func (m *MockPipeliner) ZDiff(ctx context.Context, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZDiff", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZDiff indicates an expected call of ZDiff. +func (mr *MockPipelinerMockRecorder) ZDiff(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiff", reflect.TypeOf((*MockPipeliner)(nil).ZDiff), varargs...) +} + +// ZDiffStore mocks base method. +func (m *MockPipeliner) ZDiffStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, destination} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZDiffStore", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZDiffStore indicates an expected call of ZDiffStore. +func (mr *MockPipelinerMockRecorder) ZDiffStore(ctx, destination interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, destination}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiffStore", reflect.TypeOf((*MockPipeliner)(nil).ZDiffStore), varargs...) +} + +// ZDiffWithScores mocks base method. +func (m *MockPipeliner) ZDiffWithScores(ctx context.Context, keys ...string) *redis.ZSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZDiffWithScores", varargs...) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZDiffWithScores indicates an expected call of ZDiffWithScores. +func (mr *MockPipelinerMockRecorder) ZDiffWithScores(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiffWithScores", reflect.TypeOf((*MockPipeliner)(nil).ZDiffWithScores), varargs...) +} + +// ZIncrBy mocks base method. +func (m *MockPipeliner) ZIncrBy(ctx context.Context, key string, increment float64, member string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZIncrBy", ctx, key, increment, member) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// ZIncrBy indicates an expected call of ZIncrBy. +func (mr *MockPipelinerMockRecorder) ZIncrBy(ctx, key, increment, member interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZIncrBy", reflect.TypeOf((*MockPipeliner)(nil).ZIncrBy), ctx, key, increment, member) +} + +// ZInter mocks base method. +func (m *MockPipeliner) ZInter(ctx context.Context, store *redis.ZStore) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZInter", ctx, store) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZInter indicates an expected call of ZInter. +func (mr *MockPipelinerMockRecorder) ZInter(ctx, store interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInter", reflect.TypeOf((*MockPipeliner)(nil).ZInter), ctx, store) +} + +// ZInterCard mocks base method. +func (m *MockPipeliner) ZInterCard(ctx context.Context, limit int64, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, limit} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZInterCard", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZInterCard indicates an expected call of ZInterCard. +func (mr *MockPipelinerMockRecorder) ZInterCard(ctx, limit interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, limit}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterCard", reflect.TypeOf((*MockPipeliner)(nil).ZInterCard), varargs...) +} + +// ZInterStore mocks base method. +func (m *MockPipeliner) ZInterStore(ctx context.Context, destination string, store *redis.ZStore) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZInterStore", ctx, destination, store) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZInterStore indicates an expected call of ZInterStore. +func (mr *MockPipelinerMockRecorder) ZInterStore(ctx, destination, store interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterStore", reflect.TypeOf((*MockPipeliner)(nil).ZInterStore), ctx, destination, store) +} + +// ZInterWithScores mocks base method. +func (m *MockPipeliner) ZInterWithScores(ctx context.Context, store *redis.ZStore) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZInterWithScores", ctx, store) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZInterWithScores indicates an expected call of ZInterWithScores. +func (mr *MockPipelinerMockRecorder) ZInterWithScores(ctx, store interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterWithScores", reflect.TypeOf((*MockPipeliner)(nil).ZInterWithScores), ctx, store) +} + +// ZLexCount mocks base method. +func (m *MockPipeliner) ZLexCount(ctx context.Context, key, min, max string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZLexCount", ctx, key, min, max) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZLexCount indicates an expected call of ZLexCount. +func (mr *MockPipelinerMockRecorder) ZLexCount(ctx, key, min, max interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZLexCount", reflect.TypeOf((*MockPipeliner)(nil).ZLexCount), ctx, key, min, max) +} + +// ZMPop mocks base method. +func (m *MockPipeliner) ZMPop(ctx context.Context, order string, count int64, keys ...string) *redis.ZSliceWithKeyCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, order, count} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZMPop", varargs...) + ret0, _ := ret[0].(*redis.ZSliceWithKeyCmd) + return ret0 +} + +// ZMPop indicates an expected call of ZMPop. +func (mr *MockPipelinerMockRecorder) ZMPop(ctx, order, count interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, order, count}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZMPop", reflect.TypeOf((*MockPipeliner)(nil).ZMPop), varargs...) +} + +// ZMScore mocks base method. +func (m *MockPipeliner) ZMScore(ctx context.Context, key string, members ...string) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZMScore", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// ZMScore indicates an expected call of ZMScore. +func (mr *MockPipelinerMockRecorder) ZMScore(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZMScore", reflect.TypeOf((*MockPipeliner)(nil).ZMScore), varargs...) +} + +// ZPopMax mocks base method. +func (m *MockPipeliner) ZPopMax(ctx context.Context, key string, count ...int64) *redis.ZSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range count { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZPopMax", varargs...) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZPopMax indicates an expected call of ZPopMax. +func (mr *MockPipelinerMockRecorder) ZPopMax(ctx, key interface{}, count ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, count...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZPopMax", reflect.TypeOf((*MockPipeliner)(nil).ZPopMax), varargs...) +} + +// ZPopMin mocks base method. +func (m *MockPipeliner) ZPopMin(ctx context.Context, key string, count ...int64) *redis.ZSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range count { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZPopMin", varargs...) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZPopMin indicates an expected call of ZPopMin. +func (mr *MockPipelinerMockRecorder) ZPopMin(ctx, key interface{}, count ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, count...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZPopMin", reflect.TypeOf((*MockPipeliner)(nil).ZPopMin), varargs...) +} + +// ZRandMember mocks base method. +func (m *MockPipeliner) ZRandMember(ctx context.Context, key string, count int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRandMember", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRandMember indicates an expected call of ZRandMember. +func (mr *MockPipelinerMockRecorder) ZRandMember(ctx, key, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMember", reflect.TypeOf((*MockPipeliner)(nil).ZRandMember), ctx, key, count) +} + +// ZRandMemberWithScores mocks base method. +func (m *MockPipeliner) ZRandMemberWithScores(ctx context.Context, key string, count int) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRandMemberWithScores", ctx, key, count) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRandMemberWithScores indicates an expected call of ZRandMemberWithScores. +func (mr *MockPipelinerMockRecorder) ZRandMemberWithScores(ctx, key, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMemberWithScores", reflect.TypeOf((*MockPipeliner)(nil).ZRandMemberWithScores), ctx, key, count) +} + +// ZRange mocks base method. +func (m *MockPipeliner) ZRange(ctx context.Context, key string, start, stop int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRange", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRange indicates an expected call of ZRange. +func (mr *MockPipelinerMockRecorder) ZRange(ctx, key, start, stop interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRange", reflect.TypeOf((*MockPipeliner)(nil).ZRange), ctx, key, start, stop) +} + +// ZRangeArgs mocks base method. +func (m *MockPipeliner) ZRangeArgs(ctx context.Context, z redis.ZRangeArgs) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeArgs", ctx, z) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRangeArgs indicates an expected call of ZRangeArgs. +func (mr *MockPipelinerMockRecorder) ZRangeArgs(ctx, z interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgs", reflect.TypeOf((*MockPipeliner)(nil).ZRangeArgs), ctx, z) +} + +// ZRangeArgsWithScores mocks base method. +func (m *MockPipeliner) ZRangeArgsWithScores(ctx context.Context, z redis.ZRangeArgs) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeArgsWithScores", ctx, z) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRangeArgsWithScores indicates an expected call of ZRangeArgsWithScores. +func (mr *MockPipelinerMockRecorder) ZRangeArgsWithScores(ctx, z interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgsWithScores", reflect.TypeOf((*MockPipeliner)(nil).ZRangeArgsWithScores), ctx, z) +} + +// ZRangeByLex mocks base method. +func (m *MockPipeliner) ZRangeByLex(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeByLex", ctx, key, opt) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRangeByLex indicates an expected call of ZRangeByLex. +func (mr *MockPipelinerMockRecorder) ZRangeByLex(ctx, key, opt interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByLex", reflect.TypeOf((*MockPipeliner)(nil).ZRangeByLex), ctx, key, opt) +} + +// ZRangeByScore mocks base method. +func (m *MockPipeliner) ZRangeByScore(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeByScore", ctx, key, opt) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRangeByScore indicates an expected call of ZRangeByScore. +func (mr *MockPipelinerMockRecorder) ZRangeByScore(ctx, key, opt interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScore", reflect.TypeOf((*MockPipeliner)(nil).ZRangeByScore), ctx, key, opt) +} + +// ZRangeByScoreWithScores mocks base method. +func (m *MockPipeliner) ZRangeByScoreWithScores(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeByScoreWithScores", ctx, key, opt) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRangeByScoreWithScores indicates an expected call of ZRangeByScoreWithScores. +func (mr *MockPipelinerMockRecorder) ZRangeByScoreWithScores(ctx, key, opt interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScoreWithScores", reflect.TypeOf((*MockPipeliner)(nil).ZRangeByScoreWithScores), ctx, key, opt) +} + +// ZRangeStore mocks base method. +func (m *MockPipeliner) ZRangeStore(ctx context.Context, dst string, z redis.ZRangeArgs) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeStore", ctx, dst, z) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRangeStore indicates an expected call of ZRangeStore. +func (mr *MockPipelinerMockRecorder) ZRangeStore(ctx, dst, z interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeStore", reflect.TypeOf((*MockPipeliner)(nil).ZRangeStore), ctx, dst, z) +} + +// ZRangeWithScores mocks base method. +func (m *MockPipeliner) ZRangeWithScores(ctx context.Context, key string, start, stop int64) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeWithScores", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRangeWithScores indicates an expected call of ZRangeWithScores. +func (mr *MockPipelinerMockRecorder) ZRangeWithScores(ctx, key, start, stop interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeWithScores", reflect.TypeOf((*MockPipeliner)(nil).ZRangeWithScores), ctx, key, start, stop) +} + +// ZRank mocks base method. +func (m *MockPipeliner) ZRank(ctx context.Context, key, member string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRank", ctx, key, member) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRank indicates an expected call of ZRank. +func (mr *MockPipelinerMockRecorder) ZRank(ctx, key, member interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRank", reflect.TypeOf((*MockPipeliner)(nil).ZRank), ctx, key, member) +} + +// ZRankWithScore mocks base method. +func (m *MockPipeliner) ZRankWithScore(ctx context.Context, key, member string) *redis.RankWithScoreCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRankWithScore", ctx, key, member) + ret0, _ := ret[0].(*redis.RankWithScoreCmd) + return ret0 +} + +// ZRankWithScore indicates an expected call of ZRankWithScore. +func (mr *MockPipelinerMockRecorder) ZRankWithScore(ctx, key, member interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRankWithScore", reflect.TypeOf((*MockPipeliner)(nil).ZRankWithScore), ctx, key, member) +} + +// ZRem mocks base method. +func (m *MockPipeliner) ZRem(ctx context.Context, key string, members ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZRem", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRem indicates an expected call of ZRem. +func (mr *MockPipelinerMockRecorder) ZRem(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRem", reflect.TypeOf((*MockPipeliner)(nil).ZRem), varargs...) +} + +// ZRemRangeByLex mocks base method. +func (m *MockPipeliner) ZRemRangeByLex(ctx context.Context, key, min, max string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRemRangeByLex", ctx, key, min, max) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRemRangeByLex indicates an expected call of ZRemRangeByLex. +func (mr *MockPipelinerMockRecorder) ZRemRangeByLex(ctx, key, min, max interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByLex", reflect.TypeOf((*MockPipeliner)(nil).ZRemRangeByLex), ctx, key, min, max) +} + +// ZRemRangeByRank mocks base method. +func (m *MockPipeliner) ZRemRangeByRank(ctx context.Context, key string, start, stop int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRemRangeByRank", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRemRangeByRank indicates an expected call of ZRemRangeByRank. +func (mr *MockPipelinerMockRecorder) ZRemRangeByRank(ctx, key, start, stop interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByRank", reflect.TypeOf((*MockPipeliner)(nil).ZRemRangeByRank), ctx, key, start, stop) +} + +// ZRemRangeByScore mocks base method. +func (m *MockPipeliner) ZRemRangeByScore(ctx context.Context, key, min, max string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRemRangeByScore", ctx, key, min, max) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRemRangeByScore indicates an expected call of ZRemRangeByScore. +func (mr *MockPipelinerMockRecorder) ZRemRangeByScore(ctx, key, min, max interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByScore", reflect.TypeOf((*MockPipeliner)(nil).ZRemRangeByScore), ctx, key, min, max) +} + +// ZRevRange mocks base method. +func (m *MockPipeliner) ZRevRange(ctx context.Context, key string, start, stop int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRange", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRevRange indicates an expected call of ZRevRange. +func (mr *MockPipelinerMockRecorder) ZRevRange(ctx, key, start, stop interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRange", reflect.TypeOf((*MockPipeliner)(nil).ZRevRange), ctx, key, start, stop) +} + +// ZRevRangeByLex mocks base method. +func (m *MockPipeliner) ZRevRangeByLex(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRangeByLex", ctx, key, opt) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRevRangeByLex indicates an expected call of ZRevRangeByLex. +func (mr *MockPipelinerMockRecorder) ZRevRangeByLex(ctx, key, opt interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByLex", reflect.TypeOf((*MockPipeliner)(nil).ZRevRangeByLex), ctx, key, opt) +} + +// ZRevRangeByScore mocks base method. +func (m *MockPipeliner) ZRevRangeByScore(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRangeByScore", ctx, key, opt) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRevRangeByScore indicates an expected call of ZRevRangeByScore. +func (mr *MockPipelinerMockRecorder) ZRevRangeByScore(ctx, key, opt interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScore", reflect.TypeOf((*MockPipeliner)(nil).ZRevRangeByScore), ctx, key, opt) +} + +// ZRevRangeByScoreWithScores mocks base method. +func (m *MockPipeliner) ZRevRangeByScoreWithScores(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRangeByScoreWithScores", ctx, key, opt) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRevRangeByScoreWithScores indicates an expected call of ZRevRangeByScoreWithScores. +func (mr *MockPipelinerMockRecorder) ZRevRangeByScoreWithScores(ctx, key, opt interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScoreWithScores", reflect.TypeOf((*MockPipeliner)(nil).ZRevRangeByScoreWithScores), ctx, key, opt) +} + +// ZRevRangeWithScores mocks base method. +func (m *MockPipeliner) ZRevRangeWithScores(ctx context.Context, key string, start, stop int64) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRangeWithScores", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRevRangeWithScores indicates an expected call of ZRevRangeWithScores. +func (mr *MockPipelinerMockRecorder) ZRevRangeWithScores(ctx, key, start, stop interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeWithScores", reflect.TypeOf((*MockPipeliner)(nil).ZRevRangeWithScores), ctx, key, start, stop) +} + +// ZRevRank mocks base method. +func (m *MockPipeliner) ZRevRank(ctx context.Context, key, member string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRank", ctx, key, member) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRevRank indicates an expected call of ZRevRank. +func (mr *MockPipelinerMockRecorder) ZRevRank(ctx, key, member interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRank", reflect.TypeOf((*MockPipeliner)(nil).ZRevRank), ctx, key, member) +} + +// ZRevRankWithScore mocks base method. +func (m *MockPipeliner) ZRevRankWithScore(ctx context.Context, key, member string) *redis.RankWithScoreCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRankWithScore", ctx, key, member) + ret0, _ := ret[0].(*redis.RankWithScoreCmd) + return ret0 +} + +// ZRevRankWithScore indicates an expected call of ZRevRankWithScore. +func (mr *MockPipelinerMockRecorder) ZRevRankWithScore(ctx, key, member interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRankWithScore", reflect.TypeOf((*MockPipeliner)(nil).ZRevRankWithScore), ctx, key, member) +} + +// ZScan mocks base method. +func (m *MockPipeliner) ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZScan", ctx, key, cursor, match, count) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// ZScan indicates an expected call of ZScan. +func (mr *MockPipelinerMockRecorder) ZScan(ctx, key, cursor, match, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZScan", reflect.TypeOf((*MockPipeliner)(nil).ZScan), ctx, key, cursor, match, count) +} + +// ZScore mocks base method. +func (m *MockPipeliner) ZScore(ctx context.Context, key, member string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZScore", ctx, key, member) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// ZScore indicates an expected call of ZScore. +func (mr *MockPipelinerMockRecorder) ZScore(ctx, key, member interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZScore", reflect.TypeOf((*MockPipeliner)(nil).ZScore), ctx, key, member) +} + +// ZUnion mocks base method. +func (m *MockPipeliner) ZUnion(ctx context.Context, store redis.ZStore) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZUnion", ctx, store) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZUnion indicates an expected call of ZUnion. +func (mr *MockPipelinerMockRecorder) ZUnion(ctx, store interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnion", reflect.TypeOf((*MockPipeliner)(nil).ZUnion), ctx, store) +} + +// ZUnionStore mocks base method. +func (m *MockPipeliner) ZUnionStore(ctx context.Context, dest string, store *redis.ZStore) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZUnionStore", ctx, dest, store) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZUnionStore indicates an expected call of ZUnionStore. +func (mr *MockPipelinerMockRecorder) ZUnionStore(ctx, dest, store interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionStore", reflect.TypeOf((*MockPipeliner)(nil).ZUnionStore), ctx, dest, store) +} + +// ZUnionWithScores mocks base method. +func (m *MockPipeliner) ZUnionWithScores(ctx context.Context, store redis.ZStore) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZUnionWithScores", ctx, store) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZUnionWithScores indicates an expected call of ZUnionWithScores. +func (mr *MockPipelinerMockRecorder) ZUnionWithScores(ctx, store interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionWithScores", reflect.TypeOf((*MockPipeliner)(nil).ZUnionWithScores), ctx, store) +} diff --git a/redis/cluster/mocks/redis.go b/redis/cluster/mocks/redis.go new file mode 100644 index 0000000..3b0618b --- /dev/null +++ b/redis/cluster/mocks/redis.go @@ -0,0 +1,7863 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: redis/experimental/interfaces/redis.go + +package mocks + +import ( + context "context" + reflect "reflect" + time "time" + + gomock "github.com/golang/mock/gomock" + redis "github.com/redis/go-redis/v9" +) + +// MockUniversalClient is a mock of UniversalClient interface. +type MockUniversalClient struct { + ctrl *gomock.Controller + recorder *MockUniversalClientMockRecorder +} + +// MockUniversalClientMockRecorder is the mock recorder for MockUniversalClient. +type MockUniversalClientMockRecorder struct { + mock *MockUniversalClient +} + +// NewMockUniversalClient creates a new mock instance. +func NewMockUniversalClient(ctrl *gomock.Controller) *MockUniversalClient { + mock := &MockUniversalClient{ctrl: ctrl} + mock.recorder = &MockUniversalClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockUniversalClient) EXPECT() *MockUniversalClientMockRecorder { + return m.recorder +} + +// ACLDryRun mocks base method. +func (m *MockUniversalClient) ACLDryRun(ctx context.Context, username string, command ...interface{}) *redis.StringCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, username} + for _, a := range command { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ACLDryRun", varargs...) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ACLDryRun indicates an expected call of ACLDryRun. +func (mr *MockUniversalClientMockRecorder) ACLDryRun(ctx, username interface{}, command ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, username}, command...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLDryRun", reflect.TypeOf((*MockUniversalClient)(nil).ACLDryRun), varargs...) +} + +// ACLLog mocks base method. +func (m *MockUniversalClient) ACLLog(ctx context.Context, count int64) *redis.ACLLogCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ACLLog", ctx, count) + ret0, _ := ret[0].(*redis.ACLLogCmd) + return ret0 +} + +// ACLLog indicates an expected call of ACLLog. +func (mr *MockUniversalClientMockRecorder) ACLLog(ctx, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLog", reflect.TypeOf((*MockUniversalClient)(nil).ACLLog), ctx, count) +} + +// ACLLogReset mocks base method. +func (m *MockUniversalClient) ACLLogReset(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ACLLogReset", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ACLLogReset indicates an expected call of ACLLogReset. +func (mr *MockUniversalClientMockRecorder) ACLLogReset(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLogReset", reflect.TypeOf((*MockUniversalClient)(nil).ACLLogReset), ctx) +} + +// AddHook mocks base method. +func (m *MockUniversalClient) AddHook(arg0 redis.Hook) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "AddHook", arg0) +} + +// AddHook indicates an expected call of AddHook. +func (mr *MockUniversalClientMockRecorder) AddHook(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddHook", reflect.TypeOf((*MockUniversalClient)(nil).AddHook), arg0) +} + +// Append mocks base method. +func (m *MockUniversalClient) Append(ctx context.Context, key, value string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Append", ctx, key, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Append indicates an expected call of Append. +func (mr *MockUniversalClientMockRecorder) Append(ctx, key, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Append", reflect.TypeOf((*MockUniversalClient)(nil).Append), ctx, key, value) +} + +// BFAdd mocks base method. +func (m *MockUniversalClient) BFAdd(ctx context.Context, key string, element interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFAdd", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// BFAdd indicates an expected call of BFAdd. +func (mr *MockUniversalClientMockRecorder) BFAdd(ctx, key, element interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFAdd", reflect.TypeOf((*MockUniversalClient)(nil).BFAdd), ctx, key, element) +} + +// BFCard mocks base method. +func (m *MockUniversalClient) BFCard(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFCard", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BFCard indicates an expected call of BFCard. +func (mr *MockUniversalClientMockRecorder) BFCard(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFCard", reflect.TypeOf((*MockUniversalClient)(nil).BFCard), ctx, key) +} + +// BFExists mocks base method. +func (m *MockUniversalClient) BFExists(ctx context.Context, key string, element interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFExists", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// BFExists indicates an expected call of BFExists. +func (mr *MockUniversalClientMockRecorder) BFExists(ctx, key, element interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFExists", reflect.TypeOf((*MockUniversalClient)(nil).BFExists), ctx, key, element) +} + +// BFInfo mocks base method. +func (m *MockUniversalClient) BFInfo(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfo", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfo indicates an expected call of BFInfo. +func (mr *MockUniversalClientMockRecorder) BFInfo(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfo", reflect.TypeOf((*MockUniversalClient)(nil).BFInfo), ctx, key) +} + +// BFInfoArg mocks base method. +func (m *MockUniversalClient) BFInfoArg(ctx context.Context, key, option string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoArg", ctx, key, option) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoArg indicates an expected call of BFInfoArg. +func (mr *MockUniversalClientMockRecorder) BFInfoArg(ctx, key, option interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoArg", reflect.TypeOf((*MockUniversalClient)(nil).BFInfoArg), ctx, key, option) +} + +// BFInfoCapacity mocks base method. +func (m *MockUniversalClient) BFInfoCapacity(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoCapacity", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoCapacity indicates an expected call of BFInfoCapacity. +func (mr *MockUniversalClientMockRecorder) BFInfoCapacity(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoCapacity", reflect.TypeOf((*MockUniversalClient)(nil).BFInfoCapacity), ctx, key) +} + +// BFInfoExpansion mocks base method. +func (m *MockUniversalClient) BFInfoExpansion(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoExpansion", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoExpansion indicates an expected call of BFInfoExpansion. +func (mr *MockUniversalClientMockRecorder) BFInfoExpansion(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoExpansion", reflect.TypeOf((*MockUniversalClient)(nil).BFInfoExpansion), ctx, key) +} + +// BFInfoFilters mocks base method. +func (m *MockUniversalClient) BFInfoFilters(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoFilters", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoFilters indicates an expected call of BFInfoFilters. +func (mr *MockUniversalClientMockRecorder) BFInfoFilters(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoFilters", reflect.TypeOf((*MockUniversalClient)(nil).BFInfoFilters), ctx, key) +} + +// BFInfoItems mocks base method. +func (m *MockUniversalClient) BFInfoItems(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoItems", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoItems indicates an expected call of BFInfoItems. +func (mr *MockUniversalClientMockRecorder) BFInfoItems(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoItems", reflect.TypeOf((*MockUniversalClient)(nil).BFInfoItems), ctx, key) +} + +// BFInfoSize mocks base method. +func (m *MockUniversalClient) BFInfoSize(ctx context.Context, key string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoSize", ctx, key) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoSize indicates an expected call of BFInfoSize. +func (mr *MockUniversalClientMockRecorder) BFInfoSize(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoSize", reflect.TypeOf((*MockUniversalClient)(nil).BFInfoSize), ctx, key) +} + +// BFInsert mocks base method. +func (m *MockUniversalClient) BFInsert(ctx context.Context, key string, options *redis.BFInsertOptions, elements ...interface{}) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, options} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BFInsert", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// BFInsert indicates an expected call of BFInsert. +func (mr *MockUniversalClientMockRecorder) BFInsert(ctx, key, options interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, options}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInsert", reflect.TypeOf((*MockUniversalClient)(nil).BFInsert), varargs...) +} + +// BFLoadChunk mocks base method. +func (m *MockUniversalClient) BFLoadChunk(ctx context.Context, key string, iterator int64, data interface{}) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFLoadChunk", ctx, key, iterator, data) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFLoadChunk indicates an expected call of BFLoadChunk. +func (mr *MockUniversalClientMockRecorder) BFLoadChunk(ctx, key, iterator, data interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFLoadChunk", reflect.TypeOf((*MockUniversalClient)(nil).BFLoadChunk), ctx, key, iterator, data) +} + +// BFMAdd mocks base method. +func (m *MockUniversalClient) BFMAdd(ctx context.Context, key string, elements ...interface{}) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BFMAdd", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// BFMAdd indicates an expected call of BFMAdd. +func (mr *MockUniversalClientMockRecorder) BFMAdd(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFMAdd", reflect.TypeOf((*MockUniversalClient)(nil).BFMAdd), varargs...) +} + +// BFMExists mocks base method. +func (m *MockUniversalClient) BFMExists(ctx context.Context, key string, elements ...interface{}) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BFMExists", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// BFMExists indicates an expected call of BFMExists. +func (mr *MockUniversalClientMockRecorder) BFMExists(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFMExists", reflect.TypeOf((*MockUniversalClient)(nil).BFMExists), varargs...) +} + +// BFReserve mocks base method. +func (m *MockUniversalClient) BFReserve(ctx context.Context, key string, errorRate float64, capacity int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserve", ctx, key, errorRate, capacity) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserve indicates an expected call of BFReserve. +func (mr *MockUniversalClientMockRecorder) BFReserve(ctx, key, errorRate, capacity interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserve", reflect.TypeOf((*MockUniversalClient)(nil).BFReserve), ctx, key, errorRate, capacity) +} + +// BFReserveExpansion mocks base method. +func (m *MockUniversalClient) BFReserveExpansion(ctx context.Context, key string, errorRate float64, capacity, expansion int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserveExpansion", ctx, key, errorRate, capacity, expansion) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserveExpansion indicates an expected call of BFReserveExpansion. +func (mr *MockUniversalClientMockRecorder) BFReserveExpansion(ctx, key, errorRate, capacity, expansion interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveExpansion", reflect.TypeOf((*MockUniversalClient)(nil).BFReserveExpansion), ctx, key, errorRate, capacity, expansion) +} + +// BFReserveNonScaling mocks base method. +func (m *MockUniversalClient) BFReserveNonScaling(ctx context.Context, key string, errorRate float64, capacity int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserveNonScaling", ctx, key, errorRate, capacity) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserveNonScaling indicates an expected call of BFReserveNonScaling. +func (mr *MockUniversalClientMockRecorder) BFReserveNonScaling(ctx, key, errorRate, capacity interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveNonScaling", reflect.TypeOf((*MockUniversalClient)(nil).BFReserveNonScaling), ctx, key, errorRate, capacity) +} + +// BFReserveWithArgs mocks base method. +func (m *MockUniversalClient) BFReserveWithArgs(ctx context.Context, key string, options *redis.BFReserveOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserveWithArgs", ctx, key, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserveWithArgs indicates an expected call of BFReserveWithArgs. +func (mr *MockUniversalClientMockRecorder) BFReserveWithArgs(ctx, key, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).BFReserveWithArgs), ctx, key, options) +} + +// BFScanDump mocks base method. +func (m *MockUniversalClient) BFScanDump(ctx context.Context, key string, iterator int64) *redis.ScanDumpCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFScanDump", ctx, key, iterator) + ret0, _ := ret[0].(*redis.ScanDumpCmd) + return ret0 +} + +// BFScanDump indicates an expected call of BFScanDump. +func (mr *MockUniversalClientMockRecorder) BFScanDump(ctx, key, iterator interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFScanDump", reflect.TypeOf((*MockUniversalClient)(nil).BFScanDump), ctx, key, iterator) +} + +// BLMPop mocks base method. +func (m *MockUniversalClient) BLMPop(ctx context.Context, timeout time.Duration, direction string, count int64, keys ...string) *redis.KeyValuesCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, timeout, direction, count} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BLMPop", varargs...) + ret0, _ := ret[0].(*redis.KeyValuesCmd) + return ret0 +} + +// BLMPop indicates an expected call of BLMPop. +func (mr *MockUniversalClientMockRecorder) BLMPop(ctx, timeout, direction, count interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, timeout, direction, count}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLMPop", reflect.TypeOf((*MockUniversalClient)(nil).BLMPop), varargs...) +} + +// BLMove mocks base method. +func (m *MockUniversalClient) BLMove(ctx context.Context, source, destination, srcpos, destpos string, timeout time.Duration) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BLMove", ctx, source, destination, srcpos, destpos, timeout) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// BLMove indicates an expected call of BLMove. +func (mr *MockUniversalClientMockRecorder) BLMove(ctx, source, destination, srcpos, destpos, timeout interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLMove", reflect.TypeOf((*MockUniversalClient)(nil).BLMove), ctx, source, destination, srcpos, destpos, timeout) +} + +// BLPop mocks base method. +func (m *MockUniversalClient) BLPop(ctx context.Context, timeout time.Duration, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, timeout} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BLPop", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// BLPop indicates an expected call of BLPop. +func (mr *MockUniversalClientMockRecorder) BLPop(ctx, timeout interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, timeout}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLPop", reflect.TypeOf((*MockUniversalClient)(nil).BLPop), varargs...) +} + +// BRPop mocks base method. +func (m *MockUniversalClient) BRPop(ctx context.Context, timeout time.Duration, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, timeout} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BRPop", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// BRPop indicates an expected call of BRPop. +func (mr *MockUniversalClientMockRecorder) BRPop(ctx, timeout interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, timeout}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BRPop", reflect.TypeOf((*MockUniversalClient)(nil).BRPop), varargs...) +} + +// BRPopLPush mocks base method. +func (m *MockUniversalClient) BRPopLPush(ctx context.Context, source, destination string, timeout time.Duration) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BRPopLPush", ctx, source, destination, timeout) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// BRPopLPush indicates an expected call of BRPopLPush. +func (mr *MockUniversalClientMockRecorder) BRPopLPush(ctx, source, destination, timeout interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BRPopLPush", reflect.TypeOf((*MockUniversalClient)(nil).BRPopLPush), ctx, source, destination, timeout) +} + +// BZMPop mocks base method. +func (m *MockUniversalClient) BZMPop(ctx context.Context, timeout time.Duration, order string, count int64, keys ...string) *redis.ZSliceWithKeyCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, timeout, order, count} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BZMPop", varargs...) + ret0, _ := ret[0].(*redis.ZSliceWithKeyCmd) + return ret0 +} + +// BZMPop indicates an expected call of BZMPop. +func (mr *MockUniversalClientMockRecorder) BZMPop(ctx, timeout, order, count interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, timeout, order, count}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZMPop", reflect.TypeOf((*MockUniversalClient)(nil).BZMPop), varargs...) +} + +// BZPopMax mocks base method. +func (m *MockUniversalClient) BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) *redis.ZWithKeyCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, timeout} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BZPopMax", varargs...) + ret0, _ := ret[0].(*redis.ZWithKeyCmd) + return ret0 +} + +// BZPopMax indicates an expected call of BZPopMax. +func (mr *MockUniversalClientMockRecorder) BZPopMax(ctx, timeout interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, timeout}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZPopMax", reflect.TypeOf((*MockUniversalClient)(nil).BZPopMax), varargs...) +} + +// BZPopMin mocks base method. +func (m *MockUniversalClient) BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) *redis.ZWithKeyCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, timeout} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BZPopMin", varargs...) + ret0, _ := ret[0].(*redis.ZWithKeyCmd) + return ret0 +} + +// BZPopMin indicates an expected call of BZPopMin. +func (mr *MockUniversalClientMockRecorder) BZPopMin(ctx, timeout interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, timeout}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZPopMin", reflect.TypeOf((*MockUniversalClient)(nil).BZPopMin), varargs...) +} + +// BgRewriteAOF mocks base method. +func (m *MockUniversalClient) BgRewriteAOF(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BgRewriteAOF", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BgRewriteAOF indicates an expected call of BgRewriteAOF. +func (mr *MockUniversalClientMockRecorder) BgRewriteAOF(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BgRewriteAOF", reflect.TypeOf((*MockUniversalClient)(nil).BgRewriteAOF), ctx) +} + +// BgSave mocks base method. +func (m *MockUniversalClient) BgSave(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BgSave", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BgSave indicates an expected call of BgSave. +func (mr *MockUniversalClientMockRecorder) BgSave(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BgSave", reflect.TypeOf((*MockUniversalClient)(nil).BgSave), ctx) +} + +// BitCount mocks base method. +func (m *MockUniversalClient) BitCount(ctx context.Context, key string, bitCount *redis.BitCount) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BitCount", ctx, key, bitCount) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitCount indicates an expected call of BitCount. +func (mr *MockUniversalClientMockRecorder) BitCount(ctx, key, bitCount interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitCount", reflect.TypeOf((*MockUniversalClient)(nil).BitCount), ctx, key, bitCount) +} + +// BitField mocks base method. +func (m *MockUniversalClient) BitField(ctx context.Context, key string, values ...interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitField", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// BitField indicates an expected call of BitField. +func (mr *MockUniversalClientMockRecorder) BitField(ctx, key interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitField", reflect.TypeOf((*MockUniversalClient)(nil).BitField), varargs...) +} + +// BitFieldRO mocks base method. +func (m *MockUniversalClient) BitFieldRO(ctx context.Context, key string, values ...interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitFieldRO", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// BitFieldRO indicates an expected call of BitFieldRO. +func (mr *MockUniversalClientMockRecorder) BitFieldRO(ctx, key interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitFieldRO", reflect.TypeOf((*MockUniversalClient)(nil).BitFieldRO), varargs...) +} + +// BitOpAnd mocks base method. +func (m *MockUniversalClient) BitOpAnd(ctx context.Context, destKey string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, destKey} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitOpAnd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitOpAnd indicates an expected call of BitOpAnd. +func (mr *MockUniversalClientMockRecorder) BitOpAnd(ctx, destKey interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, destKey}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpAnd", reflect.TypeOf((*MockUniversalClient)(nil).BitOpAnd), varargs...) +} + +// BitOpNot mocks base method. +func (m *MockUniversalClient) BitOpNot(ctx context.Context, destKey, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BitOpNot", ctx, destKey, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitOpNot indicates an expected call of BitOpNot. +func (mr *MockUniversalClientMockRecorder) BitOpNot(ctx, destKey, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpNot", reflect.TypeOf((*MockUniversalClient)(nil).BitOpNot), ctx, destKey, key) +} + +// BitOpOr mocks base method. +func (m *MockUniversalClient) BitOpOr(ctx context.Context, destKey string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, destKey} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitOpOr", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitOpOr indicates an expected call of BitOpOr. +func (mr *MockUniversalClientMockRecorder) BitOpOr(ctx, destKey interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, destKey}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpOr", reflect.TypeOf((*MockUniversalClient)(nil).BitOpOr), varargs...) +} + +// BitOpXor mocks base method. +func (m *MockUniversalClient) BitOpXor(ctx context.Context, destKey string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, destKey} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitOpXor", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitOpXor indicates an expected call of BitOpXor. +func (mr *MockUniversalClientMockRecorder) BitOpXor(ctx, destKey interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, destKey}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpXor", reflect.TypeOf((*MockUniversalClient)(nil).BitOpXor), varargs...) +} + +// BitPos mocks base method. +func (m *MockUniversalClient) BitPos(ctx context.Context, key string, bit int64, pos ...int64) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, bit} + for _, a := range pos { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitPos", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitPos indicates an expected call of BitPos. +func (mr *MockUniversalClientMockRecorder) BitPos(ctx, key, bit interface{}, pos ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, bit}, pos...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitPos", reflect.TypeOf((*MockUniversalClient)(nil).BitPos), varargs...) +} + +// BitPosSpan mocks base method. +func (m *MockUniversalClient) BitPosSpan(ctx context.Context, key string, bit int8, start, end int64, span string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BitPosSpan", ctx, key, bit, start, end, span) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitPosSpan indicates an expected call of BitPosSpan. +func (mr *MockUniversalClientMockRecorder) BitPosSpan(ctx, key, bit, start, end, span interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitPosSpan", reflect.TypeOf((*MockUniversalClient)(nil).BitPosSpan), ctx, key, bit, start, end, span) +} + +// CFAdd mocks base method. +func (m *MockUniversalClient) CFAdd(ctx context.Context, key string, element interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFAdd", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// CFAdd indicates an expected call of CFAdd. +func (mr *MockUniversalClientMockRecorder) CFAdd(ctx, key, element interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAdd", reflect.TypeOf((*MockUniversalClient)(nil).CFAdd), ctx, key, element) +} + +// CFAddNX mocks base method. +func (m *MockUniversalClient) CFAddNX(ctx context.Context, key string, element interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFAddNX", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// CFAddNX indicates an expected call of CFAddNX. +func (mr *MockUniversalClientMockRecorder) CFAddNX(ctx, key, element interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAddNX", reflect.TypeOf((*MockUniversalClient)(nil).CFAddNX), ctx, key, element) +} + +// CFCount mocks base method. +func (m *MockUniversalClient) CFCount(ctx context.Context, key string, element interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFCount", ctx, key, element) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// CFCount indicates an expected call of CFCount. +func (mr *MockUniversalClientMockRecorder) CFCount(ctx, key, element interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFCount", reflect.TypeOf((*MockUniversalClient)(nil).CFCount), ctx, key, element) +} + +// CFDel mocks base method. +func (m *MockUniversalClient) CFDel(ctx context.Context, key string, element interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFDel", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// CFDel indicates an expected call of CFDel. +func (mr *MockUniversalClientMockRecorder) CFDel(ctx, key, element interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFDel", reflect.TypeOf((*MockUniversalClient)(nil).CFDel), ctx, key, element) +} + +// CFExists mocks base method. +func (m *MockUniversalClient) CFExists(ctx context.Context, key string, element interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFExists", ctx, key, element) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// CFExists indicates an expected call of CFExists. +func (mr *MockUniversalClientMockRecorder) CFExists(ctx, key, element interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFExists", reflect.TypeOf((*MockUniversalClient)(nil).CFExists), ctx, key, element) +} + +// CFInfo mocks base method. +func (m *MockUniversalClient) CFInfo(ctx context.Context, key string) *redis.CFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFInfo", ctx, key) + ret0, _ := ret[0].(*redis.CFInfoCmd) + return ret0 +} + +// CFInfo indicates an expected call of CFInfo. +func (mr *MockUniversalClientMockRecorder) CFInfo(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInfo", reflect.TypeOf((*MockUniversalClient)(nil).CFInfo), ctx, key) +} + +// CFInsert mocks base method. +func (m *MockUniversalClient) CFInsert(ctx context.Context, key string, options *redis.CFInsertOptions, elements ...interface{}) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, options} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CFInsert", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// CFInsert indicates an expected call of CFInsert. +func (mr *MockUniversalClientMockRecorder) CFInsert(ctx, key, options interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, options}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInsert", reflect.TypeOf((*MockUniversalClient)(nil).CFInsert), varargs...) +} + +// CFInsertNX mocks base method. +func (m *MockUniversalClient) CFInsertNX(ctx context.Context, key string, options *redis.CFInsertOptions, elements ...interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, options} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CFInsertNX", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// CFInsertNX indicates an expected call of CFInsertNX. +func (mr *MockUniversalClientMockRecorder) CFInsertNX(ctx, key, options interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, options}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInsertNX", reflect.TypeOf((*MockUniversalClient)(nil).CFInsertNX), varargs...) +} + +// CFLoadChunk mocks base method. +func (m *MockUniversalClient) CFLoadChunk(ctx context.Context, key string, iterator int64, data interface{}) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFLoadChunk", ctx, key, iterator, data) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFLoadChunk indicates an expected call of CFLoadChunk. +func (mr *MockUniversalClientMockRecorder) CFLoadChunk(ctx, key, iterator, data interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFLoadChunk", reflect.TypeOf((*MockUniversalClient)(nil).CFLoadChunk), ctx, key, iterator, data) +} + +// CFMExists mocks base method. +func (m *MockUniversalClient) CFMExists(ctx context.Context, key string, elements ...interface{}) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CFMExists", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// CFMExists indicates an expected call of CFMExists. +func (mr *MockUniversalClientMockRecorder) CFMExists(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFMExists", reflect.TypeOf((*MockUniversalClient)(nil).CFMExists), varargs...) +} + +// CFReserve mocks base method. +func (m *MockUniversalClient) CFReserve(ctx context.Context, key string, capacity int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserve", ctx, key, capacity) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserve indicates an expected call of CFReserve. +func (mr *MockUniversalClientMockRecorder) CFReserve(ctx, key, capacity interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserve", reflect.TypeOf((*MockUniversalClient)(nil).CFReserve), ctx, key, capacity) +} + +// CFReserveBucketSize mocks base method. +func (m *MockUniversalClient) CFReserveBucketSize(ctx context.Context, key string, capacity, bucketsize int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveBucketSize", ctx, key, capacity, bucketsize) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveBucketSize indicates an expected call of CFReserveBucketSize. +func (mr *MockUniversalClientMockRecorder) CFReserveBucketSize(ctx, key, capacity, bucketsize interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveBucketSize", reflect.TypeOf((*MockUniversalClient)(nil).CFReserveBucketSize), ctx, key, capacity, bucketsize) +} + +// CFReserveExpansion mocks base method. +func (m *MockUniversalClient) CFReserveExpansion(ctx context.Context, key string, capacity, expansion int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveExpansion", ctx, key, capacity, expansion) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveExpansion indicates an expected call of CFReserveExpansion. +func (mr *MockUniversalClientMockRecorder) CFReserveExpansion(ctx, key, capacity, expansion interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveExpansion", reflect.TypeOf((*MockUniversalClient)(nil).CFReserveExpansion), ctx, key, capacity, expansion) +} + +// CFReserveMaxIterations mocks base method. +func (m *MockUniversalClient) CFReserveMaxIterations(ctx context.Context, key string, capacity, maxiterations int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveMaxIterations", ctx, key, capacity, maxiterations) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveMaxIterations indicates an expected call of CFReserveMaxIterations. +func (mr *MockUniversalClientMockRecorder) CFReserveMaxIterations(ctx, key, capacity, maxiterations interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveMaxIterations", reflect.TypeOf((*MockUniversalClient)(nil).CFReserveMaxIterations), ctx, key, capacity, maxiterations) +} + +// CFReserveWithArgs mocks base method. +func (m *MockUniversalClient) CFReserveWithArgs(ctx context.Context, key string, options *redis.CFReserveOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveWithArgs", ctx, key, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveWithArgs indicates an expected call of CFReserveWithArgs. +func (mr *MockUniversalClientMockRecorder) CFReserveWithArgs(ctx, key, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).CFReserveWithArgs), ctx, key, options) +} + +// CFScanDump mocks base method. +func (m *MockUniversalClient) CFScanDump(ctx context.Context, key string, iterator int64) *redis.ScanDumpCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFScanDump", ctx, key, iterator) + ret0, _ := ret[0].(*redis.ScanDumpCmd) + return ret0 +} + +// CFScanDump indicates an expected call of CFScanDump. +func (mr *MockUniversalClientMockRecorder) CFScanDump(ctx, key, iterator interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFScanDump", reflect.TypeOf((*MockUniversalClient)(nil).CFScanDump), ctx, key, iterator) +} + +// CMSIncrBy mocks base method. +func (m *MockUniversalClient) CMSIncrBy(ctx context.Context, key string, elements ...interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CMSIncrBy", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// CMSIncrBy indicates an expected call of CMSIncrBy. +func (mr *MockUniversalClientMockRecorder) CMSIncrBy(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSIncrBy", reflect.TypeOf((*MockUniversalClient)(nil).CMSIncrBy), varargs...) +} + +// CMSInfo mocks base method. +func (m *MockUniversalClient) CMSInfo(ctx context.Context, key string) *redis.CMSInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CMSInfo", ctx, key) + ret0, _ := ret[0].(*redis.CMSInfoCmd) + return ret0 +} + +// CMSInfo indicates an expected call of CMSInfo. +func (mr *MockUniversalClientMockRecorder) CMSInfo(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInfo", reflect.TypeOf((*MockUniversalClient)(nil).CMSInfo), ctx, key) +} + +// CMSInitByDim mocks base method. +func (m *MockUniversalClient) CMSInitByDim(ctx context.Context, key string, width, height int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CMSInitByDim", ctx, key, width, height) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CMSInitByDim indicates an expected call of CMSInitByDim. +func (mr *MockUniversalClientMockRecorder) CMSInitByDim(ctx, key, width, height interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInitByDim", reflect.TypeOf((*MockUniversalClient)(nil).CMSInitByDim), ctx, key, width, height) +} + +// CMSInitByProb mocks base method. +func (m *MockUniversalClient) CMSInitByProb(ctx context.Context, key string, errorRate, probability float64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CMSInitByProb", ctx, key, errorRate, probability) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CMSInitByProb indicates an expected call of CMSInitByProb. +func (mr *MockUniversalClientMockRecorder) CMSInitByProb(ctx, key, errorRate, probability interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInitByProb", reflect.TypeOf((*MockUniversalClient)(nil).CMSInitByProb), ctx, key, errorRate, probability) +} + +// CMSMerge mocks base method. +func (m *MockUniversalClient) CMSMerge(ctx context.Context, destKey string, sourceKeys ...string) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, destKey} + for _, a := range sourceKeys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CMSMerge", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CMSMerge indicates an expected call of CMSMerge. +func (mr *MockUniversalClientMockRecorder) CMSMerge(ctx, destKey interface{}, sourceKeys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, destKey}, sourceKeys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSMerge", reflect.TypeOf((*MockUniversalClient)(nil).CMSMerge), varargs...) +} + +// CMSMergeWithWeight mocks base method. +func (m *MockUniversalClient) CMSMergeWithWeight(ctx context.Context, destKey string, sourceKeys map[string]int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CMSMergeWithWeight", ctx, destKey, sourceKeys) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CMSMergeWithWeight indicates an expected call of CMSMergeWithWeight. +func (mr *MockUniversalClientMockRecorder) CMSMergeWithWeight(ctx, destKey, sourceKeys interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSMergeWithWeight", reflect.TypeOf((*MockUniversalClient)(nil).CMSMergeWithWeight), ctx, destKey, sourceKeys) +} + +// CMSQuery mocks base method. +func (m *MockUniversalClient) CMSQuery(ctx context.Context, key string, elements ...interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CMSQuery", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// CMSQuery indicates an expected call of CMSQuery. +func (mr *MockUniversalClientMockRecorder) CMSQuery(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSQuery", reflect.TypeOf((*MockUniversalClient)(nil).CMSQuery), varargs...) +} + +// ClientGetName mocks base method. +func (m *MockUniversalClient) ClientGetName(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientGetName", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClientGetName indicates an expected call of ClientGetName. +func (mr *MockUniversalClientMockRecorder) ClientGetName(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientGetName", reflect.TypeOf((*MockUniversalClient)(nil).ClientGetName), ctx) +} + +// ClientID mocks base method. +func (m *MockUniversalClient) ClientID(ctx context.Context) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientID", ctx) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClientID indicates an expected call of ClientID. +func (mr *MockUniversalClientMockRecorder) ClientID(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientID", reflect.TypeOf((*MockUniversalClient)(nil).ClientID), ctx) +} + +// ClientInfo mocks base method. +func (m *MockUniversalClient) ClientInfo(ctx context.Context) *redis.ClientInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientInfo", ctx) + ret0, _ := ret[0].(*redis.ClientInfoCmd) + return ret0 +} + +// ClientInfo indicates an expected call of ClientInfo. +func (mr *MockUniversalClientMockRecorder) ClientInfo(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientInfo", reflect.TypeOf((*MockUniversalClient)(nil).ClientInfo), ctx) +} + +// ClientKill mocks base method. +func (m *MockUniversalClient) ClientKill(ctx context.Context, ipPort string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientKill", ctx, ipPort) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClientKill indicates an expected call of ClientKill. +func (mr *MockUniversalClientMockRecorder) ClientKill(ctx, ipPort interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientKill", reflect.TypeOf((*MockUniversalClient)(nil).ClientKill), ctx, ipPort) +} + +// ClientKillByFilter mocks base method. +func (m *MockUniversalClient) ClientKillByFilter(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ClientKillByFilter", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClientKillByFilter indicates an expected call of ClientKillByFilter. +func (mr *MockUniversalClientMockRecorder) ClientKillByFilter(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientKillByFilter", reflect.TypeOf((*MockUniversalClient)(nil).ClientKillByFilter), varargs...) +} + +// ClientList mocks base method. +func (m *MockUniversalClient) ClientList(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientList", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClientList indicates an expected call of ClientList. +func (mr *MockUniversalClientMockRecorder) ClientList(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientList", reflect.TypeOf((*MockUniversalClient)(nil).ClientList), ctx) +} + +// ClientPause mocks base method. +func (m *MockUniversalClient) ClientPause(ctx context.Context, dur time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientPause", ctx, dur) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ClientPause indicates an expected call of ClientPause. +func (mr *MockUniversalClientMockRecorder) ClientPause(ctx, dur interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientPause", reflect.TypeOf((*MockUniversalClient)(nil).ClientPause), ctx, dur) +} + +// ClientUnblock mocks base method. +func (m *MockUniversalClient) ClientUnblock(ctx context.Context, id int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientUnblock", ctx, id) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClientUnblock indicates an expected call of ClientUnblock. +func (mr *MockUniversalClientMockRecorder) ClientUnblock(ctx, id interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblock", reflect.TypeOf((*MockUniversalClient)(nil).ClientUnblock), ctx, id) +} + +// ClientUnblockWithError mocks base method. +func (m *MockUniversalClient) ClientUnblockWithError(ctx context.Context, id int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientUnblockWithError", ctx, id) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClientUnblockWithError indicates an expected call of ClientUnblockWithError. +func (mr *MockUniversalClientMockRecorder) ClientUnblockWithError(ctx, id interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblockWithError", reflect.TypeOf((*MockUniversalClient)(nil).ClientUnblockWithError), ctx, id) +} + +// ClientUnpause mocks base method. +func (m *MockUniversalClient) ClientUnpause(ctx context.Context) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientUnpause", ctx) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ClientUnpause indicates an expected call of ClientUnpause. +func (mr *MockUniversalClientMockRecorder) ClientUnpause(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnpause", reflect.TypeOf((*MockUniversalClient)(nil).ClientUnpause), ctx) +} + +// Close mocks base method. +func (m *MockUniversalClient) Close() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) + return ret0 +} + +// Close indicates an expected call of Close. +func (mr *MockUniversalClientMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockUniversalClient)(nil).Close)) +} + +// ClusterAddSlots mocks base method. +func (m *MockUniversalClient) ClusterAddSlots(ctx context.Context, slots ...int) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range slots { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ClusterAddSlots", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterAddSlots indicates an expected call of ClusterAddSlots. +func (mr *MockUniversalClientMockRecorder) ClusterAddSlots(ctx interface{}, slots ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, slots...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterAddSlots", reflect.TypeOf((*MockUniversalClient)(nil).ClusterAddSlots), varargs...) +} + +// ClusterAddSlotsRange mocks base method. +func (m *MockUniversalClient) ClusterAddSlotsRange(ctx context.Context, min, max int) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterAddSlotsRange", ctx, min, max) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterAddSlotsRange indicates an expected call of ClusterAddSlotsRange. +func (mr *MockUniversalClientMockRecorder) ClusterAddSlotsRange(ctx, min, max interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterAddSlotsRange", reflect.TypeOf((*MockUniversalClient)(nil).ClusterAddSlotsRange), ctx, min, max) +} + +// ClusterCountFailureReports mocks base method. +func (m *MockUniversalClient) ClusterCountFailureReports(ctx context.Context, nodeID string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterCountFailureReports", ctx, nodeID) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClusterCountFailureReports indicates an expected call of ClusterCountFailureReports. +func (mr *MockUniversalClientMockRecorder) ClusterCountFailureReports(ctx, nodeID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountFailureReports", reflect.TypeOf((*MockUniversalClient)(nil).ClusterCountFailureReports), ctx, nodeID) +} + +// ClusterCountKeysInSlot mocks base method. +func (m *MockUniversalClient) ClusterCountKeysInSlot(ctx context.Context, slot int) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterCountKeysInSlot", ctx, slot) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClusterCountKeysInSlot indicates an expected call of ClusterCountKeysInSlot. +func (mr *MockUniversalClientMockRecorder) ClusterCountKeysInSlot(ctx, slot interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountKeysInSlot", reflect.TypeOf((*MockUniversalClient)(nil).ClusterCountKeysInSlot), ctx, slot) +} + +// ClusterDelSlots mocks base method. +func (m *MockUniversalClient) ClusterDelSlots(ctx context.Context, slots ...int) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range slots { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ClusterDelSlots", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterDelSlots indicates an expected call of ClusterDelSlots. +func (mr *MockUniversalClientMockRecorder) ClusterDelSlots(ctx interface{}, slots ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, slots...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterDelSlots", reflect.TypeOf((*MockUniversalClient)(nil).ClusterDelSlots), varargs...) +} + +// ClusterDelSlotsRange mocks base method. +func (m *MockUniversalClient) ClusterDelSlotsRange(ctx context.Context, min, max int) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterDelSlotsRange", ctx, min, max) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterDelSlotsRange indicates an expected call of ClusterDelSlotsRange. +func (mr *MockUniversalClientMockRecorder) ClusterDelSlotsRange(ctx, min, max interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterDelSlotsRange", reflect.TypeOf((*MockUniversalClient)(nil).ClusterDelSlotsRange), ctx, min, max) +} + +// ClusterFailover mocks base method. +func (m *MockUniversalClient) ClusterFailover(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterFailover", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterFailover indicates an expected call of ClusterFailover. +func (mr *MockUniversalClientMockRecorder) ClusterFailover(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterFailover", reflect.TypeOf((*MockUniversalClient)(nil).ClusterFailover), ctx) +} + +// ClusterForget mocks base method. +func (m *MockUniversalClient) ClusterForget(ctx context.Context, nodeID string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterForget", ctx, nodeID) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterForget indicates an expected call of ClusterForget. +func (mr *MockUniversalClientMockRecorder) ClusterForget(ctx, nodeID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterForget", reflect.TypeOf((*MockUniversalClient)(nil).ClusterForget), ctx, nodeID) +} + +// ClusterGetKeysInSlot mocks base method. +func (m *MockUniversalClient) ClusterGetKeysInSlot(ctx context.Context, slot, count int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterGetKeysInSlot", ctx, slot, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ClusterGetKeysInSlot indicates an expected call of ClusterGetKeysInSlot. +func (mr *MockUniversalClientMockRecorder) ClusterGetKeysInSlot(ctx, slot, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterGetKeysInSlot", reflect.TypeOf((*MockUniversalClient)(nil).ClusterGetKeysInSlot), ctx, slot, count) +} + +// ClusterInfo mocks base method. +func (m *MockUniversalClient) ClusterInfo(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterInfo", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClusterInfo indicates an expected call of ClusterInfo. +func (mr *MockUniversalClientMockRecorder) ClusterInfo(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterInfo", reflect.TypeOf((*MockUniversalClient)(nil).ClusterInfo), ctx) +} + +// ClusterKeySlot mocks base method. +func (m *MockUniversalClient) ClusterKeySlot(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterKeySlot", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClusterKeySlot indicates an expected call of ClusterKeySlot. +func (mr *MockUniversalClientMockRecorder) ClusterKeySlot(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterKeySlot", reflect.TypeOf((*MockUniversalClient)(nil).ClusterKeySlot), ctx, key) +} + +// ClusterLinks mocks base method. +func (m *MockUniversalClient) ClusterLinks(ctx context.Context) *redis.ClusterLinksCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterLinks", ctx) + ret0, _ := ret[0].(*redis.ClusterLinksCmd) + return ret0 +} + +// ClusterLinks indicates an expected call of ClusterLinks. +func (mr *MockUniversalClientMockRecorder) ClusterLinks(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterLinks", reflect.TypeOf((*MockUniversalClient)(nil).ClusterLinks), ctx) +} + +// ClusterMeet mocks base method. +func (m *MockUniversalClient) ClusterMeet(ctx context.Context, host, port string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterMeet", ctx, host, port) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterMeet indicates an expected call of ClusterMeet. +func (mr *MockUniversalClientMockRecorder) ClusterMeet(ctx, host, port interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMeet", reflect.TypeOf((*MockUniversalClient)(nil).ClusterMeet), ctx, host, port) +} + +// ClusterMyShardID mocks base method. +func (m *MockUniversalClient) ClusterMyShardID(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterMyShardID", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClusterMyShardID indicates an expected call of ClusterMyShardID. +func (mr *MockUniversalClientMockRecorder) ClusterMyShardID(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMyShardID", reflect.TypeOf((*MockUniversalClient)(nil).ClusterMyShardID), ctx) +} + +// ClusterNodes mocks base method. +func (m *MockUniversalClient) ClusterNodes(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterNodes", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClusterNodes indicates an expected call of ClusterNodes. +func (mr *MockUniversalClientMockRecorder) ClusterNodes(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterNodes", reflect.TypeOf((*MockUniversalClient)(nil).ClusterNodes), ctx) +} + +// ClusterReplicate mocks base method. +func (m *MockUniversalClient) ClusterReplicate(ctx context.Context, nodeID string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterReplicate", ctx, nodeID) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterReplicate indicates an expected call of ClusterReplicate. +func (mr *MockUniversalClientMockRecorder) ClusterReplicate(ctx, nodeID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterReplicate", reflect.TypeOf((*MockUniversalClient)(nil).ClusterReplicate), ctx, nodeID) +} + +// ClusterResetHard mocks base method. +func (m *MockUniversalClient) ClusterResetHard(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterResetHard", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterResetHard indicates an expected call of ClusterResetHard. +func (mr *MockUniversalClientMockRecorder) ClusterResetHard(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetHard", reflect.TypeOf((*MockUniversalClient)(nil).ClusterResetHard), ctx) +} + +// ClusterResetSoft mocks base method. +func (m *MockUniversalClient) ClusterResetSoft(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterResetSoft", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterResetSoft indicates an expected call of ClusterResetSoft. +func (mr *MockUniversalClientMockRecorder) ClusterResetSoft(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetSoft", reflect.TypeOf((*MockUniversalClient)(nil).ClusterResetSoft), ctx) +} + +// ClusterSaveConfig mocks base method. +func (m *MockUniversalClient) ClusterSaveConfig(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterSaveConfig", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterSaveConfig indicates an expected call of ClusterSaveConfig. +func (mr *MockUniversalClientMockRecorder) ClusterSaveConfig(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSaveConfig", reflect.TypeOf((*MockUniversalClient)(nil).ClusterSaveConfig), ctx) +} + +// ClusterShards mocks base method. +func (m *MockUniversalClient) ClusterShards(ctx context.Context) *redis.ClusterShardsCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterShards", ctx) + ret0, _ := ret[0].(*redis.ClusterShardsCmd) + return ret0 +} + +// ClusterShards indicates an expected call of ClusterShards. +func (mr *MockUniversalClientMockRecorder) ClusterShards(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterShards", reflect.TypeOf((*MockUniversalClient)(nil).ClusterShards), ctx) +} + +// ClusterSlaves mocks base method. +func (m *MockUniversalClient) ClusterSlaves(ctx context.Context, nodeID string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterSlaves", ctx, nodeID) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ClusterSlaves indicates an expected call of ClusterSlaves. +func (mr *MockUniversalClientMockRecorder) ClusterSlaves(ctx, nodeID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlaves", reflect.TypeOf((*MockUniversalClient)(nil).ClusterSlaves), ctx, nodeID) +} + +// ClusterSlots mocks base method. +func (m *MockUniversalClient) ClusterSlots(ctx context.Context) *redis.ClusterSlotsCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterSlots", ctx) + ret0, _ := ret[0].(*redis.ClusterSlotsCmd) + return ret0 +} + +// ClusterSlots indicates an expected call of ClusterSlots. +func (mr *MockUniversalClientMockRecorder) ClusterSlots(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlots", reflect.TypeOf((*MockUniversalClient)(nil).ClusterSlots), ctx) +} + +// Command mocks base method. +func (m *MockUniversalClient) Command(ctx context.Context) *redis.CommandsInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Command", ctx) + ret0, _ := ret[0].(*redis.CommandsInfoCmd) + return ret0 +} + +// Command indicates an expected call of Command. +func (mr *MockUniversalClientMockRecorder) Command(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Command", reflect.TypeOf((*MockUniversalClient)(nil).Command), ctx) +} + +// CommandGetKeys mocks base method. +func (m *MockUniversalClient) CommandGetKeys(ctx context.Context, commands ...interface{}) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range commands { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CommandGetKeys", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// CommandGetKeys indicates an expected call of CommandGetKeys. +func (mr *MockUniversalClientMockRecorder) CommandGetKeys(ctx interface{}, commands ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, commands...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandGetKeys", reflect.TypeOf((*MockUniversalClient)(nil).CommandGetKeys), varargs...) +} + +// CommandGetKeysAndFlags mocks base method. +func (m *MockUniversalClient) CommandGetKeysAndFlags(ctx context.Context, commands ...interface{}) *redis.KeyFlagsCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range commands { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CommandGetKeysAndFlags", varargs...) + ret0, _ := ret[0].(*redis.KeyFlagsCmd) + return ret0 +} + +// CommandGetKeysAndFlags indicates an expected call of CommandGetKeysAndFlags. +func (mr *MockUniversalClientMockRecorder) CommandGetKeysAndFlags(ctx interface{}, commands ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, commands...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandGetKeysAndFlags", reflect.TypeOf((*MockUniversalClient)(nil).CommandGetKeysAndFlags), varargs...) +} + +// CommandList mocks base method. +func (m *MockUniversalClient) CommandList(ctx context.Context, filter *redis.FilterBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CommandList", ctx, filter) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// CommandList indicates an expected call of CommandList. +func (mr *MockUniversalClientMockRecorder) CommandList(ctx, filter interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandList", reflect.TypeOf((*MockUniversalClient)(nil).CommandList), ctx, filter) +} + +// ConfigGet mocks base method. +func (m *MockUniversalClient) ConfigGet(ctx context.Context, parameter string) *redis.MapStringStringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigGet", ctx, parameter) + ret0, _ := ret[0].(*redis.MapStringStringCmd) + return ret0 +} + +// ConfigGet indicates an expected call of ConfigGet. +func (mr *MockUniversalClientMockRecorder) ConfigGet(ctx, parameter interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigGet", reflect.TypeOf((*MockUniversalClient)(nil).ConfigGet), ctx, parameter) +} + +// ConfigResetStat mocks base method. +func (m *MockUniversalClient) ConfigResetStat(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigResetStat", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ConfigResetStat indicates an expected call of ConfigResetStat. +func (mr *MockUniversalClientMockRecorder) ConfigResetStat(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigResetStat", reflect.TypeOf((*MockUniversalClient)(nil).ConfigResetStat), ctx) +} + +// ConfigRewrite mocks base method. +func (m *MockUniversalClient) ConfigRewrite(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigRewrite", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ConfigRewrite indicates an expected call of ConfigRewrite. +func (mr *MockUniversalClientMockRecorder) ConfigRewrite(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigRewrite", reflect.TypeOf((*MockUniversalClient)(nil).ConfigRewrite), ctx) +} + +// ConfigSet mocks base method. +func (m *MockUniversalClient) ConfigSet(ctx context.Context, parameter, value string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigSet", ctx, parameter, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ConfigSet indicates an expected call of ConfigSet. +func (mr *MockUniversalClientMockRecorder) ConfigSet(ctx, parameter, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigSet", reflect.TypeOf((*MockUniversalClient)(nil).ConfigSet), ctx, parameter, value) +} + +// Copy mocks base method. +func (m *MockUniversalClient) Copy(ctx context.Context, sourceKey, destKey string, db int, replace bool) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Copy", ctx, sourceKey, destKey, db, replace) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Copy indicates an expected call of Copy. +func (mr *MockUniversalClientMockRecorder) Copy(ctx, sourceKey, destKey, db, replace interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Copy", reflect.TypeOf((*MockUniversalClient)(nil).Copy), ctx, sourceKey, destKey, db, replace) +} + +// DBSize mocks base method. +func (m *MockUniversalClient) DBSize(ctx context.Context) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DBSize", ctx) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// DBSize indicates an expected call of DBSize. +func (mr *MockUniversalClientMockRecorder) DBSize(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DBSize", reflect.TypeOf((*MockUniversalClient)(nil).DBSize), ctx) +} + +// DebugObject mocks base method. +func (m *MockUniversalClient) DebugObject(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DebugObject", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// DebugObject indicates an expected call of DebugObject. +func (mr *MockUniversalClientMockRecorder) DebugObject(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugObject", reflect.TypeOf((*MockUniversalClient)(nil).DebugObject), ctx, key) +} + +// Decr mocks base method. +func (m *MockUniversalClient) Decr(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Decr", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Decr indicates an expected call of Decr. +func (mr *MockUniversalClientMockRecorder) Decr(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decr", reflect.TypeOf((*MockUniversalClient)(nil).Decr), ctx, key) +} + +// DecrBy mocks base method. +func (m *MockUniversalClient) DecrBy(ctx context.Context, key string, decrement int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DecrBy", ctx, key, decrement) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// DecrBy indicates an expected call of DecrBy. +func (mr *MockUniversalClientMockRecorder) DecrBy(ctx, key, decrement interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecrBy", reflect.TypeOf((*MockUniversalClient)(nil).DecrBy), ctx, key, decrement) +} + +// Del mocks base method. +func (m *MockUniversalClient) Del(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Del", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Del indicates an expected call of Del. +func (mr *MockUniversalClientMockRecorder) Del(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Del", reflect.TypeOf((*MockUniversalClient)(nil).Del), varargs...) +} + +// Do mocks base method. +func (m *MockUniversalClient) Do(ctx context.Context, args ...interface{}) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Do", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// Do indicates an expected call of Do. +func (mr *MockUniversalClientMockRecorder) Do(ctx interface{}, args ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Do", reflect.TypeOf((*MockUniversalClient)(nil).Do), varargs...) +} + +// Dump mocks base method. +func (m *MockUniversalClient) Dump(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Dump", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// Dump indicates an expected call of Dump. +func (mr *MockUniversalClientMockRecorder) Dump(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Dump", reflect.TypeOf((*MockUniversalClient)(nil).Dump), ctx, key) +} + +// Echo mocks base method. +func (m *MockUniversalClient) Echo(ctx context.Context, message interface{}) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Echo", ctx, message) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// Echo indicates an expected call of Echo. +func (mr *MockUniversalClientMockRecorder) Echo(ctx, message interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Echo", reflect.TypeOf((*MockUniversalClient)(nil).Echo), ctx, message) +} + +// Eval mocks base method. +func (m *MockUniversalClient) Eval(ctx context.Context, script string, keys []string, args ...interface{}) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, script, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Eval", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// Eval indicates an expected call of Eval. +func (mr *MockUniversalClientMockRecorder) Eval(ctx, script, keys interface{}, args ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, script, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eval", reflect.TypeOf((*MockUniversalClient)(nil).Eval), varargs...) +} + +// EvalRO mocks base method. +func (m *MockUniversalClient) EvalRO(ctx context.Context, script string, keys []string, args ...interface{}) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, script, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EvalRO", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// EvalRO indicates an expected call of EvalRO. +func (mr *MockUniversalClientMockRecorder) EvalRO(ctx, script, keys interface{}, args ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, script, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalRO", reflect.TypeOf((*MockUniversalClient)(nil).EvalRO), varargs...) +} + +// EvalSha mocks base method. +func (m *MockUniversalClient) EvalSha(ctx context.Context, sha1 string, keys []string, args ...interface{}) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, sha1, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EvalSha", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// EvalSha indicates an expected call of EvalSha. +func (mr *MockUniversalClientMockRecorder) EvalSha(ctx, sha1, keys interface{}, args ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, sha1, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalSha", reflect.TypeOf((*MockUniversalClient)(nil).EvalSha), varargs...) +} + +// EvalShaRO mocks base method. +func (m *MockUniversalClient) EvalShaRO(ctx context.Context, sha1 string, keys []string, args ...interface{}) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, sha1, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EvalShaRO", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// EvalShaRO indicates an expected call of EvalShaRO. +func (mr *MockUniversalClientMockRecorder) EvalShaRO(ctx, sha1, keys interface{}, args ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, sha1, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalShaRO", reflect.TypeOf((*MockUniversalClient)(nil).EvalShaRO), varargs...) +} + +// Exists mocks base method. +func (m *MockUniversalClient) Exists(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Exists", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Exists indicates an expected call of Exists. +func (mr *MockUniversalClientMockRecorder) Exists(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockUniversalClient)(nil).Exists), varargs...) +} + +// Expire mocks base method. +func (m *MockUniversalClient) Expire(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Expire", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// Expire indicates an expected call of Expire. +func (mr *MockUniversalClientMockRecorder) Expire(ctx, key, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expire", reflect.TypeOf((*MockUniversalClient)(nil).Expire), ctx, key, expiration) +} + +// ExpireAt mocks base method. +func (m *MockUniversalClient) ExpireAt(ctx context.Context, key string, tm time.Time) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireAt", ctx, key, tm) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireAt indicates an expected call of ExpireAt. +func (mr *MockUniversalClientMockRecorder) ExpireAt(ctx, key, tm interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireAt", reflect.TypeOf((*MockUniversalClient)(nil).ExpireAt), ctx, key, tm) +} + +// ExpireGT mocks base method. +func (m *MockUniversalClient) ExpireGT(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireGT", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireGT indicates an expected call of ExpireGT. +func (mr *MockUniversalClientMockRecorder) ExpireGT(ctx, key, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireGT", reflect.TypeOf((*MockUniversalClient)(nil).ExpireGT), ctx, key, expiration) +} + +// ExpireLT mocks base method. +func (m *MockUniversalClient) ExpireLT(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireLT", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireLT indicates an expected call of ExpireLT. +func (mr *MockUniversalClientMockRecorder) ExpireLT(ctx, key, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireLT", reflect.TypeOf((*MockUniversalClient)(nil).ExpireLT), ctx, key, expiration) +} + +// ExpireNX mocks base method. +func (m *MockUniversalClient) ExpireNX(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireNX", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireNX indicates an expected call of ExpireNX. +func (mr *MockUniversalClientMockRecorder) ExpireNX(ctx, key, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireNX", reflect.TypeOf((*MockUniversalClient)(nil).ExpireNX), ctx, key, expiration) +} + +// ExpireTime mocks base method. +func (m *MockUniversalClient) ExpireTime(ctx context.Context, key string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireTime", ctx, key) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// ExpireTime indicates an expected call of ExpireTime. +func (mr *MockUniversalClientMockRecorder) ExpireTime(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireTime", reflect.TypeOf((*MockUniversalClient)(nil).ExpireTime), ctx, key) +} + +// ExpireXX mocks base method. +func (m *MockUniversalClient) ExpireXX(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireXX", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireXX indicates an expected call of ExpireXX. +func (mr *MockUniversalClientMockRecorder) ExpireXX(ctx, key, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireXX", reflect.TypeOf((*MockUniversalClient)(nil).ExpireXX), ctx, key, expiration) +} + +// FCall mocks base method. +func (m *MockUniversalClient) FCall(ctx context.Context, function string, keys []string, args ...interface{}) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, function, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FCall", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// FCall indicates an expected call of FCall. +func (mr *MockUniversalClientMockRecorder) FCall(ctx, function, keys interface{}, args ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, function, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCall", reflect.TypeOf((*MockUniversalClient)(nil).FCall), varargs...) +} + +// FCallRO mocks base method. +func (m *MockUniversalClient) FCallRO(ctx context.Context, function string, keys []string, args ...interface{}) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, function, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FCallRO", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// FCallRO indicates an expected call of FCallRO. +func (mr *MockUniversalClientMockRecorder) FCallRO(ctx, function, keys interface{}, args ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, function, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCallRO", reflect.TypeOf((*MockUniversalClient)(nil).FCallRO), varargs...) +} + +// FCallRo mocks base method. +func (m *MockUniversalClient) FCallRo(ctx context.Context, function string, keys []string, args ...interface{}) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, function, keys} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FCallRo", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// FCallRo indicates an expected call of FCallRo. +func (mr *MockUniversalClientMockRecorder) FCallRo(ctx, function, keys interface{}, args ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, function, keys}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCallRo", reflect.TypeOf((*MockUniversalClient)(nil).FCallRo), varargs...) +} + +// FTAggregate mocks base method. +func (m *MockUniversalClient) FTAggregate(ctx context.Context, index, query string) *redis.MapStringInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTAggregate", ctx, index, query) + ret0, _ := ret[0].(*redis.MapStringInterfaceCmd) + return ret0 +} + +// FTAggregate indicates an expected call of FTAggregate. +func (mr *MockUniversalClientMockRecorder) FTAggregate(ctx, index, query interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAggregate", reflect.TypeOf((*MockUniversalClient)(nil).FTAggregate), ctx, index, query) +} + +// FTAggregateWithArgs mocks base method. +func (m *MockUniversalClient) FTAggregateWithArgs(ctx context.Context, index, query string, options *redis.FTAggregateOptions) *redis.AggregateCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTAggregateWithArgs", ctx, index, query, options) + ret0, _ := ret[0].(*redis.AggregateCmd) + return ret0 +} + +// FTAggregateWithArgs indicates an expected call of FTAggregateWithArgs. +func (mr *MockUniversalClientMockRecorder) FTAggregateWithArgs(ctx, index, query, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAggregateWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTAggregateWithArgs), ctx, index, query, options) +} + +// FTAliasAdd mocks base method. +func (m *MockUniversalClient) FTAliasAdd(ctx context.Context, index, alias string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTAliasAdd", ctx, index, alias) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTAliasAdd indicates an expected call of FTAliasAdd. +func (mr *MockUniversalClientMockRecorder) FTAliasAdd(ctx, index, alias interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAliasAdd", reflect.TypeOf((*MockUniversalClient)(nil).FTAliasAdd), ctx, index, alias) +} + +// FTAliasDel mocks base method. +func (m *MockUniversalClient) FTAliasDel(ctx context.Context, alias string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTAliasDel", ctx, alias) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTAliasDel indicates an expected call of FTAliasDel. +func (mr *MockUniversalClientMockRecorder) FTAliasDel(ctx, alias interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAliasDel", reflect.TypeOf((*MockUniversalClient)(nil).FTAliasDel), ctx, alias) +} + +// FTAliasUpdate mocks base method. +func (m *MockUniversalClient) FTAliasUpdate(ctx context.Context, index, alias string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTAliasUpdate", ctx, index, alias) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTAliasUpdate indicates an expected call of FTAliasUpdate. +func (mr *MockUniversalClientMockRecorder) FTAliasUpdate(ctx, index, alias interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAliasUpdate", reflect.TypeOf((*MockUniversalClient)(nil).FTAliasUpdate), ctx, index, alias) +} + +// FTAlter mocks base method. +func (m *MockUniversalClient) FTAlter(ctx context.Context, index string, skipInitialScan bool, definition []interface{}) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTAlter", ctx, index, skipInitialScan, definition) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTAlter indicates an expected call of FTAlter. +func (mr *MockUniversalClientMockRecorder) FTAlter(ctx, index, skipInitialScan, definition interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAlter", reflect.TypeOf((*MockUniversalClient)(nil).FTAlter), ctx, index, skipInitialScan, definition) +} + +// FTConfigGet mocks base method. +func (m *MockUniversalClient) FTConfigGet(ctx context.Context, option string) *redis.MapMapStringInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTConfigGet", ctx, option) + ret0, _ := ret[0].(*redis.MapMapStringInterfaceCmd) + return ret0 +} + +// FTConfigGet indicates an expected call of FTConfigGet. +func (mr *MockUniversalClientMockRecorder) FTConfigGet(ctx, option interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTConfigGet", reflect.TypeOf((*MockUniversalClient)(nil).FTConfigGet), ctx, option) +} + +// FTConfigSet mocks base method. +func (m *MockUniversalClient) FTConfigSet(ctx context.Context, option string, value interface{}) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTConfigSet", ctx, option, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTConfigSet indicates an expected call of FTConfigSet. +func (mr *MockUniversalClientMockRecorder) FTConfigSet(ctx, option, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTConfigSet", reflect.TypeOf((*MockUniversalClient)(nil).FTConfigSet), ctx, option, value) +} + +// FTCreate mocks base method. +func (m *MockUniversalClient) FTCreate(ctx context.Context, index string, options *redis.FTCreateOptions, schema ...*redis.FieldSchema) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, index, options} + for _, a := range schema { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FTCreate", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTCreate indicates an expected call of FTCreate. +func (mr *MockUniversalClientMockRecorder) FTCreate(ctx, index, options interface{}, schema ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, index, options}, schema...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTCreate", reflect.TypeOf((*MockUniversalClient)(nil).FTCreate), varargs...) +} + +// FTCursorDel mocks base method. +func (m *MockUniversalClient) FTCursorDel(ctx context.Context, index string, cursorId int) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTCursorDel", ctx, index, cursorId) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTCursorDel indicates an expected call of FTCursorDel. +func (mr *MockUniversalClientMockRecorder) FTCursorDel(ctx, index, cursorId interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTCursorDel", reflect.TypeOf((*MockUniversalClient)(nil).FTCursorDel), ctx, index, cursorId) +} + +// FTCursorRead mocks base method. +func (m *MockUniversalClient) FTCursorRead(ctx context.Context, index string, cursorId, count int) *redis.MapStringInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTCursorRead", ctx, index, cursorId, count) + ret0, _ := ret[0].(*redis.MapStringInterfaceCmd) + return ret0 +} + +// FTCursorRead indicates an expected call of FTCursorRead. +func (mr *MockUniversalClientMockRecorder) FTCursorRead(ctx, index, cursorId, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTCursorRead", reflect.TypeOf((*MockUniversalClient)(nil).FTCursorRead), ctx, index, cursorId, count) +} + +// FTDictAdd mocks base method. +func (m *MockUniversalClient) FTDictAdd(ctx context.Context, dict string, term ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, dict} + for _, a := range term { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FTDictAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// FTDictAdd indicates an expected call of FTDictAdd. +func (mr *MockUniversalClientMockRecorder) FTDictAdd(ctx, dict interface{}, term ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, dict}, term...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDictAdd", reflect.TypeOf((*MockUniversalClient)(nil).FTDictAdd), varargs...) +} + +// FTDictDel mocks base method. +func (m *MockUniversalClient) FTDictDel(ctx context.Context, dict string, term ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, dict} + for _, a := range term { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FTDictDel", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// FTDictDel indicates an expected call of FTDictDel. +func (mr *MockUniversalClientMockRecorder) FTDictDel(ctx, dict interface{}, term ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, dict}, term...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDictDel", reflect.TypeOf((*MockUniversalClient)(nil).FTDictDel), varargs...) +} + +// FTDictDump mocks base method. +func (m *MockUniversalClient) FTDictDump(ctx context.Context, dict string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTDictDump", ctx, dict) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// FTDictDump indicates an expected call of FTDictDump. +func (mr *MockUniversalClientMockRecorder) FTDictDump(ctx, dict interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDictDump", reflect.TypeOf((*MockUniversalClient)(nil).FTDictDump), ctx, dict) +} + +// FTDropIndex mocks base method. +func (m *MockUniversalClient) FTDropIndex(ctx context.Context, index string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTDropIndex", ctx, index) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTDropIndex indicates an expected call of FTDropIndex. +func (mr *MockUniversalClientMockRecorder) FTDropIndex(ctx, index interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDropIndex", reflect.TypeOf((*MockUniversalClient)(nil).FTDropIndex), ctx, index) +} + +// FTDropIndexWithArgs mocks base method. +func (m *MockUniversalClient) FTDropIndexWithArgs(ctx context.Context, index string, options *redis.FTDropIndexOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTDropIndexWithArgs", ctx, index, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTDropIndexWithArgs indicates an expected call of FTDropIndexWithArgs. +func (mr *MockUniversalClientMockRecorder) FTDropIndexWithArgs(ctx, index, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDropIndexWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTDropIndexWithArgs), ctx, index, options) +} + +// FTExplain mocks base method. +func (m *MockUniversalClient) FTExplain(ctx context.Context, index, query string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTExplain", ctx, index, query) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FTExplain indicates an expected call of FTExplain. +func (mr *MockUniversalClientMockRecorder) FTExplain(ctx, index, query interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTExplain", reflect.TypeOf((*MockUniversalClient)(nil).FTExplain), ctx, index, query) +} + +// FTExplainWithArgs mocks base method. +func (m *MockUniversalClient) FTExplainWithArgs(ctx context.Context, index, query string, options *redis.FTExplainOptions) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTExplainWithArgs", ctx, index, query, options) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FTExplainWithArgs indicates an expected call of FTExplainWithArgs. +func (mr *MockUniversalClientMockRecorder) FTExplainWithArgs(ctx, index, query, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTExplainWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTExplainWithArgs), ctx, index, query, options) +} + +// FTInfo mocks base method. +func (m *MockUniversalClient) FTInfo(ctx context.Context, index string) *redis.FTInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTInfo", ctx, index) + ret0, _ := ret[0].(*redis.FTInfoCmd) + return ret0 +} + +// FTInfo indicates an expected call of FTInfo. +func (mr *MockUniversalClientMockRecorder) FTInfo(ctx, index interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTInfo", reflect.TypeOf((*MockUniversalClient)(nil).FTInfo), ctx, index) +} + +// FTSearch mocks base method. +func (m *MockUniversalClient) FTSearch(ctx context.Context, index, query string) *redis.FTSearchCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTSearch", ctx, index, query) + ret0, _ := ret[0].(*redis.FTSearchCmd) + return ret0 +} + +// FTSearch indicates an expected call of FTSearch. +func (mr *MockUniversalClientMockRecorder) FTSearch(ctx, index, query interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSearch", reflect.TypeOf((*MockUniversalClient)(nil).FTSearch), ctx, index, query) +} + +// FTSearchWithArgs mocks base method. +func (m *MockUniversalClient) FTSearchWithArgs(ctx context.Context, index, query string, options *redis.FTSearchOptions) *redis.FTSearchCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTSearchWithArgs", ctx, index, query, options) + ret0, _ := ret[0].(*redis.FTSearchCmd) + return ret0 +} + +// FTSearchWithArgs indicates an expected call of FTSearchWithArgs. +func (mr *MockUniversalClientMockRecorder) FTSearchWithArgs(ctx, index, query, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSearchWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTSearchWithArgs), ctx, index, query, options) +} + +// FTSpellCheck mocks base method. +func (m *MockUniversalClient) FTSpellCheck(ctx context.Context, index, query string) *redis.FTSpellCheckCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTSpellCheck", ctx, index, query) + ret0, _ := ret[0].(*redis.FTSpellCheckCmd) + return ret0 +} + +// FTSpellCheck indicates an expected call of FTSpellCheck. +func (mr *MockUniversalClientMockRecorder) FTSpellCheck(ctx, index, query interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSpellCheck", reflect.TypeOf((*MockUniversalClient)(nil).FTSpellCheck), ctx, index, query) +} + +// FTSpellCheckWithArgs mocks base method. +func (m *MockUniversalClient) FTSpellCheckWithArgs(ctx context.Context, index, query string, options *redis.FTSpellCheckOptions) *redis.FTSpellCheckCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTSpellCheckWithArgs", ctx, index, query, options) + ret0, _ := ret[0].(*redis.FTSpellCheckCmd) + return ret0 +} + +// FTSpellCheckWithArgs indicates an expected call of FTSpellCheckWithArgs. +func (mr *MockUniversalClientMockRecorder) FTSpellCheckWithArgs(ctx, index, query, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSpellCheckWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTSpellCheckWithArgs), ctx, index, query, options) +} + +// FTSynDump mocks base method. +func (m *MockUniversalClient) FTSynDump(ctx context.Context, index string) *redis.FTSynDumpCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTSynDump", ctx, index) + ret0, _ := ret[0].(*redis.FTSynDumpCmd) + return ret0 +} + +// FTSynDump indicates an expected call of FTSynDump. +func (mr *MockUniversalClientMockRecorder) FTSynDump(ctx, index interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSynDump", reflect.TypeOf((*MockUniversalClient)(nil).FTSynDump), ctx, index) +} + +// FTSynUpdate mocks base method. +func (m *MockUniversalClient) FTSynUpdate(ctx context.Context, index string, synGroupId interface{}, terms []interface{}) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTSynUpdate", ctx, index, synGroupId, terms) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTSynUpdate indicates an expected call of FTSynUpdate. +func (mr *MockUniversalClientMockRecorder) FTSynUpdate(ctx, index, synGroupId, terms interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSynUpdate", reflect.TypeOf((*MockUniversalClient)(nil).FTSynUpdate), ctx, index, synGroupId, terms) +} + +// FTSynUpdateWithArgs mocks base method. +func (m *MockUniversalClient) FTSynUpdateWithArgs(ctx context.Context, index string, synGroupId interface{}, options *redis.FTSynUpdateOptions, terms []interface{}) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTSynUpdateWithArgs", ctx, index, synGroupId, options, terms) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FTSynUpdateWithArgs indicates an expected call of FTSynUpdateWithArgs. +func (mr *MockUniversalClientMockRecorder) FTSynUpdateWithArgs(ctx, index, synGroupId, options, terms interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSynUpdateWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTSynUpdateWithArgs), ctx, index, synGroupId, options, terms) +} + +// FTTagVals mocks base method. +func (m *MockUniversalClient) FTTagVals(ctx context.Context, index, field string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FTTagVals", ctx, index, field) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// FTTagVals indicates an expected call of FTTagVals. +func (mr *MockUniversalClientMockRecorder) FTTagVals(ctx, index, field interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTTagVals", reflect.TypeOf((*MockUniversalClient)(nil).FTTagVals), ctx, index, field) +} + +// FT_List mocks base method. +func (m *MockUniversalClient) FT_List(ctx context.Context) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FT_List", ctx) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// FT_List indicates an expected call of FT_List. +func (mr *MockUniversalClientMockRecorder) FT_List(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FT_List", reflect.TypeOf((*MockUniversalClient)(nil).FT_List), ctx) +} + +// FlushAll mocks base method. +func (m *MockUniversalClient) FlushAll(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlushAll", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FlushAll indicates an expected call of FlushAll. +func (mr *MockUniversalClientMockRecorder) FlushAll(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAll", reflect.TypeOf((*MockUniversalClient)(nil).FlushAll), ctx) +} + +// FlushAllAsync mocks base method. +func (m *MockUniversalClient) FlushAllAsync(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlushAllAsync", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FlushAllAsync indicates an expected call of FlushAllAsync. +func (mr *MockUniversalClientMockRecorder) FlushAllAsync(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAllAsync", reflect.TypeOf((*MockUniversalClient)(nil).FlushAllAsync), ctx) +} + +// FlushDB mocks base method. +func (m *MockUniversalClient) FlushDB(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlushDB", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FlushDB indicates an expected call of FlushDB. +func (mr *MockUniversalClientMockRecorder) FlushDB(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDB", reflect.TypeOf((*MockUniversalClient)(nil).FlushDB), ctx) +} + +// FlushDBAsync mocks base method. +func (m *MockUniversalClient) FlushDBAsync(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlushDBAsync", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FlushDBAsync indicates an expected call of FlushDBAsync. +func (mr *MockUniversalClientMockRecorder) FlushDBAsync(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDBAsync", reflect.TypeOf((*MockUniversalClient)(nil).FlushDBAsync), ctx) +} + +// FunctionDelete mocks base method. +func (m *MockUniversalClient) FunctionDelete(ctx context.Context, libName string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionDelete", ctx, libName) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionDelete indicates an expected call of FunctionDelete. +func (mr *MockUniversalClientMockRecorder) FunctionDelete(ctx, libName interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDelete", reflect.TypeOf((*MockUniversalClient)(nil).FunctionDelete), ctx, libName) +} + +// FunctionDump mocks base method. +func (m *MockUniversalClient) FunctionDump(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionDump", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionDump indicates an expected call of FunctionDump. +func (mr *MockUniversalClientMockRecorder) FunctionDump(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDump", reflect.TypeOf((*MockUniversalClient)(nil).FunctionDump), ctx) +} + +// FunctionFlush mocks base method. +func (m *MockUniversalClient) FunctionFlush(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionFlush", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionFlush indicates an expected call of FunctionFlush. +func (mr *MockUniversalClientMockRecorder) FunctionFlush(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlush", reflect.TypeOf((*MockUniversalClient)(nil).FunctionFlush), ctx) +} + +// FunctionFlushAsync mocks base method. +func (m *MockUniversalClient) FunctionFlushAsync(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionFlushAsync", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionFlushAsync indicates an expected call of FunctionFlushAsync. +func (mr *MockUniversalClientMockRecorder) FunctionFlushAsync(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlushAsync", reflect.TypeOf((*MockUniversalClient)(nil).FunctionFlushAsync), ctx) +} + +// FunctionKill mocks base method. +func (m *MockUniversalClient) FunctionKill(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionKill", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionKill indicates an expected call of FunctionKill. +func (mr *MockUniversalClientMockRecorder) FunctionKill(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionKill", reflect.TypeOf((*MockUniversalClient)(nil).FunctionKill), ctx) +} + +// FunctionList mocks base method. +func (m *MockUniversalClient) FunctionList(ctx context.Context, q redis.FunctionListQuery) *redis.FunctionListCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionList", ctx, q) + ret0, _ := ret[0].(*redis.FunctionListCmd) + return ret0 +} + +// FunctionList indicates an expected call of FunctionList. +func (mr *MockUniversalClientMockRecorder) FunctionList(ctx, q interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionList", reflect.TypeOf((*MockUniversalClient)(nil).FunctionList), ctx, q) +} + +// FunctionLoad mocks base method. +func (m *MockUniversalClient) FunctionLoad(ctx context.Context, code string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionLoad", ctx, code) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionLoad indicates an expected call of FunctionLoad. +func (mr *MockUniversalClientMockRecorder) FunctionLoad(ctx, code interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoad", reflect.TypeOf((*MockUniversalClient)(nil).FunctionLoad), ctx, code) +} + +// FunctionLoadReplace mocks base method. +func (m *MockUniversalClient) FunctionLoadReplace(ctx context.Context, code string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionLoadReplace", ctx, code) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionLoadReplace indicates an expected call of FunctionLoadReplace. +func (mr *MockUniversalClientMockRecorder) FunctionLoadReplace(ctx, code interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoadReplace", reflect.TypeOf((*MockUniversalClient)(nil).FunctionLoadReplace), ctx, code) +} + +// FunctionRestore mocks base method. +func (m *MockUniversalClient) FunctionRestore(ctx context.Context, libDump string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionRestore", ctx, libDump) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionRestore indicates an expected call of FunctionRestore. +func (mr *MockUniversalClientMockRecorder) FunctionRestore(ctx, libDump interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionRestore", reflect.TypeOf((*MockUniversalClient)(nil).FunctionRestore), ctx, libDump) +} + +// FunctionStats mocks base method. +func (m *MockUniversalClient) FunctionStats(ctx context.Context) *redis.FunctionStatsCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionStats", ctx) + ret0, _ := ret[0].(*redis.FunctionStatsCmd) + return ret0 +} + +// FunctionStats indicates an expected call of FunctionStats. +func (mr *MockUniversalClientMockRecorder) FunctionStats(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionStats", reflect.TypeOf((*MockUniversalClient)(nil).FunctionStats), ctx) +} + +// GeoAdd mocks base method. +func (m *MockUniversalClient) GeoAdd(ctx context.Context, key string, geoLocation ...*redis.GeoLocation) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range geoLocation { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GeoAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GeoAdd indicates an expected call of GeoAdd. +func (mr *MockUniversalClientMockRecorder) GeoAdd(ctx, key interface{}, geoLocation ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, geoLocation...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoAdd", reflect.TypeOf((*MockUniversalClient)(nil).GeoAdd), varargs...) +} + +// GeoDist mocks base method. +func (m *MockUniversalClient) GeoDist(ctx context.Context, key, member1, member2, unit string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoDist", ctx, key, member1, member2, unit) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// GeoDist indicates an expected call of GeoDist. +func (mr *MockUniversalClientMockRecorder) GeoDist(ctx, key, member1, member2, unit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoDist", reflect.TypeOf((*MockUniversalClient)(nil).GeoDist), ctx, key, member1, member2, unit) +} + +// GeoHash mocks base method. +func (m *MockUniversalClient) GeoHash(ctx context.Context, key string, members ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GeoHash", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// GeoHash indicates an expected call of GeoHash. +func (mr *MockUniversalClientMockRecorder) GeoHash(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoHash", reflect.TypeOf((*MockUniversalClient)(nil).GeoHash), varargs...) +} + +// GeoPos mocks base method. +func (m *MockUniversalClient) GeoPos(ctx context.Context, key string, members ...string) *redis.GeoPosCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GeoPos", varargs...) + ret0, _ := ret[0].(*redis.GeoPosCmd) + return ret0 +} + +// GeoPos indicates an expected call of GeoPos. +func (mr *MockUniversalClientMockRecorder) GeoPos(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoPos", reflect.TypeOf((*MockUniversalClient)(nil).GeoPos), varargs...) +} + +// GeoRadius mocks base method. +func (m *MockUniversalClient) GeoRadius(ctx context.Context, key string, longitude, latitude float64, query *redis.GeoRadiusQuery) *redis.GeoLocationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoRadius", ctx, key, longitude, latitude, query) + ret0, _ := ret[0].(*redis.GeoLocationCmd) + return ret0 +} + +// GeoRadius indicates an expected call of GeoRadius. +func (mr *MockUniversalClientMockRecorder) GeoRadius(ctx, key, longitude, latitude, query interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadius", reflect.TypeOf((*MockUniversalClient)(nil).GeoRadius), ctx, key, longitude, latitude, query) +} + +// GeoRadiusByMember mocks base method. +func (m *MockUniversalClient) GeoRadiusByMember(ctx context.Context, key, member string, query *redis.GeoRadiusQuery) *redis.GeoLocationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoRadiusByMember", ctx, key, member, query) + ret0, _ := ret[0].(*redis.GeoLocationCmd) + return ret0 +} + +// GeoRadiusByMember indicates an expected call of GeoRadiusByMember. +func (mr *MockUniversalClientMockRecorder) GeoRadiusByMember(ctx, key, member, query interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMember", reflect.TypeOf((*MockUniversalClient)(nil).GeoRadiusByMember), ctx, key, member, query) +} + +// GeoRadiusByMemberStore mocks base method. +func (m *MockUniversalClient) GeoRadiusByMemberStore(ctx context.Context, key, member string, query *redis.GeoRadiusQuery) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoRadiusByMemberStore", ctx, key, member, query) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GeoRadiusByMemberStore indicates an expected call of GeoRadiusByMemberStore. +func (mr *MockUniversalClientMockRecorder) GeoRadiusByMemberStore(ctx, key, member, query interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMemberStore", reflect.TypeOf((*MockUniversalClient)(nil).GeoRadiusByMemberStore), ctx, key, member, query) +} + +// GeoRadiusStore mocks base method. +func (m *MockUniversalClient) GeoRadiusStore(ctx context.Context, key string, longitude, latitude float64, query *redis.GeoRadiusQuery) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoRadiusStore", ctx, key, longitude, latitude, query) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GeoRadiusStore indicates an expected call of GeoRadiusStore. +func (mr *MockUniversalClientMockRecorder) GeoRadiusStore(ctx, key, longitude, latitude, query interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusStore", reflect.TypeOf((*MockUniversalClient)(nil).GeoRadiusStore), ctx, key, longitude, latitude, query) +} + +// GeoSearch mocks base method. +func (m *MockUniversalClient) GeoSearch(ctx context.Context, key string, q *redis.GeoSearchQuery) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoSearch", ctx, key, q) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// GeoSearch indicates an expected call of GeoSearch. +func (mr *MockUniversalClientMockRecorder) GeoSearch(ctx, key, q interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearch", reflect.TypeOf((*MockUniversalClient)(nil).GeoSearch), ctx, key, q) +} + +// GeoSearchLocation mocks base method. +func (m *MockUniversalClient) GeoSearchLocation(ctx context.Context, key string, q *redis.GeoSearchLocationQuery) *redis.GeoSearchLocationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoSearchLocation", ctx, key, q) + ret0, _ := ret[0].(*redis.GeoSearchLocationCmd) + return ret0 +} + +// GeoSearchLocation indicates an expected call of GeoSearchLocation. +func (mr *MockUniversalClientMockRecorder) GeoSearchLocation(ctx, key, q interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchLocation", reflect.TypeOf((*MockUniversalClient)(nil).GeoSearchLocation), ctx, key, q) +} + +// GeoSearchStore mocks base method. +func (m *MockUniversalClient) GeoSearchStore(ctx context.Context, key, store string, q *redis.GeoSearchStoreQuery) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoSearchStore", ctx, key, store, q) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GeoSearchStore indicates an expected call of GeoSearchStore. +func (mr *MockUniversalClientMockRecorder) GeoSearchStore(ctx, key, store, q interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchStore", reflect.TypeOf((*MockUniversalClient)(nil).GeoSearchStore), ctx, key, store, q) +} + +// Get mocks base method. +func (m *MockUniversalClient) Get(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Get", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// Get indicates an expected call of Get. +func (mr *MockUniversalClientMockRecorder) Get(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockUniversalClient)(nil).Get), ctx, key) +} + +// GetBit mocks base method. +func (m *MockUniversalClient) GetBit(ctx context.Context, key string, offset int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetBit", ctx, key, offset) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GetBit indicates an expected call of GetBit. +func (mr *MockUniversalClientMockRecorder) GetBit(ctx, key, offset interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBit", reflect.TypeOf((*MockUniversalClient)(nil).GetBit), ctx, key, offset) +} + +// GetDel mocks base method. +func (m *MockUniversalClient) GetDel(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetDel", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// GetDel indicates an expected call of GetDel. +func (mr *MockUniversalClientMockRecorder) GetDel(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDel", reflect.TypeOf((*MockUniversalClient)(nil).GetDel), ctx, key) +} + +// GetEx mocks base method. +func (m *MockUniversalClient) GetEx(ctx context.Context, key string, expiration time.Duration) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetEx", ctx, key, expiration) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// GetEx indicates an expected call of GetEx. +func (mr *MockUniversalClientMockRecorder) GetEx(ctx, key, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEx", reflect.TypeOf((*MockUniversalClient)(nil).GetEx), ctx, key, expiration) +} + +// GetRange mocks base method. +func (m *MockUniversalClient) GetRange(ctx context.Context, key string, start, end int64) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRange", ctx, key, start, end) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// GetRange indicates an expected call of GetRange. +func (mr *MockUniversalClientMockRecorder) GetRange(ctx, key, start, end interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRange", reflect.TypeOf((*MockUniversalClient)(nil).GetRange), ctx, key, start, end) +} + +// GetSet mocks base method. +func (m *MockUniversalClient) GetSet(ctx context.Context, key string, value interface{}) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSet", ctx, key, value) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// GetSet indicates an expected call of GetSet. +func (mr *MockUniversalClientMockRecorder) GetSet(ctx, key, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSet", reflect.TypeOf((*MockUniversalClient)(nil).GetSet), ctx, key, value) +} + +// HDel mocks base method. +func (m *MockUniversalClient) HDel(ctx context.Context, key string, fields ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HDel", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// HDel indicates an expected call of HDel. +func (mr *MockUniversalClientMockRecorder) HDel(ctx, key interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HDel", reflect.TypeOf((*MockUniversalClient)(nil).HDel), varargs...) +} + +// HExists mocks base method. +func (m *MockUniversalClient) HExists(ctx context.Context, key, field string) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HExists", ctx, key, field) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// HExists indicates an expected call of HExists. +func (mr *MockUniversalClientMockRecorder) HExists(ctx, key, field interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExists", reflect.TypeOf((*MockUniversalClient)(nil).HExists), ctx, key, field) +} + +// HExpire mocks base method. +func (m *MockUniversalClient) HExpire(ctx context.Context, key string, expiration time.Duration, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, expiration} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HExpire", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HExpire indicates an expected call of HExpire. +func (mr *MockUniversalClientMockRecorder) HExpire(ctx, key, expiration interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, expiration}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpire", reflect.TypeOf((*MockUniversalClient)(nil).HExpire), varargs...) +} + +// HExpireAt mocks base method. +func (m *MockUniversalClient) HExpireAt(ctx context.Context, key string, tm time.Time, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, tm} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HExpireAt", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HExpireAt indicates an expected call of HExpireAt. +func (mr *MockUniversalClientMockRecorder) HExpireAt(ctx, key, tm interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, tm}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireAt", reflect.TypeOf((*MockUniversalClient)(nil).HExpireAt), varargs...) +} + +// HExpireAtWithArgs mocks base method. +func (m *MockUniversalClient) HExpireAtWithArgs(ctx context.Context, key string, tm time.Time, expirationArgs redis.HExpireArgs, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, tm, expirationArgs} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HExpireAtWithArgs", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HExpireAtWithArgs indicates an expected call of HExpireAtWithArgs. +func (mr *MockUniversalClientMockRecorder) HExpireAtWithArgs(ctx, key, tm, expirationArgs interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, tm, expirationArgs}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireAtWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).HExpireAtWithArgs), varargs...) +} + +// HExpireTime mocks base method. +func (m *MockUniversalClient) HExpireTime(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HExpireTime", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HExpireTime indicates an expected call of HExpireTime. +func (mr *MockUniversalClientMockRecorder) HExpireTime(ctx, key interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireTime", reflect.TypeOf((*MockUniversalClient)(nil).HExpireTime), varargs...) +} + +// HExpireWithArgs mocks base method. +func (m *MockUniversalClient) HExpireWithArgs(ctx context.Context, key string, expiration time.Duration, expirationArgs redis.HExpireArgs, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, expiration, expirationArgs} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HExpireWithArgs", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HExpireWithArgs indicates an expected call of HExpireWithArgs. +func (mr *MockUniversalClientMockRecorder) HExpireWithArgs(ctx, key, expiration, expirationArgs interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, expiration, expirationArgs}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).HExpireWithArgs), varargs...) +} + +// HGet mocks base method. +func (m *MockUniversalClient) HGet(ctx context.Context, key, field string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HGet", ctx, key, field) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// HGet indicates an expected call of HGet. +func (mr *MockUniversalClientMockRecorder) HGet(ctx, key, field interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGet", reflect.TypeOf((*MockUniversalClient)(nil).HGet), ctx, key, field) +} + +// HGetAll mocks base method. +func (m *MockUniversalClient) HGetAll(ctx context.Context, key string) *redis.MapStringStringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HGetAll", ctx, key) + ret0, _ := ret[0].(*redis.MapStringStringCmd) + return ret0 +} + +// HGetAll indicates an expected call of HGetAll. +func (mr *MockUniversalClientMockRecorder) HGetAll(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGetAll", reflect.TypeOf((*MockUniversalClient)(nil).HGetAll), ctx, key) +} + +// HIncrBy mocks base method. +func (m *MockUniversalClient) HIncrBy(ctx context.Context, key, field string, incr int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HIncrBy", ctx, key, field, incr) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// HIncrBy indicates an expected call of HIncrBy. +func (mr *MockUniversalClientMockRecorder) HIncrBy(ctx, key, field, incr interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrBy", reflect.TypeOf((*MockUniversalClient)(nil).HIncrBy), ctx, key, field, incr) +} + +// HIncrByFloat mocks base method. +func (m *MockUniversalClient) HIncrByFloat(ctx context.Context, key, field string, incr float64) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HIncrByFloat", ctx, key, field, incr) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// HIncrByFloat indicates an expected call of HIncrByFloat. +func (mr *MockUniversalClientMockRecorder) HIncrByFloat(ctx, key, field, incr interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrByFloat", reflect.TypeOf((*MockUniversalClient)(nil).HIncrByFloat), ctx, key, field, incr) +} + +// HKeys mocks base method. +func (m *MockUniversalClient) HKeys(ctx context.Context, key string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HKeys", ctx, key) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// HKeys indicates an expected call of HKeys. +func (mr *MockUniversalClientMockRecorder) HKeys(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HKeys", reflect.TypeOf((*MockUniversalClient)(nil).HKeys), ctx, key) +} + +// HLen mocks base method. +func (m *MockUniversalClient) HLen(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HLen", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// HLen indicates an expected call of HLen. +func (mr *MockUniversalClientMockRecorder) HLen(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HLen", reflect.TypeOf((*MockUniversalClient)(nil).HLen), ctx, key) +} + +// HMGet mocks base method. +func (m *MockUniversalClient) HMGet(ctx context.Context, key string, fields ...string) *redis.SliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HMGet", varargs...) + ret0, _ := ret[0].(*redis.SliceCmd) + return ret0 +} + +// HMGet indicates an expected call of HMGet. +func (mr *MockUniversalClientMockRecorder) HMGet(ctx, key interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HMGet", reflect.TypeOf((*MockUniversalClient)(nil).HMGet), varargs...) +} + +// HMSet mocks base method. +func (m *MockUniversalClient) HMSet(ctx context.Context, key string, values ...interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HMSet", varargs...) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// HMSet indicates an expected call of HMSet. +func (mr *MockUniversalClientMockRecorder) HMSet(ctx, key interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HMSet", reflect.TypeOf((*MockUniversalClient)(nil).HMSet), varargs...) +} + +// HPExpire mocks base method. +func (m *MockUniversalClient) HPExpire(ctx context.Context, key string, expiration time.Duration, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, expiration} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HPExpire", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HPExpire indicates an expected call of HPExpire. +func (mr *MockUniversalClientMockRecorder) HPExpire(ctx, key, expiration interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, expiration}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpire", reflect.TypeOf((*MockUniversalClient)(nil).HPExpire), varargs...) +} + +// HPExpireAt mocks base method. +func (m *MockUniversalClient) HPExpireAt(ctx context.Context, key string, tm time.Time, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, tm} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HPExpireAt", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HPExpireAt indicates an expected call of HPExpireAt. +func (mr *MockUniversalClientMockRecorder) HPExpireAt(ctx, key, tm interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, tm}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireAt", reflect.TypeOf((*MockUniversalClient)(nil).HPExpireAt), varargs...) +} + +// HPExpireAtWithArgs mocks base method. +func (m *MockUniversalClient) HPExpireAtWithArgs(ctx context.Context, key string, tm time.Time, expirationArgs redis.HExpireArgs, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, tm, expirationArgs} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HPExpireAtWithArgs", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HPExpireAtWithArgs indicates an expected call of HPExpireAtWithArgs. +func (mr *MockUniversalClientMockRecorder) HPExpireAtWithArgs(ctx, key, tm, expirationArgs interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, tm, expirationArgs}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireAtWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).HPExpireAtWithArgs), varargs...) +} + +// HPExpireTime mocks base method. +func (m *MockUniversalClient) HPExpireTime(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HPExpireTime", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HPExpireTime indicates an expected call of HPExpireTime. +func (mr *MockUniversalClientMockRecorder) HPExpireTime(ctx, key interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireTime", reflect.TypeOf((*MockUniversalClient)(nil).HPExpireTime), varargs...) +} + +// HPExpireWithArgs mocks base method. +func (m *MockUniversalClient) HPExpireWithArgs(ctx context.Context, key string, expiration time.Duration, expirationArgs redis.HExpireArgs, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, expiration, expirationArgs} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HPExpireWithArgs", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HPExpireWithArgs indicates an expected call of HPExpireWithArgs. +func (mr *MockUniversalClientMockRecorder) HPExpireWithArgs(ctx, key, expiration, expirationArgs interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, expiration, expirationArgs}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).HPExpireWithArgs), varargs...) +} + +// HPTTL mocks base method. +func (m *MockUniversalClient) HPTTL(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HPTTL", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HPTTL indicates an expected call of HPTTL. +func (mr *MockUniversalClientMockRecorder) HPTTL(ctx, key interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPTTL", reflect.TypeOf((*MockUniversalClient)(nil).HPTTL), varargs...) +} + +// HPersist mocks base method. +func (m *MockUniversalClient) HPersist(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HPersist", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HPersist indicates an expected call of HPersist. +func (mr *MockUniversalClientMockRecorder) HPersist(ctx, key interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPersist", reflect.TypeOf((*MockUniversalClient)(nil).HPersist), varargs...) +} + +// HRandField mocks base method. +func (m *MockUniversalClient) HRandField(ctx context.Context, key string, count int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HRandField", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// HRandField indicates an expected call of HRandField. +func (mr *MockUniversalClientMockRecorder) HRandField(ctx, key, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandField", reflect.TypeOf((*MockUniversalClient)(nil).HRandField), ctx, key, count) +} + +// HRandFieldWithValues mocks base method. +func (m *MockUniversalClient) HRandFieldWithValues(ctx context.Context, key string, count int) *redis.KeyValueSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HRandFieldWithValues", ctx, key, count) + ret0, _ := ret[0].(*redis.KeyValueSliceCmd) + return ret0 +} + +// HRandFieldWithValues indicates an expected call of HRandFieldWithValues. +func (mr *MockUniversalClientMockRecorder) HRandFieldWithValues(ctx, key, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandFieldWithValues", reflect.TypeOf((*MockUniversalClient)(nil).HRandFieldWithValues), ctx, key, count) +} + +// HScan mocks base method. +func (m *MockUniversalClient) HScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HScan", ctx, key, cursor, match, count) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// HScan indicates an expected call of HScan. +func (mr *MockUniversalClientMockRecorder) HScan(ctx, key, cursor, match, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HScan", reflect.TypeOf((*MockUniversalClient)(nil).HScan), ctx, key, cursor, match, count) +} + +// HScanNoValues mocks base method. +func (m *MockUniversalClient) HScanNoValues(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HScanNoValues", ctx, key, cursor, match, count) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// HScanNoValues indicates an expected call of HScanNoValues. +func (mr *MockUniversalClientMockRecorder) HScanNoValues(ctx, key, cursor, match, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HScanNoValues", reflect.TypeOf((*MockUniversalClient)(nil).HScanNoValues), ctx, key, cursor, match, count) +} + +// HSet mocks base method. +func (m *MockUniversalClient) HSet(ctx context.Context, key string, values ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HSet", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// HSet indicates an expected call of HSet. +func (mr *MockUniversalClientMockRecorder) HSet(ctx, key interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSet", reflect.TypeOf((*MockUniversalClient)(nil).HSet), varargs...) +} + +// HSetNX mocks base method. +func (m *MockUniversalClient) HSetNX(ctx context.Context, key, field string, value interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HSetNX", ctx, key, field, value) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// HSetNX indicates an expected call of HSetNX. +func (mr *MockUniversalClientMockRecorder) HSetNX(ctx, key, field, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSetNX", reflect.TypeOf((*MockUniversalClient)(nil).HSetNX), ctx, key, field, value) +} + +// HTTL mocks base method. +func (m *MockUniversalClient) HTTL(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range fields { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HTTL", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// HTTL indicates an expected call of HTTL. +func (mr *MockUniversalClientMockRecorder) HTTL(ctx, key interface{}, fields ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, fields...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HTTL", reflect.TypeOf((*MockUniversalClient)(nil).HTTL), varargs...) +} + +// HVals mocks base method. +func (m *MockUniversalClient) HVals(ctx context.Context, key string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HVals", ctx, key) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// HVals indicates an expected call of HVals. +func (mr *MockUniversalClientMockRecorder) HVals(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HVals", reflect.TypeOf((*MockUniversalClient)(nil).HVals), ctx, key) +} + +// Incr mocks base method. +func (m *MockUniversalClient) Incr(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Incr", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Incr indicates an expected call of Incr. +func (mr *MockUniversalClientMockRecorder) Incr(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Incr", reflect.TypeOf((*MockUniversalClient)(nil).Incr), ctx, key) +} + +// IncrBy mocks base method. +func (m *MockUniversalClient) IncrBy(ctx context.Context, key string, value int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IncrBy", ctx, key, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// IncrBy indicates an expected call of IncrBy. +func (mr *MockUniversalClientMockRecorder) IncrBy(ctx, key, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrBy", reflect.TypeOf((*MockUniversalClient)(nil).IncrBy), ctx, key, value) +} + +// IncrByFloat mocks base method. +func (m *MockUniversalClient) IncrByFloat(ctx context.Context, key string, value float64) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IncrByFloat", ctx, key, value) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// IncrByFloat indicates an expected call of IncrByFloat. +func (mr *MockUniversalClientMockRecorder) IncrByFloat(ctx, key, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrByFloat", reflect.TypeOf((*MockUniversalClient)(nil).IncrByFloat), ctx, key, value) +} + +// Info mocks base method. +func (m *MockUniversalClient) Info(ctx context.Context, section ...string) *redis.StringCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range section { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Info", varargs...) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// Info indicates an expected call of Info. +func (mr *MockUniversalClientMockRecorder) Info(ctx interface{}, section ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, section...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockUniversalClient)(nil).Info), varargs...) +} + +// JSONArrAppend mocks base method. +func (m *MockUniversalClient) JSONArrAppend(ctx context.Context, key, path string, values ...interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, path} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONArrAppend", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// JSONArrAppend indicates an expected call of JSONArrAppend. +func (mr *MockUniversalClientMockRecorder) JSONArrAppend(ctx, key, path interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, path}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrAppend", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrAppend), varargs...) +} + +// JSONArrIndex mocks base method. +func (m *MockUniversalClient) JSONArrIndex(ctx context.Context, key, path string, value ...interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, path} + for _, a := range value { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONArrIndex", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// JSONArrIndex indicates an expected call of JSONArrIndex. +func (mr *MockUniversalClientMockRecorder) JSONArrIndex(ctx, key, path interface{}, value ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, path}, value...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrIndex", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrIndex), varargs...) +} + +// JSONArrIndexWithArgs mocks base method. +func (m *MockUniversalClient) JSONArrIndexWithArgs(ctx context.Context, key, path string, options *redis.JSONArrIndexArgs, value ...interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, path, options} + for _, a := range value { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONArrIndexWithArgs", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// JSONArrIndexWithArgs indicates an expected call of JSONArrIndexWithArgs. +func (mr *MockUniversalClientMockRecorder) JSONArrIndexWithArgs(ctx, key, path, options interface{}, value ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, path, options}, value...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrIndexWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrIndexWithArgs), varargs...) +} + +// JSONArrInsert mocks base method. +func (m *MockUniversalClient) JSONArrInsert(ctx context.Context, key, path string, index int64, values ...interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, path, index} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONArrInsert", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// JSONArrInsert indicates an expected call of JSONArrInsert. +func (mr *MockUniversalClientMockRecorder) JSONArrInsert(ctx, key, path, index interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, path, index}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrInsert", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrInsert), varargs...) +} + +// JSONArrLen mocks base method. +func (m *MockUniversalClient) JSONArrLen(ctx context.Context, key, path string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONArrLen", ctx, key, path) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// JSONArrLen indicates an expected call of JSONArrLen. +func (mr *MockUniversalClientMockRecorder) JSONArrLen(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrLen", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrLen), ctx, key, path) +} + +// JSONArrPop mocks base method. +func (m *MockUniversalClient) JSONArrPop(ctx context.Context, key, path string, index int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONArrPop", ctx, key, path, index) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// JSONArrPop indicates an expected call of JSONArrPop. +func (mr *MockUniversalClientMockRecorder) JSONArrPop(ctx, key, path, index interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrPop", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrPop), ctx, key, path, index) +} + +// JSONArrTrim mocks base method. +func (m *MockUniversalClient) JSONArrTrim(ctx context.Context, key, path string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONArrTrim", ctx, key, path) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// JSONArrTrim indicates an expected call of JSONArrTrim. +func (mr *MockUniversalClientMockRecorder) JSONArrTrim(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrTrim", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrTrim), ctx, key, path) +} + +// JSONArrTrimWithArgs mocks base method. +func (m *MockUniversalClient) JSONArrTrimWithArgs(ctx context.Context, key, path string, options *redis.JSONArrTrimArgs) *redis.IntSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONArrTrimWithArgs", ctx, key, path, options) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// JSONArrTrimWithArgs indicates an expected call of JSONArrTrimWithArgs. +func (mr *MockUniversalClientMockRecorder) JSONArrTrimWithArgs(ctx, key, path, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrTrimWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrTrimWithArgs), ctx, key, path, options) +} + +// JSONClear mocks base method. +func (m *MockUniversalClient) JSONClear(ctx context.Context, key, path string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONClear", ctx, key, path) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// JSONClear indicates an expected call of JSONClear. +func (mr *MockUniversalClientMockRecorder) JSONClear(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONClear", reflect.TypeOf((*MockUniversalClient)(nil).JSONClear), ctx, key, path) +} + +// JSONDebugMemory mocks base method. +func (m *MockUniversalClient) JSONDebugMemory(ctx context.Context, key, path string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONDebugMemory", ctx, key, path) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// JSONDebugMemory indicates an expected call of JSONDebugMemory. +func (mr *MockUniversalClientMockRecorder) JSONDebugMemory(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONDebugMemory", reflect.TypeOf((*MockUniversalClient)(nil).JSONDebugMemory), ctx, key, path) +} + +// JSONDel mocks base method. +func (m *MockUniversalClient) JSONDel(ctx context.Context, key, path string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONDel", ctx, key, path) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// JSONDel indicates an expected call of JSONDel. +func (mr *MockUniversalClientMockRecorder) JSONDel(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONDel", reflect.TypeOf((*MockUniversalClient)(nil).JSONDel), ctx, key, path) +} + +// JSONForget mocks base method. +func (m *MockUniversalClient) JSONForget(ctx context.Context, key, path string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONForget", ctx, key, path) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// JSONForget indicates an expected call of JSONForget. +func (mr *MockUniversalClientMockRecorder) JSONForget(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONForget", reflect.TypeOf((*MockUniversalClient)(nil).JSONForget), ctx, key, path) +} + +// JSONGet mocks base method. +func (m *MockUniversalClient) JSONGet(ctx context.Context, key string, paths ...string) *redis.JSONCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range paths { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONGet", varargs...) + ret0, _ := ret[0].(*redis.JSONCmd) + return ret0 +} + +// JSONGet indicates an expected call of JSONGet. +func (mr *MockUniversalClientMockRecorder) JSONGet(ctx, key interface{}, paths ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, paths...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONGet", reflect.TypeOf((*MockUniversalClient)(nil).JSONGet), varargs...) +} + +// JSONGetWithArgs mocks base method. +func (m *MockUniversalClient) JSONGetWithArgs(ctx context.Context, key string, options *redis.JSONGetArgs, paths ...string) *redis.JSONCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key, options} + for _, a := range paths { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONGetWithArgs", varargs...) + ret0, _ := ret[0].(*redis.JSONCmd) + return ret0 +} + +// JSONGetWithArgs indicates an expected call of JSONGetWithArgs. +func (mr *MockUniversalClientMockRecorder) JSONGetWithArgs(ctx, key, options interface{}, paths ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key, options}, paths...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONGetWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).JSONGetWithArgs), varargs...) +} + +// JSONMGet mocks base method. +func (m *MockUniversalClient) JSONMGet(ctx context.Context, path string, keys ...string) *redis.JSONSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, path} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONMGet", varargs...) + ret0, _ := ret[0].(*redis.JSONSliceCmd) + return ret0 +} + +// JSONMGet indicates an expected call of JSONMGet. +func (mr *MockUniversalClientMockRecorder) JSONMGet(ctx, path interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, path}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMGet", reflect.TypeOf((*MockUniversalClient)(nil).JSONMGet), varargs...) +} + +// JSONMSet mocks base method. +func (m *MockUniversalClient) JSONMSet(ctx context.Context, params ...interface{}) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range params { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONMSet", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// JSONMSet indicates an expected call of JSONMSet. +func (mr *MockUniversalClientMockRecorder) JSONMSet(ctx interface{}, params ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, params...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMSet", reflect.TypeOf((*MockUniversalClient)(nil).JSONMSet), varargs...) +} + +// JSONMSetArgs mocks base method. +func (m *MockUniversalClient) JSONMSetArgs(ctx context.Context, docs []redis.JSONSetArgs) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONMSetArgs", ctx, docs) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// JSONMSetArgs indicates an expected call of JSONMSetArgs. +func (mr *MockUniversalClientMockRecorder) JSONMSetArgs(ctx, docs interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMSetArgs", reflect.TypeOf((*MockUniversalClient)(nil).JSONMSetArgs), ctx, docs) +} + +// JSONMerge mocks base method. +func (m *MockUniversalClient) JSONMerge(ctx context.Context, key, path, value string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONMerge", ctx, key, path, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// JSONMerge indicates an expected call of JSONMerge. +func (mr *MockUniversalClientMockRecorder) JSONMerge(ctx, key, path, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMerge", reflect.TypeOf((*MockUniversalClient)(nil).JSONMerge), ctx, key, path, value) +} + +// JSONNumIncrBy mocks base method. +func (m *MockUniversalClient) JSONNumIncrBy(ctx context.Context, key, path string, value float64) *redis.JSONCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONNumIncrBy", ctx, key, path, value) + ret0, _ := ret[0].(*redis.JSONCmd) + return ret0 +} + +// JSONNumIncrBy indicates an expected call of JSONNumIncrBy. +func (mr *MockUniversalClientMockRecorder) JSONNumIncrBy(ctx, key, path, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONNumIncrBy", reflect.TypeOf((*MockUniversalClient)(nil).JSONNumIncrBy), ctx, key, path, value) +} + +// JSONObjKeys mocks base method. +func (m *MockUniversalClient) JSONObjKeys(ctx context.Context, key, path string) *redis.SliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONObjKeys", ctx, key, path) + ret0, _ := ret[0].(*redis.SliceCmd) + return ret0 +} + +// JSONObjKeys indicates an expected call of JSONObjKeys. +func (mr *MockUniversalClientMockRecorder) JSONObjKeys(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONObjKeys", reflect.TypeOf((*MockUniversalClient)(nil).JSONObjKeys), ctx, key, path) +} + +// JSONObjLen mocks base method. +func (m *MockUniversalClient) JSONObjLen(ctx context.Context, key, path string) *redis.IntPointerSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONObjLen", ctx, key, path) + ret0, _ := ret[0].(*redis.IntPointerSliceCmd) + return ret0 +} + +// JSONObjLen indicates an expected call of JSONObjLen. +func (mr *MockUniversalClientMockRecorder) JSONObjLen(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONObjLen", reflect.TypeOf((*MockUniversalClient)(nil).JSONObjLen), ctx, key, path) +} + +// JSONSet mocks base method. +func (m *MockUniversalClient) JSONSet(ctx context.Context, key, path string, value interface{}) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONSet", ctx, key, path, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// JSONSet indicates an expected call of JSONSet. +func (mr *MockUniversalClientMockRecorder) JSONSet(ctx, key, path, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONSet", reflect.TypeOf((*MockUniversalClient)(nil).JSONSet), ctx, key, path, value) +} + +// JSONSetMode mocks base method. +func (m *MockUniversalClient) JSONSetMode(ctx context.Context, key, path string, value interface{}, mode string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONSetMode", ctx, key, path, value, mode) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// JSONSetMode indicates an expected call of JSONSetMode. +func (mr *MockUniversalClientMockRecorder) JSONSetMode(ctx, key, path, value, mode interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONSetMode", reflect.TypeOf((*MockUniversalClient)(nil).JSONSetMode), ctx, key, path, value, mode) +} + +// JSONStrAppend mocks base method. +func (m *MockUniversalClient) JSONStrAppend(ctx context.Context, key, path, value string) *redis.IntPointerSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONStrAppend", ctx, key, path, value) + ret0, _ := ret[0].(*redis.IntPointerSliceCmd) + return ret0 +} + +// JSONStrAppend indicates an expected call of JSONStrAppend. +func (mr *MockUniversalClientMockRecorder) JSONStrAppend(ctx, key, path, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONStrAppend", reflect.TypeOf((*MockUniversalClient)(nil).JSONStrAppend), ctx, key, path, value) +} + +// JSONStrLen mocks base method. +func (m *MockUniversalClient) JSONStrLen(ctx context.Context, key, path string) *redis.IntPointerSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONStrLen", ctx, key, path) + ret0, _ := ret[0].(*redis.IntPointerSliceCmd) + return ret0 +} + +// JSONStrLen indicates an expected call of JSONStrLen. +func (mr *MockUniversalClientMockRecorder) JSONStrLen(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONStrLen", reflect.TypeOf((*MockUniversalClient)(nil).JSONStrLen), ctx, key, path) +} + +// JSONToggle mocks base method. +func (m *MockUniversalClient) JSONToggle(ctx context.Context, key, path string) *redis.IntPointerSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONToggle", ctx, key, path) + ret0, _ := ret[0].(*redis.IntPointerSliceCmd) + return ret0 +} + +// JSONToggle indicates an expected call of JSONToggle. +func (mr *MockUniversalClientMockRecorder) JSONToggle(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONToggle", reflect.TypeOf((*MockUniversalClient)(nil).JSONToggle), ctx, key, path) +} + +// JSONType mocks base method. +func (m *MockUniversalClient) JSONType(ctx context.Context, key, path string) *redis.JSONSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONType", ctx, key, path) + ret0, _ := ret[0].(*redis.JSONSliceCmd) + return ret0 +} + +// JSONType indicates an expected call of JSONType. +func (mr *MockUniversalClientMockRecorder) JSONType(ctx, key, path interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONType", reflect.TypeOf((*MockUniversalClient)(nil).JSONType), ctx, key, path) +} + +// Keys mocks base method. +func (m *MockUniversalClient) Keys(ctx context.Context, pattern string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Keys", ctx, pattern) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// Keys indicates an expected call of Keys. +func (mr *MockUniversalClientMockRecorder) Keys(ctx, pattern interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Keys", reflect.TypeOf((*MockUniversalClient)(nil).Keys), ctx, pattern) +} + +// LCS mocks base method. +func (m *MockUniversalClient) LCS(ctx context.Context, q *redis.LCSQuery) *redis.LCSCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LCS", ctx, q) + ret0, _ := ret[0].(*redis.LCSCmd) + return ret0 +} + +// LCS indicates an expected call of LCS. +func (mr *MockUniversalClientMockRecorder) LCS(ctx, q interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LCS", reflect.TypeOf((*MockUniversalClient)(nil).LCS), ctx, q) +} + +// LIndex mocks base method. +func (m *MockUniversalClient) LIndex(ctx context.Context, key string, index int64) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LIndex", ctx, key, index) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// LIndex indicates an expected call of LIndex. +func (mr *MockUniversalClientMockRecorder) LIndex(ctx, key, index interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LIndex", reflect.TypeOf((*MockUniversalClient)(nil).LIndex), ctx, key, index) +} + +// LInsert mocks base method. +func (m *MockUniversalClient) LInsert(ctx context.Context, key, op string, pivot, value interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LInsert", ctx, key, op, pivot, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LInsert indicates an expected call of LInsert. +func (mr *MockUniversalClientMockRecorder) LInsert(ctx, key, op, pivot, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsert", reflect.TypeOf((*MockUniversalClient)(nil).LInsert), ctx, key, op, pivot, value) +} + +// LInsertAfter mocks base method. +func (m *MockUniversalClient) LInsertAfter(ctx context.Context, key string, pivot, value interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LInsertAfter", ctx, key, pivot, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LInsertAfter indicates an expected call of LInsertAfter. +func (mr *MockUniversalClientMockRecorder) LInsertAfter(ctx, key, pivot, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertAfter", reflect.TypeOf((*MockUniversalClient)(nil).LInsertAfter), ctx, key, pivot, value) +} + +// LInsertBefore mocks base method. +func (m *MockUniversalClient) LInsertBefore(ctx context.Context, key string, pivot, value interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LInsertBefore", ctx, key, pivot, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LInsertBefore indicates an expected call of LInsertBefore. +func (mr *MockUniversalClientMockRecorder) LInsertBefore(ctx, key, pivot, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertBefore", reflect.TypeOf((*MockUniversalClient)(nil).LInsertBefore), ctx, key, pivot, value) +} + +// LLen mocks base method. +func (m *MockUniversalClient) LLen(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LLen", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LLen indicates an expected call of LLen. +func (mr *MockUniversalClientMockRecorder) LLen(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LLen", reflect.TypeOf((*MockUniversalClient)(nil).LLen), ctx, key) +} + +// LMPop mocks base method. +func (m *MockUniversalClient) LMPop(ctx context.Context, direction string, count int64, keys ...string) *redis.KeyValuesCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, direction, count} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "LMPop", varargs...) + ret0, _ := ret[0].(*redis.KeyValuesCmd) + return ret0 +} + +// LMPop indicates an expected call of LMPop. +func (mr *MockUniversalClientMockRecorder) LMPop(ctx, direction, count interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, direction, count}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LMPop", reflect.TypeOf((*MockUniversalClient)(nil).LMPop), varargs...) +} + +// LMove mocks base method. +func (m *MockUniversalClient) LMove(ctx context.Context, source, destination, srcpos, destpos string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LMove", ctx, source, destination, srcpos, destpos) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// LMove indicates an expected call of LMove. +func (mr *MockUniversalClientMockRecorder) LMove(ctx, source, destination, srcpos, destpos interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LMove", reflect.TypeOf((*MockUniversalClient)(nil).LMove), ctx, source, destination, srcpos, destpos) +} + +// LPop mocks base method. +func (m *MockUniversalClient) LPop(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LPop", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// LPop indicates an expected call of LPop. +func (mr *MockUniversalClientMockRecorder) LPop(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPop", reflect.TypeOf((*MockUniversalClient)(nil).LPop), ctx, key) +} + +// LPopCount mocks base method. +func (m *MockUniversalClient) LPopCount(ctx context.Context, key string, count int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LPopCount", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// LPopCount indicates an expected call of LPopCount. +func (mr *MockUniversalClientMockRecorder) LPopCount(ctx, key, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPopCount", reflect.TypeOf((*MockUniversalClient)(nil).LPopCount), ctx, key, count) +} + +// LPos mocks base method. +func (m *MockUniversalClient) LPos(ctx context.Context, key, value string, args redis.LPosArgs) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LPos", ctx, key, value, args) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LPos indicates an expected call of LPos. +func (mr *MockUniversalClientMockRecorder) LPos(ctx, key, value, args interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPos", reflect.TypeOf((*MockUniversalClient)(nil).LPos), ctx, key, value, args) +} + +// LPosCount mocks base method. +func (m *MockUniversalClient) LPosCount(ctx context.Context, key, value string, count int64, args redis.LPosArgs) *redis.IntSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LPosCount", ctx, key, value, count, args) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// LPosCount indicates an expected call of LPosCount. +func (mr *MockUniversalClientMockRecorder) LPosCount(ctx, key, value, count, args interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPosCount", reflect.TypeOf((*MockUniversalClient)(nil).LPosCount), ctx, key, value, count, args) +} + +// LPush mocks base method. +func (m *MockUniversalClient) LPush(ctx context.Context, key string, values ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "LPush", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LPush indicates an expected call of LPush. +func (mr *MockUniversalClientMockRecorder) LPush(ctx, key interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPush", reflect.TypeOf((*MockUniversalClient)(nil).LPush), varargs...) +} + +// LPushX mocks base method. +func (m *MockUniversalClient) LPushX(ctx context.Context, key string, values ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "LPushX", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LPushX indicates an expected call of LPushX. +func (mr *MockUniversalClientMockRecorder) LPushX(ctx, key interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPushX", reflect.TypeOf((*MockUniversalClient)(nil).LPushX), varargs...) +} + +// LRange mocks base method. +func (m *MockUniversalClient) LRange(ctx context.Context, key string, start, stop int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LRange", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// LRange indicates an expected call of LRange. +func (mr *MockUniversalClientMockRecorder) LRange(ctx, key, start, stop interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRange", reflect.TypeOf((*MockUniversalClient)(nil).LRange), ctx, key, start, stop) +} + +// LRem mocks base method. +func (m *MockUniversalClient) LRem(ctx context.Context, key string, count int64, value interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LRem", ctx, key, count, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LRem indicates an expected call of LRem. +func (mr *MockUniversalClientMockRecorder) LRem(ctx, key, count, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRem", reflect.TypeOf((*MockUniversalClient)(nil).LRem), ctx, key, count, value) +} + +// LSet mocks base method. +func (m *MockUniversalClient) LSet(ctx context.Context, key string, index int64, value interface{}) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LSet", ctx, key, index, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// LSet indicates an expected call of LSet. +func (mr *MockUniversalClientMockRecorder) LSet(ctx, key, index, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LSet", reflect.TypeOf((*MockUniversalClient)(nil).LSet), ctx, key, index, value) +} + +// LTrim mocks base method. +func (m *MockUniversalClient) LTrim(ctx context.Context, key string, start, stop int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LTrim", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// LTrim indicates an expected call of LTrim. +func (mr *MockUniversalClientMockRecorder) LTrim(ctx, key, start, stop interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LTrim", reflect.TypeOf((*MockUniversalClient)(nil).LTrim), ctx, key, start, stop) +} + +// LastSave mocks base method. +func (m *MockUniversalClient) LastSave(ctx context.Context) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LastSave", ctx) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LastSave indicates an expected call of LastSave. +func (mr *MockUniversalClientMockRecorder) LastSave(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastSave", reflect.TypeOf((*MockUniversalClient)(nil).LastSave), ctx) +} + +// MGet mocks base method. +func (m *MockUniversalClient) MGet(ctx context.Context, keys ...string) *redis.SliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MGet", varargs...) + ret0, _ := ret[0].(*redis.SliceCmd) + return ret0 +} + +// MGet indicates an expected call of MGet. +func (mr *MockUniversalClientMockRecorder) MGet(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGet", reflect.TypeOf((*MockUniversalClient)(nil).MGet), varargs...) +} + +// MSet mocks base method. +func (m *MockUniversalClient) MSet(ctx context.Context, values ...interface{}) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MSet", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// MSet indicates an expected call of MSet. +func (mr *MockUniversalClientMockRecorder) MSet(ctx interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MSet", reflect.TypeOf((*MockUniversalClient)(nil).MSet), varargs...) +} + +// MSetNX mocks base method. +func (m *MockUniversalClient) MSetNX(ctx context.Context, values ...interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MSetNX", varargs...) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// MSetNX indicates an expected call of MSetNX. +func (mr *MockUniversalClientMockRecorder) MSetNX(ctx interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MSetNX", reflect.TypeOf((*MockUniversalClient)(nil).MSetNX), varargs...) +} + +// MemoryUsage mocks base method. +func (m *MockUniversalClient) MemoryUsage(ctx context.Context, key string, samples ...int) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range samples { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MemoryUsage", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// MemoryUsage indicates an expected call of MemoryUsage. +func (mr *MockUniversalClientMockRecorder) MemoryUsage(ctx, key interface{}, samples ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, samples...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MemoryUsage", reflect.TypeOf((*MockUniversalClient)(nil).MemoryUsage), varargs...) +} + +// Migrate mocks base method. +func (m *MockUniversalClient) Migrate(ctx context.Context, host, port, key string, db int, timeout time.Duration) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Migrate", ctx, host, port, key, db, timeout) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Migrate indicates an expected call of Migrate. +func (mr *MockUniversalClientMockRecorder) Migrate(ctx, host, port, key, db, timeout interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Migrate", reflect.TypeOf((*MockUniversalClient)(nil).Migrate), ctx, host, port, key, db, timeout) +} + +// ModuleLoadex mocks base method. +func (m *MockUniversalClient) ModuleLoadex(ctx context.Context, conf *redis.ModuleLoadexConfig) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModuleLoadex", ctx, conf) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ModuleLoadex indicates an expected call of ModuleLoadex. +func (mr *MockUniversalClientMockRecorder) ModuleLoadex(ctx, conf interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModuleLoadex", reflect.TypeOf((*MockUniversalClient)(nil).ModuleLoadex), ctx, conf) +} + +// Move mocks base method. +func (m *MockUniversalClient) Move(ctx context.Context, key string, db int) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Move", ctx, key, db) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// Move indicates an expected call of Move. +func (mr *MockUniversalClientMockRecorder) Move(ctx, key, db interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Move", reflect.TypeOf((*MockUniversalClient)(nil).Move), ctx, key, db) +} + +// ObjectEncoding mocks base method. +func (m *MockUniversalClient) ObjectEncoding(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ObjectEncoding", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ObjectEncoding indicates an expected call of ObjectEncoding. +func (mr *MockUniversalClientMockRecorder) ObjectEncoding(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectEncoding", reflect.TypeOf((*MockUniversalClient)(nil).ObjectEncoding), ctx, key) +} + +// ObjectFreq mocks base method. +func (m *MockUniversalClient) ObjectFreq(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ObjectFreq", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ObjectFreq indicates an expected call of ObjectFreq. +func (mr *MockUniversalClientMockRecorder) ObjectFreq(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectFreq", reflect.TypeOf((*MockUniversalClient)(nil).ObjectFreq), ctx, key) +} + +// ObjectIdleTime mocks base method. +func (m *MockUniversalClient) ObjectIdleTime(ctx context.Context, key string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ObjectIdleTime", ctx, key) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// ObjectIdleTime indicates an expected call of ObjectIdleTime. +func (mr *MockUniversalClientMockRecorder) ObjectIdleTime(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectIdleTime", reflect.TypeOf((*MockUniversalClient)(nil).ObjectIdleTime), ctx, key) +} + +// ObjectRefCount mocks base method. +func (m *MockUniversalClient) ObjectRefCount(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ObjectRefCount", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ObjectRefCount indicates an expected call of ObjectRefCount. +func (mr *MockUniversalClientMockRecorder) ObjectRefCount(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectRefCount", reflect.TypeOf((*MockUniversalClient)(nil).ObjectRefCount), ctx, key) +} + +// PExpire mocks base method. +func (m *MockUniversalClient) PExpire(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PExpire", ctx, key, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// PExpire indicates an expected call of PExpire. +func (mr *MockUniversalClientMockRecorder) PExpire(ctx, key, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpire", reflect.TypeOf((*MockUniversalClient)(nil).PExpire), ctx, key, expiration) +} + +// PExpireAt mocks base method. +func (m *MockUniversalClient) PExpireAt(ctx context.Context, key string, tm time.Time) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PExpireAt", ctx, key, tm) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// PExpireAt indicates an expected call of PExpireAt. +func (mr *MockUniversalClientMockRecorder) PExpireAt(ctx, key, tm interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpireAt", reflect.TypeOf((*MockUniversalClient)(nil).PExpireAt), ctx, key, tm) +} + +// PExpireTime mocks base method. +func (m *MockUniversalClient) PExpireTime(ctx context.Context, key string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PExpireTime", ctx, key) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// PExpireTime indicates an expected call of PExpireTime. +func (mr *MockUniversalClientMockRecorder) PExpireTime(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpireTime", reflect.TypeOf((*MockUniversalClient)(nil).PExpireTime), ctx, key) +} + +// PFAdd mocks base method. +func (m *MockUniversalClient) PFAdd(ctx context.Context, key string, els ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range els { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PFAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// PFAdd indicates an expected call of PFAdd. +func (mr *MockUniversalClientMockRecorder) PFAdd(ctx, key interface{}, els ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, els...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFAdd", reflect.TypeOf((*MockUniversalClient)(nil).PFAdd), varargs...) +} + +// PFCount mocks base method. +func (m *MockUniversalClient) PFCount(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PFCount", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// PFCount indicates an expected call of PFCount. +func (mr *MockUniversalClientMockRecorder) PFCount(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFCount", reflect.TypeOf((*MockUniversalClient)(nil).PFCount), varargs...) +} + +// PFMerge mocks base method. +func (m *MockUniversalClient) PFMerge(ctx context.Context, dest string, keys ...string) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, dest} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PFMerge", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// PFMerge indicates an expected call of PFMerge. +func (mr *MockUniversalClientMockRecorder) PFMerge(ctx, dest interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, dest}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFMerge", reflect.TypeOf((*MockUniversalClient)(nil).PFMerge), varargs...) +} + +// PSubscribe mocks base method. +func (m *MockUniversalClient) PSubscribe(ctx context.Context, channels ...string) *redis.PubSub { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range channels { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PSubscribe", varargs...) + ret0, _ := ret[0].(*redis.PubSub) + return ret0 +} + +// PSubscribe indicates an expected call of PSubscribe. +func (mr *MockUniversalClientMockRecorder) PSubscribe(ctx interface{}, channels ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, channels...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PSubscribe", reflect.TypeOf((*MockUniversalClient)(nil).PSubscribe), varargs...) +} + +// PTTL mocks base method. +func (m *MockUniversalClient) PTTL(ctx context.Context, key string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PTTL", ctx, key) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// PTTL indicates an expected call of PTTL. +func (mr *MockUniversalClientMockRecorder) PTTL(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PTTL", reflect.TypeOf((*MockUniversalClient)(nil).PTTL), ctx, key) +} + +// Persist mocks base method. +func (m *MockUniversalClient) Persist(ctx context.Context, key string) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Persist", ctx, key) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// Persist indicates an expected call of Persist. +func (mr *MockUniversalClientMockRecorder) Persist(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Persist", reflect.TypeOf((*MockUniversalClient)(nil).Persist), ctx, key) +} + +// Ping mocks base method. +func (m *MockUniversalClient) Ping(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Ping", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Ping indicates an expected call of Ping. +func (mr *MockUniversalClientMockRecorder) Ping(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockUniversalClient)(nil).Ping), ctx) +} + +// Pipeline mocks base method. +func (m *MockUniversalClient) Pipeline() redis.Pipeliner { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Pipeline") + ret0, _ := ret[0].(redis.Pipeliner) + return ret0 +} + +// Pipeline indicates an expected call of Pipeline. +func (mr *MockUniversalClientMockRecorder) Pipeline() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipeline", reflect.TypeOf((*MockUniversalClient)(nil).Pipeline)) +} + +// Pipelined mocks base method. +func (m *MockUniversalClient) Pipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Pipelined", ctx, fn) + ret0, _ := ret[0].([]redis.Cmder) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Pipelined indicates an expected call of Pipelined. +func (mr *MockUniversalClientMockRecorder) Pipelined(ctx, fn interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipelined", reflect.TypeOf((*MockUniversalClient)(nil).Pipelined), ctx, fn) +} + +// PoolStats mocks base method. +func (m *MockUniversalClient) PoolStats() *redis.PoolStats { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PoolStats") + ret0, _ := ret[0].(*redis.PoolStats) + return ret0 +} + +// PoolStats indicates an expected call of PoolStats. +func (mr *MockUniversalClientMockRecorder) PoolStats() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PoolStats", reflect.TypeOf((*MockUniversalClient)(nil).PoolStats)) +} + +// Process mocks base method. +func (m *MockUniversalClient) Process(ctx context.Context, cmd redis.Cmder) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Process", ctx, cmd) + ret0, _ := ret[0].(error) + return ret0 +} + +// Process indicates an expected call of Process. +func (mr *MockUniversalClientMockRecorder) Process(ctx, cmd interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Process", reflect.TypeOf((*MockUniversalClient)(nil).Process), ctx, cmd) +} + +// PubSubChannels mocks base method. +func (m *MockUniversalClient) PubSubChannels(ctx context.Context, pattern string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PubSubChannels", ctx, pattern) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// PubSubChannels indicates an expected call of PubSubChannels. +func (mr *MockUniversalClientMockRecorder) PubSubChannels(ctx, pattern interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubChannels", reflect.TypeOf((*MockUniversalClient)(nil).PubSubChannels), ctx, pattern) +} + +// PubSubNumPat mocks base method. +func (m *MockUniversalClient) PubSubNumPat(ctx context.Context) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PubSubNumPat", ctx) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// PubSubNumPat indicates an expected call of PubSubNumPat. +func (mr *MockUniversalClientMockRecorder) PubSubNumPat(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubNumPat", reflect.TypeOf((*MockUniversalClient)(nil).PubSubNumPat), ctx) +} + +// PubSubNumSub mocks base method. +func (m *MockUniversalClient) PubSubNumSub(ctx context.Context, channels ...string) *redis.MapStringIntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range channels { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PubSubNumSub", varargs...) + ret0, _ := ret[0].(*redis.MapStringIntCmd) + return ret0 +} + +// PubSubNumSub indicates an expected call of PubSubNumSub. +func (mr *MockUniversalClientMockRecorder) PubSubNumSub(ctx interface{}, channels ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, channels...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubNumSub", reflect.TypeOf((*MockUniversalClient)(nil).PubSubNumSub), varargs...) +} + +// PubSubShardChannels mocks base method. +func (m *MockUniversalClient) PubSubShardChannels(ctx context.Context, pattern string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PubSubShardChannels", ctx, pattern) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// PubSubShardChannels indicates an expected call of PubSubShardChannels. +func (mr *MockUniversalClientMockRecorder) PubSubShardChannels(ctx, pattern interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubShardChannels", reflect.TypeOf((*MockUniversalClient)(nil).PubSubShardChannels), ctx, pattern) +} + +// PubSubShardNumSub mocks base method. +func (m *MockUniversalClient) PubSubShardNumSub(ctx context.Context, channels ...string) *redis.MapStringIntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range channels { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PubSubShardNumSub", varargs...) + ret0, _ := ret[0].(*redis.MapStringIntCmd) + return ret0 +} + +// PubSubShardNumSub indicates an expected call of PubSubShardNumSub. +func (mr *MockUniversalClientMockRecorder) PubSubShardNumSub(ctx interface{}, channels ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, channels...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubShardNumSub", reflect.TypeOf((*MockUniversalClient)(nil).PubSubShardNumSub), varargs...) +} + +// Publish mocks base method. +func (m *MockUniversalClient) Publish(ctx context.Context, channel string, message interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Publish", ctx, channel, message) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Publish indicates an expected call of Publish. +func (mr *MockUniversalClientMockRecorder) Publish(ctx, channel, message interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Publish", reflect.TypeOf((*MockUniversalClient)(nil).Publish), ctx, channel, message) +} + +// Quit mocks base method. +func (m *MockUniversalClient) Quit(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Quit", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Quit indicates an expected call of Quit. +func (mr *MockUniversalClientMockRecorder) Quit(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Quit", reflect.TypeOf((*MockUniversalClient)(nil).Quit), ctx) +} + +// RPop mocks base method. +func (m *MockUniversalClient) RPop(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RPop", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// RPop indicates an expected call of RPop. +func (mr *MockUniversalClientMockRecorder) RPop(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPop", reflect.TypeOf((*MockUniversalClient)(nil).RPop), ctx, key) +} + +// RPopCount mocks base method. +func (m *MockUniversalClient) RPopCount(ctx context.Context, key string, count int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RPopCount", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// RPopCount indicates an expected call of RPopCount. +func (mr *MockUniversalClientMockRecorder) RPopCount(ctx, key, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopCount", reflect.TypeOf((*MockUniversalClient)(nil).RPopCount), ctx, key, count) +} + +// RPopLPush mocks base method. +func (m *MockUniversalClient) RPopLPush(ctx context.Context, source, destination string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RPopLPush", ctx, source, destination) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// RPopLPush indicates an expected call of RPopLPush. +func (mr *MockUniversalClientMockRecorder) RPopLPush(ctx, source, destination interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopLPush", reflect.TypeOf((*MockUniversalClient)(nil).RPopLPush), ctx, source, destination) +} + +// RPush mocks base method. +func (m *MockUniversalClient) RPush(ctx context.Context, key string, values ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RPush", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// RPush indicates an expected call of RPush. +func (mr *MockUniversalClientMockRecorder) RPush(ctx, key interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPush", reflect.TypeOf((*MockUniversalClient)(nil).RPush), varargs...) +} + +// RPushX mocks base method. +func (m *MockUniversalClient) RPushX(ctx context.Context, key string, values ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RPushX", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// RPushX indicates an expected call of RPushX. +func (mr *MockUniversalClientMockRecorder) RPushX(ctx, key interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPushX", reflect.TypeOf((*MockUniversalClient)(nil).RPushX), varargs...) +} + +// RandomKey mocks base method. +func (m *MockUniversalClient) RandomKey(ctx context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RandomKey", ctx) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// RandomKey indicates an expected call of RandomKey. +func (mr *MockUniversalClientMockRecorder) RandomKey(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RandomKey", reflect.TypeOf((*MockUniversalClient)(nil).RandomKey), ctx) +} + +// ReadOnly mocks base method. +func (m *MockUniversalClient) ReadOnly(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadOnly", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ReadOnly indicates an expected call of ReadOnly. +func (mr *MockUniversalClientMockRecorder) ReadOnly(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadOnly", reflect.TypeOf((*MockUniversalClient)(nil).ReadOnly), ctx) +} + +// ReadWrite mocks base method. +func (m *MockUniversalClient) ReadWrite(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadWrite", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ReadWrite indicates an expected call of ReadWrite. +func (mr *MockUniversalClientMockRecorder) ReadWrite(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadWrite", reflect.TypeOf((*MockUniversalClient)(nil).ReadWrite), ctx) +} + +// Rename mocks base method. +func (m *MockUniversalClient) Rename(ctx context.Context, key, newkey string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Rename", ctx, key, newkey) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Rename indicates an expected call of Rename. +func (mr *MockUniversalClientMockRecorder) Rename(ctx, key, newkey interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rename", reflect.TypeOf((*MockUniversalClient)(nil).Rename), ctx, key, newkey) +} + +// RenameNX mocks base method. +func (m *MockUniversalClient) RenameNX(ctx context.Context, key, newkey string) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RenameNX", ctx, key, newkey) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// RenameNX indicates an expected call of RenameNX. +func (mr *MockUniversalClientMockRecorder) RenameNX(ctx, key, newkey interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameNX", reflect.TypeOf((*MockUniversalClient)(nil).RenameNX), ctx, key, newkey) +} + +// Restore mocks base method. +func (m *MockUniversalClient) Restore(ctx context.Context, key string, ttl time.Duration, value string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Restore", ctx, key, ttl, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Restore indicates an expected call of Restore. +func (mr *MockUniversalClientMockRecorder) Restore(ctx, key, ttl, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Restore", reflect.TypeOf((*MockUniversalClient)(nil).Restore), ctx, key, ttl, value) +} + +// RestoreReplace mocks base method. +func (m *MockUniversalClient) RestoreReplace(ctx context.Context, key string, ttl time.Duration, value string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RestoreReplace", ctx, key, ttl, value) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// RestoreReplace indicates an expected call of RestoreReplace. +func (mr *MockUniversalClientMockRecorder) RestoreReplace(ctx, key, ttl, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreReplace", reflect.TypeOf((*MockUniversalClient)(nil).RestoreReplace), ctx, key, ttl, value) +} + +// SAdd mocks base method. +func (m *MockUniversalClient) SAdd(ctx context.Context, key string, members ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SAdd indicates an expected call of SAdd. +func (mr *MockUniversalClientMockRecorder) SAdd(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SAdd", reflect.TypeOf((*MockUniversalClient)(nil).SAdd), varargs...) +} + +// SCard mocks base method. +func (m *MockUniversalClient) SCard(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SCard", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SCard indicates an expected call of SCard. +func (mr *MockUniversalClientMockRecorder) SCard(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SCard", reflect.TypeOf((*MockUniversalClient)(nil).SCard), ctx, key) +} + +// SDiff mocks base method. +func (m *MockUniversalClient) SDiff(ctx context.Context, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SDiff", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SDiff indicates an expected call of SDiff. +func (mr *MockUniversalClientMockRecorder) SDiff(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SDiff", reflect.TypeOf((*MockUniversalClient)(nil).SDiff), varargs...) +} + +// SDiffStore mocks base method. +func (m *MockUniversalClient) SDiffStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, destination} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SDiffStore", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SDiffStore indicates an expected call of SDiffStore. +func (mr *MockUniversalClientMockRecorder) SDiffStore(ctx, destination interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, destination}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SDiffStore", reflect.TypeOf((*MockUniversalClient)(nil).SDiffStore), varargs...) +} + +// SInter mocks base method. +func (m *MockUniversalClient) SInter(ctx context.Context, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SInter", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SInter indicates an expected call of SInter. +func (mr *MockUniversalClientMockRecorder) SInter(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInter", reflect.TypeOf((*MockUniversalClient)(nil).SInter), varargs...) +} + +// SInterCard mocks base method. +func (m *MockUniversalClient) SInterCard(ctx context.Context, limit int64, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, limit} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SInterCard", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SInterCard indicates an expected call of SInterCard. +func (mr *MockUniversalClientMockRecorder) SInterCard(ctx, limit interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, limit}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInterCard", reflect.TypeOf((*MockUniversalClient)(nil).SInterCard), varargs...) +} + +// SInterStore mocks base method. +func (m *MockUniversalClient) SInterStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, destination} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SInterStore", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SInterStore indicates an expected call of SInterStore. +func (mr *MockUniversalClientMockRecorder) SInterStore(ctx, destination interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, destination}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInterStore", reflect.TypeOf((*MockUniversalClient)(nil).SInterStore), varargs...) +} + +// SIsMember mocks base method. +func (m *MockUniversalClient) SIsMember(ctx context.Context, key string, member interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SIsMember", ctx, key, member) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// SIsMember indicates an expected call of SIsMember. +func (mr *MockUniversalClientMockRecorder) SIsMember(ctx, key, member interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SIsMember", reflect.TypeOf((*MockUniversalClient)(nil).SIsMember), ctx, key, member) +} + +// SMIsMember mocks base method. +func (m *MockUniversalClient) SMIsMember(ctx context.Context, key string, members ...interface{}) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SMIsMember", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// SMIsMember indicates an expected call of SMIsMember. +func (mr *MockUniversalClientMockRecorder) SMIsMember(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMIsMember", reflect.TypeOf((*MockUniversalClient)(nil).SMIsMember), varargs...) +} + +// SMembers mocks base method. +func (m *MockUniversalClient) SMembers(ctx context.Context, key string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SMembers", ctx, key) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SMembers indicates an expected call of SMembers. +func (mr *MockUniversalClientMockRecorder) SMembers(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembers", reflect.TypeOf((*MockUniversalClient)(nil).SMembers), ctx, key) +} + +// SMembersMap mocks base method. +func (m *MockUniversalClient) SMembersMap(ctx context.Context, key string) *redis.StringStructMapCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SMembersMap", ctx, key) + ret0, _ := ret[0].(*redis.StringStructMapCmd) + return ret0 +} + +// SMembersMap indicates an expected call of SMembersMap. +func (mr *MockUniversalClientMockRecorder) SMembersMap(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembersMap", reflect.TypeOf((*MockUniversalClient)(nil).SMembersMap), ctx, key) +} + +// SMove mocks base method. +func (m *MockUniversalClient) SMove(ctx context.Context, source, destination string, member interface{}) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SMove", ctx, source, destination, member) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// SMove indicates an expected call of SMove. +func (mr *MockUniversalClientMockRecorder) SMove(ctx, source, destination, member interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMove", reflect.TypeOf((*MockUniversalClient)(nil).SMove), ctx, source, destination, member) +} + +// SPop mocks base method. +func (m *MockUniversalClient) SPop(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SPop", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// SPop indicates an expected call of SPop. +func (mr *MockUniversalClientMockRecorder) SPop(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPop", reflect.TypeOf((*MockUniversalClient)(nil).SPop), ctx, key) +} + +// SPopN mocks base method. +func (m *MockUniversalClient) SPopN(ctx context.Context, key string, count int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SPopN", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SPopN indicates an expected call of SPopN. +func (mr *MockUniversalClientMockRecorder) SPopN(ctx, key, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPopN", reflect.TypeOf((*MockUniversalClient)(nil).SPopN), ctx, key, count) +} + +// SPublish mocks base method. +func (m *MockUniversalClient) SPublish(ctx context.Context, channel string, message interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SPublish", ctx, channel, message) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SPublish indicates an expected call of SPublish. +func (mr *MockUniversalClientMockRecorder) SPublish(ctx, channel, message interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPublish", reflect.TypeOf((*MockUniversalClient)(nil).SPublish), ctx, channel, message) +} + +// SRandMember mocks base method. +func (m *MockUniversalClient) SRandMember(ctx context.Context, key string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SRandMember", ctx, key) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// SRandMember indicates an expected call of SRandMember. +func (mr *MockUniversalClientMockRecorder) SRandMember(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMember", reflect.TypeOf((*MockUniversalClient)(nil).SRandMember), ctx, key) +} + +// SRandMemberN mocks base method. +func (m *MockUniversalClient) SRandMemberN(ctx context.Context, key string, count int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SRandMemberN", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SRandMemberN indicates an expected call of SRandMemberN. +func (mr *MockUniversalClientMockRecorder) SRandMemberN(ctx, key, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMemberN", reflect.TypeOf((*MockUniversalClient)(nil).SRandMemberN), ctx, key, count) +} + +// SRem mocks base method. +func (m *MockUniversalClient) SRem(ctx context.Context, key string, members ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SRem", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SRem indicates an expected call of SRem. +func (mr *MockUniversalClientMockRecorder) SRem(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRem", reflect.TypeOf((*MockUniversalClient)(nil).SRem), varargs...) +} + +// SScan mocks base method. +func (m *MockUniversalClient) SScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SScan", ctx, key, cursor, match, count) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// SScan indicates an expected call of SScan. +func (mr *MockUniversalClientMockRecorder) SScan(ctx, key, cursor, match, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SScan", reflect.TypeOf((*MockUniversalClient)(nil).SScan), ctx, key, cursor, match, count) +} + +// SSubscribe mocks base method. +func (m *MockUniversalClient) SSubscribe(ctx context.Context, channels ...string) *redis.PubSub { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range channels { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SSubscribe", varargs...) + ret0, _ := ret[0].(*redis.PubSub) + return ret0 +} + +// SSubscribe indicates an expected call of SSubscribe. +func (mr *MockUniversalClientMockRecorder) SSubscribe(ctx interface{}, channels ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, channels...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SSubscribe", reflect.TypeOf((*MockUniversalClient)(nil).SSubscribe), varargs...) +} + +// SUnion mocks base method. +func (m *MockUniversalClient) SUnion(ctx context.Context, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SUnion", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SUnion indicates an expected call of SUnion. +func (mr *MockUniversalClientMockRecorder) SUnion(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnion", reflect.TypeOf((*MockUniversalClient)(nil).SUnion), varargs...) +} + +// SUnionStore mocks base method. +func (m *MockUniversalClient) SUnionStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, destination} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SUnionStore", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SUnionStore indicates an expected call of SUnionStore. +func (mr *MockUniversalClientMockRecorder) SUnionStore(ctx, destination interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, destination}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnionStore", reflect.TypeOf((*MockUniversalClient)(nil).SUnionStore), varargs...) +} + +// Save mocks base method. +func (m *MockUniversalClient) Save(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Save", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Save indicates an expected call of Save. +func (mr *MockUniversalClientMockRecorder) Save(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockUniversalClient)(nil).Save), ctx) +} + +// Scan mocks base method. +func (m *MockUniversalClient) Scan(ctx context.Context, cursor uint64, match string, count int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Scan", ctx, cursor, match, count) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// Scan indicates an expected call of Scan. +func (mr *MockUniversalClientMockRecorder) Scan(ctx, cursor, match, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockUniversalClient)(nil).Scan), ctx, cursor, match, count) +} + +// ScanType mocks base method. +func (m *MockUniversalClient) ScanType(ctx context.Context, cursor uint64, match string, count int64, keyType string) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScanType", ctx, cursor, match, count, keyType) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// ScanType indicates an expected call of ScanType. +func (mr *MockUniversalClientMockRecorder) ScanType(ctx, cursor, match, count, keyType interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanType", reflect.TypeOf((*MockUniversalClient)(nil).ScanType), ctx, cursor, match, count, keyType) +} + +// ScriptExists mocks base method. +func (m *MockUniversalClient) ScriptExists(ctx context.Context, hashes ...string) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range hashes { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ScriptExists", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// ScriptExists indicates an expected call of ScriptExists. +func (mr *MockUniversalClientMockRecorder) ScriptExists(ctx interface{}, hashes ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, hashes...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptExists", reflect.TypeOf((*MockUniversalClient)(nil).ScriptExists), varargs...) +} + +// ScriptFlush mocks base method. +func (m *MockUniversalClient) ScriptFlush(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScriptFlush", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ScriptFlush indicates an expected call of ScriptFlush. +func (mr *MockUniversalClientMockRecorder) ScriptFlush(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptFlush", reflect.TypeOf((*MockUniversalClient)(nil).ScriptFlush), ctx) +} + +// ScriptKill mocks base method. +func (m *MockUniversalClient) ScriptKill(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScriptKill", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ScriptKill indicates an expected call of ScriptKill. +func (mr *MockUniversalClientMockRecorder) ScriptKill(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptKill", reflect.TypeOf((*MockUniversalClient)(nil).ScriptKill), ctx) +} + +// ScriptLoad mocks base method. +func (m *MockUniversalClient) ScriptLoad(ctx context.Context, script string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScriptLoad", ctx, script) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ScriptLoad indicates an expected call of ScriptLoad. +func (mr *MockUniversalClientMockRecorder) ScriptLoad(ctx, script interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptLoad", reflect.TypeOf((*MockUniversalClient)(nil).ScriptLoad), ctx, script) +} + +// Set mocks base method. +func (m *MockUniversalClient) Set(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Set", ctx, key, value, expiration) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Set indicates an expected call of Set. +func (mr *MockUniversalClientMockRecorder) Set(ctx, key, value, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockUniversalClient)(nil).Set), ctx, key, value, expiration) +} + +// SetArgs mocks base method. +func (m *MockUniversalClient) SetArgs(ctx context.Context, key string, value interface{}, a redis.SetArgs) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetArgs", ctx, key, value, a) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// SetArgs indicates an expected call of SetArgs. +func (mr *MockUniversalClientMockRecorder) SetArgs(ctx, key, value, a interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetArgs", reflect.TypeOf((*MockUniversalClient)(nil).SetArgs), ctx, key, value, a) +} + +// SetBit mocks base method. +func (m *MockUniversalClient) SetBit(ctx context.Context, key string, offset int64, value int) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetBit", ctx, key, offset, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SetBit indicates an expected call of SetBit. +func (mr *MockUniversalClientMockRecorder) SetBit(ctx, key, offset, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBit", reflect.TypeOf((*MockUniversalClient)(nil).SetBit), ctx, key, offset, value) +} + +// SetEx mocks base method. +func (m *MockUniversalClient) SetEx(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetEx", ctx, key, value, expiration) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// SetEx indicates an expected call of SetEx. +func (mr *MockUniversalClientMockRecorder) SetEx(ctx, key, value, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEx", reflect.TypeOf((*MockUniversalClient)(nil).SetEx), ctx, key, value, expiration) +} + +// SetNX mocks base method. +func (m *MockUniversalClient) SetNX(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetNX", ctx, key, value, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// SetNX indicates an expected call of SetNX. +func (mr *MockUniversalClientMockRecorder) SetNX(ctx, key, value, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNX", reflect.TypeOf((*MockUniversalClient)(nil).SetNX), ctx, key, value, expiration) +} + +// SetRange mocks base method. +func (m *MockUniversalClient) SetRange(ctx context.Context, key string, offset int64, value string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetRange", ctx, key, offset, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SetRange indicates an expected call of SetRange. +func (mr *MockUniversalClientMockRecorder) SetRange(ctx, key, offset, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRange", reflect.TypeOf((*MockUniversalClient)(nil).SetRange), ctx, key, offset, value) +} + +// SetXX mocks base method. +func (m *MockUniversalClient) SetXX(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetXX", ctx, key, value, expiration) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// SetXX indicates an expected call of SetXX. +func (mr *MockUniversalClientMockRecorder) SetXX(ctx, key, value, expiration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetXX", reflect.TypeOf((*MockUniversalClient)(nil).SetXX), ctx, key, value, expiration) +} + +// Shutdown mocks base method. +func (m *MockUniversalClient) Shutdown(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Shutdown", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Shutdown indicates an expected call of Shutdown. +func (mr *MockUniversalClientMockRecorder) Shutdown(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockUniversalClient)(nil).Shutdown), ctx) +} + +// ShutdownNoSave mocks base method. +func (m *MockUniversalClient) ShutdownNoSave(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ShutdownNoSave", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ShutdownNoSave indicates an expected call of ShutdownNoSave. +func (mr *MockUniversalClientMockRecorder) ShutdownNoSave(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownNoSave", reflect.TypeOf((*MockUniversalClient)(nil).ShutdownNoSave), ctx) +} + +// ShutdownSave mocks base method. +func (m *MockUniversalClient) ShutdownSave(ctx context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ShutdownSave", ctx) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ShutdownSave indicates an expected call of ShutdownSave. +func (mr *MockUniversalClientMockRecorder) ShutdownSave(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownSave", reflect.TypeOf((*MockUniversalClient)(nil).ShutdownSave), ctx) +} + +// SlaveOf mocks base method. +func (m *MockUniversalClient) SlaveOf(ctx context.Context, host, port string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SlaveOf", ctx, host, port) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// SlaveOf indicates an expected call of SlaveOf. +func (mr *MockUniversalClientMockRecorder) SlaveOf(ctx, host, port interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlaveOf", reflect.TypeOf((*MockUniversalClient)(nil).SlaveOf), ctx, host, port) +} + +// SlowLogGet mocks base method. +func (m *MockUniversalClient) SlowLogGet(ctx context.Context, num int64) *redis.SlowLogCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SlowLogGet", ctx, num) + ret0, _ := ret[0].(*redis.SlowLogCmd) + return ret0 +} + +// SlowLogGet indicates an expected call of SlowLogGet. +func (mr *MockUniversalClientMockRecorder) SlowLogGet(ctx, num interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlowLogGet", reflect.TypeOf((*MockUniversalClient)(nil).SlowLogGet), ctx, num) +} + +// Sort mocks base method. +func (m *MockUniversalClient) Sort(ctx context.Context, key string, sort *redis.Sort) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Sort", ctx, key, sort) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// Sort indicates an expected call of Sort. +func (mr *MockUniversalClientMockRecorder) Sort(ctx, key, sort interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sort", reflect.TypeOf((*MockUniversalClient)(nil).Sort), ctx, key, sort) +} + +// SortInterfaces mocks base method. +func (m *MockUniversalClient) SortInterfaces(ctx context.Context, key string, sort *redis.Sort) *redis.SliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SortInterfaces", ctx, key, sort) + ret0, _ := ret[0].(*redis.SliceCmd) + return ret0 +} + +// SortInterfaces indicates an expected call of SortInterfaces. +func (mr *MockUniversalClientMockRecorder) SortInterfaces(ctx, key, sort interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortInterfaces", reflect.TypeOf((*MockUniversalClient)(nil).SortInterfaces), ctx, key, sort) +} + +// SortRO mocks base method. +func (m *MockUniversalClient) SortRO(ctx context.Context, key string, sort *redis.Sort) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SortRO", ctx, key, sort) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SortRO indicates an expected call of SortRO. +func (mr *MockUniversalClientMockRecorder) SortRO(ctx, key, sort interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortRO", reflect.TypeOf((*MockUniversalClient)(nil).SortRO), ctx, key, sort) +} + +// SortStore mocks base method. +func (m *MockUniversalClient) SortStore(ctx context.Context, key, store string, sort *redis.Sort) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SortStore", ctx, key, store, sort) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SortStore indicates an expected call of SortStore. +func (mr *MockUniversalClientMockRecorder) SortStore(ctx, key, store, sort interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortStore", reflect.TypeOf((*MockUniversalClient)(nil).SortStore), ctx, key, store, sort) +} + +// StrLen mocks base method. +func (m *MockUniversalClient) StrLen(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StrLen", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// StrLen indicates an expected call of StrLen. +func (mr *MockUniversalClientMockRecorder) StrLen(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StrLen", reflect.TypeOf((*MockUniversalClient)(nil).StrLen), ctx, key) +} + +// Subscribe mocks base method. +func (m *MockUniversalClient) Subscribe(ctx context.Context, channels ...string) *redis.PubSub { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range channels { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Subscribe", varargs...) + ret0, _ := ret[0].(*redis.PubSub) + return ret0 +} + +// Subscribe indicates an expected call of Subscribe. +func (mr *MockUniversalClientMockRecorder) Subscribe(ctx interface{}, channels ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, channels...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Subscribe", reflect.TypeOf((*MockUniversalClient)(nil).Subscribe), varargs...) +} + +// TDigestAdd mocks base method. +func (m *MockUniversalClient) TDigestAdd(ctx context.Context, key string, elements ...float64) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestAdd", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestAdd indicates an expected call of TDigestAdd. +func (mr *MockUniversalClientMockRecorder) TDigestAdd(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestAdd", reflect.TypeOf((*MockUniversalClient)(nil).TDigestAdd), varargs...) +} + +// TDigestByRank mocks base method. +func (m *MockUniversalClient) TDigestByRank(ctx context.Context, key string, rank ...uint64) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range rank { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestByRank", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// TDigestByRank indicates an expected call of TDigestByRank. +func (mr *MockUniversalClientMockRecorder) TDigestByRank(ctx, key interface{}, rank ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, rank...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestByRank", reflect.TypeOf((*MockUniversalClient)(nil).TDigestByRank), varargs...) +} + +// TDigestByRevRank mocks base method. +func (m *MockUniversalClient) TDigestByRevRank(ctx context.Context, key string, rank ...uint64) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range rank { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestByRevRank", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// TDigestByRevRank indicates an expected call of TDigestByRevRank. +func (mr *MockUniversalClientMockRecorder) TDigestByRevRank(ctx, key interface{}, rank ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, rank...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestByRevRank", reflect.TypeOf((*MockUniversalClient)(nil).TDigestByRevRank), varargs...) +} + +// TDigestCDF mocks base method. +func (m *MockUniversalClient) TDigestCDF(ctx context.Context, key string, elements ...float64) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestCDF", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// TDigestCDF indicates an expected call of TDigestCDF. +func (mr *MockUniversalClientMockRecorder) TDigestCDF(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCDF", reflect.TypeOf((*MockUniversalClient)(nil).TDigestCDF), varargs...) +} + +// TDigestCreate mocks base method. +func (m *MockUniversalClient) TDigestCreate(ctx context.Context, key string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestCreate", ctx, key) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestCreate indicates an expected call of TDigestCreate. +func (mr *MockUniversalClientMockRecorder) TDigestCreate(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCreate", reflect.TypeOf((*MockUniversalClient)(nil).TDigestCreate), ctx, key) +} + +// TDigestCreateWithCompression mocks base method. +func (m *MockUniversalClient) TDigestCreateWithCompression(ctx context.Context, key string, compression int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestCreateWithCompression", ctx, key, compression) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestCreateWithCompression indicates an expected call of TDigestCreateWithCompression. +func (mr *MockUniversalClientMockRecorder) TDigestCreateWithCompression(ctx, key, compression interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCreateWithCompression", reflect.TypeOf((*MockUniversalClient)(nil).TDigestCreateWithCompression), ctx, key, compression) +} + +// TDigestInfo mocks base method. +func (m *MockUniversalClient) TDigestInfo(ctx context.Context, key string) *redis.TDigestInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestInfo", ctx, key) + ret0, _ := ret[0].(*redis.TDigestInfoCmd) + return ret0 +} + +// TDigestInfo indicates an expected call of TDigestInfo. +func (mr *MockUniversalClientMockRecorder) TDigestInfo(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestInfo", reflect.TypeOf((*MockUniversalClient)(nil).TDigestInfo), ctx, key) +} + +// TDigestMax mocks base method. +func (m *MockUniversalClient) TDigestMax(ctx context.Context, key string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestMax", ctx, key) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// TDigestMax indicates an expected call of TDigestMax. +func (mr *MockUniversalClientMockRecorder) TDigestMax(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMax", reflect.TypeOf((*MockUniversalClient)(nil).TDigestMax), ctx, key) +} + +// TDigestMerge mocks base method. +func (m *MockUniversalClient) TDigestMerge(ctx context.Context, destKey string, options *redis.TDigestMergeOptions, sourceKeys ...string) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, destKey, options} + for _, a := range sourceKeys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestMerge", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestMerge indicates an expected call of TDigestMerge. +func (mr *MockUniversalClientMockRecorder) TDigestMerge(ctx, destKey, options interface{}, sourceKeys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, destKey, options}, sourceKeys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMerge", reflect.TypeOf((*MockUniversalClient)(nil).TDigestMerge), varargs...) +} + +// TDigestMin mocks base method. +func (m *MockUniversalClient) TDigestMin(ctx context.Context, key string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestMin", ctx, key) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// TDigestMin indicates an expected call of TDigestMin. +func (mr *MockUniversalClientMockRecorder) TDigestMin(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMin", reflect.TypeOf((*MockUniversalClient)(nil).TDigestMin), ctx, key) +} + +// TDigestQuantile mocks base method. +func (m *MockUniversalClient) TDigestQuantile(ctx context.Context, key string, elements ...float64) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestQuantile", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// TDigestQuantile indicates an expected call of TDigestQuantile. +func (mr *MockUniversalClientMockRecorder) TDigestQuantile(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestQuantile", reflect.TypeOf((*MockUniversalClient)(nil).TDigestQuantile), varargs...) +} + +// TDigestRank mocks base method. +func (m *MockUniversalClient) TDigestRank(ctx context.Context, key string, values ...float64) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestRank", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// TDigestRank indicates an expected call of TDigestRank. +func (mr *MockUniversalClientMockRecorder) TDigestRank(ctx, key interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestRank", reflect.TypeOf((*MockUniversalClient)(nil).TDigestRank), varargs...) +} + +// TDigestReset mocks base method. +func (m *MockUniversalClient) TDigestReset(ctx context.Context, key string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestReset", ctx, key) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestReset indicates an expected call of TDigestReset. +func (mr *MockUniversalClientMockRecorder) TDigestReset(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestReset", reflect.TypeOf((*MockUniversalClient)(nil).TDigestReset), ctx, key) +} + +// TDigestRevRank mocks base method. +func (m *MockUniversalClient) TDigestRevRank(ctx context.Context, key string, values ...float64) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range values { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestRevRank", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// TDigestRevRank indicates an expected call of TDigestRevRank. +func (mr *MockUniversalClientMockRecorder) TDigestRevRank(ctx, key interface{}, values ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, values...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestRevRank", reflect.TypeOf((*MockUniversalClient)(nil).TDigestRevRank), varargs...) +} + +// TDigestTrimmedMean mocks base method. +func (m *MockUniversalClient) TDigestTrimmedMean(ctx context.Context, key string, lowCutQuantile, highCutQuantile float64) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestTrimmedMean", ctx, key, lowCutQuantile, highCutQuantile) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// TDigestTrimmedMean indicates an expected call of TDigestTrimmedMean. +func (mr *MockUniversalClientMockRecorder) TDigestTrimmedMean(ctx, key, lowCutQuantile, highCutQuantile interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestTrimmedMean", reflect.TypeOf((*MockUniversalClient)(nil).TDigestTrimmedMean), ctx, key, lowCutQuantile, highCutQuantile) +} + +// TFCall mocks base method. +func (m *MockUniversalClient) TFCall(ctx context.Context, libName, funcName string, numKeys int) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCall", ctx, libName, funcName, numKeys) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCall indicates an expected call of TFCall. +func (mr *MockUniversalClientMockRecorder) TFCall(ctx, libName, funcName, numKeys interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCall", reflect.TypeOf((*MockUniversalClient)(nil).TFCall), ctx, libName, funcName, numKeys) +} + +// TFCallASYNC mocks base method. +func (m *MockUniversalClient) TFCallASYNC(ctx context.Context, libName, funcName string, numKeys int) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCallASYNC", ctx, libName, funcName, numKeys) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCallASYNC indicates an expected call of TFCallASYNC. +func (mr *MockUniversalClientMockRecorder) TFCallASYNC(ctx, libName, funcName, numKeys interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallASYNC", reflect.TypeOf((*MockUniversalClient)(nil).TFCallASYNC), ctx, libName, funcName, numKeys) +} + +// TFCallASYNCArgs mocks base method. +func (m *MockUniversalClient) TFCallASYNCArgs(ctx context.Context, libName, funcName string, numKeys int, options *redis.TFCallOptions) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCallASYNCArgs", ctx, libName, funcName, numKeys, options) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCallASYNCArgs indicates an expected call of TFCallASYNCArgs. +func (mr *MockUniversalClientMockRecorder) TFCallASYNCArgs(ctx, libName, funcName, numKeys, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallASYNCArgs", reflect.TypeOf((*MockUniversalClient)(nil).TFCallASYNCArgs), ctx, libName, funcName, numKeys, options) +} + +// TFCallArgs mocks base method. +func (m *MockUniversalClient) TFCallArgs(ctx context.Context, libName, funcName string, numKeys int, options *redis.TFCallOptions) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCallArgs", ctx, libName, funcName, numKeys, options) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCallArgs indicates an expected call of TFCallArgs. +func (mr *MockUniversalClientMockRecorder) TFCallArgs(ctx, libName, funcName, numKeys, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallArgs", reflect.TypeOf((*MockUniversalClient)(nil).TFCallArgs), ctx, libName, funcName, numKeys, options) +} + +// TFunctionDelete mocks base method. +func (m *MockUniversalClient) TFunctionDelete(ctx context.Context, libName string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionDelete", ctx, libName) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TFunctionDelete indicates an expected call of TFunctionDelete. +func (mr *MockUniversalClientMockRecorder) TFunctionDelete(ctx, libName interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionDelete", reflect.TypeOf((*MockUniversalClient)(nil).TFunctionDelete), ctx, libName) +} + +// TFunctionList mocks base method. +func (m *MockUniversalClient) TFunctionList(ctx context.Context) *redis.MapStringInterfaceSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionList", ctx) + ret0, _ := ret[0].(*redis.MapStringInterfaceSliceCmd) + return ret0 +} + +// TFunctionList indicates an expected call of TFunctionList. +func (mr *MockUniversalClientMockRecorder) TFunctionList(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionList", reflect.TypeOf((*MockUniversalClient)(nil).TFunctionList), ctx) +} + +// TFunctionListArgs mocks base method. +func (m *MockUniversalClient) TFunctionListArgs(ctx context.Context, options *redis.TFunctionListOptions) *redis.MapStringInterfaceSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionListArgs", ctx, options) + ret0, _ := ret[0].(*redis.MapStringInterfaceSliceCmd) + return ret0 +} + +// TFunctionListArgs indicates an expected call of TFunctionListArgs. +func (mr *MockUniversalClientMockRecorder) TFunctionListArgs(ctx, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionListArgs", reflect.TypeOf((*MockUniversalClient)(nil).TFunctionListArgs), ctx, options) +} + +// TFunctionLoad mocks base method. +func (m *MockUniversalClient) TFunctionLoad(ctx context.Context, lib string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionLoad", ctx, lib) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TFunctionLoad indicates an expected call of TFunctionLoad. +func (mr *MockUniversalClientMockRecorder) TFunctionLoad(ctx, lib interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionLoad", reflect.TypeOf((*MockUniversalClient)(nil).TFunctionLoad), ctx, lib) +} + +// TFunctionLoadArgs mocks base method. +func (m *MockUniversalClient) TFunctionLoadArgs(ctx context.Context, lib string, options *redis.TFunctionLoadOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionLoadArgs", ctx, lib, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TFunctionLoadArgs indicates an expected call of TFunctionLoadArgs. +func (mr *MockUniversalClientMockRecorder) TFunctionLoadArgs(ctx, lib, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionLoadArgs", reflect.TypeOf((*MockUniversalClient)(nil).TFunctionLoadArgs), ctx, lib, options) +} + +// TSAdd mocks base method. +func (m *MockUniversalClient) TSAdd(ctx context.Context, key string, timestamp interface{}, value float64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSAdd", ctx, key, timestamp, value) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// TSAdd indicates an expected call of TSAdd. +func (mr *MockUniversalClientMockRecorder) TSAdd(ctx, key, timestamp, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSAdd", reflect.TypeOf((*MockUniversalClient)(nil).TSAdd), ctx, key, timestamp, value) +} + +// TSAddWithArgs mocks base method. +func (m *MockUniversalClient) TSAddWithArgs(ctx context.Context, key string, timestamp interface{}, value float64, options *redis.TSOptions) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSAddWithArgs", ctx, key, timestamp, value, options) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// TSAddWithArgs indicates an expected call of TSAddWithArgs. +func (mr *MockUniversalClientMockRecorder) TSAddWithArgs(ctx, key, timestamp, value, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSAddWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSAddWithArgs), ctx, key, timestamp, value, options) +} + +// TSAlter mocks base method. +func (m *MockUniversalClient) TSAlter(ctx context.Context, key string, options *redis.TSAlterOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSAlter", ctx, key, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TSAlter indicates an expected call of TSAlter. +func (mr *MockUniversalClientMockRecorder) TSAlter(ctx, key, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSAlter", reflect.TypeOf((*MockUniversalClient)(nil).TSAlter), ctx, key, options) +} + +// TSCreate mocks base method. +func (m *MockUniversalClient) TSCreate(ctx context.Context, key string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSCreate", ctx, key) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TSCreate indicates an expected call of TSCreate. +func (mr *MockUniversalClientMockRecorder) TSCreate(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreate", reflect.TypeOf((*MockUniversalClient)(nil).TSCreate), ctx, key) +} + +// TSCreateRule mocks base method. +func (m *MockUniversalClient) TSCreateRule(ctx context.Context, sourceKey, destKey string, aggregator redis.Aggregator, bucketDuration int) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSCreateRule", ctx, sourceKey, destKey, aggregator, bucketDuration) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TSCreateRule indicates an expected call of TSCreateRule. +func (mr *MockUniversalClientMockRecorder) TSCreateRule(ctx, sourceKey, destKey, aggregator, bucketDuration interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreateRule", reflect.TypeOf((*MockUniversalClient)(nil).TSCreateRule), ctx, sourceKey, destKey, aggregator, bucketDuration) +} + +// TSCreateRuleWithArgs mocks base method. +func (m *MockUniversalClient) TSCreateRuleWithArgs(ctx context.Context, sourceKey, destKey string, aggregator redis.Aggregator, bucketDuration int, options *redis.TSCreateRuleOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSCreateRuleWithArgs", ctx, sourceKey, destKey, aggregator, bucketDuration, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TSCreateRuleWithArgs indicates an expected call of TSCreateRuleWithArgs. +func (mr *MockUniversalClientMockRecorder) TSCreateRuleWithArgs(ctx, sourceKey, destKey, aggregator, bucketDuration, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreateRuleWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSCreateRuleWithArgs), ctx, sourceKey, destKey, aggregator, bucketDuration, options) +} + +// TSCreateWithArgs mocks base method. +func (m *MockUniversalClient) TSCreateWithArgs(ctx context.Context, key string, options *redis.TSOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSCreateWithArgs", ctx, key, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TSCreateWithArgs indicates an expected call of TSCreateWithArgs. +func (mr *MockUniversalClientMockRecorder) TSCreateWithArgs(ctx, key, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreateWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSCreateWithArgs), ctx, key, options) +} + +// TSDecrBy mocks base method. +func (m *MockUniversalClient) TSDecrBy(ctx context.Context, Key string, timestamp float64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSDecrBy", ctx, Key, timestamp) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// TSDecrBy indicates an expected call of TSDecrBy. +func (mr *MockUniversalClientMockRecorder) TSDecrBy(ctx, Key, timestamp interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDecrBy", reflect.TypeOf((*MockUniversalClient)(nil).TSDecrBy), ctx, Key, timestamp) +} + +// TSDecrByWithArgs mocks base method. +func (m *MockUniversalClient) TSDecrByWithArgs(ctx context.Context, key string, timestamp float64, options *redis.TSIncrDecrOptions) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSDecrByWithArgs", ctx, key, timestamp, options) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// TSDecrByWithArgs indicates an expected call of TSDecrByWithArgs. +func (mr *MockUniversalClientMockRecorder) TSDecrByWithArgs(ctx, key, timestamp, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDecrByWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSDecrByWithArgs), ctx, key, timestamp, options) +} + +// TSDel mocks base method. +func (m *MockUniversalClient) TSDel(ctx context.Context, Key string, fromTimestamp, toTimestamp int) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSDel", ctx, Key, fromTimestamp, toTimestamp) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// TSDel indicates an expected call of TSDel. +func (mr *MockUniversalClientMockRecorder) TSDel(ctx, Key, fromTimestamp, toTimestamp interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDel", reflect.TypeOf((*MockUniversalClient)(nil).TSDel), ctx, Key, fromTimestamp, toTimestamp) +} + +// TSDeleteRule mocks base method. +func (m *MockUniversalClient) TSDeleteRule(ctx context.Context, sourceKey, destKey string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSDeleteRule", ctx, sourceKey, destKey) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TSDeleteRule indicates an expected call of TSDeleteRule. +func (mr *MockUniversalClientMockRecorder) TSDeleteRule(ctx, sourceKey, destKey interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDeleteRule", reflect.TypeOf((*MockUniversalClient)(nil).TSDeleteRule), ctx, sourceKey, destKey) +} + +// TSGet mocks base method. +func (m *MockUniversalClient) TSGet(ctx context.Context, key string) *redis.TSTimestampValueCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSGet", ctx, key) + ret0, _ := ret[0].(*redis.TSTimestampValueCmd) + return ret0 +} + +// TSGet indicates an expected call of TSGet. +func (mr *MockUniversalClientMockRecorder) TSGet(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSGet", reflect.TypeOf((*MockUniversalClient)(nil).TSGet), ctx, key) +} + +// TSGetWithArgs mocks base method. +func (m *MockUniversalClient) TSGetWithArgs(ctx context.Context, key string, options *redis.TSGetOptions) *redis.TSTimestampValueCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSGetWithArgs", ctx, key, options) + ret0, _ := ret[0].(*redis.TSTimestampValueCmd) + return ret0 +} + +// TSGetWithArgs indicates an expected call of TSGetWithArgs. +func (mr *MockUniversalClientMockRecorder) TSGetWithArgs(ctx, key, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSGetWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSGetWithArgs), ctx, key, options) +} + +// TSIncrBy mocks base method. +func (m *MockUniversalClient) TSIncrBy(ctx context.Context, Key string, timestamp float64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSIncrBy", ctx, Key, timestamp) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// TSIncrBy indicates an expected call of TSIncrBy. +func (mr *MockUniversalClientMockRecorder) TSIncrBy(ctx, Key, timestamp interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSIncrBy", reflect.TypeOf((*MockUniversalClient)(nil).TSIncrBy), ctx, Key, timestamp) +} + +// TSIncrByWithArgs mocks base method. +func (m *MockUniversalClient) TSIncrByWithArgs(ctx context.Context, key string, timestamp float64, options *redis.TSIncrDecrOptions) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSIncrByWithArgs", ctx, key, timestamp, options) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// TSIncrByWithArgs indicates an expected call of TSIncrByWithArgs. +func (mr *MockUniversalClientMockRecorder) TSIncrByWithArgs(ctx, key, timestamp, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSIncrByWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSIncrByWithArgs), ctx, key, timestamp, options) +} + +// TSInfo mocks base method. +func (m *MockUniversalClient) TSInfo(ctx context.Context, key string) *redis.MapStringInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSInfo", ctx, key) + ret0, _ := ret[0].(*redis.MapStringInterfaceCmd) + return ret0 +} + +// TSInfo indicates an expected call of TSInfo. +func (mr *MockUniversalClientMockRecorder) TSInfo(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSInfo", reflect.TypeOf((*MockUniversalClient)(nil).TSInfo), ctx, key) +} + +// TSInfoWithArgs mocks base method. +func (m *MockUniversalClient) TSInfoWithArgs(ctx context.Context, key string, options *redis.TSInfoOptions) *redis.MapStringInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSInfoWithArgs", ctx, key, options) + ret0, _ := ret[0].(*redis.MapStringInterfaceCmd) + return ret0 +} + +// TSInfoWithArgs indicates an expected call of TSInfoWithArgs. +func (mr *MockUniversalClientMockRecorder) TSInfoWithArgs(ctx, key, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSInfoWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSInfoWithArgs), ctx, key, options) +} + +// TSMAdd mocks base method. +func (m *MockUniversalClient) TSMAdd(ctx context.Context, ktvSlices [][]interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSMAdd", ctx, ktvSlices) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// TSMAdd indicates an expected call of TSMAdd. +func (mr *MockUniversalClientMockRecorder) TSMAdd(ctx, ktvSlices interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMAdd", reflect.TypeOf((*MockUniversalClient)(nil).TSMAdd), ctx, ktvSlices) +} + +// TSMGet mocks base method. +func (m *MockUniversalClient) TSMGet(ctx context.Context, filters []string) *redis.MapStringSliceInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSMGet", ctx, filters) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) + return ret0 +} + +// TSMGet indicates an expected call of TSMGet. +func (mr *MockUniversalClientMockRecorder) TSMGet(ctx, filters interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMGet", reflect.TypeOf((*MockUniversalClient)(nil).TSMGet), ctx, filters) +} + +// TSMGetWithArgs mocks base method. +func (m *MockUniversalClient) TSMGetWithArgs(ctx context.Context, filters []string, options *redis.TSMGetOptions) *redis.MapStringSliceInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSMGetWithArgs", ctx, filters, options) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) + return ret0 +} + +// TSMGetWithArgs indicates an expected call of TSMGetWithArgs. +func (mr *MockUniversalClientMockRecorder) TSMGetWithArgs(ctx, filters, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMGetWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSMGetWithArgs), ctx, filters, options) +} + +// TSMRange mocks base method. +func (m *MockUniversalClient) TSMRange(ctx context.Context, fromTimestamp, toTimestamp int, filterExpr []string) *redis.MapStringSliceInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSMRange", ctx, fromTimestamp, toTimestamp, filterExpr) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) + return ret0 +} + +// TSMRange indicates an expected call of TSMRange. +func (mr *MockUniversalClientMockRecorder) TSMRange(ctx, fromTimestamp, toTimestamp, filterExpr interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRange", reflect.TypeOf((*MockUniversalClient)(nil).TSMRange), ctx, fromTimestamp, toTimestamp, filterExpr) +} + +// TSMRangeWithArgs mocks base method. +func (m *MockUniversalClient) TSMRangeWithArgs(ctx context.Context, fromTimestamp, toTimestamp int, filterExpr []string, options *redis.TSMRangeOptions) *redis.MapStringSliceInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSMRangeWithArgs", ctx, fromTimestamp, toTimestamp, filterExpr, options) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) + return ret0 +} + +// TSMRangeWithArgs indicates an expected call of TSMRangeWithArgs. +func (mr *MockUniversalClientMockRecorder) TSMRangeWithArgs(ctx, fromTimestamp, toTimestamp, filterExpr, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRangeWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSMRangeWithArgs), ctx, fromTimestamp, toTimestamp, filterExpr, options) +} + +// TSMRevRange mocks base method. +func (m *MockUniversalClient) TSMRevRange(ctx context.Context, fromTimestamp, toTimestamp int, filterExpr []string) *redis.MapStringSliceInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSMRevRange", ctx, fromTimestamp, toTimestamp, filterExpr) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) + return ret0 +} + +// TSMRevRange indicates an expected call of TSMRevRange. +func (mr *MockUniversalClientMockRecorder) TSMRevRange(ctx, fromTimestamp, toTimestamp, filterExpr interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRevRange", reflect.TypeOf((*MockUniversalClient)(nil).TSMRevRange), ctx, fromTimestamp, toTimestamp, filterExpr) +} + +// TSMRevRangeWithArgs mocks base method. +func (m *MockUniversalClient) TSMRevRangeWithArgs(ctx context.Context, fromTimestamp, toTimestamp int, filterExpr []string, options *redis.TSMRevRangeOptions) *redis.MapStringSliceInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSMRevRangeWithArgs", ctx, fromTimestamp, toTimestamp, filterExpr, options) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) + return ret0 +} + +// TSMRevRangeWithArgs indicates an expected call of TSMRevRangeWithArgs. +func (mr *MockUniversalClientMockRecorder) TSMRevRangeWithArgs(ctx, fromTimestamp, toTimestamp, filterExpr, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRevRangeWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSMRevRangeWithArgs), ctx, fromTimestamp, toTimestamp, filterExpr, options) +} + +// TSQueryIndex mocks base method. +func (m *MockUniversalClient) TSQueryIndex(ctx context.Context, filterExpr []string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSQueryIndex", ctx, filterExpr) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// TSQueryIndex indicates an expected call of TSQueryIndex. +func (mr *MockUniversalClientMockRecorder) TSQueryIndex(ctx, filterExpr interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSQueryIndex", reflect.TypeOf((*MockUniversalClient)(nil).TSQueryIndex), ctx, filterExpr) +} + +// TSRange mocks base method. +func (m *MockUniversalClient) TSRange(ctx context.Context, key string, fromTimestamp, toTimestamp int) *redis.TSTimestampValueSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSRange", ctx, key, fromTimestamp, toTimestamp) + ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd) + return ret0 +} + +// TSRange indicates an expected call of TSRange. +func (mr *MockUniversalClientMockRecorder) TSRange(ctx, key, fromTimestamp, toTimestamp interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRange", reflect.TypeOf((*MockUniversalClient)(nil).TSRange), ctx, key, fromTimestamp, toTimestamp) +} + +// TSRangeWithArgs mocks base method. +func (m *MockUniversalClient) TSRangeWithArgs(ctx context.Context, key string, fromTimestamp, toTimestamp int, options *redis.TSRangeOptions) *redis.TSTimestampValueSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSRangeWithArgs", ctx, key, fromTimestamp, toTimestamp, options) + ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd) + return ret0 +} + +// TSRangeWithArgs indicates an expected call of TSRangeWithArgs. +func (mr *MockUniversalClientMockRecorder) TSRangeWithArgs(ctx, key, fromTimestamp, toTimestamp, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRangeWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSRangeWithArgs), ctx, key, fromTimestamp, toTimestamp, options) +} + +// TSRevRange mocks base method. +func (m *MockUniversalClient) TSRevRange(ctx context.Context, key string, fromTimestamp, toTimestamp int) *redis.TSTimestampValueSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSRevRange", ctx, key, fromTimestamp, toTimestamp) + ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd) + return ret0 +} + +// TSRevRange indicates an expected call of TSRevRange. +func (mr *MockUniversalClientMockRecorder) TSRevRange(ctx, key, fromTimestamp, toTimestamp interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRevRange", reflect.TypeOf((*MockUniversalClient)(nil).TSRevRange), ctx, key, fromTimestamp, toTimestamp) +} + +// TSRevRangeWithArgs mocks base method. +func (m *MockUniversalClient) TSRevRangeWithArgs(ctx context.Context, key string, fromTimestamp, toTimestamp int, options *redis.TSRevRangeOptions) *redis.TSTimestampValueSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSRevRangeWithArgs", ctx, key, fromTimestamp, toTimestamp, options) + ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd) + return ret0 +} + +// TSRevRangeWithArgs indicates an expected call of TSRevRangeWithArgs. +func (mr *MockUniversalClientMockRecorder) TSRevRangeWithArgs(ctx, key, fromTimestamp, toTimestamp, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRevRangeWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSRevRangeWithArgs), ctx, key, fromTimestamp, toTimestamp, options) +} + +// TTL mocks base method. +func (m *MockUniversalClient) TTL(ctx context.Context, key string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TTL", ctx, key) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// TTL indicates an expected call of TTL. +func (mr *MockUniversalClientMockRecorder) TTL(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TTL", reflect.TypeOf((*MockUniversalClient)(nil).TTL), ctx, key) +} + +// Time mocks base method. +func (m *MockUniversalClient) Time(ctx context.Context) *redis.TimeCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Time", ctx) + ret0, _ := ret[0].(*redis.TimeCmd) + return ret0 +} + +// Time indicates an expected call of Time. +func (mr *MockUniversalClientMockRecorder) Time(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Time", reflect.TypeOf((*MockUniversalClient)(nil).Time), ctx) +} + +// TopKAdd mocks base method. +func (m *MockUniversalClient) TopKAdd(ctx context.Context, key string, elements ...interface{}) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TopKAdd", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// TopKAdd indicates an expected call of TopKAdd. +func (mr *MockUniversalClientMockRecorder) TopKAdd(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKAdd", reflect.TypeOf((*MockUniversalClient)(nil).TopKAdd), varargs...) +} + +// TopKCount mocks base method. +func (m *MockUniversalClient) TopKCount(ctx context.Context, key string, elements ...interface{}) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TopKCount", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// TopKCount indicates an expected call of TopKCount. +func (mr *MockUniversalClientMockRecorder) TopKCount(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKCount", reflect.TypeOf((*MockUniversalClient)(nil).TopKCount), varargs...) +} + +// TopKIncrBy mocks base method. +func (m *MockUniversalClient) TopKIncrBy(ctx context.Context, key string, elements ...interface{}) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TopKIncrBy", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// TopKIncrBy indicates an expected call of TopKIncrBy. +func (mr *MockUniversalClientMockRecorder) TopKIncrBy(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKIncrBy", reflect.TypeOf((*MockUniversalClient)(nil).TopKIncrBy), varargs...) +} + +// TopKInfo mocks base method. +func (m *MockUniversalClient) TopKInfo(ctx context.Context, key string) *redis.TopKInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKInfo", ctx, key) + ret0, _ := ret[0].(*redis.TopKInfoCmd) + return ret0 +} + +// TopKInfo indicates an expected call of TopKInfo. +func (mr *MockUniversalClientMockRecorder) TopKInfo(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKInfo", reflect.TypeOf((*MockUniversalClient)(nil).TopKInfo), ctx, key) +} + +// TopKList mocks base method. +func (m *MockUniversalClient) TopKList(ctx context.Context, key string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKList", ctx, key) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// TopKList indicates an expected call of TopKList. +func (mr *MockUniversalClientMockRecorder) TopKList(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKList", reflect.TypeOf((*MockUniversalClient)(nil).TopKList), ctx, key) +} + +// TopKListWithCount mocks base method. +func (m *MockUniversalClient) TopKListWithCount(ctx context.Context, key string) *redis.MapStringIntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKListWithCount", ctx, key) + ret0, _ := ret[0].(*redis.MapStringIntCmd) + return ret0 +} + +// TopKListWithCount indicates an expected call of TopKListWithCount. +func (mr *MockUniversalClientMockRecorder) TopKListWithCount(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKListWithCount", reflect.TypeOf((*MockUniversalClient)(nil).TopKListWithCount), ctx, key) +} + +// TopKQuery mocks base method. +func (m *MockUniversalClient) TopKQuery(ctx context.Context, key string, elements ...interface{}) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range elements { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TopKQuery", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// TopKQuery indicates an expected call of TopKQuery. +func (mr *MockUniversalClientMockRecorder) TopKQuery(ctx, key interface{}, elements ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, elements...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKQuery", reflect.TypeOf((*MockUniversalClient)(nil).TopKQuery), varargs...) +} + +// TopKReserve mocks base method. +func (m *MockUniversalClient) TopKReserve(ctx context.Context, key string, k int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKReserve", ctx, key, k) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TopKReserve indicates an expected call of TopKReserve. +func (mr *MockUniversalClientMockRecorder) TopKReserve(ctx, key, k interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKReserve", reflect.TypeOf((*MockUniversalClient)(nil).TopKReserve), ctx, key, k) +} + +// TopKReserveWithOptions mocks base method. +func (m *MockUniversalClient) TopKReserveWithOptions(ctx context.Context, key string, k, width, depth int64, decay float64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKReserveWithOptions", ctx, key, k, width, depth, decay) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TopKReserveWithOptions indicates an expected call of TopKReserveWithOptions. +func (mr *MockUniversalClientMockRecorder) TopKReserveWithOptions(ctx, key, k, width, depth, decay interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKReserveWithOptions", reflect.TypeOf((*MockUniversalClient)(nil).TopKReserveWithOptions), ctx, key, k, width, depth, decay) +} + +// Touch mocks base method. +func (m *MockUniversalClient) Touch(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Touch", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Touch indicates an expected call of Touch. +func (mr *MockUniversalClientMockRecorder) Touch(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Touch", reflect.TypeOf((*MockUniversalClient)(nil).Touch), varargs...) +} + +// TxPipeline mocks base method. +func (m *MockUniversalClient) TxPipeline() redis.Pipeliner { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TxPipeline") + ret0, _ := ret[0].(redis.Pipeliner) + return ret0 +} + +// TxPipeline indicates an expected call of TxPipeline. +func (mr *MockUniversalClientMockRecorder) TxPipeline() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipeline", reflect.TypeOf((*MockUniversalClient)(nil).TxPipeline)) +} + +// TxPipelined mocks base method. +func (m *MockUniversalClient) TxPipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TxPipelined", ctx, fn) + ret0, _ := ret[0].([]redis.Cmder) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TxPipelined indicates an expected call of TxPipelined. +func (mr *MockUniversalClientMockRecorder) TxPipelined(ctx, fn interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipelined", reflect.TypeOf((*MockUniversalClient)(nil).TxPipelined), ctx, fn) +} + +// Type mocks base method. +func (m *MockUniversalClient) Type(ctx context.Context, key string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Type", ctx, key) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Type indicates an expected call of Type. +func (mr *MockUniversalClientMockRecorder) Type(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockUniversalClient)(nil).Type), ctx, key) +} + +// Unlink mocks base method. +func (m *MockUniversalClient) Unlink(ctx context.Context, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Unlink", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Unlink indicates an expected call of Unlink. +func (mr *MockUniversalClientMockRecorder) Unlink(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unlink", reflect.TypeOf((*MockUniversalClient)(nil).Unlink), varargs...) +} + +// Watch mocks base method. +func (m *MockUniversalClient) Watch(ctx context.Context, fn func(*redis.Tx) error, keys ...string) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, fn} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Watch", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// Watch indicates an expected call of Watch. +func (mr *MockUniversalClientMockRecorder) Watch(ctx, fn interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, fn}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockUniversalClient)(nil).Watch), varargs...) +} + +// XAck mocks base method. +func (m *MockUniversalClient) XAck(ctx context.Context, stream, group string, ids ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, stream, group} + for _, a := range ids { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "XAck", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XAck indicates an expected call of XAck. +func (mr *MockUniversalClientMockRecorder) XAck(ctx, stream, group interface{}, ids ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, stream, group}, ids...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAck", reflect.TypeOf((*MockUniversalClient)(nil).XAck), varargs...) +} + +// XAdd mocks base method. +func (m *MockUniversalClient) XAdd(ctx context.Context, a *redis.XAddArgs) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XAdd", ctx, a) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// XAdd indicates an expected call of XAdd. +func (mr *MockUniversalClientMockRecorder) XAdd(ctx, a interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAdd", reflect.TypeOf((*MockUniversalClient)(nil).XAdd), ctx, a) +} + +// XAutoClaim mocks base method. +func (m *MockUniversalClient) XAutoClaim(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XAutoClaim", ctx, a) + ret0, _ := ret[0].(*redis.XAutoClaimCmd) + return ret0 +} + +// XAutoClaim indicates an expected call of XAutoClaim. +func (mr *MockUniversalClientMockRecorder) XAutoClaim(ctx, a interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaim", reflect.TypeOf((*MockUniversalClient)(nil).XAutoClaim), ctx, a) +} + +// XAutoClaimJustID mocks base method. +func (m *MockUniversalClient) XAutoClaimJustID(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimJustIDCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XAutoClaimJustID", ctx, a) + ret0, _ := ret[0].(*redis.XAutoClaimJustIDCmd) + return ret0 +} + +// XAutoClaimJustID indicates an expected call of XAutoClaimJustID. +func (mr *MockUniversalClientMockRecorder) XAutoClaimJustID(ctx, a interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaimJustID", reflect.TypeOf((*MockUniversalClient)(nil).XAutoClaimJustID), ctx, a) +} + +// XClaim mocks base method. +func (m *MockUniversalClient) XClaim(ctx context.Context, a *redis.XClaimArgs) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XClaim", ctx, a) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XClaim indicates an expected call of XClaim. +func (mr *MockUniversalClientMockRecorder) XClaim(ctx, a interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaim", reflect.TypeOf((*MockUniversalClient)(nil).XClaim), ctx, a) +} + +// XClaimJustID mocks base method. +func (m *MockUniversalClient) XClaimJustID(ctx context.Context, a *redis.XClaimArgs) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XClaimJustID", ctx, a) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// XClaimJustID indicates an expected call of XClaimJustID. +func (mr *MockUniversalClientMockRecorder) XClaimJustID(ctx, a interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaimJustID", reflect.TypeOf((*MockUniversalClient)(nil).XClaimJustID), ctx, a) +} + +// XDel mocks base method. +func (m *MockUniversalClient) XDel(ctx context.Context, stream string, ids ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, stream} + for _, a := range ids { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "XDel", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XDel indicates an expected call of XDel. +func (mr *MockUniversalClientMockRecorder) XDel(ctx, stream interface{}, ids ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, stream}, ids...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XDel", reflect.TypeOf((*MockUniversalClient)(nil).XDel), varargs...) +} + +// XGroupCreate mocks base method. +func (m *MockUniversalClient) XGroupCreate(ctx context.Context, stream, group, start string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupCreate", ctx, stream, group, start) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// XGroupCreate indicates an expected call of XGroupCreate. +func (mr *MockUniversalClientMockRecorder) XGroupCreate(ctx, stream, group, start interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreate", reflect.TypeOf((*MockUniversalClient)(nil).XGroupCreate), ctx, stream, group, start) +} + +// XGroupCreateConsumer mocks base method. +func (m *MockUniversalClient) XGroupCreateConsumer(ctx context.Context, stream, group, consumer string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupCreateConsumer", ctx, stream, group, consumer) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XGroupCreateConsumer indicates an expected call of XGroupCreateConsumer. +func (mr *MockUniversalClientMockRecorder) XGroupCreateConsumer(ctx, stream, group, consumer interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreateConsumer", reflect.TypeOf((*MockUniversalClient)(nil).XGroupCreateConsumer), ctx, stream, group, consumer) +} + +// XGroupCreateMkStream mocks base method. +func (m *MockUniversalClient) XGroupCreateMkStream(ctx context.Context, stream, group, start string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupCreateMkStream", ctx, stream, group, start) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// XGroupCreateMkStream indicates an expected call of XGroupCreateMkStream. +func (mr *MockUniversalClientMockRecorder) XGroupCreateMkStream(ctx, stream, group, start interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreateMkStream", reflect.TypeOf((*MockUniversalClient)(nil).XGroupCreateMkStream), ctx, stream, group, start) +} + +// XGroupDelConsumer mocks base method. +func (m *MockUniversalClient) XGroupDelConsumer(ctx context.Context, stream, group, consumer string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupDelConsumer", ctx, stream, group, consumer) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XGroupDelConsumer indicates an expected call of XGroupDelConsumer. +func (mr *MockUniversalClientMockRecorder) XGroupDelConsumer(ctx, stream, group, consumer interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDelConsumer", reflect.TypeOf((*MockUniversalClient)(nil).XGroupDelConsumer), ctx, stream, group, consumer) +} + +// XGroupDestroy mocks base method. +func (m *MockUniversalClient) XGroupDestroy(ctx context.Context, stream, group string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupDestroy", ctx, stream, group) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XGroupDestroy indicates an expected call of XGroupDestroy. +func (mr *MockUniversalClientMockRecorder) XGroupDestroy(ctx, stream, group interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDestroy", reflect.TypeOf((*MockUniversalClient)(nil).XGroupDestroy), ctx, stream, group) +} + +// XGroupSetID mocks base method. +func (m *MockUniversalClient) XGroupSetID(ctx context.Context, stream, group, start string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupSetID", ctx, stream, group, start) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// XGroupSetID indicates an expected call of XGroupSetID. +func (mr *MockUniversalClientMockRecorder) XGroupSetID(ctx, stream, group, start interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupSetID", reflect.TypeOf((*MockUniversalClient)(nil).XGroupSetID), ctx, stream, group, start) +} + +// XInfoConsumers mocks base method. +func (m *MockUniversalClient) XInfoConsumers(ctx context.Context, key, group string) *redis.XInfoConsumersCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XInfoConsumers", ctx, key, group) + ret0, _ := ret[0].(*redis.XInfoConsumersCmd) + return ret0 +} + +// XInfoConsumers indicates an expected call of XInfoConsumers. +func (mr *MockUniversalClientMockRecorder) XInfoConsumers(ctx, key, group interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoConsumers", reflect.TypeOf((*MockUniversalClient)(nil).XInfoConsumers), ctx, key, group) +} + +// XInfoGroups mocks base method. +func (m *MockUniversalClient) XInfoGroups(ctx context.Context, key string) *redis.XInfoGroupsCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XInfoGroups", ctx, key) + ret0, _ := ret[0].(*redis.XInfoGroupsCmd) + return ret0 +} + +// XInfoGroups indicates an expected call of XInfoGroups. +func (mr *MockUniversalClientMockRecorder) XInfoGroups(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoGroups", reflect.TypeOf((*MockUniversalClient)(nil).XInfoGroups), ctx, key) +} + +// XInfoStream mocks base method. +func (m *MockUniversalClient) XInfoStream(ctx context.Context, key string) *redis.XInfoStreamCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XInfoStream", ctx, key) + ret0, _ := ret[0].(*redis.XInfoStreamCmd) + return ret0 +} + +// XInfoStream indicates an expected call of XInfoStream. +func (mr *MockUniversalClientMockRecorder) XInfoStream(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoStream", reflect.TypeOf((*MockUniversalClient)(nil).XInfoStream), ctx, key) +} + +// XInfoStreamFull mocks base method. +func (m *MockUniversalClient) XInfoStreamFull(ctx context.Context, key string, count int) *redis.XInfoStreamFullCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XInfoStreamFull", ctx, key, count) + ret0, _ := ret[0].(*redis.XInfoStreamFullCmd) + return ret0 +} + +// XInfoStreamFull indicates an expected call of XInfoStreamFull. +func (mr *MockUniversalClientMockRecorder) XInfoStreamFull(ctx, key, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoStreamFull", reflect.TypeOf((*MockUniversalClient)(nil).XInfoStreamFull), ctx, key, count) +} + +// XLen mocks base method. +func (m *MockUniversalClient) XLen(ctx context.Context, stream string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XLen", ctx, stream) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XLen indicates an expected call of XLen. +func (mr *MockUniversalClientMockRecorder) XLen(ctx, stream interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XLen", reflect.TypeOf((*MockUniversalClient)(nil).XLen), ctx, stream) +} + +// XPending mocks base method. +func (m *MockUniversalClient) XPending(ctx context.Context, stream, group string) *redis.XPendingCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XPending", ctx, stream, group) + ret0, _ := ret[0].(*redis.XPendingCmd) + return ret0 +} + +// XPending indicates an expected call of XPending. +func (mr *MockUniversalClientMockRecorder) XPending(ctx, stream, group interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPending", reflect.TypeOf((*MockUniversalClient)(nil).XPending), ctx, stream, group) +} + +// XPendingExt mocks base method. +func (m *MockUniversalClient) XPendingExt(ctx context.Context, a *redis.XPendingExtArgs) *redis.XPendingExtCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XPendingExt", ctx, a) + ret0, _ := ret[0].(*redis.XPendingExtCmd) + return ret0 +} + +// XPendingExt indicates an expected call of XPendingExt. +func (mr *MockUniversalClientMockRecorder) XPendingExt(ctx, a interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPendingExt", reflect.TypeOf((*MockUniversalClient)(nil).XPendingExt), ctx, a) +} + +// XRange mocks base method. +func (m *MockUniversalClient) XRange(ctx context.Context, stream, start, stop string) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRange", ctx, stream, start, stop) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XRange indicates an expected call of XRange. +func (mr *MockUniversalClientMockRecorder) XRange(ctx, stream, start, stop interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRange", reflect.TypeOf((*MockUniversalClient)(nil).XRange), ctx, stream, start, stop) +} + +// XRangeN mocks base method. +func (m *MockUniversalClient) XRangeN(ctx context.Context, stream, start, stop string, count int64) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRangeN", ctx, stream, start, stop, count) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XRangeN indicates an expected call of XRangeN. +func (mr *MockUniversalClientMockRecorder) XRangeN(ctx, stream, start, stop, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRangeN", reflect.TypeOf((*MockUniversalClient)(nil).XRangeN), ctx, stream, start, stop, count) +} + +// XRead mocks base method. +func (m *MockUniversalClient) XRead(ctx context.Context, a *redis.XReadArgs) *redis.XStreamSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRead", ctx, a) + ret0, _ := ret[0].(*redis.XStreamSliceCmd) + return ret0 +} + +// XRead indicates an expected call of XRead. +func (mr *MockUniversalClientMockRecorder) XRead(ctx, a interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRead", reflect.TypeOf((*MockUniversalClient)(nil).XRead), ctx, a) +} + +// XReadGroup mocks base method. +func (m *MockUniversalClient) XReadGroup(ctx context.Context, a *redis.XReadGroupArgs) *redis.XStreamSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XReadGroup", ctx, a) + ret0, _ := ret[0].(*redis.XStreamSliceCmd) + return ret0 +} + +// XReadGroup indicates an expected call of XReadGroup. +func (mr *MockUniversalClientMockRecorder) XReadGroup(ctx, a interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XReadGroup", reflect.TypeOf((*MockUniversalClient)(nil).XReadGroup), ctx, a) +} + +// XReadStreams mocks base method. +func (m *MockUniversalClient) XReadStreams(ctx context.Context, streams ...string) *redis.XStreamSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range streams { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "XReadStreams", varargs...) + ret0, _ := ret[0].(*redis.XStreamSliceCmd) + return ret0 +} + +// XReadStreams indicates an expected call of XReadStreams. +func (mr *MockUniversalClientMockRecorder) XReadStreams(ctx interface{}, streams ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, streams...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XReadStreams", reflect.TypeOf((*MockUniversalClient)(nil).XReadStreams), varargs...) +} + +// XRevRange mocks base method. +func (m *MockUniversalClient) XRevRange(ctx context.Context, stream, start, stop string) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRevRange", ctx, stream, start, stop) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XRevRange indicates an expected call of XRevRange. +func (mr *MockUniversalClientMockRecorder) XRevRange(ctx, stream, start, stop interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRevRange", reflect.TypeOf((*MockUniversalClient)(nil).XRevRange), ctx, stream, start, stop) +} + +// XRevRangeN mocks base method. +func (m *MockUniversalClient) XRevRangeN(ctx context.Context, stream, start, stop string, count int64) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRevRangeN", ctx, stream, start, stop, count) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XRevRangeN indicates an expected call of XRevRangeN. +func (mr *MockUniversalClientMockRecorder) XRevRangeN(ctx, stream, start, stop, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRevRangeN", reflect.TypeOf((*MockUniversalClient)(nil).XRevRangeN), ctx, stream, start, stop, count) +} + +// XTrimMaxLen mocks base method. +func (m *MockUniversalClient) XTrimMaxLen(ctx context.Context, key string, maxLen int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XTrimMaxLen", ctx, key, maxLen) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XTrimMaxLen indicates an expected call of XTrimMaxLen. +func (mr *MockUniversalClientMockRecorder) XTrimMaxLen(ctx, key, maxLen interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLen", reflect.TypeOf((*MockUniversalClient)(nil).XTrimMaxLen), ctx, key, maxLen) +} + +// XTrimMaxLenApprox mocks base method. +func (m *MockUniversalClient) XTrimMaxLenApprox(ctx context.Context, key string, maxLen, limit int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XTrimMaxLenApprox", ctx, key, maxLen, limit) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XTrimMaxLenApprox indicates an expected call of XTrimMaxLenApprox. +func (mr *MockUniversalClientMockRecorder) XTrimMaxLenApprox(ctx, key, maxLen, limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLenApprox", reflect.TypeOf((*MockUniversalClient)(nil).XTrimMaxLenApprox), ctx, key, maxLen, limit) +} + +// XTrimMinID mocks base method. +func (m *MockUniversalClient) XTrimMinID(ctx context.Context, key, minID string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XTrimMinID", ctx, key, minID) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XTrimMinID indicates an expected call of XTrimMinID. +func (mr *MockUniversalClientMockRecorder) XTrimMinID(ctx, key, minID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinID", reflect.TypeOf((*MockUniversalClient)(nil).XTrimMinID), ctx, key, minID) +} + +// XTrimMinIDApprox mocks base method. +func (m *MockUniversalClient) XTrimMinIDApprox(ctx context.Context, key, minID string, limit int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XTrimMinIDApprox", ctx, key, minID, limit) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XTrimMinIDApprox indicates an expected call of XTrimMinIDApprox. +func (mr *MockUniversalClientMockRecorder) XTrimMinIDApprox(ctx, key, minID, limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinIDApprox", reflect.TypeOf((*MockUniversalClient)(nil).XTrimMinIDApprox), ctx, key, minID, limit) +} + +// ZAdd mocks base method. +func (m *MockUniversalClient) ZAdd(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAdd indicates an expected call of ZAdd. +func (mr *MockUniversalClientMockRecorder) ZAdd(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAdd", reflect.TypeOf((*MockUniversalClient)(nil).ZAdd), varargs...) +} + +// ZAddArgs mocks base method. +func (m *MockUniversalClient) ZAddArgs(ctx context.Context, key string, args redis.ZAddArgs) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZAddArgs", ctx, key, args) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddArgs indicates an expected call of ZAddArgs. +func (mr *MockUniversalClientMockRecorder) ZAddArgs(ctx, key, args interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgs", reflect.TypeOf((*MockUniversalClient)(nil).ZAddArgs), ctx, key, args) +} + +// ZAddArgsIncr mocks base method. +func (m *MockUniversalClient) ZAddArgsIncr(ctx context.Context, key string, args redis.ZAddArgs) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZAddArgsIncr", ctx, key, args) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// ZAddArgsIncr indicates an expected call of ZAddArgsIncr. +func (mr *MockUniversalClientMockRecorder) ZAddArgsIncr(ctx, key, args interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgsIncr", reflect.TypeOf((*MockUniversalClient)(nil).ZAddArgsIncr), ctx, key, args) +} + +// ZAddGT mocks base method. +func (m *MockUniversalClient) ZAddGT(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAddGT", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddGT indicates an expected call of ZAddGT. +func (mr *MockUniversalClientMockRecorder) ZAddGT(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddGT", reflect.TypeOf((*MockUniversalClient)(nil).ZAddGT), varargs...) +} + +// ZAddLT mocks base method. +func (m *MockUniversalClient) ZAddLT(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAddLT", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddLT indicates an expected call of ZAddLT. +func (mr *MockUniversalClientMockRecorder) ZAddLT(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddLT", reflect.TypeOf((*MockUniversalClient)(nil).ZAddLT), varargs...) +} + +// ZAddNX mocks base method. +func (m *MockUniversalClient) ZAddNX(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAddNX", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddNX indicates an expected call of ZAddNX. +func (mr *MockUniversalClientMockRecorder) ZAddNX(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddNX", reflect.TypeOf((*MockUniversalClient)(nil).ZAddNX), varargs...) +} + +// ZAddXX mocks base method. +func (m *MockUniversalClient) ZAddXX(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAddXX", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddXX indicates an expected call of ZAddXX. +func (mr *MockUniversalClientMockRecorder) ZAddXX(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddXX", reflect.TypeOf((*MockUniversalClient)(nil).ZAddXX), varargs...) +} + +// ZCard mocks base method. +func (m *MockUniversalClient) ZCard(ctx context.Context, key string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZCard", ctx, key) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZCard indicates an expected call of ZCard. +func (mr *MockUniversalClientMockRecorder) ZCard(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZCard", reflect.TypeOf((*MockUniversalClient)(nil).ZCard), ctx, key) +} + +// ZCount mocks base method. +func (m *MockUniversalClient) ZCount(ctx context.Context, key, min, max string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZCount", ctx, key, min, max) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZCount indicates an expected call of ZCount. +func (mr *MockUniversalClientMockRecorder) ZCount(ctx, key, min, max interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZCount", reflect.TypeOf((*MockUniversalClient)(nil).ZCount), ctx, key, min, max) +} + +// ZDiff mocks base method. +func (m *MockUniversalClient) ZDiff(ctx context.Context, keys ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZDiff", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZDiff indicates an expected call of ZDiff. +func (mr *MockUniversalClientMockRecorder) ZDiff(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiff", reflect.TypeOf((*MockUniversalClient)(nil).ZDiff), varargs...) +} + +// ZDiffStore mocks base method. +func (m *MockUniversalClient) ZDiffStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, destination} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZDiffStore", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZDiffStore indicates an expected call of ZDiffStore. +func (mr *MockUniversalClientMockRecorder) ZDiffStore(ctx, destination interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, destination}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiffStore", reflect.TypeOf((*MockUniversalClient)(nil).ZDiffStore), varargs...) +} + +// ZDiffWithScores mocks base method. +func (m *MockUniversalClient) ZDiffWithScores(ctx context.Context, keys ...string) *redis.ZSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZDiffWithScores", varargs...) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZDiffWithScores indicates an expected call of ZDiffWithScores. +func (mr *MockUniversalClientMockRecorder) ZDiffWithScores(ctx interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiffWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZDiffWithScores), varargs...) +} + +// ZIncrBy mocks base method. +func (m *MockUniversalClient) ZIncrBy(ctx context.Context, key string, increment float64, member string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZIncrBy", ctx, key, increment, member) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// ZIncrBy indicates an expected call of ZIncrBy. +func (mr *MockUniversalClientMockRecorder) ZIncrBy(ctx, key, increment, member interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZIncrBy", reflect.TypeOf((*MockUniversalClient)(nil).ZIncrBy), ctx, key, increment, member) +} + +// ZInter mocks base method. +func (m *MockUniversalClient) ZInter(ctx context.Context, store *redis.ZStore) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZInter", ctx, store) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZInter indicates an expected call of ZInter. +func (mr *MockUniversalClientMockRecorder) ZInter(ctx, store interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInter", reflect.TypeOf((*MockUniversalClient)(nil).ZInter), ctx, store) +} + +// ZInterCard mocks base method. +func (m *MockUniversalClient) ZInterCard(ctx context.Context, limit int64, keys ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, limit} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZInterCard", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZInterCard indicates an expected call of ZInterCard. +func (mr *MockUniversalClientMockRecorder) ZInterCard(ctx, limit interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, limit}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterCard", reflect.TypeOf((*MockUniversalClient)(nil).ZInterCard), varargs...) +} + +// ZInterStore mocks base method. +func (m *MockUniversalClient) ZInterStore(ctx context.Context, destination string, store *redis.ZStore) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZInterStore", ctx, destination, store) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZInterStore indicates an expected call of ZInterStore. +func (mr *MockUniversalClientMockRecorder) ZInterStore(ctx, destination, store interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterStore", reflect.TypeOf((*MockUniversalClient)(nil).ZInterStore), ctx, destination, store) +} + +// ZInterWithScores mocks base method. +func (m *MockUniversalClient) ZInterWithScores(ctx context.Context, store *redis.ZStore) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZInterWithScores", ctx, store) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZInterWithScores indicates an expected call of ZInterWithScores. +func (mr *MockUniversalClientMockRecorder) ZInterWithScores(ctx, store interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZInterWithScores), ctx, store) +} + +// ZLexCount mocks base method. +func (m *MockUniversalClient) ZLexCount(ctx context.Context, key, min, max string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZLexCount", ctx, key, min, max) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZLexCount indicates an expected call of ZLexCount. +func (mr *MockUniversalClientMockRecorder) ZLexCount(ctx, key, min, max interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZLexCount", reflect.TypeOf((*MockUniversalClient)(nil).ZLexCount), ctx, key, min, max) +} + +// ZMPop mocks base method. +func (m *MockUniversalClient) ZMPop(ctx context.Context, order string, count int64, keys ...string) *redis.ZSliceWithKeyCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, order, count} + for _, a := range keys { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZMPop", varargs...) + ret0, _ := ret[0].(*redis.ZSliceWithKeyCmd) + return ret0 +} + +// ZMPop indicates an expected call of ZMPop. +func (mr *MockUniversalClientMockRecorder) ZMPop(ctx, order, count interface{}, keys ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, order, count}, keys...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZMPop", reflect.TypeOf((*MockUniversalClient)(nil).ZMPop), varargs...) +} + +// ZMScore mocks base method. +func (m *MockUniversalClient) ZMScore(ctx context.Context, key string, members ...string) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZMScore", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// ZMScore indicates an expected call of ZMScore. +func (mr *MockUniversalClientMockRecorder) ZMScore(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZMScore", reflect.TypeOf((*MockUniversalClient)(nil).ZMScore), varargs...) +} + +// ZPopMax mocks base method. +func (m *MockUniversalClient) ZPopMax(ctx context.Context, key string, count ...int64) *redis.ZSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range count { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZPopMax", varargs...) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZPopMax indicates an expected call of ZPopMax. +func (mr *MockUniversalClientMockRecorder) ZPopMax(ctx, key interface{}, count ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, count...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZPopMax", reflect.TypeOf((*MockUniversalClient)(nil).ZPopMax), varargs...) +} + +// ZPopMin mocks base method. +func (m *MockUniversalClient) ZPopMin(ctx context.Context, key string, count ...int64) *redis.ZSliceCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range count { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZPopMin", varargs...) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZPopMin indicates an expected call of ZPopMin. +func (mr *MockUniversalClientMockRecorder) ZPopMin(ctx, key interface{}, count ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, count...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZPopMin", reflect.TypeOf((*MockUniversalClient)(nil).ZPopMin), varargs...) +} + +// ZRandMember mocks base method. +func (m *MockUniversalClient) ZRandMember(ctx context.Context, key string, count int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRandMember", ctx, key, count) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRandMember indicates an expected call of ZRandMember. +func (mr *MockUniversalClientMockRecorder) ZRandMember(ctx, key, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMember", reflect.TypeOf((*MockUniversalClient)(nil).ZRandMember), ctx, key, count) +} + +// ZRandMemberWithScores mocks base method. +func (m *MockUniversalClient) ZRandMemberWithScores(ctx context.Context, key string, count int) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRandMemberWithScores", ctx, key, count) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRandMemberWithScores indicates an expected call of ZRandMemberWithScores. +func (mr *MockUniversalClientMockRecorder) ZRandMemberWithScores(ctx, key, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMemberWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZRandMemberWithScores), ctx, key, count) +} + +// ZRange mocks base method. +func (m *MockUniversalClient) ZRange(ctx context.Context, key string, start, stop int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRange", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRange indicates an expected call of ZRange. +func (mr *MockUniversalClientMockRecorder) ZRange(ctx, key, start, stop interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRange", reflect.TypeOf((*MockUniversalClient)(nil).ZRange), ctx, key, start, stop) +} + +// ZRangeArgs mocks base method. +func (m *MockUniversalClient) ZRangeArgs(ctx context.Context, z redis.ZRangeArgs) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeArgs", ctx, z) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRangeArgs indicates an expected call of ZRangeArgs. +func (mr *MockUniversalClientMockRecorder) ZRangeArgs(ctx, z interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgs", reflect.TypeOf((*MockUniversalClient)(nil).ZRangeArgs), ctx, z) +} + +// ZRangeArgsWithScores mocks base method. +func (m *MockUniversalClient) ZRangeArgsWithScores(ctx context.Context, z redis.ZRangeArgs) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeArgsWithScores", ctx, z) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRangeArgsWithScores indicates an expected call of ZRangeArgsWithScores. +func (mr *MockUniversalClientMockRecorder) ZRangeArgsWithScores(ctx, z interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgsWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZRangeArgsWithScores), ctx, z) +} + +// ZRangeByLex mocks base method. +func (m *MockUniversalClient) ZRangeByLex(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeByLex", ctx, key, opt) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRangeByLex indicates an expected call of ZRangeByLex. +func (mr *MockUniversalClientMockRecorder) ZRangeByLex(ctx, key, opt interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByLex", reflect.TypeOf((*MockUniversalClient)(nil).ZRangeByLex), ctx, key, opt) +} + +// ZRangeByScore mocks base method. +func (m *MockUniversalClient) ZRangeByScore(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeByScore", ctx, key, opt) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRangeByScore indicates an expected call of ZRangeByScore. +func (mr *MockUniversalClientMockRecorder) ZRangeByScore(ctx, key, opt interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScore", reflect.TypeOf((*MockUniversalClient)(nil).ZRangeByScore), ctx, key, opt) +} + +// ZRangeByScoreWithScores mocks base method. +func (m *MockUniversalClient) ZRangeByScoreWithScores(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeByScoreWithScores", ctx, key, opt) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRangeByScoreWithScores indicates an expected call of ZRangeByScoreWithScores. +func (mr *MockUniversalClientMockRecorder) ZRangeByScoreWithScores(ctx, key, opt interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScoreWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZRangeByScoreWithScores), ctx, key, opt) +} + +// ZRangeStore mocks base method. +func (m *MockUniversalClient) ZRangeStore(ctx context.Context, dst string, z redis.ZRangeArgs) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeStore", ctx, dst, z) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRangeStore indicates an expected call of ZRangeStore. +func (mr *MockUniversalClientMockRecorder) ZRangeStore(ctx, dst, z interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeStore", reflect.TypeOf((*MockUniversalClient)(nil).ZRangeStore), ctx, dst, z) +} + +// ZRangeWithScores mocks base method. +func (m *MockUniversalClient) ZRangeWithScores(ctx context.Context, key string, start, stop int64) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeWithScores", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRangeWithScores indicates an expected call of ZRangeWithScores. +func (mr *MockUniversalClientMockRecorder) ZRangeWithScores(ctx, key, start, stop interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZRangeWithScores), ctx, key, start, stop) +} + +// ZRank mocks base method. +func (m *MockUniversalClient) ZRank(ctx context.Context, key, member string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRank", ctx, key, member) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRank indicates an expected call of ZRank. +func (mr *MockUniversalClientMockRecorder) ZRank(ctx, key, member interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRank", reflect.TypeOf((*MockUniversalClient)(nil).ZRank), ctx, key, member) +} + +// ZRankWithScore mocks base method. +func (m *MockUniversalClient) ZRankWithScore(ctx context.Context, key, member string) *redis.RankWithScoreCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRankWithScore", ctx, key, member) + ret0, _ := ret[0].(*redis.RankWithScoreCmd) + return ret0 +} + +// ZRankWithScore indicates an expected call of ZRankWithScore. +func (mr *MockUniversalClientMockRecorder) ZRankWithScore(ctx, key, member interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRankWithScore", reflect.TypeOf((*MockUniversalClient)(nil).ZRankWithScore), ctx, key, member) +} + +// ZRem mocks base method. +func (m *MockUniversalClient) ZRem(ctx context.Context, key string, members ...interface{}) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range members { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZRem", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRem indicates an expected call of ZRem. +func (mr *MockUniversalClientMockRecorder) ZRem(ctx, key interface{}, members ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, members...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRem", reflect.TypeOf((*MockUniversalClient)(nil).ZRem), varargs...) +} + +// ZRemRangeByLex mocks base method. +func (m *MockUniversalClient) ZRemRangeByLex(ctx context.Context, key, min, max string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRemRangeByLex", ctx, key, min, max) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRemRangeByLex indicates an expected call of ZRemRangeByLex. +func (mr *MockUniversalClientMockRecorder) ZRemRangeByLex(ctx, key, min, max interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByLex", reflect.TypeOf((*MockUniversalClient)(nil).ZRemRangeByLex), ctx, key, min, max) +} + +// ZRemRangeByRank mocks base method. +func (m *MockUniversalClient) ZRemRangeByRank(ctx context.Context, key string, start, stop int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRemRangeByRank", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRemRangeByRank indicates an expected call of ZRemRangeByRank. +func (mr *MockUniversalClientMockRecorder) ZRemRangeByRank(ctx, key, start, stop interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByRank", reflect.TypeOf((*MockUniversalClient)(nil).ZRemRangeByRank), ctx, key, start, stop) +} + +// ZRemRangeByScore mocks base method. +func (m *MockUniversalClient) ZRemRangeByScore(ctx context.Context, key, min, max string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRemRangeByScore", ctx, key, min, max) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRemRangeByScore indicates an expected call of ZRemRangeByScore. +func (mr *MockUniversalClientMockRecorder) ZRemRangeByScore(ctx, key, min, max interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByScore", reflect.TypeOf((*MockUniversalClient)(nil).ZRemRangeByScore), ctx, key, min, max) +} + +// ZRevRange mocks base method. +func (m *MockUniversalClient) ZRevRange(ctx context.Context, key string, start, stop int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRange", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRevRange indicates an expected call of ZRevRange. +func (mr *MockUniversalClientMockRecorder) ZRevRange(ctx, key, start, stop interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRange", reflect.TypeOf((*MockUniversalClient)(nil).ZRevRange), ctx, key, start, stop) +} + +// ZRevRangeByLex mocks base method. +func (m *MockUniversalClient) ZRevRangeByLex(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRangeByLex", ctx, key, opt) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRevRangeByLex indicates an expected call of ZRevRangeByLex. +func (mr *MockUniversalClientMockRecorder) ZRevRangeByLex(ctx, key, opt interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByLex", reflect.TypeOf((*MockUniversalClient)(nil).ZRevRangeByLex), ctx, key, opt) +} + +// ZRevRangeByScore mocks base method. +func (m *MockUniversalClient) ZRevRangeByScore(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRangeByScore", ctx, key, opt) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRevRangeByScore indicates an expected call of ZRevRangeByScore. +func (mr *MockUniversalClientMockRecorder) ZRevRangeByScore(ctx, key, opt interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScore", reflect.TypeOf((*MockUniversalClient)(nil).ZRevRangeByScore), ctx, key, opt) +} + +// ZRevRangeByScoreWithScores mocks base method. +func (m *MockUniversalClient) ZRevRangeByScoreWithScores(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRangeByScoreWithScores", ctx, key, opt) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRevRangeByScoreWithScores indicates an expected call of ZRevRangeByScoreWithScores. +func (mr *MockUniversalClientMockRecorder) ZRevRangeByScoreWithScores(ctx, key, opt interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScoreWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZRevRangeByScoreWithScores), ctx, key, opt) +} + +// ZRevRangeWithScores mocks base method. +func (m *MockUniversalClient) ZRevRangeWithScores(ctx context.Context, key string, start, stop int64) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRangeWithScores", ctx, key, start, stop) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRevRangeWithScores indicates an expected call of ZRevRangeWithScores. +func (mr *MockUniversalClientMockRecorder) ZRevRangeWithScores(ctx, key, start, stop interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZRevRangeWithScores), ctx, key, start, stop) +} + +// ZRevRank mocks base method. +func (m *MockUniversalClient) ZRevRank(ctx context.Context, key, member string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRank", ctx, key, member) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRevRank indicates an expected call of ZRevRank. +func (mr *MockUniversalClientMockRecorder) ZRevRank(ctx, key, member interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRank", reflect.TypeOf((*MockUniversalClient)(nil).ZRevRank), ctx, key, member) +} + +// ZRevRankWithScore mocks base method. +func (m *MockUniversalClient) ZRevRankWithScore(ctx context.Context, key, member string) *redis.RankWithScoreCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRankWithScore", ctx, key, member) + ret0, _ := ret[0].(*redis.RankWithScoreCmd) + return ret0 +} + +// ZRevRankWithScore indicates an expected call of ZRevRankWithScore. +func (mr *MockUniversalClientMockRecorder) ZRevRankWithScore(ctx, key, member interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRankWithScore", reflect.TypeOf((*MockUniversalClient)(nil).ZRevRankWithScore), ctx, key, member) +} + +// ZScan mocks base method. +func (m *MockUniversalClient) ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZScan", ctx, key, cursor, match, count) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// ZScan indicates an expected call of ZScan. +func (mr *MockUniversalClientMockRecorder) ZScan(ctx, key, cursor, match, count interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZScan", reflect.TypeOf((*MockUniversalClient)(nil).ZScan), ctx, key, cursor, match, count) +} + +// ZScore mocks base method. +func (m *MockUniversalClient) ZScore(ctx context.Context, key, member string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZScore", ctx, key, member) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// ZScore indicates an expected call of ZScore. +func (mr *MockUniversalClientMockRecorder) ZScore(ctx, key, member interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZScore", reflect.TypeOf((*MockUniversalClient)(nil).ZScore), ctx, key, member) +} + +// ZUnion mocks base method. +func (m *MockUniversalClient) ZUnion(ctx context.Context, store redis.ZStore) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZUnion", ctx, store) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZUnion indicates an expected call of ZUnion. +func (mr *MockUniversalClientMockRecorder) ZUnion(ctx, store interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnion", reflect.TypeOf((*MockUniversalClient)(nil).ZUnion), ctx, store) +} + +// ZUnionStore mocks base method. +func (m *MockUniversalClient) ZUnionStore(ctx context.Context, dest string, store *redis.ZStore) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZUnionStore", ctx, dest, store) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZUnionStore indicates an expected call of ZUnionStore. +func (mr *MockUniversalClientMockRecorder) ZUnionStore(ctx, dest, store interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionStore", reflect.TypeOf((*MockUniversalClient)(nil).ZUnionStore), ctx, dest, store) +} + +// ZUnionWithScores mocks base method. +func (m *MockUniversalClient) ZUnionWithScores(ctx context.Context, store redis.ZStore) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZUnionWithScores", ctx, store) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZUnionWithScores indicates an expected call of ZUnionWithScores. +func (mr *MockUniversalClientMockRecorder) ZUnionWithScores(ctx, store interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZUnionWithScores), ctx, store) +} diff --git a/redis/cluster/redis.go b/redis/cluster/redis.go new file mode 100644 index 0000000..a8265b8 --- /dev/null +++ b/redis/cluster/redis.go @@ -0,0 +1,182 @@ +/* + * Copyright (c) 2016 TFG Co + * Author: TFG Co + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + * the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +package cluster + +import ( + "context" + "fmt" + "strings" + + "github.com/redis/go-redis/extra/redisotel/v9" + "github.com/redis/go-redis/v9" + "github.com/spf13/viper" +) + +// Client identifies uniquely one redis client with a pool of connections +type Client struct { + Instance redis.UniversalClient + ClusterMode bool +} + +type ClientArgs struct { + Url string + ClusterMode bool + EnableMetrics bool + EnableTracing bool +} + +// NewClient creates and returns a new redis client based on the given settings. It only supports redis 7 engine and uses go-redis v9. +func NewClient(args *ClientArgs) (*Client, error) { + if args == nil { + return nil, fmt.Errorf("NewClient must have a non-nil args") + } + + client := &Client{ + ClusterMode: args.ClusterMode, + } + + if args.ClusterMode { + if err := client.ConnectCluster(args.Url); err != nil { + return nil, err + } + } else { + if err := client.Connect(args.Url); err != nil { + return nil, err + } + } + + if args.EnableTracing { + if err := redisotel.InstrumentTracing(client.Instance); err != nil { + return nil, err + } + } + + if args.EnableMetrics { + if err := redisotel.InstrumentMetrics(client.Instance); err != nil { + return nil, err + } + } + + return client, nil +} + +// NewClientFromConfig creates and returns a new redis client based on the given settings from predefined env vars. It only supports redis 7 engine and uses go-redis v9. +func NewClientFromConfig(config *viper.Viper, prefix string) (*Client, error) { + if config == nil { + return nil, fmt.Errorf("NewClientFromConfig must have a non-nil config") + } + + args := CreateClientArgs(config, prefix) + + return NewClient(args) +} + +func CreateClientArgs(config *viper.Viper, prefix string) *ClientArgs { + url := config.GetString(fmt.Sprintf("%s.url", prefix)) + + if url == "" { + tls := config.GetBool(fmt.Sprintf("%s.tls", prefix)) + + endpoint := config.GetString(fmt.Sprintf("%s.endpoint", prefix)) + port := config.GetString(fmt.Sprintf("%s.port", prefix)) + pass := config.GetString(fmt.Sprintf("%s.password", prefix)) + + var baseUrl string + if tls { + baseUrl = "rediss://" + } else { + baseUrl = "redis://" + } + + url = fmt.Sprintf("%s:%s@%s:%s", baseUrl, pass, endpoint, port) + } + + clusterMode := config.GetBool(fmt.Sprintf("%s.clusterMode", prefix)) + enableMetrics := config.GetBool(fmt.Sprintf("%s.enableMetrics", prefix)) + enableTracing := config.GetBool(fmt.Sprintf("%s.enableTracing", prefix)) + + // Extra parameters + var queryParameters []string + maxRedirects := config.GetString(fmt.Sprintf("%s.maxRedirects", prefix)) + if maxRedirects != "" { + queryParameters = append(queryParameters, fmt.Sprintf("max_redirects=%s", maxRedirects)) + } + + poolSize := config.GetString(fmt.Sprintf("%s.poolSize", prefix)) + if poolSize != "" { + queryParameters = append(queryParameters, fmt.Sprintf("pool_size=%s", poolSize)) + } + + readTimeout := config.GetString(fmt.Sprintf("%s.timeout", prefix)) + if readTimeout != "" { + queryParameters = append(queryParameters, fmt.Sprintf("read_timeout=%s", readTimeout)) + } + + if len(queryParameters) > 0 { + url = fmt.Sprintf("%s?%s", url, strings.Join(queryParameters, "&")) + } + + return &ClientArgs{ + ClusterMode: clusterMode, + Url: url, + EnableMetrics: enableMetrics, + EnableTracing: enableTracing, + } +} + +// Connect to Redis +func (c *Client) Connect(url string) error { + opts, err := redis.ParseURL(url) + if err != nil { + return err + } + + c.Instance = redis.NewClient(opts) + + return nil +} + +// ConnectCluster to Redis cluster +func (c *Client) ConnectCluster(url string) error { + opts, err := redis.ParseClusterURL(url) + if err != nil { + return err + } + + c.Instance = redis.NewClusterClient(opts) + + return nil +} + +// IsConnected determines if the client is connected to redis +func (c *Client) IsConnected(ctx context.Context) (bool, error) { + result := c.Instance.Ping(ctx) + if result != nil { + res, err := result.Result() + if err != nil { + return false, err + } + return res == "PONG", nil + } + return true, nil +}