// Code generated by MockGen. DO NOT EDIT.
// Source: redis.go

// Package redismock is a generated GoMock package.
package redismock

import (
	context "context"
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
)

// MockRedis is a mock of Redis interface
type MockRedis struct {
	ctrl     *gomock.Controller
	recorder *MockRedisMockRecorder
}

// MockRedisMockRecorder is the mock recorder for MockRedis
type MockRedisMockRecorder struct {
	mock *MockRedis
}

// NewMockRedis creates a new mock instance
func NewMockRedis(ctrl *gomock.Controller) *MockRedis {
	mock := &MockRedis{ctrl: ctrl}
	mock.recorder = &MockRedisMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockRedis) EXPECT() *MockRedisMockRecorder {
	return m.recorder
}

// Close mocks base method
func (m *MockRedis) 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 *MockRedisMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockRedis)(nil).Close))
}

// IsErrNil mocks base method
func (m *MockRedis) IsErrNil(err error) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsErrNil", err)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsErrNil indicates an expected call of IsErrNil
func (mr *MockRedisMockRecorder) IsErrNil(err interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsErrNil", reflect.TypeOf((*MockRedis)(nil).IsErrNil), err)
}

// IsResponseOK mocks base method
func (m *MockRedis) IsResponseOK(result string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsResponseOK", result)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsResponseOK indicates an expected call of IsResponseOK
func (mr *MockRedisMockRecorder) IsResponseOK(result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsResponseOK", reflect.TypeOf((*MockRedis)(nil).IsResponseOK), result)
}

// Set mocks base method
func (m *MockRedis) Set(ctx context.Context, key string, value interface{}) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Set", ctx, key, value)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Set indicates an expected call of Set
func (mr *MockRedisMockRecorder) Set(ctx, key, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockRedis)(nil).Set), ctx, key, value)
}

// SetNX mocks base method
func (m *MockRedis) SetNX(ctx context.Context, key string, value interface{}, expire int) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetNX", ctx, key, value, expire)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetNX indicates an expected call of SetNX
func (mr *MockRedisMockRecorder) SetNX(ctx, key, value, expire interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNX", reflect.TypeOf((*MockRedis)(nil).SetNX), ctx, key, value, expire)
}

// SetEX mocks base method
func (m *MockRedis) SetEX(ctx context.Context, key string, value interface{}, expire int) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetEX", ctx, key, value, expire)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetEX indicates an expected call of SetEX
func (mr *MockRedisMockRecorder) SetEX(ctx, key, value, expire interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEX", reflect.TypeOf((*MockRedis)(nil).SetEX), ctx, key, value, expire)
}

// Get mocks base method
func (m *MockRedis) Get(ctx context.Context, key string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, key)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get
func (mr *MockRedisMockRecorder) Get(ctx, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockRedis)(nil).Get), ctx, key)
}

// Delete mocks base method
func (m *MockRedis) Delete(ctx context.Context, key string) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, key)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete
func (mr *MockRedisMockRecorder) Delete(ctx, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRedis)(nil).Delete), ctx, key)
}

// Increment mocks base method
func (m *MockRedis) Increment(ctx context.Context, key string) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Increment", ctx, key)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Increment indicates an expected call of Increment
func (mr *MockRedisMockRecorder) Increment(ctx, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Increment", reflect.TypeOf((*MockRedis)(nil).Increment), ctx, key)
}

// IncrementBy mocks base method
func (m *MockRedis) IncrementBy(ctx context.Context, key string, amount int) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncrementBy", ctx, key, amount)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IncrementBy indicates an expected call of IncrementBy
func (mr *MockRedisMockRecorder) IncrementBy(ctx, key, amount interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrementBy", reflect.TypeOf((*MockRedis)(nil).IncrementBy), ctx, key, amount)
}

// Expire mocks base method
func (m *MockRedis) Expire(ctx context.Context, key string, duration int) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Expire", ctx, key, duration)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Expire indicates an expected call of Expire
func (mr *MockRedisMockRecorder) Expire(ctx, key, duration interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expire", reflect.TypeOf((*MockRedis)(nil).Expire), ctx, key, duration)
}

// MSet mocks base method
func (m *MockRedis) MSet(ctx context.Context, pairs ...interface{}) (string, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range pairs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MSet", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MSet indicates an expected call of MSet
func (mr *MockRedisMockRecorder) MSet(ctx interface{}, pairs ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, pairs...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MSet", reflect.TypeOf((*MockRedis)(nil).MSet), varargs...)
}

// MGet mocks base method
func (m *MockRedis) MGet(ctx context.Context, keys ...string) ([]string, error) {
	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].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MGet indicates an expected call of MGet
func (mr *MockRedisMockRecorder) 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((*MockRedis)(nil).MGet), varargs...)
}

// HSet mocks base method
func (m *MockRedis) HSet(ctx context.Context, key, field string, value interface{}) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HSet", ctx, key, field, value)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HSet indicates an expected call of HSet
func (mr *MockRedisMockRecorder) HSet(ctx, key, field, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSet", reflect.TypeOf((*MockRedis)(nil).HSet), ctx, key, field, value)
}

// HSetEX mocks base method
func (m *MockRedis) HSetEX(ctx context.Context, key, field string, value interface{}, expire int) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HSetEX", ctx, key, field, value, expire)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HSetEX indicates an expected call of HSetEX
func (mr *MockRedisMockRecorder) HSetEX(ctx, key, field, value, expire interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSetEX", reflect.TypeOf((*MockRedis)(nil).HSetEX), ctx, key, field, value, expire)
}

// HGet mocks base method
func (m *MockRedis) HGet(ctx context.Context, key, field string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HGet", ctx, key, field)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HGet indicates an expected call of HGet
func (mr *MockRedisMockRecorder) HGet(ctx, key, field interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGet", reflect.TypeOf((*MockRedis)(nil).HGet), ctx, key, field)
}

// HGetAll mocks base method
func (m *MockRedis) HGetAll(ctx context.Context, key string) (map[string]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HGetAll", ctx, key)
	ret0, _ := ret[0].(map[string]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HGetAll indicates an expected call of HGetAll
func (mr *MockRedisMockRecorder) HGetAll(ctx, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGetAll", reflect.TypeOf((*MockRedis)(nil).HGetAll), ctx, key)
}

// HMSet mocks base method
func (m *MockRedis) HMSet(ctx context.Context, key string, kv map[string]interface{}) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HMSet", ctx, key, kv)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HMSet indicates an expected call of HMSet
func (mr *MockRedisMockRecorder) HMSet(ctx, key, kv interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HMSet", reflect.TypeOf((*MockRedis)(nil).HMSet), ctx, key, kv)
}

// HMGet mocks base method
func (m *MockRedis) HMGet(ctx context.Context, key string, fields ...string) ([]string, error) {
	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].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HMGet indicates an expected call of HMGet
func (mr *MockRedisMockRecorder) 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((*MockRedis)(nil).HMGet), varargs...)
}

// HDel mocks base method
func (m *MockRedis) HDel(ctx context.Context, key string, fields ...string) (int, error) {
	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].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HDel indicates an expected call of HDel
func (mr *MockRedisMockRecorder) 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((*MockRedis)(nil).HDel), varargs...)
}

// LLen mocks base method
func (m *MockRedis) LLen(ctx context.Context, key string) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LLen", ctx, key)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LLen indicates an expected call of LLen
func (mr *MockRedisMockRecorder) LLen(ctx, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LLen", reflect.TypeOf((*MockRedis)(nil).LLen), ctx, key)
}

// LIndex mocks base method
func (m *MockRedis) LIndex(ctx context.Context, key string, index int) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LIndex", ctx, key, index)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LIndex indicates an expected call of LIndex
func (mr *MockRedisMockRecorder) LIndex(ctx, key, index interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LIndex", reflect.TypeOf((*MockRedis)(nil).LIndex), ctx, key, index)
}

// LSet mocks base method
func (m *MockRedis) LSet(ctx context.Context, key, value string, index int) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LSet", ctx, key, value, index)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LSet indicates an expected call of LSet
func (mr *MockRedisMockRecorder) LSet(ctx, key, value, index interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LSet", reflect.TypeOf((*MockRedis)(nil).LSet), ctx, key, value, index)
}

// LPush mocks base method
func (m *MockRedis) LPush(ctx context.Context, key string, values ...interface{}) (int, error) {
	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].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LPush indicates an expected call of LPush
func (mr *MockRedisMockRecorder) 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((*MockRedis)(nil).LPush), varargs...)
}

// LPushX mocks base method
func (m *MockRedis) LPushX(ctx context.Context, key string, values ...interface{}) (int, error) {
	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].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LPushX indicates an expected call of LPushX
func (mr *MockRedisMockRecorder) 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((*MockRedis)(nil).LPushX), varargs...)
}

// LPop mocks base method
func (m *MockRedis) LPop(ctx context.Context, key string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LPop", ctx, key)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LPop indicates an expected call of LPop
func (mr *MockRedisMockRecorder) LPop(ctx, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPop", reflect.TypeOf((*MockRedis)(nil).LPop), ctx, key)
}

// LRem mocks base method
func (m *MockRedis) LRem(ctx context.Context, key, value string, count int) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LRem", ctx, key, value, count)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LRem indicates an expected call of LRem
func (mr *MockRedisMockRecorder) LRem(ctx, key, value, count interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRem", reflect.TypeOf((*MockRedis)(nil).LRem), ctx, key, value, count)
}

// LTrim mocks base method
func (m *MockRedis) LTrim(ctd context.Context, key string, start, stop int) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LTrim", ctd, key, start, stop)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LTrim indicates an expected call of LTrim
func (mr *MockRedisMockRecorder) LTrim(ctd, key, start, stop interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LTrim", reflect.TypeOf((*MockRedis)(nil).LTrim), ctd, key, start, stop)
}
