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

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

import (
	context "context"
	reflect "reflect"

	envelope "github.com/bacalhau-project/bacalhau/pkg/lib/envelope"
	nats "github.com/nats-io/nats.go"
	gomock "go.uber.org/mock/gomock"
)

// MockMessageHandler is a mock of MessageHandler interface.
type MockMessageHandler struct {
	ctrl     *gomock.Controller
	recorder *MockMessageHandlerMockRecorder
}

// MockMessageHandlerMockRecorder is the mock recorder for MockMessageHandler.
type MockMessageHandlerMockRecorder struct {
	mock *MockMessageHandler
}

// NewMockMessageHandler creates a new mock instance.
func NewMockMessageHandler(ctrl *gomock.Controller) *MockMessageHandler {
	mock := &MockMessageHandler{ctrl: ctrl}
	mock.recorder = &MockMessageHandlerMockRecorder{mock}
	return mock
}

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

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

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

// ShouldProcess mocks base method.
func (m *MockMessageHandler) ShouldProcess(ctx context.Context, message *envelope.Message) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ShouldProcess", ctx, message)
	ret0, _ := ret[0].(bool)
	return ret0
}

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

// MockRequestHandler is a mock of RequestHandler interface.
type MockRequestHandler struct {
	ctrl     *gomock.Controller
	recorder *MockRequestHandlerMockRecorder
}

// MockRequestHandlerMockRecorder is the mock recorder for MockRequestHandler.
type MockRequestHandlerMockRecorder struct {
	mock *MockRequestHandler
}

// NewMockRequestHandler creates a new mock instance.
func NewMockRequestHandler(ctrl *gomock.Controller) *MockRequestHandler {
	mock := &MockRequestHandler{ctrl: ctrl}
	mock.recorder = &MockRequestHandlerMockRecorder{mock}
	return mock
}

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

// HandleRequest mocks base method.
func (m *MockRequestHandler) HandleRequest(ctx context.Context, message *envelope.Message) (*envelope.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleRequest", ctx, message)
	ret0, _ := ret[0].(*envelope.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockMessageFilter is a mock of MessageFilter interface.
type MockMessageFilter struct {
	ctrl     *gomock.Controller
	recorder *MockMessageFilterMockRecorder
}

// MockMessageFilterMockRecorder is the mock recorder for MockMessageFilter.
type MockMessageFilterMockRecorder struct {
	mock *MockMessageFilter
}

// NewMockMessageFilter creates a new mock instance.
func NewMockMessageFilter(ctrl *gomock.Controller) *MockMessageFilter {
	mock := &MockMessageFilter{ctrl: ctrl}
	mock.recorder = &MockMessageFilterMockRecorder{mock}
	return mock
}

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

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

// ShouldFilter indicates an expected call of ShouldFilter.
func (mr *MockMessageFilterMockRecorder) ShouldFilter(metadata interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShouldFilter", reflect.TypeOf((*MockMessageFilter)(nil).ShouldFilter), metadata)
}

// MockProcessingNotifier is a mock of ProcessingNotifier interface.
type MockProcessingNotifier struct {
	ctrl     *gomock.Controller
	recorder *MockProcessingNotifierMockRecorder
}

// MockProcessingNotifierMockRecorder is the mock recorder for MockProcessingNotifier.
type MockProcessingNotifierMockRecorder struct {
	mock *MockProcessingNotifier
}

// NewMockProcessingNotifier creates a new mock instance.
func NewMockProcessingNotifier(ctrl *gomock.Controller) *MockProcessingNotifier {
	mock := &MockProcessingNotifier{ctrl: ctrl}
	mock.recorder = &MockProcessingNotifierMockRecorder{mock}
	return mock
}

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

// OnProcessed mocks base method.
func (m *MockProcessingNotifier) OnProcessed(ctx context.Context, message *envelope.Message) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnProcessed", ctx, message)
}

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

// MockPublisher is a mock of Publisher interface.
type MockPublisher struct {
	ctrl     *gomock.Controller
	recorder *MockPublisherMockRecorder
}

// MockPublisherMockRecorder is the mock recorder for MockPublisher.
type MockPublisherMockRecorder struct {
	mock *MockPublisher
}

// NewMockPublisher creates a new mock instance.
func NewMockPublisher(ctrl *gomock.Controller) *MockPublisher {
	mock := &MockPublisher{ctrl: ctrl}
	mock.recorder = &MockPublisherMockRecorder{mock}
	return mock
}

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

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

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

// Request mocks base method.
func (m *MockPublisher) Request(ctx context.Context, request PublishRequest) (*envelope.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Request", ctx, request)
	ret0, _ := ret[0].(*envelope.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockOrderedPublisher is a mock of OrderedPublisher interface.
type MockOrderedPublisher struct {
	ctrl     *gomock.Controller
	recorder *MockOrderedPublisherMockRecorder
}

// MockOrderedPublisherMockRecorder is the mock recorder for MockOrderedPublisher.
type MockOrderedPublisherMockRecorder struct {
	mock *MockOrderedPublisher
}

// NewMockOrderedPublisher creates a new mock instance.
func NewMockOrderedPublisher(ctrl *gomock.Controller) *MockOrderedPublisher {
	mock := &MockOrderedPublisher{ctrl: ctrl}
	mock.recorder = &MockOrderedPublisherMockRecorder{mock}
	return mock
}

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

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

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

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

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

// PublishAsync mocks base method.
func (m *MockOrderedPublisher) PublishAsync(ctx context.Context, request PublishRequest) (PubFuture, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PublishAsync", ctx, request)
	ret0, _ := ret[0].(PubFuture)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Request mocks base method.
func (m *MockOrderedPublisher) Request(ctx context.Context, request PublishRequest) (*envelope.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Request", ctx, request)
	ret0, _ := ret[0].(*envelope.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Reset mocks base method.
func (m *MockOrderedPublisher) Reset(ctx context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Reset", ctx)
}

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

// MockPubFuture is a mock of PubFuture interface.
type MockPubFuture struct {
	ctrl     *gomock.Controller
	recorder *MockPubFutureMockRecorder
}

// MockPubFutureMockRecorder is the mock recorder for MockPubFuture.
type MockPubFutureMockRecorder struct {
	mock *MockPubFuture
}

// NewMockPubFuture creates a new mock instance.
func NewMockPubFuture(ctrl *gomock.Controller) *MockPubFuture {
	mock := &MockPubFuture{ctrl: ctrl}
	mock.recorder = &MockPubFutureMockRecorder{mock}
	return mock
}

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

// Done mocks base method.
func (m *MockPubFuture) Done() <-chan struct{} {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Done")
	ret0, _ := ret[0].(<-chan struct{})
	return ret0
}

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

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

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

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

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

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

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

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

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

// MockSubscriber is a mock of Subscriber interface.
type MockSubscriber struct {
	ctrl     *gomock.Controller
	recorder *MockSubscriberMockRecorder
}

// MockSubscriberMockRecorder is the mock recorder for MockSubscriber.
type MockSubscriberMockRecorder struct {
	mock *MockSubscriber
}

// NewMockSubscriber creates a new mock instance.
func NewMockSubscriber(ctrl *gomock.Controller) *MockSubscriber {
	mock := &MockSubscriber{ctrl: ctrl}
	mock.recorder = &MockSubscriberMockRecorder{mock}
	return mock
}

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

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

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

// Subscribe mocks base method.
func (m *MockSubscriber) Subscribe(ctx context.Context, subjects ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range subjects {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Subscribe", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockResponder is a mock of Responder interface.
type MockResponder struct {
	ctrl     *gomock.Controller
	recorder *MockResponderMockRecorder
}

// MockResponderMockRecorder is the mock recorder for MockResponder.
type MockResponderMockRecorder struct {
	mock *MockResponder
}

// NewMockResponder creates a new mock instance.
func NewMockResponder(ctrl *gomock.Controller) *MockResponder {
	mock := &MockResponder{ctrl: ctrl}
	mock.recorder = &MockResponderMockRecorder{mock}
	return mock
}

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

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

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

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

// Listen indicates an expected call of Listen.
func (mr *MockResponderMockRecorder) Listen(ctx, messageType, handler interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Listen", reflect.TypeOf((*MockResponder)(nil).Listen), ctx, messageType, handler)
}
