MockHandler is a mock of Handler interface.

Field name	Field type	Comment
ctrl	*gomock.Controller	No comment on field.
recorder	*MockHandlerMockRecorder	No comment on field.

type MockHandler struct {
	ctrl		*gomock.Controller
	recorder	*MockHandlerMockRecorder
}

MockHandlerMockRecorder is the mock recorder for MockHandler.

Field name	Field type	Comment
mock	*MockHandler	No comment on field.

type MockHandlerMockRecorder struct {
	mock *MockHandler
}

NewMockHandler creates a new mock instance.

func NewMockHandler(ctrl *gomock.Controller) *MockHandler {
	mock := &MockHandler{ctrl: ctrl}
	mock.recorder = &MockHandlerMockRecorder{mock}
	return mock
}

Cognitive complexity: 2, Cyclomatic complexity: 1

AddToSet mocks base method.

func (m *MockHandler) AddToSet(arg0, arg1 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddToSet", arg0, arg1)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

AddToSortedSet mocks base method.

func (m *MockHandler) AddToSortedSet(arg0, arg1 string, arg2 float64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddToSortedSet", arg0, arg1, arg2)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

AppendToSet mocks base method.

func (m *MockHandler) AppendToSet(arg0, arg1 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendToSet", arg0, arg1)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Connect mocks base method.

func (m *MockHandler) Connect() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Connect")
	ret0, _ := ret[0].(bool)
	return ret0
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Decrement mocks base method.

func (m *MockHandler) Decrement(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Decrement", arg0)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

DeleteAllKeys mocks base method.

func (m *MockHandler) DeleteAllKeys() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAllKeys")
	ret0, _ := ret[0].(bool)
	return ret0
}

Cognitive complexity: 0, Cyclomatic complexity: 1

DeleteKey mocks base method.

func (m *MockHandler) DeleteKey(arg0 string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteKey", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

Cognitive complexity: 0, Cyclomatic complexity: 1

DeleteKeys mocks base method.

func (m *MockHandler) DeleteKeys(arg0 []string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteKeys", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

Cognitive complexity: 0, Cyclomatic complexity: 1

DeleteRawKey mocks base method.

func (m *MockHandler) DeleteRawKey(arg0 string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRawKey", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

Cognitive complexity: 0, Cyclomatic complexity: 1

DeleteRawKeys mocks base method.

func (m *MockHandler) DeleteRawKeys(arg0 []string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRawKeys", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

Cognitive complexity: 0, Cyclomatic complexity: 1

DeleteScanMatch mocks base method.

func (m *MockHandler) DeleteScanMatch(arg0 string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteScanMatch", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

Cognitive complexity: 0, Cyclomatic complexity: 1

EXPECT returns an object that allows the caller to indicate expected use.

func (m *MockHandler) EXPECT() *MockHandlerMockRecorder {
	return m.recorder
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Exists mocks base method.

func (m *MockHandler) Exists(arg0 string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Exists", arg0)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

Cognitive complexity: 0, Cyclomatic complexity: 1

GetAndDeleteSet mocks base method.

func (m *MockHandler) GetAndDeleteSet(arg0 string) []any {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAndDeleteSet", arg0)
	ret0, _ := ret[0].([]any)
	return ret0
}

Cognitive complexity: 0, Cyclomatic complexity: 1

GetExp mocks base method.

func (m *MockHandler) GetExp(arg0 string) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExp", arg0)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

Cognitive complexity: 0, Cyclomatic complexity: 1

GetKey mocks base method.

func (m *MockHandler) GetKey(arg0 string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetKey", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

Cognitive complexity: 0, Cyclomatic complexity: 1

GetKeyPrefix mocks base method.

func (m *MockHandler) GetKeyPrefix() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetKeyPrefix")
	ret0, _ := ret[0].(string)
	return ret0
}

Cognitive complexity: 0, Cyclomatic complexity: 1

GetKeys mocks base method.

func (m *MockHandler) GetKeys(arg0 string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetKeys", arg0)
	ret0, _ := ret[0].([]string)
	return ret0
}

Cognitive complexity: 0, Cyclomatic complexity: 1

GetKeysAndValues mocks base method.

func (m *MockHandler) GetKeysAndValues() map[string]string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetKeysAndValues")
	ret0, _ := ret[0].(map[string]string)
	return ret0
}

Cognitive complexity: 0, Cyclomatic complexity: 1

GetKeysAndValuesWithFilter mocks base method.

func (m *MockHandler) GetKeysAndValuesWithFilter(arg0 string) map[string]string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetKeysAndValuesWithFilter", arg0)
	ret0, _ := ret[0].(map[string]string)
	return ret0
}

Cognitive complexity: 0, Cyclomatic complexity: 1

GetListRange mocks base method.

func (m *MockHandler) GetListRange(arg0 string, arg1, arg2 int64) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetListRange", arg0, arg1, arg2)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

Cognitive complexity: 0, Cyclomatic complexity: 1

GetMultiKey mocks base method.

func (m *MockHandler) GetMultiKey(arg0 []string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMultiKey", arg0)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

Cognitive complexity: 0, Cyclomatic complexity: 1

GetRawKey mocks base method.

func (m *MockHandler) GetRawKey(arg0 string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRawKey", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

Cognitive complexity: 0, Cyclomatic complexity: 1

GetRollingWindow mocks base method.

func (m *MockHandler) GetRollingWindow(arg0 string, arg1 int64, arg2 bool) (int, []any) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRollingWindow", arg0, arg1, arg2)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].([]any)
	return ret0, ret1
}

Cognitive complexity: 0, Cyclomatic complexity: 1

GetSet mocks base method.

func (m *MockHandler) GetSet(arg0 string) (map[string]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSet", arg0)
	ret0, _ := ret[0].(map[string]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

Cognitive complexity: 0, Cyclomatic complexity: 1

GetSortedSetRange mocks base method.

func (m *MockHandler) GetSortedSetRange(arg0, arg1, arg2 string) ([]string, []float64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSortedSetRange", arg0, arg1, arg2)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].([]float64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

Cognitive complexity: 0, Cyclomatic complexity: 1

IncrememntWithExpire mocks base method.

func (m *MockHandler) IncrememntWithExpire(arg0 string, arg1 int64) int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncrememntWithExpire", arg0, arg1)
	ret0, _ := ret[0].(int64)
	return ret0
}

Cognitive complexity: 0, Cyclomatic complexity: 1

RemoveFromList mocks base method.

func (m *MockHandler) RemoveFromList(arg0, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveFromList", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

Cognitive complexity: 0, Cyclomatic complexity: 1

RemoveFromSet mocks base method.

func (m *MockHandler) RemoveFromSet(arg0, arg1 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RemoveFromSet", arg0, arg1)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

RemoveSortedSetRange mocks base method.

func (m *MockHandler) RemoveSortedSetRange(arg0, arg1, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveSortedSetRange", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

Cognitive complexity: 0, Cyclomatic complexity: 1

SetExp mocks base method.

func (m *MockHandler) SetExp(arg0 string, arg1 int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetExp", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

Cognitive complexity: 0, Cyclomatic complexity: 1

SetKey mocks base method.

func (m *MockHandler) SetKey(arg0, arg1 string, arg2 int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetKey", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

Cognitive complexity: 0, Cyclomatic complexity: 1

SetRawKey mocks base method.

func (m *MockHandler) SetRawKey(arg0, arg1 string, arg2 int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetRawKey", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

Cognitive complexity: 0, Cyclomatic complexity: 1

SetRollingWindow mocks base method.

func (m *MockHandler) SetRollingWindow(arg0 string, arg1 int64, arg2 string, arg3 bool) (int, []any) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetRollingWindow", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].([]any)
	return ret0, ret1
}

Cognitive complexity: 0, Cyclomatic complexity: 1

AddToSet indicates an expected call of AddToSet.

func (mr *MockHandlerMockRecorder) AddToSet(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddToSet", reflect.TypeOf((*MockHandler)(nil).AddToSet), arg0, arg1)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

AddToSortedSet indicates an expected call of AddToSortedSet.

func (mr *MockHandlerMockRecorder) AddToSortedSet(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddToSortedSet", reflect.TypeOf((*MockHandler)(nil).AddToSortedSet), arg0, arg1, arg2)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

AppendToSet indicates an expected call of AppendToSet.

func (mr *MockHandlerMockRecorder) AppendToSet(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendToSet", reflect.TypeOf((*MockHandler)(nil).AppendToSet), arg0, arg1)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

Connect indicates an expected call of Connect.

func (mr *MockHandlerMockRecorder) Connect() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connect", reflect.TypeOf((*MockHandler)(nil).Connect))
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

Decrement indicates an expected call of Decrement.

func (mr *MockHandlerMockRecorder) Decrement(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decrement", reflect.TypeOf((*MockHandler)(nil).Decrement), arg0)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

DeleteAllKeys indicates an expected call of DeleteAllKeys.

func (mr *MockHandlerMockRecorder) DeleteAllKeys() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllKeys", reflect.TypeOf((*MockHandler)(nil).DeleteAllKeys))
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

DeleteKey indicates an expected call of DeleteKey.

func (mr *MockHandlerMockRecorder) DeleteKey(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKey", reflect.TypeOf((*MockHandler)(nil).DeleteKey), arg0)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

DeleteKeys indicates an expected call of DeleteKeys.

func (mr *MockHandlerMockRecorder) DeleteKeys(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeys", reflect.TypeOf((*MockHandler)(nil).DeleteKeys), arg0)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

DeleteRawKey indicates an expected call of DeleteRawKey.

func (mr *MockHandlerMockRecorder) DeleteRawKey(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRawKey", reflect.TypeOf((*MockHandler)(nil).DeleteRawKey), arg0)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

DeleteRawKeys indicates an expected call of DeleteRawKeys.

func (mr *MockHandlerMockRecorder) DeleteRawKeys(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRawKeys", reflect.TypeOf((*MockHandler)(nil).DeleteRawKeys), arg0)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

DeleteScanMatch indicates an expected call of DeleteScanMatch.

func (mr *MockHandlerMockRecorder) DeleteScanMatch(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteScanMatch", reflect.TypeOf((*MockHandler)(nil).DeleteScanMatch), arg0)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

Exists indicates an expected call of Exists.

func (mr *MockHandlerMockRecorder) Exists(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockHandler)(nil).Exists), arg0)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

GetAndDeleteSet indicates an expected call of GetAndDeleteSet.

func (mr *MockHandlerMockRecorder) GetAndDeleteSet(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAndDeleteSet", reflect.TypeOf((*MockHandler)(nil).GetAndDeleteSet), arg0)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

GetExp indicates an expected call of GetExp.

func (mr *MockHandlerMockRecorder) GetExp(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExp", reflect.TypeOf((*MockHandler)(nil).GetExp), arg0)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

GetKey indicates an expected call of GetKey.

func (mr *MockHandlerMockRecorder) GetKey(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKey", reflect.TypeOf((*MockHandler)(nil).GetKey), arg0)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

GetKeyPrefix indicates an expected call of GetKeyPrefix.

func (mr *MockHandlerMockRecorder) GetKeyPrefix() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKeyPrefix", reflect.TypeOf((*MockHandler)(nil).GetKeyPrefix))
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

GetKeys indicates an expected call of GetKeys.

func (mr *MockHandlerMockRecorder) GetKeys(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKeys", reflect.TypeOf((*MockHandler)(nil).GetKeys), arg0)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

GetKeysAndValues indicates an expected call of GetKeysAndValues.

func (mr *MockHandlerMockRecorder) GetKeysAndValues() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKeysAndValues", reflect.TypeOf((*MockHandler)(nil).GetKeysAndValues))
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

GetKeysAndValuesWithFilter indicates an expected call of GetKeysAndValuesWithFilter.

func (mr *MockHandlerMockRecorder) GetKeysAndValuesWithFilter(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKeysAndValuesWithFilter", reflect.TypeOf((*MockHandler)(nil).GetKeysAndValuesWithFilter), arg0)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

GetListRange indicates an expected call of GetListRange.

func (mr *MockHandlerMockRecorder) GetListRange(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetListRange", reflect.TypeOf((*MockHandler)(nil).GetListRange), arg0, arg1, arg2)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

GetMultiKey indicates an expected call of GetMultiKey.

func (mr *MockHandlerMockRecorder) GetMultiKey(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMultiKey", reflect.TypeOf((*MockHandler)(nil).GetMultiKey), arg0)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

GetRawKey indicates an expected call of GetRawKey.

func (mr *MockHandlerMockRecorder) GetRawKey(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRawKey", reflect.TypeOf((*MockHandler)(nil).GetRawKey), arg0)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

GetRollingWindow indicates an expected call of GetRollingWindow.

func (mr *MockHandlerMockRecorder) GetRollingWindow(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRollingWindow", reflect.TypeOf((*MockHandler)(nil).GetRollingWindow), arg0, arg1, arg2)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

GetSet indicates an expected call of GetSet.

func (mr *MockHandlerMockRecorder) GetSet(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSet", reflect.TypeOf((*MockHandler)(nil).GetSet), arg0)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

GetSortedSetRange indicates an expected call of GetSortedSetRange.

func (mr *MockHandlerMockRecorder) GetSortedSetRange(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSortedSetRange", reflect.TypeOf((*MockHandler)(nil).GetSortedSetRange), arg0, arg1, arg2)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

IncrememntWithExpire indicates an expected call of IncrememntWithExpire.

func (mr *MockHandlerMockRecorder) IncrememntWithExpire(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrememntWithExpire", reflect.TypeOf((*MockHandler)(nil).IncrememntWithExpire), arg0, arg1)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

RemoveFromList indicates an expected call of RemoveFromList.

func (mr *MockHandlerMockRecorder) RemoveFromList(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveFromList", reflect.TypeOf((*MockHandler)(nil).RemoveFromList), arg0, arg1)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

RemoveFromSet indicates an expected call of RemoveFromSet.

func (mr *MockHandlerMockRecorder) RemoveFromSet(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveFromSet", reflect.TypeOf((*MockHandler)(nil).RemoveFromSet), arg0, arg1)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

RemoveSortedSetRange indicates an expected call of RemoveSortedSetRange.

func (mr *MockHandlerMockRecorder) RemoveSortedSetRange(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveSortedSetRange", reflect.TypeOf((*MockHandler)(nil).RemoveSortedSetRange), arg0, arg1, arg2)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

SetExp indicates an expected call of SetExp.

func (mr *MockHandlerMockRecorder) SetExp(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExp", reflect.TypeOf((*MockHandler)(nil).SetExp), arg0, arg1)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

SetKey indicates an expected call of SetKey.

func (mr *MockHandlerMockRecorder) SetKey(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetKey", reflect.TypeOf((*MockHandler)(nil).SetKey), arg0, arg1, arg2)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

SetRawKey indicates an expected call of SetRawKey.

func (mr *MockHandlerMockRecorder) SetRawKey(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRawKey", reflect.TypeOf((*MockHandler)(nil).SetRawKey), arg0, arg1, arg2)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.

SetRollingWindow indicates an expected call of SetRollingWindow.

func (mr *MockHandlerMockRecorder) SetRollingWindow(arg0, arg1, arg2, arg3 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRollingWindow", reflect.TypeOf((*MockHandler)(nil).SetRollingWindow), arg0, arg1, arg2, arg3)
}

Cognitive complexity: 0, Cyclomatic complexity: 1

Uses: reflect.TypeOf.