github.com/portworx/kvdb@v0.0.0-20241107215734-a185a966f535/mock/mock_kvdb.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/portworx/kvdb (interfaces: Kvdb)

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

import (
	reflect "reflect"
	time "time"

	gomock "github.com/golang/mock/gomock"
	kvdb "github.com/portworx/kvdb"
)

// MockKvdb is a mock of Kvdb interface.
type MockKvdb struct {
	ctrl     *gomock.Controller
	recorder *MockKvdbMockRecorder
}

// MockKvdbMockRecorder is the mock recorder for MockKvdb.
type MockKvdbMockRecorder struct {
	mock *MockKvdb
}

// NewMockKvdb creates a new mock instance.
func NewMockKvdb(ctrl *gomock.Controller) *MockKvdb {
	mock := &MockKvdb{ctrl: ctrl}
	mock.recorder = &MockKvdbMockRecorder{mock}
	return mock
}

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

// AddLearner mocks base method.
func (m *MockKvdb) AddLearner(arg0, arg1, arg2 string) (map[string][]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddLearner", arg0, arg1, arg2)
	ret0, _ := ret[0].(map[string][]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddMember mocks base method.
func (m *MockKvdb) AddMember(arg0, arg1, arg2 string) (map[string][]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddMember", arg0, arg1, arg2)
	ret0, _ := ret[0].(map[string][]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

// CompareAndDelete mocks base method.
func (m *MockKvdb) CompareAndDelete(arg0 *kvdb.KVPair, arg1 kvdb.KVFlags) (*kvdb.KVPair, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompareAndDelete", arg0, arg1)
	ret0, _ := ret[0].(*kvdb.KVPair)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CompareAndSet mocks base method.
func (m *MockKvdb) CompareAndSet(arg0 *kvdb.KVPair, arg1 kvdb.KVFlags, arg2 []byte) (*kvdb.KVPair, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompareAndSet", arg0, arg1, arg2)
	ret0, _ := ret[0].(*kvdb.KVPair)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Create mocks base method.
func (m *MockKvdb) Create(arg0 string, arg1 interface{}, arg2 uint64) (*kvdb.KVPair, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2)
	ret0, _ := ret[0].(*kvdb.KVPair)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Defragment mocks base method.
func (m *MockKvdb) Defragment(arg0 string, arg1 int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Defragment", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

// Deserialize mocks base method.
func (m *MockKvdb) Deserialize(arg0 []byte) (kvdb.KVPairs, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Deserialize", arg0)
	ret0, _ := ret[0].(kvdb.KVPairs)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Enumerate mocks base method.
func (m *MockKvdb) Enumerate(arg0 string) (kvdb.KVPairs, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Enumerate", arg0)
	ret0, _ := ret[0].(kvdb.KVPairs)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnumerateKVPWithSelect mocks base method.
func (m *MockKvdb) EnumerateKVPWithSelect(arg0 string, arg1 kvdb.EnumerateKVPSelect, arg2 kvdb.CopyKVPSelect) (kvdb.KVPairs, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnumerateKVPWithSelect", arg0, arg1, arg2)
	ret0, _ := ret[0].(kvdb.KVPairs)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnumerateWithSelect mocks base method.
func (m *MockKvdb) EnumerateWithSelect(arg0 string, arg1 kvdb.EnumerateSelect, arg2 kvdb.CopySelect) ([]interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnumerateWithSelect", arg0, arg1, arg2)
	ret0, _ := ret[0].([]interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

// GetVal mocks base method.
func (m *MockKvdb) GetVal(arg0 string, arg1 interface{}) (*kvdb.KVPair, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVal", arg0, arg1)
	ret0, _ := ret[0].(*kvdb.KVPair)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWithCopy mocks base method.
func (m *MockKvdb) GetWithCopy(arg0 string, arg1 kvdb.CopySelect) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWithCopy", arg0, arg1)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GrantUserAccess mocks base method.
func (m *MockKvdb) GrantUserAccess(arg0 string, arg1 kvdb.PermissionType, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GrantUserAccess", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// IsKeyLocked mocks base method.
func (m *MockKvdb) IsKeyLocked(arg0 string) (bool, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsKeyLocked", arg0)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

// ListMembers mocks base method.
func (m *MockKvdb) ListMembers() (map[uint64]*kvdb.MemberInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMembers")
	ret0, _ := ret[0].(map[uint64]*kvdb.MemberInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Lock mocks base method.
func (m *MockKvdb) Lock(arg0 string) (*kvdb.KVPair, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Lock", arg0)
	ret0, _ := ret[0].(*kvdb.KVPair)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LockWithID mocks base method.
func (m *MockKvdb) LockWithID(arg0, arg1 string) (*kvdb.KVPair, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LockWithID", arg0, arg1)
	ret0, _ := ret[0].(*kvdb.KVPair)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LockWithTimeout mocks base method.
func (m *MockKvdb) LockWithTimeout(arg0, arg1 string, arg2, arg3 time.Duration) (*kvdb.KVPair, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LockWithTimeout", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*kvdb.KVPair)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LockWithTimeout indicates an expected call of LockWithTimeout.
func (mr *MockKvdbMockRecorder) LockWithTimeout(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LockWithTimeout", reflect.TypeOf((*MockKvdb)(nil).LockWithTimeout), arg0, arg1, arg2, arg3)
}

// Put mocks base method.
func (m *MockKvdb) Put(arg0 string, arg1 interface{}, arg2 uint64) (*kvdb.KVPair, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Put", arg0, arg1, arg2)
	ret0, _ := ret[0].(*kvdb.KVPair)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

// RevokeUsersAccess mocks base method.
func (m *MockKvdb) RevokeUsersAccess(arg0 string, arg1 kvdb.PermissionType, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RevokeUsersAccess", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

// SetFatalCb mocks base method.
func (m *MockKvdb) SetFatalCb(arg0 kvdb.FatalErrorCB) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFatalCb", arg0)
}

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

// SetLockHoldDuration mocks base method.
func (m *MockKvdb) SetLockHoldDuration(arg0 time.Duration) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLockHoldDuration", arg0)
}

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

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

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

// SnapPut mocks base method.
func (m *MockKvdb) SnapPut(arg0 *kvdb.KVPair) (*kvdb.KVPair, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SnapPut", arg0)
	ret0, _ := ret[0].(*kvdb.KVPair)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Snapshot mocks base method.
func (m *MockKvdb) Snapshot(arg0 []string, arg1 bool) (kvdb.Kvdb, uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Snapshot", arg0, arg1)
	ret0, _ := ret[0].(kvdb.Kvdb)
	ret1, _ := ret[1].(uint64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

// TxNew mocks base method.
func (m *MockKvdb) TxNew() (kvdb.Tx, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TxNew")
	ret0, _ := ret[0].(kvdb.Tx)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// Update mocks base method.
func (m *MockKvdb) Update(arg0 string, arg1 interface{}, arg2 uint64) (*kvdb.KVPair, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", arg0, arg1, arg2)
	ret0, _ := ret[0].(*kvdb.KVPair)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateMember mocks base method.
func (m *MockKvdb) UpdateMember(arg0, arg1, arg2 string) (map[string][]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMember", arg0, arg1, arg2)
	ret0, _ := ret[0].(map[string][]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// WatchKey mocks base method.
func (m *MockKvdb) WatchKey(arg0 string, arg1 uint64, arg2 interface{}, arg3 kvdb.WatchCB) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchKey", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// WatchKey indicates an expected call of WatchKey.
func (mr *MockKvdbMockRecorder) WatchKey(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchKey", reflect.TypeOf((*MockKvdb)(nil).WatchKey), arg0, arg1, arg2, arg3)
}

// WatchTree mocks base method.
func (m *MockKvdb) WatchTree(arg0 string, arg1 uint64, arg2 interface{}, arg3 kvdb.WatchCB) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchTree", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// WatchTree indicates an expected call of WatchTree.
func (mr *MockKvdbMockRecorder) WatchTree(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchTree", reflect.TypeOf((*MockKvdb)(nil).WatchTree), arg0, arg1, arg2, arg3)
}

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

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

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

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