github.com/m3db/m3@v1.5.0/src/cluster/kv/kv_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/m3db/m3/src/cluster/kv/types.go

// Copyright (c) 2021 Uber Technologies, Inc.
//
// 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 kv is a generated GoMock package.
package kv

import (
	"reflect"

	"github.com/golang/mock/gomock"
	"github.com/golang/protobuf/proto"
)

// MockValue is a mock of Value interface.
type MockValue struct {
	ctrl     *gomock.Controller
	recorder *MockValueMockRecorder
}

// MockValueMockRecorder is the mock recorder for MockValue.
type MockValueMockRecorder struct {
	mock *MockValue
}

// NewMockValue creates a new mock instance.
func NewMockValue(ctrl *gomock.Controller) *MockValue {
	mock := &MockValue{ctrl: ctrl}
	mock.recorder = &MockValueMockRecorder{mock}
	return mock
}

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

// IsNewer mocks base method.
func (m *MockValue) IsNewer(other Value) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsNewer", other)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsNewer indicates an expected call of IsNewer.
func (mr *MockValueMockRecorder) IsNewer(other interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNewer", reflect.TypeOf((*MockValue)(nil).IsNewer), other)
}

// Unmarshal mocks base method.
func (m *MockValue) Unmarshal(v proto.Message) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Unmarshal", v)
	ret0, _ := ret[0].(error)
	return ret0
}

// Unmarshal indicates an expected call of Unmarshal.
func (mr *MockValueMockRecorder) Unmarshal(v interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unmarshal", reflect.TypeOf((*MockValue)(nil).Unmarshal), v)
}

// Version mocks base method.
func (m *MockValue) Version() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Version")
	ret0, _ := ret[0].(int)
	return ret0
}

// Version indicates an expected call of Version.
func (mr *MockValueMockRecorder) Version() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockValue)(nil).Version))
}

// MockValueWatch is a mock of ValueWatch interface.
type MockValueWatch struct {
	ctrl     *gomock.Controller
	recorder *MockValueWatchMockRecorder
}

// MockValueWatchMockRecorder is the mock recorder for MockValueWatch.
type MockValueWatchMockRecorder struct {
	mock *MockValueWatch
}

// NewMockValueWatch creates a new mock instance.
func NewMockValueWatch(ctrl *gomock.Controller) *MockValueWatch {
	mock := &MockValueWatch{ctrl: ctrl}
	mock.recorder = &MockValueWatchMockRecorder{mock}
	return mock
}

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

// C mocks base method.
func (m *MockValueWatch) C() <-chan struct{} {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "C")
	ret0, _ := ret[0].(<-chan struct{})
	return ret0
}

// C indicates an expected call of C.
func (mr *MockValueWatchMockRecorder) C() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "C", reflect.TypeOf((*MockValueWatch)(nil).C))
}

// Close mocks base method.
func (m *MockValueWatch) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

// Close indicates an expected call of Close.
func (mr *MockValueWatchMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockValueWatch)(nil).Close))
}

// Get mocks base method.
func (m *MockValueWatch) Get() Value {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get")
	ret0, _ := ret[0].(Value)
	return ret0
}

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

// MockValueWatchable is a mock of ValueWatchable interface.
type MockValueWatchable struct {
	ctrl     *gomock.Controller
	recorder *MockValueWatchableMockRecorder
}

// MockValueWatchableMockRecorder is the mock recorder for MockValueWatchable.
type MockValueWatchableMockRecorder struct {
	mock *MockValueWatchable
}

// NewMockValueWatchable creates a new mock instance.
func NewMockValueWatchable(ctrl *gomock.Controller) *MockValueWatchable {
	mock := &MockValueWatchable{ctrl: ctrl}
	mock.recorder = &MockValueWatchableMockRecorder{mock}
	return mock
}

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

// Close mocks base method.
func (m *MockValueWatchable) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

// Close indicates an expected call of Close.
func (mr *MockValueWatchableMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockValueWatchable)(nil).Close))
}

// Get mocks base method.
func (m *MockValueWatchable) Get() Value {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get")
	ret0, _ := ret[0].(Value)
	return ret0
}

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

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

// IsClosed indicates an expected call of IsClosed.
func (mr *MockValueWatchableMockRecorder) IsClosed() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsClosed", reflect.TypeOf((*MockValueWatchable)(nil).IsClosed))
}

// NumWatches mocks base method.
func (m *MockValueWatchable) NumWatches() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NumWatches")
	ret0, _ := ret[0].(int)
	return ret0
}

// NumWatches indicates an expected call of NumWatches.
func (mr *MockValueWatchableMockRecorder) NumWatches() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NumWatches", reflect.TypeOf((*MockValueWatchable)(nil).NumWatches))
}

// Update mocks base method.
func (m *MockValueWatchable) Update(arg0 Value) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockValueWatchableMockRecorder) Update(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockValueWatchable)(nil).Update), arg0)
}

// Watch mocks base method.
func (m *MockValueWatchable) Watch() (Value, ValueWatch, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Watch")
	ret0, _ := ret[0].(Value)
	ret1, _ := ret[1].(ValueWatch)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Watch indicates an expected call of Watch.
func (mr *MockValueWatchableMockRecorder) Watch() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockValueWatchable)(nil).Watch))
}

// MockOverrideOptions is a mock of OverrideOptions interface.
type MockOverrideOptions struct {
	ctrl     *gomock.Controller
	recorder *MockOverrideOptionsMockRecorder
}

// MockOverrideOptionsMockRecorder is the mock recorder for MockOverrideOptions.
type MockOverrideOptionsMockRecorder struct {
	mock *MockOverrideOptions
}

// NewMockOverrideOptions creates a new mock instance.
func NewMockOverrideOptions(ctrl *gomock.Controller) *MockOverrideOptions {
	mock := &MockOverrideOptions{ctrl: ctrl}
	mock.recorder = &MockOverrideOptionsMockRecorder{mock}
	return mock
}

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

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

// Environment indicates an expected call of Environment.
func (mr *MockOverrideOptionsMockRecorder) Environment() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Environment", reflect.TypeOf((*MockOverrideOptions)(nil).Environment))
}

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

// Namespace indicates an expected call of Namespace.
func (mr *MockOverrideOptionsMockRecorder) Namespace() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Namespace", reflect.TypeOf((*MockOverrideOptions)(nil).Namespace))
}

// SetEnvironment mocks base method.
func (m *MockOverrideOptions) SetEnvironment(env string) OverrideOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetEnvironment", env)
	ret0, _ := ret[0].(OverrideOptions)
	return ret0
}

// SetEnvironment indicates an expected call of SetEnvironment.
func (mr *MockOverrideOptionsMockRecorder) SetEnvironment(env interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEnvironment", reflect.TypeOf((*MockOverrideOptions)(nil).SetEnvironment), env)
}

// SetNamespace mocks base method.
func (m *MockOverrideOptions) SetNamespace(namespace string) OverrideOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetNamespace", namespace)
	ret0, _ := ret[0].(OverrideOptions)
	return ret0
}

// SetNamespace indicates an expected call of SetNamespace.
func (mr *MockOverrideOptionsMockRecorder) SetNamespace(namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNamespace", reflect.TypeOf((*MockOverrideOptions)(nil).SetNamespace), namespace)
}

// SetZone mocks base method.
func (m *MockOverrideOptions) SetZone(value string) OverrideOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetZone", value)
	ret0, _ := ret[0].(OverrideOptions)
	return ret0
}

// SetZone indicates an expected call of SetZone.
func (mr *MockOverrideOptionsMockRecorder) SetZone(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetZone", reflect.TypeOf((*MockOverrideOptions)(nil).SetZone), value)
}

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

// Validate indicates an expected call of Validate.
func (mr *MockOverrideOptionsMockRecorder) Validate() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Validate", reflect.TypeOf((*MockOverrideOptions)(nil).Validate))
}

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

// Zone indicates an expected call of Zone.
func (mr *MockOverrideOptionsMockRecorder) Zone() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Zone", reflect.TypeOf((*MockOverrideOptions)(nil).Zone))
}

// MockStore is a mock of Store interface.
type MockStore struct {
	ctrl     *gomock.Controller
	recorder *MockStoreMockRecorder
}

// MockStoreMockRecorder is the mock recorder for MockStore.
type MockStoreMockRecorder struct {
	mock *MockStore
}

// NewMockStore creates a new mock instance.
func NewMockStore(ctrl *gomock.Controller) *MockStore {
	mock := &MockStore{ctrl: ctrl}
	mock.recorder = &MockStoreMockRecorder{mock}
	return mock
}

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

// CheckAndSet mocks base method.
func (m *MockStore) CheckAndSet(key string, version int, v proto.Message) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckAndSet", key, version, v)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CheckAndSet indicates an expected call of CheckAndSet.
func (mr *MockStoreMockRecorder) CheckAndSet(key, version, v interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckAndSet", reflect.TypeOf((*MockStore)(nil).CheckAndSet), key, version, v)
}

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

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

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

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

// History mocks base method.
func (m *MockStore) History(key string, from, to int) ([]Value, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "History", key, from, to)
	ret0, _ := ret[0].([]Value)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// History indicates an expected call of History.
func (mr *MockStoreMockRecorder) History(key, from, to interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "History", reflect.TypeOf((*MockStore)(nil).History), key, from, to)
}

// Set mocks base method.
func (m *MockStore) Set(key string, v proto.Message) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Set", key, v)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SetIfNotExists mocks base method.
func (m *MockStore) SetIfNotExists(key string, v proto.Message) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetIfNotExists", key, v)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetIfNotExists indicates an expected call of SetIfNotExists.
func (mr *MockStoreMockRecorder) SetIfNotExists(key, v interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIfNotExists", reflect.TypeOf((*MockStore)(nil).SetIfNotExists), key, v)
}

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

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

// MockCondition is a mock of Condition interface.
type MockCondition struct {
	ctrl     *gomock.Controller
	recorder *MockConditionMockRecorder
}

// MockConditionMockRecorder is the mock recorder for MockCondition.
type MockConditionMockRecorder struct {
	mock *MockCondition
}

// NewMockCondition creates a new mock instance.
func NewMockCondition(ctrl *gomock.Controller) *MockCondition {
	mock := &MockCondition{ctrl: ctrl}
	mock.recorder = &MockConditionMockRecorder{mock}
	return mock
}

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

// CompareType mocks base method.
func (m *MockCondition) CompareType() CompareType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompareType")
	ret0, _ := ret[0].(CompareType)
	return ret0
}

// CompareType indicates an expected call of CompareType.
func (mr *MockConditionMockRecorder) CompareType() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompareType", reflect.TypeOf((*MockCondition)(nil).CompareType))
}

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

// Key indicates an expected call of Key.
func (mr *MockConditionMockRecorder) Key() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Key", reflect.TypeOf((*MockCondition)(nil).Key))
}

// SetCompareType mocks base method.
func (m *MockCondition) SetCompareType(t CompareType) Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetCompareType", t)
	ret0, _ := ret[0].(Condition)
	return ret0
}

// SetCompareType indicates an expected call of SetCompareType.
func (mr *MockConditionMockRecorder) SetCompareType(t interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCompareType", reflect.TypeOf((*MockCondition)(nil).SetCompareType), t)
}

// SetKey mocks base method.
func (m *MockCondition) SetKey(key string) Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetKey", key)
	ret0, _ := ret[0].(Condition)
	return ret0
}

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

// SetTargetType mocks base method.
func (m *MockCondition) SetTargetType(t TargetType) Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetTargetType", t)
	ret0, _ := ret[0].(Condition)
	return ret0
}

// SetTargetType indicates an expected call of SetTargetType.
func (mr *MockConditionMockRecorder) SetTargetType(t interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTargetType", reflect.TypeOf((*MockCondition)(nil).SetTargetType), t)
}

// SetValue mocks base method.
func (m *MockCondition) SetValue(value interface{}) Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetValue", value)
	ret0, _ := ret[0].(Condition)
	return ret0
}

// SetValue indicates an expected call of SetValue.
func (mr *MockConditionMockRecorder) SetValue(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValue", reflect.TypeOf((*MockCondition)(nil).SetValue), value)
}

// TargetType mocks base method.
func (m *MockCondition) TargetType() TargetType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TargetType")
	ret0, _ := ret[0].(TargetType)
	return ret0
}

// TargetType indicates an expected call of TargetType.
func (mr *MockConditionMockRecorder) TargetType() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TargetType", reflect.TypeOf((*MockCondition)(nil).TargetType))
}

// Value mocks base method.
func (m *MockCondition) Value() interface{} {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Value")
	ret0, _ := ret[0].(interface{})
	return ret0
}

// Value indicates an expected call of Value.
func (mr *MockConditionMockRecorder) Value() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Value", reflect.TypeOf((*MockCondition)(nil).Value))
}

// MockOp is a mock of Op interface.
type MockOp struct {
	ctrl     *gomock.Controller
	recorder *MockOpMockRecorder
}

// MockOpMockRecorder is the mock recorder for MockOp.
type MockOpMockRecorder struct {
	mock *MockOp
}

// NewMockOp creates a new mock instance.
func NewMockOp(ctrl *gomock.Controller) *MockOp {
	mock := &MockOp{ctrl: ctrl}
	mock.recorder = &MockOpMockRecorder{mock}
	return mock
}

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

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

// Key indicates an expected call of Key.
func (mr *MockOpMockRecorder) Key() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Key", reflect.TypeOf((*MockOp)(nil).Key))
}

// SetKey mocks base method.
func (m *MockOp) SetKey(key string) Op {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetKey", key)
	ret0, _ := ret[0].(Op)
	return ret0
}

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

// SetType mocks base method.
func (m *MockOp) SetType(ot OpType) Op {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetType", ot)
	ret0, _ := ret[0].(Op)
	return ret0
}

// SetType indicates an expected call of SetType.
func (mr *MockOpMockRecorder) SetType(ot interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetType", reflect.TypeOf((*MockOp)(nil).SetType), ot)
}

// Type mocks base method.
func (m *MockOp) Type() OpType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Type")
	ret0, _ := ret[0].(OpType)
	return ret0
}

// Type indicates an expected call of Type.
func (mr *MockOpMockRecorder) Type() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockOp)(nil).Type))
}

// MockOpResponse is a mock of OpResponse interface.
type MockOpResponse struct {
	ctrl     *gomock.Controller
	recorder *MockOpResponseMockRecorder
}

// MockOpResponseMockRecorder is the mock recorder for MockOpResponse.
type MockOpResponseMockRecorder struct {
	mock *MockOpResponse
}

// NewMockOpResponse creates a new mock instance.
func NewMockOpResponse(ctrl *gomock.Controller) *MockOpResponse {
	mock := &MockOpResponse{ctrl: ctrl}
	mock.recorder = &MockOpResponseMockRecorder{mock}
	return mock
}

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

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

// Key indicates an expected call of Key.
func (mr *MockOpResponseMockRecorder) Key() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Key", reflect.TypeOf((*MockOpResponse)(nil).Key))
}

// SetKey mocks base method.
func (m *MockOpResponse) SetKey(key string) Op {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetKey", key)
	ret0, _ := ret[0].(Op)
	return ret0
}

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

// SetType mocks base method.
func (m *MockOpResponse) SetType(ot OpType) Op {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetType", ot)
	ret0, _ := ret[0].(Op)
	return ret0
}

// SetType indicates an expected call of SetType.
func (mr *MockOpResponseMockRecorder) SetType(ot interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetType", reflect.TypeOf((*MockOpResponse)(nil).SetType), ot)
}

// SetValue mocks base method.
func (m *MockOpResponse) SetValue(v interface{}) OpResponse {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetValue", v)
	ret0, _ := ret[0].(OpResponse)
	return ret0
}

// SetValue indicates an expected call of SetValue.
func (mr *MockOpResponseMockRecorder) SetValue(v interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValue", reflect.TypeOf((*MockOpResponse)(nil).SetValue), v)
}

// Type mocks base method.
func (m *MockOpResponse) Type() OpType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Type")
	ret0, _ := ret[0].(OpType)
	return ret0
}

// Type indicates an expected call of Type.
func (mr *MockOpResponseMockRecorder) Type() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockOpResponse)(nil).Type))
}

// Value mocks base method.
func (m *MockOpResponse) Value() interface{} {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Value")
	ret0, _ := ret[0].(interface{})
	return ret0
}

// Value indicates an expected call of Value.
func (mr *MockOpResponseMockRecorder) Value() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Value", reflect.TypeOf((*MockOpResponse)(nil).Value))
}

// MockResponse is a mock of Response interface.
type MockResponse struct {
	ctrl     *gomock.Controller
	recorder *MockResponseMockRecorder
}

// MockResponseMockRecorder is the mock recorder for MockResponse.
type MockResponseMockRecorder struct {
	mock *MockResponse
}

// NewMockResponse creates a new mock instance.
func NewMockResponse(ctrl *gomock.Controller) *MockResponse {
	mock := &MockResponse{ctrl: ctrl}
	mock.recorder = &MockResponseMockRecorder{mock}
	return mock
}

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

// Responses mocks base method.
func (m *MockResponse) Responses() []OpResponse {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Responses")
	ret0, _ := ret[0].([]OpResponse)
	return ret0
}

// Responses indicates an expected call of Responses.
func (mr *MockResponseMockRecorder) Responses() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Responses", reflect.TypeOf((*MockResponse)(nil).Responses))
}

// SetResponses mocks base method.
func (m *MockResponse) SetResponses(oprs []OpResponse) Response {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetResponses", oprs)
	ret0, _ := ret[0].(Response)
	return ret0
}

// SetResponses indicates an expected call of SetResponses.
func (mr *MockResponseMockRecorder) SetResponses(oprs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetResponses", reflect.TypeOf((*MockResponse)(nil).SetResponses), oprs)
}

// MockTxnStore is a mock of TxnStore interface.
type MockTxnStore struct {
	ctrl     *gomock.Controller
	recorder *MockTxnStoreMockRecorder
}

// MockTxnStoreMockRecorder is the mock recorder for MockTxnStore.
type MockTxnStoreMockRecorder struct {
	mock *MockTxnStore
}

// NewMockTxnStore creates a new mock instance.
func NewMockTxnStore(ctrl *gomock.Controller) *MockTxnStore {
	mock := &MockTxnStore{ctrl: ctrl}
	mock.recorder = &MockTxnStoreMockRecorder{mock}
	return mock
}

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

// CheckAndSet mocks base method.
func (m *MockTxnStore) CheckAndSet(key string, version int, v proto.Message) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckAndSet", key, version, v)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CheckAndSet indicates an expected call of CheckAndSet.
func (mr *MockTxnStoreMockRecorder) CheckAndSet(key, version, v interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckAndSet", reflect.TypeOf((*MockTxnStore)(nil).CheckAndSet), key, version, v)
}

// Commit mocks base method.
func (m *MockTxnStore) Commit(arg0 []Condition, arg1 []Op) (Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Commit", arg0, arg1)
	ret0, _ := ret[0].(Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Commit indicates an expected call of Commit.
func (mr *MockTxnStoreMockRecorder) Commit(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockTxnStore)(nil).Commit), arg0, arg1)
}

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

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

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

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

// History mocks base method.
func (m *MockTxnStore) History(key string, from, to int) ([]Value, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "History", key, from, to)
	ret0, _ := ret[0].([]Value)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// History indicates an expected call of History.
func (mr *MockTxnStoreMockRecorder) History(key, from, to interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "History", reflect.TypeOf((*MockTxnStore)(nil).History), key, from, to)
}

// Set mocks base method.
func (m *MockTxnStore) Set(key string, v proto.Message) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Set", key, v)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SetIfNotExists mocks base method.
func (m *MockTxnStore) SetIfNotExists(key string, v proto.Message) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetIfNotExists", key, v)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetIfNotExists indicates an expected call of SetIfNotExists.
func (mr *MockTxnStoreMockRecorder) SetIfNotExists(key, v interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIfNotExists", reflect.TypeOf((*MockTxnStore)(nil).SetIfNotExists), key, v)
}

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

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