// Code generated by MockGen. DO NOT EDIT.
// Source: pkg/etcd/client.go

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

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	clientv3 "go.etcd.io/etcd/client/v3"
	concurrency "go.etcd.io/etcd/client/v3/concurrency"
)

// MockClient is a mock of Client interface.
type MockClient struct {
	ctrl     *gomock.Controller
	recorder *MockClientMockRecorder
}

// MockClientMockRecorder is the mock recorder for MockClient.
type MockClientMockRecorder struct {
	mock *MockClient
}

// NewMockClient creates a new mock instance.
func NewMockClient(ctrl *gomock.Controller) *MockClient {
	mock := &MockClient{ctrl: ctrl}
	mock.recorder = &MockClientMockRecorder{mock}
	return mock
}

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

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

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

// Delete indicates an expected call of Delete.
func (mr *MockClientMockRecorder) Delete(ctx, key interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, key}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockClient)(nil).Delete), varargs...)
}

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

// Get indicates an expected call of Get.
func (mr *MockClientMockRecorder) Get(ctx, key interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, key}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockClient)(nil).Get), varargs...)
}

// Grant mocks base method.
func (m *MockClient) Grant(ctx context.Context, ttl int64) (*clientv3.LeaseGrantResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Grant", ctx, ttl)
	ret0, _ := ret[0].(*clientv3.LeaseGrantResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Grant indicates an expected call of Grant.
func (mr *MockClientMockRecorder) Grant(ctx, ttl interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Grant", reflect.TypeOf((*MockClient)(nil).Grant), ctx, ttl)
}

// NewSession mocks base method.
func (m *MockClient) NewSession(opts ...concurrency.SessionOption) (*concurrency.Session, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "NewSession", varargs...)
	ret0, _ := ret[0].(*concurrency.Session)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewSession indicates an expected call of NewSession.
func (mr *MockClientMockRecorder) NewSession(opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewSession", reflect.TypeOf((*MockClient)(nil).NewSession), opts...)
}

// Put mocks base method.
func (m *MockClient) Put(ctx context.Context, key, val string, opts ...clientv3.OpOption) (*clientv3.PutResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, key, val}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Put", varargs...)
	ret0, _ := ret[0].(*clientv3.PutResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Put indicates an expected call of Put.
func (mr *MockClientMockRecorder) Put(ctx, key, val interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, key, val}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockClient)(nil).Put), varargs...)
}

// Revoke mocks base method.
func (m *MockClient) Revoke(ctx context.Context, id clientv3.LeaseID) (*clientv3.LeaseRevokeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Revoke", ctx, id)
	ret0, _ := ret[0].(*clientv3.LeaseRevokeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Revoke indicates an expected call of Revoke.
func (mr *MockClientMockRecorder) Revoke(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Revoke", reflect.TypeOf((*MockClient)(nil).Revoke), ctx, id)
}

// TimeToLive mocks base method.
func (m *MockClient) TimeToLive(ctx context.Context, lease clientv3.LeaseID, opts ...clientv3.LeaseOption) (*clientv3.LeaseTimeToLiveResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, lease}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TimeToLive", varargs...)
	ret0, _ := ret[0].(*clientv3.LeaseTimeToLiveResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TimeToLive indicates an expected call of TimeToLive.
func (mr *MockClientMockRecorder) TimeToLive(ctx, lease interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, lease}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TimeToLive", reflect.TypeOf((*MockClient)(nil).TimeToLive), varargs...)
}

// Txn mocks base method.
func (m *MockClient) Txn(ctx context.Context, cmps []clientv3.Cmp, opsThen, opsElse []clientv3.Op) (*clientv3.TxnResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Txn", ctx, cmps, opsThen, opsElse)
	ret0, _ := ret[0].(*clientv3.TxnResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Txn indicates an expected call of Txn.
func (mr *MockClientMockRecorder) Txn(ctx, cmps, opsThen, opsElse interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Txn", reflect.TypeOf((*MockClient)(nil).Txn), ctx, cmps, opsThen, opsElse)
}

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

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

// Watch mocks base method.
func (m *MockClient) Watch(ctx context.Context, key, role string, opts ...clientv3.OpOption) clientv3.WatchChan {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, key, role}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Watch", varargs...)
	ret0, _ := ret[0].(clientv3.WatchChan)
	return ret0
}

// Watch indicates an expected call of Watch.
func (mr *MockClientMockRecorder) Watch(ctx, key, role interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, key, role}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockClient)(nil).Watch), varargs...)
}