// Code generated by mockery v2.46.0. DO NOT EDIT.

package meta

import mock "github.com/stretchr/testify/mock"

// MockReplica is an autogenerated mock type for the ReplicaInterface type
type MockReplica struct {
	mock.Mock
}

type MockReplica_Expecter struct {
	mock *mock.Mock
}

func (_m *MockReplica) EXPECT() *MockReplica_Expecter {
	return &MockReplica_Expecter{mock: &_m.Mock}
}

// ContainRONode provides a mock function with given fields: node
func (_m *MockReplica) ContainRONode(node int64) bool {
	ret := _m.Called(node)

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

	var r0 bool
	if rf, ok := ret.Get(0).(func(int64) bool); ok {
		r0 = rf(node)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

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

// ContainRONode is a helper method to define mock.On call
//   - node int64
func (_e *MockReplica_Expecter) ContainRONode(node interface{}) *MockReplica_ContainRONode_Call {
	return &MockReplica_ContainRONode_Call{Call: _e.mock.On("ContainRONode", node)}
}

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

func (_c *MockReplica_ContainRONode_Call) Return(_a0 bool) *MockReplica_ContainRONode_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplica_ContainRONode_Call) RunAndReturn(run func(int64) bool) *MockReplica_ContainRONode_Call {
	_c.Call.Return(run)
	return _c
}

// ContainROSQNode provides a mock function with given fields: node
func (_m *MockReplica) ContainROSQNode(node int64) bool {
	ret := _m.Called(node)

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

	var r0 bool
	if rf, ok := ret.Get(0).(func(int64) bool); ok {
		r0 = rf(node)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

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

// ContainROSQNode is a helper method to define mock.On call
//   - node int64
func (_e *MockReplica_Expecter) ContainROSQNode(node interface{}) *MockReplica_ContainROSQNode_Call {
	return &MockReplica_ContainROSQNode_Call{Call: _e.mock.On("ContainROSQNode", node)}
}

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

func (_c *MockReplica_ContainROSQNode_Call) Return(_a0 bool) *MockReplica_ContainROSQNode_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplica_ContainROSQNode_Call) RunAndReturn(run func(int64) bool) *MockReplica_ContainROSQNode_Call {
	_c.Call.Return(run)
	return _c
}

// ContainRWNode provides a mock function with given fields: node
func (_m *MockReplica) ContainRWNode(node int64) bool {
	ret := _m.Called(node)

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

	var r0 bool
	if rf, ok := ret.Get(0).(func(int64) bool); ok {
		r0 = rf(node)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

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

// ContainRWNode is a helper method to define mock.On call
//   - node int64
func (_e *MockReplica_Expecter) ContainRWNode(node interface{}) *MockReplica_ContainRWNode_Call {
	return &MockReplica_ContainRWNode_Call{Call: _e.mock.On("ContainRWNode", node)}
}

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

func (_c *MockReplica_ContainRWNode_Call) Return(_a0 bool) *MockReplica_ContainRWNode_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplica_ContainRWNode_Call) RunAndReturn(run func(int64) bool) *MockReplica_ContainRWNode_Call {
	_c.Call.Return(run)
	return _c
}

// ContainRWSQNode provides a mock function with given fields: node
func (_m *MockReplica) ContainRWSQNode(node int64) bool {
	ret := _m.Called(node)

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

	var r0 bool
	if rf, ok := ret.Get(0).(func(int64) bool); ok {
		r0 = rf(node)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

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

// ContainRWSQNode is a helper method to define mock.On call
//   - node int64
func (_e *MockReplica_Expecter) ContainRWSQNode(node interface{}) *MockReplica_ContainRWSQNode_Call {
	return &MockReplica_ContainRWSQNode_Call{Call: _e.mock.On("ContainRWSQNode", node)}
}

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

func (_c *MockReplica_ContainRWSQNode_Call) Return(_a0 bool) *MockReplica_ContainRWSQNode_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplica_ContainRWSQNode_Call) RunAndReturn(run func(int64) bool) *MockReplica_ContainRWSQNode_Call {
	_c.Call.Return(run)
	return _c
}

// ContainSQNode provides a mock function with given fields: node
func (_m *MockReplica) ContainSQNode(node int64) bool {
	ret := _m.Called(node)

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

	var r0 bool
	if rf, ok := ret.Get(0).(func(int64) bool); ok {
		r0 = rf(node)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

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

// ContainSQNode is a helper method to define mock.On call
//   - node int64
func (_e *MockReplica_Expecter) ContainSQNode(node interface{}) *MockReplica_ContainSQNode_Call {
	return &MockReplica_ContainSQNode_Call{Call: _e.mock.On("ContainSQNode", node)}
}

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

func (_c *MockReplica_ContainSQNode_Call) Return(_a0 bool) *MockReplica_ContainSQNode_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplica_ContainSQNode_Call) RunAndReturn(run func(int64) bool) *MockReplica_ContainSQNode_Call {
	_c.Call.Return(run)
	return _c
}

// Contains provides a mock function with given fields: node
func (_m *MockReplica) Contains(node int64) bool {
	ret := _m.Called(node)

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

	var r0 bool
	if rf, ok := ret.Get(0).(func(int64) bool); ok {
		r0 = rf(node)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

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

// Contains is a helper method to define mock.On call
//   - node int64
func (_e *MockReplica_Expecter) Contains(node interface{}) *MockReplica_Contains_Call {
	return &MockReplica_Contains_Call{Call: _e.mock.On("Contains", node)}
}

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

func (_c *MockReplica_Contains_Call) Return(_a0 bool) *MockReplica_Contains_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplica_Contains_Call) RunAndReturn(run func(int64) bool) *MockReplica_Contains_Call {
	_c.Call.Return(run)
	return _c
}

// GetCollectionID provides a mock function with given fields:
func (_m *MockReplica) GetCollectionID() int64 {
	ret := _m.Called()

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

	var r0 int64
	if rf, ok := ret.Get(0).(func() int64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int64)
	}

	return r0
}

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

// GetCollectionID is a helper method to define mock.On call
func (_e *MockReplica_Expecter) GetCollectionID() *MockReplica_GetCollectionID_Call {
	return &MockReplica_GetCollectionID_Call{Call: _e.mock.On("GetCollectionID")}
}

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

func (_c *MockReplica_GetCollectionID_Call) Return(_a0 int64) *MockReplica_GetCollectionID_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplica_GetCollectionID_Call) RunAndReturn(run func() int64) *MockReplica_GetCollectionID_Call {
	_c.Call.Return(run)
	return _c
}

// GetID provides a mock function with given fields:
func (_m *MockReplica) GetID() int64 {
	ret := _m.Called()

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

	var r0 int64
	if rf, ok := ret.Get(0).(func() int64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int64)
	}

	return r0
}

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

// GetID is a helper method to define mock.On call
func (_e *MockReplica_Expecter) GetID() *MockReplica_GetID_Call {
	return &MockReplica_GetID_Call{Call: _e.mock.On("GetID")}
}

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

func (_c *MockReplica_GetID_Call) Return(_a0 int64) *MockReplica_GetID_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplica_GetID_Call) RunAndReturn(run func() int64) *MockReplica_GetID_Call {
	_c.Call.Return(run)
	return _c
}

// GetNodes provides a mock function with given fields:
func (_m *MockReplica) GetNodes() []int64 {
	ret := _m.Called()

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

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

	return r0
}

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

// GetNodes is a helper method to define mock.On call
func (_e *MockReplica_Expecter) GetNodes() *MockReplica_GetNodes_Call {
	return &MockReplica_GetNodes_Call{Call: _e.mock.On("GetNodes")}
}

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

func (_c *MockReplica_GetNodes_Call) Return(_a0 []int64) *MockReplica_GetNodes_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplica_GetNodes_Call) RunAndReturn(run func() []int64) *MockReplica_GetNodes_Call {
	_c.Call.Return(run)
	return _c
}

// GetRONodes provides a mock function with given fields:
func (_m *MockReplica) GetRONodes() []int64 {
	ret := _m.Called()

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

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

	return r0
}

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

// GetRONodes is a helper method to define mock.On call
func (_e *MockReplica_Expecter) GetRONodes() *MockReplica_GetRONodes_Call {
	return &MockReplica_GetRONodes_Call{Call: _e.mock.On("GetRONodes")}
}

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

func (_c *MockReplica_GetRONodes_Call) Return(_a0 []int64) *MockReplica_GetRONodes_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplica_GetRONodes_Call) RunAndReturn(run func() []int64) *MockReplica_GetRONodes_Call {
	_c.Call.Return(run)
	return _c
}

// GetROSQNodes provides a mock function with given fields:
func (_m *MockReplica) GetROSQNodes() []int64 {
	ret := _m.Called()

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

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

	return r0
}

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

// GetROSQNodes is a helper method to define mock.On call
func (_e *MockReplica_Expecter) GetROSQNodes() *MockReplica_GetROSQNodes_Call {
	return &MockReplica_GetROSQNodes_Call{Call: _e.mock.On("GetROSQNodes")}
}

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

func (_c *MockReplica_GetROSQNodes_Call) Return(_a0 []int64) *MockReplica_GetROSQNodes_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplica_GetROSQNodes_Call) RunAndReturn(run func() []int64) *MockReplica_GetROSQNodes_Call {
	_c.Call.Return(run)
	return _c
}

// GetRWNodes provides a mock function with given fields:
func (_m *MockReplica) GetRWNodes() []int64 {
	ret := _m.Called()

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

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

	return r0
}

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

// GetRWNodes is a helper method to define mock.On call
func (_e *MockReplica_Expecter) GetRWNodes() *MockReplica_GetRWNodes_Call {
	return &MockReplica_GetRWNodes_Call{Call: _e.mock.On("GetRWNodes")}
}

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

func (_c *MockReplica_GetRWNodes_Call) Return(_a0 []int64) *MockReplica_GetRWNodes_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplica_GetRWNodes_Call) RunAndReturn(run func() []int64) *MockReplica_GetRWNodes_Call {
	_c.Call.Return(run)
	return _c
}

// GetRWSQNodes provides a mock function with given fields:
func (_m *MockReplica) GetRWSQNodes() []int64 {
	ret := _m.Called()

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

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

	return r0
}

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

// GetRWSQNodes is a helper method to define mock.On call
func (_e *MockReplica_Expecter) GetRWSQNodes() *MockReplica_GetRWSQNodes_Call {
	return &MockReplica_GetRWSQNodes_Call{Call: _e.mock.On("GetRWSQNodes")}
}

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

func (_c *MockReplica_GetRWSQNodes_Call) Return(_a0 []int64) *MockReplica_GetRWSQNodes_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplica_GetRWSQNodes_Call) RunAndReturn(run func() []int64) *MockReplica_GetRWSQNodes_Call {
	_c.Call.Return(run)
	return _c
}

// GetResourceGroup provides a mock function with given fields:
func (_m *MockReplica) GetResourceGroup() string {
	ret := _m.Called()

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

	var r0 string
	if rf, ok := ret.Get(0).(func() string); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(string)
	}

	return r0
}

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

// GetResourceGroup is a helper method to define mock.On call
func (_e *MockReplica_Expecter) GetResourceGroup() *MockReplica_GetResourceGroup_Call {
	return &MockReplica_GetResourceGroup_Call{Call: _e.mock.On("GetResourceGroup")}
}

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

func (_c *MockReplica_GetResourceGroup_Call) Return(_a0 string) *MockReplica_GetResourceGroup_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplica_GetResourceGroup_Call) RunAndReturn(run func() string) *MockReplica_GetResourceGroup_Call {
	_c.Call.Return(run)
	return _c
}

// NodesCount provides a mock function with given fields:
func (_m *MockReplica) NodesCount() int {
	ret := _m.Called()

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

	var r0 int
	if rf, ok := ret.Get(0).(func() int); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int)
	}

	return r0
}

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

// NodesCount is a helper method to define mock.On call
func (_e *MockReplica_Expecter) NodesCount() *MockReplica_NodesCount_Call {
	return &MockReplica_NodesCount_Call{Call: _e.mock.On("NodesCount")}
}

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

func (_c *MockReplica_NodesCount_Call) Return(_a0 int) *MockReplica_NodesCount_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplica_NodesCount_Call) RunAndReturn(run func() int) *MockReplica_NodesCount_Call {
	_c.Call.Return(run)
	return _c
}

// RONodesCount provides a mock function with given fields:
func (_m *MockReplica) RONodesCount() int {
	ret := _m.Called()

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

	var r0 int
	if rf, ok := ret.Get(0).(func() int); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int)
	}

	return r0
}

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

// RONodesCount is a helper method to define mock.On call
func (_e *MockReplica_Expecter) RONodesCount() *MockReplica_RONodesCount_Call {
	return &MockReplica_RONodesCount_Call{Call: _e.mock.On("RONodesCount")}
}

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

func (_c *MockReplica_RONodesCount_Call) Return(_a0 int) *MockReplica_RONodesCount_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplica_RONodesCount_Call) RunAndReturn(run func() int) *MockReplica_RONodesCount_Call {
	_c.Call.Return(run)
	return _c
}

// ROSQNodesCount provides a mock function with given fields:
func (_m *MockReplica) ROSQNodesCount() int {
	ret := _m.Called()

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

	var r0 int
	if rf, ok := ret.Get(0).(func() int); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int)
	}

	return r0
}

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

// ROSQNodesCount is a helper method to define mock.On call
func (_e *MockReplica_Expecter) ROSQNodesCount() *MockReplica_ROSQNodesCount_Call {
	return &MockReplica_ROSQNodesCount_Call{Call: _e.mock.On("ROSQNodesCount")}
}

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

func (_c *MockReplica_ROSQNodesCount_Call) Return(_a0 int) *MockReplica_ROSQNodesCount_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplica_ROSQNodesCount_Call) RunAndReturn(run func() int) *MockReplica_ROSQNodesCount_Call {
	_c.Call.Return(run)
	return _c
}

// RWNodesCount provides a mock function with given fields:
func (_m *MockReplica) RWNodesCount() int {
	ret := _m.Called()

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

	var r0 int
	if rf, ok := ret.Get(0).(func() int); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int)
	}

	return r0
}

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

// RWNodesCount is a helper method to define mock.On call
func (_e *MockReplica_Expecter) RWNodesCount() *MockReplica_RWNodesCount_Call {
	return &MockReplica_RWNodesCount_Call{Call: _e.mock.On("RWNodesCount")}
}

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

func (_c *MockReplica_RWNodesCount_Call) Return(_a0 int) *MockReplica_RWNodesCount_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplica_RWNodesCount_Call) RunAndReturn(run func() int) *MockReplica_RWNodesCount_Call {
	_c.Call.Return(run)
	return _c
}

// RWSQNodesCount provides a mock function with given fields:
func (_m *MockReplica) RWSQNodesCount() int {
	ret := _m.Called()

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

	var r0 int
	if rf, ok := ret.Get(0).(func() int); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int)
	}

	return r0
}

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

// RWSQNodesCount is a helper method to define mock.On call
func (_e *MockReplica_Expecter) RWSQNodesCount() *MockReplica_RWSQNodesCount_Call {
	return &MockReplica_RWSQNodesCount_Call{Call: _e.mock.On("RWSQNodesCount")}
}

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

func (_c *MockReplica_RWSQNodesCount_Call) Return(_a0 int) *MockReplica_RWSQNodesCount_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplica_RWSQNodesCount_Call) RunAndReturn(run func() int) *MockReplica_RWSQNodesCount_Call {
	_c.Call.Return(run)
	return _c
}

// RangeOverRONodes provides a mock function with given fields: f
func (_m *MockReplica) RangeOverRONodes(f func(int64) bool) {
	_m.Called(f)
}

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

// RangeOverRONodes is a helper method to define mock.On call
//   - f func(int64) bool
func (_e *MockReplica_Expecter) RangeOverRONodes(f interface{}) *MockReplica_RangeOverRONodes_Call {
	return &MockReplica_RangeOverRONodes_Call{Call: _e.mock.On("RangeOverRONodes", f)}
}

func (_c *MockReplica_RangeOverRONodes_Call) Run(run func(f func(int64) bool)) *MockReplica_RangeOverRONodes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(int64) bool))
	})
	return _c
}

func (_c *MockReplica_RangeOverRONodes_Call) Return() *MockReplica_RangeOverRONodes_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockReplica_RangeOverRONodes_Call) RunAndReturn(run func(func(int64) bool)) *MockReplica_RangeOverRONodes_Call {
	_c.Call.Return(run)
	return _c
}

// RangeOverROSQNodes provides a mock function with given fields: f
func (_m *MockReplica) RangeOverROSQNodes(f func(int64) bool) {
	_m.Called(f)
}

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

// RangeOverROSQNodes is a helper method to define mock.On call
//   - f func(int64) bool
func (_e *MockReplica_Expecter) RangeOverROSQNodes(f interface{}) *MockReplica_RangeOverROSQNodes_Call {
	return &MockReplica_RangeOverROSQNodes_Call{Call: _e.mock.On("RangeOverROSQNodes", f)}
}

func (_c *MockReplica_RangeOverROSQNodes_Call) Run(run func(f func(int64) bool)) *MockReplica_RangeOverROSQNodes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(int64) bool))
	})
	return _c
}

func (_c *MockReplica_RangeOverROSQNodes_Call) Return() *MockReplica_RangeOverROSQNodes_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockReplica_RangeOverROSQNodes_Call) RunAndReturn(run func(func(int64) bool)) *MockReplica_RangeOverROSQNodes_Call {
	_c.Call.Return(run)
	return _c
}

// RangeOverRWNodes provides a mock function with given fields: f
func (_m *MockReplica) RangeOverRWNodes(f func(int64) bool) {
	_m.Called(f)
}

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

// RangeOverRWNodes is a helper method to define mock.On call
//   - f func(int64) bool
func (_e *MockReplica_Expecter) RangeOverRWNodes(f interface{}) *MockReplica_RangeOverRWNodes_Call {
	return &MockReplica_RangeOverRWNodes_Call{Call: _e.mock.On("RangeOverRWNodes", f)}
}

func (_c *MockReplica_RangeOverRWNodes_Call) Run(run func(f func(int64) bool)) *MockReplica_RangeOverRWNodes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(int64) bool))
	})
	return _c
}

func (_c *MockReplica_RangeOverRWNodes_Call) Return() *MockReplica_RangeOverRWNodes_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockReplica_RangeOverRWNodes_Call) RunAndReturn(run func(func(int64) bool)) *MockReplica_RangeOverRWNodes_Call {
	_c.Call.Return(run)
	return _c
}

// RangeOverRWSQNodes provides a mock function with given fields: f
func (_m *MockReplica) RangeOverRWSQNodes(f func(int64) bool) {
	_m.Called(f)
}

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

// RangeOverRWSQNodes is a helper method to define mock.On call
//   - f func(int64) bool
func (_e *MockReplica_Expecter) RangeOverRWSQNodes(f interface{}) *MockReplica_RangeOverRWSQNodes_Call {
	return &MockReplica_RangeOverRWSQNodes_Call{Call: _e.mock.On("RangeOverRWSQNodes", f)}
}

func (_c *MockReplica_RangeOverRWSQNodes_Call) Run(run func(f func(int64) bool)) *MockReplica_RangeOverRWSQNodes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(int64) bool))
	})
	return _c
}

func (_c *MockReplica_RangeOverRWSQNodes_Call) Return() *MockReplica_RangeOverRWSQNodes_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockReplica_RangeOverRWSQNodes_Call) RunAndReturn(run func(func(int64) bool)) *MockReplica_RangeOverRWSQNodes_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockReplica creates a new instance of MockReplica. 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 NewMockReplica(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockReplica {
	mock := &MockReplica{}
	mock.Mock.Test(t)

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

	return mock
}
