// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package mocks

import (
	"github.com/aerospike/backup-go/models"
	"github.com/aerospike/backup-go/pkg/asinfo"
	mock "github.com/stretchr/testify/mock"
)

// NewMockInfoGetter creates a new instance of MockInfoGetter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockInfoGetter(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInfoGetter {
	mock := &MockInfoGetter{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockInfoGetter is an autogenerated mock type for the InfoGetter type
type MockInfoGetter struct {
	mock.Mock
}

type MockInfoGetter_Expecter struct {
	mock *mock.Mock
}

func (_m *MockInfoGetter) EXPECT() *MockInfoGetter_Expecter {
	return &MockInfoGetter_Expecter{mock: &_m.Mock}
}

// BlockMRTWrites provides a mock function for the type MockInfoGetter
func (_mock *MockInfoGetter) BlockMRTWrites(nodeName string, namespace string) error {
	ret := _mock.Called(nodeName, namespace)

	if len(ret) == 0 {
		panic("no return value specified for BlockMRTWrites")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, string) error); ok {
		r0 = returnFunc(nodeName, namespace)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockInfoGetter_BlockMRTWrites_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockMRTWrites'
type MockInfoGetter_BlockMRTWrites_Call struct {
	*mock.Call
}

// BlockMRTWrites is a helper method to define mock.On call
//   - nodeName
//   - namespace
func (_e *MockInfoGetter_Expecter) BlockMRTWrites(nodeName interface{}, namespace interface{}) *MockInfoGetter_BlockMRTWrites_Call {
	return &MockInfoGetter_BlockMRTWrites_Call{Call: _e.mock.On("BlockMRTWrites", nodeName, namespace)}
}

func (_c *MockInfoGetter_BlockMRTWrites_Call) Run(run func(nodeName string, namespace string)) *MockInfoGetter_BlockMRTWrites_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string))
	})
	return _c
}

func (_c *MockInfoGetter_BlockMRTWrites_Call) Return(err error) *MockInfoGetter_BlockMRTWrites_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockInfoGetter_BlockMRTWrites_Call) RunAndReturn(run func(nodeName string, namespace string) error) *MockInfoGetter_BlockMRTWrites_Call {
	_c.Call.Return(run)
	return _c
}

// GetDCsList provides a mock function for the type MockInfoGetter
func (_mock *MockInfoGetter) GetDCsList() ([]string, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetDCsList")
	}

	var r0 []string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() ([]string, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() []string); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockInfoGetter_GetDCsList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDCsList'
type MockInfoGetter_GetDCsList_Call struct {
	*mock.Call
}

// GetDCsList is a helper method to define mock.On call
func (_e *MockInfoGetter_Expecter) GetDCsList() *MockInfoGetter_GetDCsList_Call {
	return &MockInfoGetter_GetDCsList_Call{Call: _e.mock.On("GetDCsList")}
}

func (_c *MockInfoGetter_GetDCsList_Call) Run(run func()) *MockInfoGetter_GetDCsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockInfoGetter_GetDCsList_Call) Return(strings []string, err error) *MockInfoGetter_GetDCsList_Call {
	_c.Call.Return(strings, err)
	return _c
}

func (_c *MockInfoGetter_GetDCsList_Call) RunAndReturn(run func() ([]string, error)) *MockInfoGetter_GetDCsList_Call {
	_c.Call.Return(run)
	return _c
}

// GetNamespacesList provides a mock function for the type MockInfoGetter
func (_mock *MockInfoGetter) GetNamespacesList() ([]string, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetNamespacesList")
	}

	var r0 []string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() ([]string, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() []string); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockInfoGetter_GetNamespacesList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNamespacesList'
type MockInfoGetter_GetNamespacesList_Call struct {
	*mock.Call
}

// GetNamespacesList is a helper method to define mock.On call
func (_e *MockInfoGetter_Expecter) GetNamespacesList() *MockInfoGetter_GetNamespacesList_Call {
	return &MockInfoGetter_GetNamespacesList_Call{Call: _e.mock.On("GetNamespacesList")}
}

func (_c *MockInfoGetter_GetNamespacesList_Call) Run(run func()) *MockInfoGetter_GetNamespacesList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockInfoGetter_GetNamespacesList_Call) Return(strings []string, err error) *MockInfoGetter_GetNamespacesList_Call {
	_c.Call.Return(strings, err)
	return _c
}

func (_c *MockInfoGetter_GetNamespacesList_Call) RunAndReturn(run func() ([]string, error)) *MockInfoGetter_GetNamespacesList_Call {
	_c.Call.Return(run)
	return _c
}

// GetNodesNames provides a mock function for the type MockInfoGetter
func (_mock *MockInfoGetter) GetNodesNames() []string {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetNodesNames")
	}

	var r0 []string
	if returnFunc, ok := ret.Get(0).(func() []string); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	return r0
}

// MockInfoGetter_GetNodesNames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNodesNames'
type MockInfoGetter_GetNodesNames_Call struct {
	*mock.Call
}

// GetNodesNames is a helper method to define mock.On call
func (_e *MockInfoGetter_Expecter) GetNodesNames() *MockInfoGetter_GetNodesNames_Call {
	return &MockInfoGetter_GetNodesNames_Call{Call: _e.mock.On("GetNodesNames")}
}

func (_c *MockInfoGetter_GetNodesNames_Call) Run(run func()) *MockInfoGetter_GetNodesNames_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockInfoGetter_GetNodesNames_Call) Return(strings []string) *MockInfoGetter_GetNodesNames_Call {
	_c.Call.Return(strings)
	return _c
}

func (_c *MockInfoGetter_GetNodesNames_Call) RunAndReturn(run func() []string) *MockInfoGetter_GetNodesNames_Call {
	_c.Call.Return(run)
	return _c
}

// GetRackNodes provides a mock function for the type MockInfoGetter
func (_mock *MockInfoGetter) GetRackNodes(rackID int) ([]string, error) {
	ret := _mock.Called(rackID)

	if len(ret) == 0 {
		panic("no return value specified for GetRackNodes")
	}

	var r0 []string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int) ([]string, error)); ok {
		return returnFunc(rackID)
	}
	if returnFunc, ok := ret.Get(0).(func(int) []string); ok {
		r0 = returnFunc(rackID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int) error); ok {
		r1 = returnFunc(rackID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockInfoGetter_GetRackNodes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRackNodes'
type MockInfoGetter_GetRackNodes_Call struct {
	*mock.Call
}

// GetRackNodes is a helper method to define mock.On call
//   - rackID
func (_e *MockInfoGetter_Expecter) GetRackNodes(rackID interface{}) *MockInfoGetter_GetRackNodes_Call {
	return &MockInfoGetter_GetRackNodes_Call{Call: _e.mock.On("GetRackNodes", rackID)}
}

func (_c *MockInfoGetter_GetRackNodes_Call) Run(run func(rackID int)) *MockInfoGetter_GetRackNodes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int))
	})
	return _c
}

func (_c *MockInfoGetter_GetRackNodes_Call) Return(strings []string, err error) *MockInfoGetter_GetRackNodes_Call {
	_c.Call.Return(strings, err)
	return _c
}

func (_c *MockInfoGetter_GetRackNodes_Call) RunAndReturn(run func(rackID int) ([]string, error)) *MockInfoGetter_GetRackNodes_Call {
	_c.Call.Return(run)
	return _c
}

// GetRecordCount provides a mock function for the type MockInfoGetter
func (_mock *MockInfoGetter) GetRecordCount(namespace string, sets []string) (uint64, error) {
	ret := _mock.Called(namespace, sets)

	if len(ret) == 0 {
		panic("no return value specified for GetRecordCount")
	}

	var r0 uint64
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string, []string) (uint64, error)); ok {
		return returnFunc(namespace, sets)
	}
	if returnFunc, ok := ret.Get(0).(func(string, []string) uint64); ok {
		r0 = returnFunc(namespace, sets)
	} else {
		r0 = ret.Get(0).(uint64)
	}
	if returnFunc, ok := ret.Get(1).(func(string, []string) error); ok {
		r1 = returnFunc(namespace, sets)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockInfoGetter_GetRecordCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecordCount'
type MockInfoGetter_GetRecordCount_Call struct {
	*mock.Call
}

// GetRecordCount is a helper method to define mock.On call
//   - namespace
//   - sets
func (_e *MockInfoGetter_Expecter) GetRecordCount(namespace interface{}, sets interface{}) *MockInfoGetter_GetRecordCount_Call {
	return &MockInfoGetter_GetRecordCount_Call{Call: _e.mock.On("GetRecordCount", namespace, sets)}
}

func (_c *MockInfoGetter_GetRecordCount_Call) Run(run func(namespace string, sets []string)) *MockInfoGetter_GetRecordCount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].([]string))
	})
	return _c
}

func (_c *MockInfoGetter_GetRecordCount_Call) Return(v uint64, err error) *MockInfoGetter_GetRecordCount_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *MockInfoGetter_GetRecordCount_Call) RunAndReturn(run func(namespace string, sets []string) (uint64, error)) *MockInfoGetter_GetRecordCount_Call {
	_c.Call.Return(run)
	return _c
}

// GetSIndexes provides a mock function for the type MockInfoGetter
func (_mock *MockInfoGetter) GetSIndexes(namespace string) ([]*models.SIndex, error) {
	ret := _mock.Called(namespace)

	if len(ret) == 0 {
		panic("no return value specified for GetSIndexes")
	}

	var r0 []*models.SIndex
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string) ([]*models.SIndex, error)); ok {
		return returnFunc(namespace)
	}
	if returnFunc, ok := ret.Get(0).(func(string) []*models.SIndex); ok {
		r0 = returnFunc(namespace)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*models.SIndex)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
		r1 = returnFunc(namespace)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockInfoGetter_GetSIndexes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSIndexes'
type MockInfoGetter_GetSIndexes_Call struct {
	*mock.Call
}

// GetSIndexes is a helper method to define mock.On call
//   - namespace
func (_e *MockInfoGetter_Expecter) GetSIndexes(namespace interface{}) *MockInfoGetter_GetSIndexes_Call {
	return &MockInfoGetter_GetSIndexes_Call{Call: _e.mock.On("GetSIndexes", namespace)}
}

func (_c *MockInfoGetter_GetSIndexes_Call) Run(run func(namespace string)) *MockInfoGetter_GetSIndexes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockInfoGetter_GetSIndexes_Call) Return(sIndexs []*models.SIndex, err error) *MockInfoGetter_GetSIndexes_Call {
	_c.Call.Return(sIndexs, err)
	return _c
}

func (_c *MockInfoGetter_GetSIndexes_Call) RunAndReturn(run func(namespace string) ([]*models.SIndex, error)) *MockInfoGetter_GetSIndexes_Call {
	_c.Call.Return(run)
	return _c
}

// GetService provides a mock function for the type MockInfoGetter
func (_mock *MockInfoGetter) GetService(node string) (string, error) {
	ret := _mock.Called(node)

	if len(ret) == 0 {
		panic("no return value specified for GetService")
	}

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string) (string, error)); ok {
		return returnFunc(node)
	}
	if returnFunc, ok := ret.Get(0).(func(string) string); ok {
		r0 = returnFunc(node)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
		r1 = returnFunc(node)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockInfoGetter_GetService_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetService'
type MockInfoGetter_GetService_Call struct {
	*mock.Call
}

// GetService is a helper method to define mock.On call
//   - node
func (_e *MockInfoGetter_Expecter) GetService(node interface{}) *MockInfoGetter_GetService_Call {
	return &MockInfoGetter_GetService_Call{Call: _e.mock.On("GetService", node)}
}

func (_c *MockInfoGetter_GetService_Call) Run(run func(node string)) *MockInfoGetter_GetService_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockInfoGetter_GetService_Call) Return(s string, err error) *MockInfoGetter_GetService_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockInfoGetter_GetService_Call) RunAndReturn(run func(node string) (string, error)) *MockInfoGetter_GetService_Call {
	_c.Call.Return(run)
	return _c
}

// GetSetsList provides a mock function for the type MockInfoGetter
func (_mock *MockInfoGetter) GetSetsList(namespace string) ([]string, error) {
	ret := _mock.Called(namespace)

	if len(ret) == 0 {
		panic("no return value specified for GetSetsList")
	}

	var r0 []string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string) ([]string, error)); ok {
		return returnFunc(namespace)
	}
	if returnFunc, ok := ret.Get(0).(func(string) []string); ok {
		r0 = returnFunc(namespace)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
		r1 = returnFunc(namespace)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockInfoGetter_GetSetsList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSetsList'
type MockInfoGetter_GetSetsList_Call struct {
	*mock.Call
}

// GetSetsList is a helper method to define mock.On call
//   - namespace
func (_e *MockInfoGetter_Expecter) GetSetsList(namespace interface{}) *MockInfoGetter_GetSetsList_Call {
	return &MockInfoGetter_GetSetsList_Call{Call: _e.mock.On("GetSetsList", namespace)}
}

func (_c *MockInfoGetter_GetSetsList_Call) Run(run func(namespace string)) *MockInfoGetter_GetSetsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockInfoGetter_GetSetsList_Call) Return(strings []string, err error) *MockInfoGetter_GetSetsList_Call {
	_c.Call.Return(strings, err)
	return _c
}

func (_c *MockInfoGetter_GetSetsList_Call) RunAndReturn(run func(namespace string) ([]string, error)) *MockInfoGetter_GetSetsList_Call {
	_c.Call.Return(run)
	return _c
}

// GetStats provides a mock function for the type MockInfoGetter
func (_mock *MockInfoGetter) GetStats(nodeName string, dc string, namespace string) (asinfo.Stats, error) {
	ret := _mock.Called(nodeName, dc, namespace)

	if len(ret) == 0 {
		panic("no return value specified for GetStats")
	}

	var r0 asinfo.Stats
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string, string, string) (asinfo.Stats, error)); ok {
		return returnFunc(nodeName, dc, namespace)
	}
	if returnFunc, ok := ret.Get(0).(func(string, string, string) asinfo.Stats); ok {
		r0 = returnFunc(nodeName, dc, namespace)
	} else {
		r0 = ret.Get(0).(asinfo.Stats)
	}
	if returnFunc, ok := ret.Get(1).(func(string, string, string) error); ok {
		r1 = returnFunc(nodeName, dc, namespace)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockInfoGetter_GetStats_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStats'
type MockInfoGetter_GetStats_Call struct {
	*mock.Call
}

// GetStats is a helper method to define mock.On call
//   - nodeName
//   - dc
//   - namespace
func (_e *MockInfoGetter_Expecter) GetStats(nodeName interface{}, dc interface{}, namespace interface{}) *MockInfoGetter_GetStats_Call {
	return &MockInfoGetter_GetStats_Call{Call: _e.mock.On("GetStats", nodeName, dc, namespace)}
}

func (_c *MockInfoGetter_GetStats_Call) Run(run func(nodeName string, dc string, namespace string)) *MockInfoGetter_GetStats_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockInfoGetter_GetStats_Call) Return(stats asinfo.Stats, err error) *MockInfoGetter_GetStats_Call {
	_c.Call.Return(stats, err)
	return _c
}

func (_c *MockInfoGetter_GetStats_Call) RunAndReturn(run func(nodeName string, dc string, namespace string) (asinfo.Stats, error)) *MockInfoGetter_GetStats_Call {
	_c.Call.Return(run)
	return _c
}

// GetStatus provides a mock function for the type MockInfoGetter
func (_mock *MockInfoGetter) GetStatus() (string, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetStatus")
	}

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockInfoGetter_GetStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStatus'
type MockInfoGetter_GetStatus_Call struct {
	*mock.Call
}

// GetStatus is a helper method to define mock.On call
func (_e *MockInfoGetter_Expecter) GetStatus() *MockInfoGetter_GetStatus_Call {
	return &MockInfoGetter_GetStatus_Call{Call: _e.mock.On("GetStatus")}
}

func (_c *MockInfoGetter_GetStatus_Call) Run(run func()) *MockInfoGetter_GetStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockInfoGetter_GetStatus_Call) Return(s string, err error) *MockInfoGetter_GetStatus_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockInfoGetter_GetStatus_Call) RunAndReturn(run func() (string, error)) *MockInfoGetter_GetStatus_Call {
	_c.Call.Return(run)
	return _c
}

// GetUDFs provides a mock function for the type MockInfoGetter
func (_mock *MockInfoGetter) GetUDFs() ([]*models.UDF, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetUDFs")
	}

	var r0 []*models.UDF
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() ([]*models.UDF, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() []*models.UDF); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*models.UDF)
		}
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockInfoGetter_GetUDFs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUDFs'
type MockInfoGetter_GetUDFs_Call struct {
	*mock.Call
}

// GetUDFs is a helper method to define mock.On call
func (_e *MockInfoGetter_Expecter) GetUDFs() *MockInfoGetter_GetUDFs_Call {
	return &MockInfoGetter_GetUDFs_Call{Call: _e.mock.On("GetUDFs")}
}

func (_c *MockInfoGetter_GetUDFs_Call) Run(run func()) *MockInfoGetter_GetUDFs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockInfoGetter_GetUDFs_Call) Return(uDFs []*models.UDF, err error) *MockInfoGetter_GetUDFs_Call {
	_c.Call.Return(uDFs, err)
	return _c
}

func (_c *MockInfoGetter_GetUDFs_Call) RunAndReturn(run func() ([]*models.UDF, error)) *MockInfoGetter_GetUDFs_Call {
	_c.Call.Return(run)
	return _c
}

// GetVersion provides a mock function for the type MockInfoGetter
func (_mock *MockInfoGetter) GetVersion() (asinfo.AerospikeVersion, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetVersion")
	}

	var r0 asinfo.AerospikeVersion
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (asinfo.AerospikeVersion, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() asinfo.AerospikeVersion); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(asinfo.AerospikeVersion)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockInfoGetter_GetVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVersion'
type MockInfoGetter_GetVersion_Call struct {
	*mock.Call
}

// GetVersion is a helper method to define mock.On call
func (_e *MockInfoGetter_Expecter) GetVersion() *MockInfoGetter_GetVersion_Call {
	return &MockInfoGetter_GetVersion_Call{Call: _e.mock.On("GetVersion")}
}

func (_c *MockInfoGetter_GetVersion_Call) Run(run func()) *MockInfoGetter_GetVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockInfoGetter_GetVersion_Call) Return(aerospikeVersion asinfo.AerospikeVersion, err error) *MockInfoGetter_GetVersion_Call {
	_c.Call.Return(aerospikeVersion, err)
	return _c
}

func (_c *MockInfoGetter_GetVersion_Call) RunAndReturn(run func() (asinfo.AerospikeVersion, error)) *MockInfoGetter_GetVersion_Call {
	_c.Call.Return(run)
	return _c
}

// HasExpressionSIndex provides a mock function for the type MockInfoGetter
func (_mock *MockInfoGetter) HasExpressionSIndex(namespace string) (bool, error) {
	ret := _mock.Called(namespace)

	if len(ret) == 0 {
		panic("no return value specified for HasExpressionSIndex")
	}

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string) (bool, error)); ok {
		return returnFunc(namespace)
	}
	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
		r0 = returnFunc(namespace)
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
		r1 = returnFunc(namespace)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockInfoGetter_HasExpressionSIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasExpressionSIndex'
type MockInfoGetter_HasExpressionSIndex_Call struct {
	*mock.Call
}

// HasExpressionSIndex is a helper method to define mock.On call
//   - namespace
func (_e *MockInfoGetter_Expecter) HasExpressionSIndex(namespace interface{}) *MockInfoGetter_HasExpressionSIndex_Call {
	return &MockInfoGetter_HasExpressionSIndex_Call{Call: _e.mock.On("HasExpressionSIndex", namespace)}
}

func (_c *MockInfoGetter_HasExpressionSIndex_Call) Run(run func(namespace string)) *MockInfoGetter_HasExpressionSIndex_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockInfoGetter_HasExpressionSIndex_Call) Return(b bool, err error) *MockInfoGetter_HasExpressionSIndex_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *MockInfoGetter_HasExpressionSIndex_Call) RunAndReturn(run func(namespace string) (bool, error)) *MockInfoGetter_HasExpressionSIndex_Call {
	_c.Call.Return(run)
	return _c
}

// StartXDR provides a mock function for the type MockInfoGetter
func (_mock *MockInfoGetter) StartXDR(nodeName string, dc string, hostPort string, namespace string, rewind string, throughput int, forward bool) error {
	ret := _mock.Called(nodeName, dc, hostPort, namespace, rewind, throughput, forward)

	if len(ret) == 0 {
		panic("no return value specified for StartXDR")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, string, string, string, string, int, bool) error); ok {
		r0 = returnFunc(nodeName, dc, hostPort, namespace, rewind, throughput, forward)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockInfoGetter_StartXDR_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartXDR'
type MockInfoGetter_StartXDR_Call struct {
	*mock.Call
}

// StartXDR is a helper method to define mock.On call
//   - nodeName
//   - dc
//   - hostPort
//   - namespace
//   - rewind
//   - throughput
//   - forward
func (_e *MockInfoGetter_Expecter) StartXDR(nodeName interface{}, dc interface{}, hostPort interface{}, namespace interface{}, rewind interface{}, throughput interface{}, forward interface{}) *MockInfoGetter_StartXDR_Call {
	return &MockInfoGetter_StartXDR_Call{Call: _e.mock.On("StartXDR", nodeName, dc, hostPort, namespace, rewind, throughput, forward)}
}

func (_c *MockInfoGetter_StartXDR_Call) Run(run func(nodeName string, dc string, hostPort string, namespace string, rewind string, throughput int, forward bool)) *MockInfoGetter_StartXDR_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(int), args[6].(bool))
	})
	return _c
}

func (_c *MockInfoGetter_StartXDR_Call) Return(err error) *MockInfoGetter_StartXDR_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockInfoGetter_StartXDR_Call) RunAndReturn(run func(nodeName string, dc string, hostPort string, namespace string, rewind string, throughput int, forward bool) error) *MockInfoGetter_StartXDR_Call {
	_c.Call.Return(run)
	return _c
}

// StopXDR provides a mock function for the type MockInfoGetter
func (_mock *MockInfoGetter) StopXDR(nodeName string, dc string) error {
	ret := _mock.Called(nodeName, dc)

	if len(ret) == 0 {
		panic("no return value specified for StopXDR")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, string) error); ok {
		r0 = returnFunc(nodeName, dc)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockInfoGetter_StopXDR_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StopXDR'
type MockInfoGetter_StopXDR_Call struct {
	*mock.Call
}

// StopXDR is a helper method to define mock.On call
//   - nodeName
//   - dc
func (_e *MockInfoGetter_Expecter) StopXDR(nodeName interface{}, dc interface{}) *MockInfoGetter_StopXDR_Call {
	return &MockInfoGetter_StopXDR_Call{Call: _e.mock.On("StopXDR", nodeName, dc)}
}

func (_c *MockInfoGetter_StopXDR_Call) Run(run func(nodeName string, dc string)) *MockInfoGetter_StopXDR_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string))
	})
	return _c
}

func (_c *MockInfoGetter_StopXDR_Call) Return(err error) *MockInfoGetter_StopXDR_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockInfoGetter_StopXDR_Call) RunAndReturn(run func(nodeName string, dc string) error) *MockInfoGetter_StopXDR_Call {
	_c.Call.Return(run)
	return _c
}

// SupportsBatchWrite provides a mock function for the type MockInfoGetter
func (_mock *MockInfoGetter) SupportsBatchWrite() (bool, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for SupportsBatchWrite")
	}

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (bool, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockInfoGetter_SupportsBatchWrite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SupportsBatchWrite'
type MockInfoGetter_SupportsBatchWrite_Call struct {
	*mock.Call
}

// SupportsBatchWrite is a helper method to define mock.On call
func (_e *MockInfoGetter_Expecter) SupportsBatchWrite() *MockInfoGetter_SupportsBatchWrite_Call {
	return &MockInfoGetter_SupportsBatchWrite_Call{Call: _e.mock.On("SupportsBatchWrite")}
}

func (_c *MockInfoGetter_SupportsBatchWrite_Call) Run(run func()) *MockInfoGetter_SupportsBatchWrite_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockInfoGetter_SupportsBatchWrite_Call) Return(b bool, err error) *MockInfoGetter_SupportsBatchWrite_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *MockInfoGetter_SupportsBatchWrite_Call) RunAndReturn(run func() (bool, error)) *MockInfoGetter_SupportsBatchWrite_Call {
	_c.Call.Return(run)
	return _c
}

// UnBlockMRTWrites provides a mock function for the type MockInfoGetter
func (_mock *MockInfoGetter) UnBlockMRTWrites(nodeName string, namespace string) error {
	ret := _mock.Called(nodeName, namespace)

	if len(ret) == 0 {
		panic("no return value specified for UnBlockMRTWrites")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, string) error); ok {
		r0 = returnFunc(nodeName, namespace)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockInfoGetter_UnBlockMRTWrites_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnBlockMRTWrites'
type MockInfoGetter_UnBlockMRTWrites_Call struct {
	*mock.Call
}

// UnBlockMRTWrites is a helper method to define mock.On call
//   - nodeName
//   - namespace
func (_e *MockInfoGetter_Expecter) UnBlockMRTWrites(nodeName interface{}, namespace interface{}) *MockInfoGetter_UnBlockMRTWrites_Call {
	return &MockInfoGetter_UnBlockMRTWrites_Call{Call: _e.mock.On("UnBlockMRTWrites", nodeName, namespace)}
}

func (_c *MockInfoGetter_UnBlockMRTWrites_Call) Run(run func(nodeName string, namespace string)) *MockInfoGetter_UnBlockMRTWrites_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string))
	})
	return _c
}

func (_c *MockInfoGetter_UnBlockMRTWrites_Call) Return(err error) *MockInfoGetter_UnBlockMRTWrites_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockInfoGetter_UnBlockMRTWrites_Call) RunAndReturn(run func(nodeName string, namespace string) error) *MockInfoGetter_UnBlockMRTWrites_Call {
	_c.Call.Return(run)
	return _c
}
