// Code generated by MockGen. DO NOT EDIT.
// Source: types.go

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

import (
	context "context"
	reflect "reflect"

	models "github.com/bacalhau-project/bacalhau/pkg/models"
	messages "github.com/bacalhau-project/bacalhau/pkg/models/messages"
	gomock "go.uber.org/mock/gomock"
)

// MockManager is a mock of Manager interface.
type MockManager struct {
	ctrl     *gomock.Controller
	recorder *MockManagerMockRecorder
}

// MockManagerMockRecorder is the mock recorder for MockManager.
type MockManagerMockRecorder struct {
	mock *MockManager
}

// NewMockManager creates a new mock instance.
func NewMockManager(ctrl *gomock.Controller) *MockManager {
	mock := &MockManager{ctrl: ctrl}
	mock.recorder = &MockManagerMockRecorder{mock}
	return mock
}

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

// ApproveNode mocks base method.
func (m *MockManager) ApproveNode(ctx context.Context, nodeID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApproveNode", ctx, nodeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// ApproveNode indicates an expected call of ApproveNode.
func (mr *MockManagerMockRecorder) ApproveNode(ctx, nodeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApproveNode", reflect.TypeOf((*MockManager)(nil).ApproveNode), ctx, nodeID)
}

// DeleteNode mocks base method.
func (m *MockManager) DeleteNode(ctx context.Context, nodeID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNode", ctx, nodeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteNode indicates an expected call of DeleteNode.
func (mr *MockManagerMockRecorder) DeleteNode(ctx, nodeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNode", reflect.TypeOf((*MockManager)(nil).DeleteNode), ctx, nodeID)
}

// Get mocks base method.
func (m *MockManager) Get(ctx context.Context, nodeID string) (models.NodeState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, nodeID)
	ret0, _ := ret[0].(models.NodeState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetByPrefix mocks base method.
func (m *MockManager) GetByPrefix(ctx context.Context, prefix string) (models.NodeState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByPrefix", ctx, prefix)
	ret0, _ := ret[0].(models.NodeState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByPrefix indicates an expected call of GetByPrefix.
func (mr *MockManagerMockRecorder) GetByPrefix(ctx, prefix interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByPrefix", reflect.TypeOf((*MockManager)(nil).GetByPrefix), ctx, prefix)
}

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

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

// Handshake mocks base method.
func (m *MockManager) Handshake(ctx context.Context, request messages.HandshakeRequest) (messages.HandshakeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Handshake", ctx, request)
	ret0, _ := ret[0].(messages.HandshakeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Handshake indicates an expected call of Handshake.
func (mr *MockManagerMockRecorder) Handshake(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Handshake", reflect.TypeOf((*MockManager)(nil).Handshake), ctx, request)
}

// Heartbeat mocks base method.
func (m *MockManager) Heartbeat(ctx context.Context, request ExtendedHeartbeatRequest) (messages.HeartbeatResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Heartbeat", ctx, request)
	ret0, _ := ret[0].(messages.HeartbeatResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Heartbeat indicates an expected call of Heartbeat.
func (mr *MockManagerMockRecorder) Heartbeat(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Heartbeat", reflect.TypeOf((*MockManager)(nil).Heartbeat), ctx, request)
}

// List mocks base method.
func (m *MockManager) List(ctx context.Context, filters ...NodeStateFilter) ([]models.NodeState, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range filters {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "List", varargs...)
	ret0, _ := ret[0].([]models.NodeState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockManagerMockRecorder) List(ctx interface{}, filters ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, filters...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockManager)(nil).List), varargs...)
}

// OnConnectionStateChange mocks base method.
func (m *MockManager) OnConnectionStateChange(handler ConnectionStateChangeHandler) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnConnectionStateChange", handler)
}

// OnConnectionStateChange indicates an expected call of OnConnectionStateChange.
func (mr *MockManagerMockRecorder) OnConnectionStateChange(handler interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnConnectionStateChange", reflect.TypeOf((*MockManager)(nil).OnConnectionStateChange), handler)
}

// RejectNode mocks base method.
func (m *MockManager) RejectNode(ctx context.Context, nodeID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RejectNode", ctx, nodeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// RejectNode indicates an expected call of RejectNode.
func (mr *MockManagerMockRecorder) RejectNode(ctx, nodeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectNode", reflect.TypeOf((*MockManager)(nil).RejectNode), ctx, nodeID)
}

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

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

// ShutdownNotice mocks base method.
func (m *MockManager) ShutdownNotice(ctx context.Context, request ExtendedShutdownNoticeRequest) (messages.ShutdownNoticeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ShutdownNotice", ctx, request)
	ret0, _ := ret[0].(messages.ShutdownNoticeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ShutdownNotice indicates an expected call of ShutdownNotice.
func (mr *MockManagerMockRecorder) ShutdownNotice(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownNotice", reflect.TypeOf((*MockManager)(nil).ShutdownNotice), ctx, request)
}

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

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

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

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

// UpdateNodeInfo mocks base method.
func (m *MockManager) UpdateNodeInfo(ctx context.Context, request messages.UpdateNodeInfoRequest) (messages.UpdateNodeInfoResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNodeInfo", ctx, request)
	ret0, _ := ret[0].(messages.UpdateNodeInfoResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateNodeInfo indicates an expected call of UpdateNodeInfo.
func (mr *MockManagerMockRecorder) UpdateNodeInfo(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNodeInfo", reflect.TypeOf((*MockManager)(nil).UpdateNodeInfo), ctx, request)
}

// MockLookup is a mock of Lookup interface.
type MockLookup struct {
	ctrl     *gomock.Controller
	recorder *MockLookupMockRecorder
}

// MockLookupMockRecorder is the mock recorder for MockLookup.
type MockLookupMockRecorder struct {
	mock *MockLookup
}

// NewMockLookup creates a new mock instance.
func NewMockLookup(ctrl *gomock.Controller) *MockLookup {
	mock := &MockLookup{ctrl: ctrl}
	mock.recorder = &MockLookupMockRecorder{mock}
	return mock
}

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

// Get mocks base method.
func (m *MockLookup) Get(ctx context.Context, nodeID string) (models.NodeState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, nodeID)
	ret0, _ := ret[0].(models.NodeState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetByPrefix mocks base method.
func (m *MockLookup) GetByPrefix(ctx context.Context, prefix string) (models.NodeState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByPrefix", ctx, prefix)
	ret0, _ := ret[0].(models.NodeState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByPrefix indicates an expected call of GetByPrefix.
func (mr *MockLookupMockRecorder) GetByPrefix(ctx, prefix interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByPrefix", reflect.TypeOf((*MockLookup)(nil).GetByPrefix), ctx, prefix)
}

// List mocks base method.
func (m *MockLookup) List(ctx context.Context, filters ...NodeStateFilter) ([]models.NodeState, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range filters {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "List", varargs...)
	ret0, _ := ret[0].([]models.NodeState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockLookupMockRecorder) List(ctx interface{}, filters ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, filters...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockLookup)(nil).List), varargs...)
}

// MockTracker is a mock of Tracker interface.
type MockTracker struct {
	ctrl     *gomock.Controller
	recorder *MockTrackerMockRecorder
}

// MockTrackerMockRecorder is the mock recorder for MockTracker.
type MockTrackerMockRecorder struct {
	mock *MockTracker
}

// NewMockTracker creates a new mock instance.
func NewMockTracker(ctrl *gomock.Controller) *MockTracker {
	mock := &MockTracker{ctrl: ctrl}
	mock.recorder = &MockTrackerMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// Delete mocks base method.
func (m *MockStore) Delete(ctx context.Context, nodeID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, nodeID)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// GetByPrefix mocks base method.
func (m *MockStore) GetByPrefix(ctx context.Context, prefix string) (models.NodeState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByPrefix", ctx, prefix)
	ret0, _ := ret[0].(models.NodeState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// List mocks base method.
func (m *MockStore) List(ctx context.Context, filters ...NodeStateFilter) ([]models.NodeState, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range filters {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "List", varargs...)
	ret0, _ := ret[0].([]models.NodeState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockStoreMockRecorder) List(ctx interface{}, filters ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, filters...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockStore)(nil).List), varargs...)
}

// Put mocks base method.
func (m *MockStore) Put(ctx context.Context, state models.NodeState) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Put", ctx, state)
	ret0, _ := ret[0].(error)
	return ret0
}

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