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

package portsmocks

import (
	"context"

	"github.com/bnema/vev/internal/domain"
	"github.com/bnema/vev/internal/ports"
	mock "github.com/stretchr/testify/mock"
)

// NewMockBrokerSubscription creates a new instance of MockBrokerSubscription. 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 NewMockBrokerSubscription(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBrokerSubscription {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockBrokerSubscription{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockBrokerSubscription is an autogenerated mock type for the BrokerSubscription type
type MockBrokerSubscription struct {
	mock.Mock
}

type MockBrokerSubscription_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBrokerSubscription) EXPECT() *MockBrokerSubscription_Expecter {
	return &MockBrokerSubscription_Expecter{mock: &_m.Mock}
}

// Changed provides a mock function for the type MockBrokerSubscription
func (_mock *MockBrokerSubscription) Changed() <-chan struct{} {
	ret := _mock.Called()

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

	var r0 <-chan struct{}
	if returnFunc, ok := ret.Get(0).(func() <-chan struct{}); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan struct{})
		}
	}
	return r0
}

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

// Changed is a helper method to define mock.On call
func (_e *MockBrokerSubscription_Expecter) Changed() *MockBrokerSubscription_Changed_Call {
	return &MockBrokerSubscription_Changed_Call{Call: _e.mock.On("Changed")}
}

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

func (_c *MockBrokerSubscription_Changed_Call) Return(valCh <-chan struct{}) *MockBrokerSubscription_Changed_Call {
	_c.Call.Return(valCh)
	return _c
}

func (_c *MockBrokerSubscription_Changed_Call) RunAndReturn(run func() <-chan struct{}) *MockBrokerSubscription_Changed_Call {
	_c.Call.Return(run)
	return _c
}

// Close provides a mock function for the type MockBrokerSubscription
func (_mock *MockBrokerSubscription) Close() {
	_mock.Called()
	return
}

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

// Close is a helper method to define mock.On call
func (_e *MockBrokerSubscription_Expecter) Close() *MockBrokerSubscription_Close_Call {
	return &MockBrokerSubscription_Close_Call{Call: _e.mock.On("Close")}
}

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

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

func (_c *MockBrokerSubscription_Close_Call) RunAndReturn(run func()) *MockBrokerSubscription_Close_Call {
	_c.Run(run)
	return _c
}

// NewMockBrokerPreviewSubscription creates a new instance of MockBrokerPreviewSubscription. 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 NewMockBrokerPreviewSubscription(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBrokerPreviewSubscription {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockBrokerPreviewSubscription{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockBrokerPreviewSubscription is an autogenerated mock type for the BrokerPreviewSubscription type
type MockBrokerPreviewSubscription struct {
	mock.Mock
}

type MockBrokerPreviewSubscription_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBrokerPreviewSubscription) EXPECT() *MockBrokerPreviewSubscription_Expecter {
	return &MockBrokerPreviewSubscription_Expecter{mock: &_m.Mock}
}

// Changed provides a mock function for the type MockBrokerPreviewSubscription
func (_mock *MockBrokerPreviewSubscription) Changed() <-chan struct{} {
	ret := _mock.Called()

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

	var r0 <-chan struct{}
	if returnFunc, ok := ret.Get(0).(func() <-chan struct{}); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan struct{})
		}
	}
	return r0
}

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

// Changed is a helper method to define mock.On call
func (_e *MockBrokerPreviewSubscription_Expecter) Changed() *MockBrokerPreviewSubscription_Changed_Call {
	return &MockBrokerPreviewSubscription_Changed_Call{Call: _e.mock.On("Changed")}
}

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

func (_c *MockBrokerPreviewSubscription_Changed_Call) Return(valCh <-chan struct{}) *MockBrokerPreviewSubscription_Changed_Call {
	_c.Call.Return(valCh)
	return _c
}

func (_c *MockBrokerPreviewSubscription_Changed_Call) RunAndReturn(run func() <-chan struct{}) *MockBrokerPreviewSubscription_Changed_Call {
	_c.Call.Return(run)
	return _c
}

// Close provides a mock function for the type MockBrokerPreviewSubscription
func (_mock *MockBrokerPreviewSubscription) Close() {
	_mock.Called()
	return
}

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

// Close is a helper method to define mock.On call
func (_e *MockBrokerPreviewSubscription_Expecter) Close() *MockBrokerPreviewSubscription_Close_Call {
	return &MockBrokerPreviewSubscription_Close_Call{Call: _e.mock.On("Close")}
}

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

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

func (_c *MockBrokerPreviewSubscription_Close_Call) RunAndReturn(run func()) *MockBrokerPreviewSubscription_Close_Call {
	_c.Run(run)
	return _c
}

// Latest provides a mock function for the type MockBrokerPreviewSubscription
func (_mock *MockBrokerPreviewSubscription) Latest() ports.BrokerPreviewPublication {
	ret := _mock.Called()

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

	var r0 ports.BrokerPreviewPublication
	if returnFunc, ok := ret.Get(0).(func() ports.BrokerPreviewPublication); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(ports.BrokerPreviewPublication)
	}
	return r0
}

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

// Latest is a helper method to define mock.On call
func (_e *MockBrokerPreviewSubscription_Expecter) Latest() *MockBrokerPreviewSubscription_Latest_Call {
	return &MockBrokerPreviewSubscription_Latest_Call{Call: _e.mock.On("Latest")}
}

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

func (_c *MockBrokerPreviewSubscription_Latest_Call) Return(brokerPreviewPublication ports.BrokerPreviewPublication) *MockBrokerPreviewSubscription_Latest_Call {
	_c.Call.Return(brokerPreviewPublication)
	return _c
}

func (_c *MockBrokerPreviewSubscription_Latest_Call) RunAndReturn(run func() ports.BrokerPreviewPublication) *MockBrokerPreviewSubscription_Latest_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockBrokerConnection creates a new instance of MockBrokerConnection. 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 NewMockBrokerConnection(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBrokerConnection {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockBrokerConnection{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockBrokerConnection is an autogenerated mock type for the BrokerConnection type
type MockBrokerConnection struct {
	mock.Mock
}

type MockBrokerConnection_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBrokerConnection) EXPECT() *MockBrokerConnection_Expecter {
	return &MockBrokerConnection_Expecter{mock: &_m.Mock}
}

// Close provides a mock function for the type MockBrokerConnection
func (_mock *MockBrokerConnection) Close() error {
	ret := _mock.Called()

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

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

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

// Close is a helper method to define mock.On call
func (_e *MockBrokerConnection_Expecter) Close() *MockBrokerConnection_Close_Call {
	return &MockBrokerConnection_Close_Call{Call: _e.mock.On("Close")}
}

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

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

func (_c *MockBrokerConnection_Close_Call) RunAndReturn(run func() error) *MockBrokerConnection_Close_Call {
	_c.Call.Return(run)
	return _c
}

// ConnectionID provides a mock function for the type MockBrokerConnection
func (_mock *MockBrokerConnection) ConnectionID() ports.BrokerConnectionID {
	ret := _mock.Called()

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

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

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

// ConnectionID is a helper method to define mock.On call
func (_e *MockBrokerConnection_Expecter) ConnectionID() *MockBrokerConnection_ConnectionID_Call {
	return &MockBrokerConnection_ConnectionID_Call{Call: _e.mock.On("ConnectionID")}
}

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

func (_c *MockBrokerConnection_ConnectionID_Call) Return(brokerConnectionID ports.BrokerConnectionID) *MockBrokerConnection_ConnectionID_Call {
	_c.Call.Return(brokerConnectionID)
	return _c
}

func (_c *MockBrokerConnection_ConnectionID_Call) RunAndReturn(run func() ports.BrokerConnectionID) *MockBrokerConnection_ConnectionID_Call {
	_c.Call.Return(run)
	return _c
}

// Done provides a mock function for the type MockBrokerConnection
func (_mock *MockBrokerConnection) Done() <-chan struct{} {
	ret := _mock.Called()

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

	var r0 <-chan struct{}
	if returnFunc, ok := ret.Get(0).(func() <-chan struct{}); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan struct{})
		}
	}
	return r0
}

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

// Done is a helper method to define mock.On call
func (_e *MockBrokerConnection_Expecter) Done() *MockBrokerConnection_Done_Call {
	return &MockBrokerConnection_Done_Call{Call: _e.mock.On("Done")}
}

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

func (_c *MockBrokerConnection_Done_Call) Return(valCh <-chan struct{}) *MockBrokerConnection_Done_Call {
	_c.Call.Return(valCh)
	return _c
}

func (_c *MockBrokerConnection_Done_Call) RunAndReturn(run func() <-chan struct{}) *MockBrokerConnection_Done_Call {
	_c.Call.Return(run)
	return _c
}

// Err provides a mock function for the type MockBrokerConnection
func (_mock *MockBrokerConnection) Err() error {
	ret := _mock.Called()

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

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

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

// Err is a helper method to define mock.On call
func (_e *MockBrokerConnection_Expecter) Err() *MockBrokerConnection_Err_Call {
	return &MockBrokerConnection_Err_Call{Call: _e.mock.On("Err")}
}

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

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

func (_c *MockBrokerConnection_Err_Call) RunAndReturn(run func() error) *MockBrokerConnection_Err_Call {
	_c.Call.Return(run)
	return _c
}

// NextStreamID provides a mock function for the type MockBrokerConnection
func (_mock *MockBrokerConnection) NextStreamID() (ports.BrokerStreamID, error) {
	ret := _mock.Called()

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

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

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

// NextStreamID is a helper method to define mock.On call
func (_e *MockBrokerConnection_Expecter) NextStreamID() *MockBrokerConnection_NextStreamID_Call {
	return &MockBrokerConnection_NextStreamID_Call{Call: _e.mock.On("NextStreamID")}
}

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

func (_c *MockBrokerConnection_NextStreamID_Call) Return(brokerStreamID ports.BrokerStreamID, err error) *MockBrokerConnection_NextStreamID_Call {
	_c.Call.Return(brokerStreamID, err)
	return _c
}

func (_c *MockBrokerConnection_NextStreamID_Call) RunAndReturn(run func() (ports.BrokerStreamID, error)) *MockBrokerConnection_NextStreamID_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockBrokerObservation creates a new instance of MockBrokerObservation. 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 NewMockBrokerObservation(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBrokerObservation {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockBrokerObservation{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockBrokerObservation is an autogenerated mock type for the BrokerObservation type
type MockBrokerObservation struct {
	mock.Mock
}

type MockBrokerObservation_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBrokerObservation) EXPECT() *MockBrokerObservation_Expecter {
	return &MockBrokerObservation_Expecter{mock: &_m.Mock}
}

// RequestReconcile provides a mock function for the type MockBrokerObservation
func (_mock *MockBrokerObservation) RequestReconcile(endpoint string) {
	_mock.Called(endpoint)
	return
}

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

// RequestReconcile is a helper method to define mock.On call
//   - endpoint string
func (_e *MockBrokerObservation_Expecter) RequestReconcile(endpoint any) *MockBrokerObservation_RequestReconcile_Call {
	return &MockBrokerObservation_RequestReconcile_Call{Call: _e.mock.On("RequestReconcile", endpoint)}
}

func (_c *MockBrokerObservation_RequestReconcile_Call) Run(run func(endpoint string)) *MockBrokerObservation_RequestReconcile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockBrokerObservation_RequestReconcile_Call) RunAndReturn(run func(endpoint string)) *MockBrokerObservation_RequestReconcile_Call {
	_c.Run(run)
	return _c
}

// Snapshot provides a mock function for the type MockBrokerObservation
func (_mock *MockBrokerObservation) Snapshot() ports.BrokerSnapshot {
	ret := _mock.Called()

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

	var r0 ports.BrokerSnapshot
	if returnFunc, ok := ret.Get(0).(func() ports.BrokerSnapshot); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(ports.BrokerSnapshot)
	}
	return r0
}

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

// Snapshot is a helper method to define mock.On call
func (_e *MockBrokerObservation_Expecter) Snapshot() *MockBrokerObservation_Snapshot_Call {
	return &MockBrokerObservation_Snapshot_Call{Call: _e.mock.On("Snapshot")}
}

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

func (_c *MockBrokerObservation_Snapshot_Call) Return(brokerSnapshot ports.BrokerSnapshot) *MockBrokerObservation_Snapshot_Call {
	_c.Call.Return(brokerSnapshot)
	return _c
}

func (_c *MockBrokerObservation_Snapshot_Call) RunAndReturn(run func() ports.BrokerSnapshot) *MockBrokerObservation_Snapshot_Call {
	_c.Call.Return(run)
	return _c
}

// Subscribe provides a mock function for the type MockBrokerObservation
func (_mock *MockBrokerObservation) Subscribe() (ports.BrokerSubscription, error) {
	ret := _mock.Called()

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

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

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

// Subscribe is a helper method to define mock.On call
func (_e *MockBrokerObservation_Expecter) Subscribe() *MockBrokerObservation_Subscribe_Call {
	return &MockBrokerObservation_Subscribe_Call{Call: _e.mock.On("Subscribe")}
}

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

func (_c *MockBrokerObservation_Subscribe_Call) Return(brokerSubscription ports.BrokerSubscription, err error) *MockBrokerObservation_Subscribe_Call {
	_c.Call.Return(brokerSubscription, err)
	return _c
}

func (_c *MockBrokerObservation_Subscribe_Call) RunAndReturn(run func() (ports.BrokerSubscription, error)) *MockBrokerObservation_Subscribe_Call {
	_c.Call.Return(run)
	return _c
}

// SubscribePreview provides a mock function for the type MockBrokerObservation
func (_mock *MockBrokerObservation) SubscribePreview(request ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error) {
	ret := _mock.Called(request)

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

	var r0 ports.BrokerPreviewSubscription
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error)); ok {
		return returnFunc(request)
	}
	if returnFunc, ok := ret.Get(0).(func(ports.BrokerPreviewRequest) ports.BrokerPreviewSubscription); ok {
		r0 = returnFunc(request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(ports.BrokerPreviewSubscription)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(ports.BrokerPreviewRequest) error); ok {
		r1 = returnFunc(request)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SubscribePreview is a helper method to define mock.On call
//   - request ports.BrokerPreviewRequest
func (_e *MockBrokerObservation_Expecter) SubscribePreview(request any) *MockBrokerObservation_SubscribePreview_Call {
	return &MockBrokerObservation_SubscribePreview_Call{Call: _e.mock.On("SubscribePreview", request)}
}

func (_c *MockBrokerObservation_SubscribePreview_Call) Run(run func(request ports.BrokerPreviewRequest)) *MockBrokerObservation_SubscribePreview_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 ports.BrokerPreviewRequest
		if args[0] != nil {
			arg0 = args[0].(ports.BrokerPreviewRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBrokerObservation_SubscribePreview_Call) Return(brokerPreviewSubscription ports.BrokerPreviewSubscription, err error) *MockBrokerObservation_SubscribePreview_Call {
	_c.Call.Return(brokerPreviewSubscription, err)
	return _c
}

func (_c *MockBrokerObservation_SubscribePreview_Call) RunAndReturn(run func(request ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error)) *MockBrokerObservation_SubscribePreview_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockBrokerHostMembership creates a new instance of MockBrokerHostMembership. 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 NewMockBrokerHostMembership(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBrokerHostMembership {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockBrokerHostMembership{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockBrokerHostMembership is an autogenerated mock type for the BrokerHostMembership type
type MockBrokerHostMembership struct {
	mock.Mock
}

type MockBrokerHostMembership_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBrokerHostMembership) EXPECT() *MockBrokerHostMembership_Expecter {
	return &MockBrokerHostMembership_Expecter{mock: &_m.Mock}
}

// AddHost provides a mock function for the type MockBrokerHostMembership
func (_mock *MockBrokerHostMembership) AddHost(ctx context.Context, endpoint string, policy ports.BrokerPolicy) (domain.RemoteRegistration, error) {
	ret := _mock.Called(ctx, endpoint, policy)

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

	var r0 domain.RemoteRegistration
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, ports.BrokerPolicy) (domain.RemoteRegistration, error)); ok {
		return returnFunc(ctx, endpoint, policy)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, ports.BrokerPolicy) domain.RemoteRegistration); ok {
		r0 = returnFunc(ctx, endpoint, policy)
	} else {
		r0 = ret.Get(0).(domain.RemoteRegistration)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, ports.BrokerPolicy) error); ok {
		r1 = returnFunc(ctx, endpoint, policy)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddHost is a helper method to define mock.On call
//   - ctx context.Context
//   - endpoint string
//   - policy ports.BrokerPolicy
func (_e *MockBrokerHostMembership_Expecter) AddHost(ctx any, endpoint any, policy any) *MockBrokerHostMembership_AddHost_Call {
	return &MockBrokerHostMembership_AddHost_Call{Call: _e.mock.On("AddHost", ctx, endpoint, policy)}
}

func (_c *MockBrokerHostMembership_AddHost_Call) Run(run func(ctx context.Context, endpoint string, policy ports.BrokerPolicy)) *MockBrokerHostMembership_AddHost_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 ports.BrokerPolicy
		if args[2] != nil {
			arg2 = args[2].(ports.BrokerPolicy)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockBrokerHostMembership_AddHost_Call) Return(remoteRegistration domain.RemoteRegistration, err error) *MockBrokerHostMembership_AddHost_Call {
	_c.Call.Return(remoteRegistration, err)
	return _c
}

func (_c *MockBrokerHostMembership_AddHost_Call) RunAndReturn(run func(ctx context.Context, endpoint string, policy ports.BrokerPolicy) (domain.RemoteRegistration, error)) *MockBrokerHostMembership_AddHost_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveHost provides a mock function for the type MockBrokerHostMembership
func (_mock *MockBrokerHostMembership) RemoveHost(ctx context.Context, expected domain.RemoteRegistration) (bool, error) {
	ret := _mock.Called(ctx, expected)

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

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

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

// RemoveHost is a helper method to define mock.On call
//   - ctx context.Context
//   - expected domain.RemoteRegistration
func (_e *MockBrokerHostMembership_Expecter) RemoveHost(ctx any, expected any) *MockBrokerHostMembership_RemoveHost_Call {
	return &MockBrokerHostMembership_RemoveHost_Call{Call: _e.mock.On("RemoveHost", ctx, expected)}
}

func (_c *MockBrokerHostMembership_RemoveHost_Call) Run(run func(ctx context.Context, expected domain.RemoteRegistration)) *MockBrokerHostMembership_RemoveHost_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.RemoteRegistration
		if args[1] != nil {
			arg1 = args[1].(domain.RemoteRegistration)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockBrokerHostMembership_RemoveHost_Call) RunAndReturn(run func(ctx context.Context, expected domain.RemoteRegistration) (bool, error)) *MockBrokerHostMembership_RemoveHost_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateHostPolicy provides a mock function for the type MockBrokerHostMembership
func (_mock *MockBrokerHostMembership) UpdateHostPolicy(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy) (domain.RemoteRegistration, error) {
	ret := _mock.Called(ctx, expected, policy)

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

	var r0 domain.RemoteRegistration
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) (domain.RemoteRegistration, error)); ok {
		return returnFunc(ctx, expected, policy)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) domain.RemoteRegistration); ok {
		r0 = returnFunc(ctx, expected, policy)
	} else {
		r0 = ret.Get(0).(domain.RemoteRegistration)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) error); ok {
		r1 = returnFunc(ctx, expected, policy)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateHostPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - expected domain.RemoteRegistration
//   - policy ports.BrokerPolicy
func (_e *MockBrokerHostMembership_Expecter) UpdateHostPolicy(ctx any, expected any, policy any) *MockBrokerHostMembership_UpdateHostPolicy_Call {
	return &MockBrokerHostMembership_UpdateHostPolicy_Call{Call: _e.mock.On("UpdateHostPolicy", ctx, expected, policy)}
}

func (_c *MockBrokerHostMembership_UpdateHostPolicy_Call) Run(run func(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy)) *MockBrokerHostMembership_UpdateHostPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.RemoteRegistration
		if args[1] != nil {
			arg1 = args[1].(domain.RemoteRegistration)
		}
		var arg2 ports.BrokerPolicy
		if args[2] != nil {
			arg2 = args[2].(ports.BrokerPolicy)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockBrokerHostMembership_UpdateHostPolicy_Call) Return(remoteRegistration domain.RemoteRegistration, err error) *MockBrokerHostMembership_UpdateHostPolicy_Call {
	_c.Call.Return(remoteRegistration, err)
	return _c
}

func (_c *MockBrokerHostMembership_UpdateHostPolicy_Call) RunAndReturn(run func(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy) (domain.RemoteRegistration, error)) *MockBrokerHostMembership_UpdateHostPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockBrokerSession creates a new instance of MockBrokerSession. 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 NewMockBrokerSession(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBrokerSession {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockBrokerSession{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockBrokerSession is an autogenerated mock type for the BrokerSession type
type MockBrokerSession struct {
	mock.Mock
}

type MockBrokerSession_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBrokerSession) EXPECT() *MockBrokerSession_Expecter {
	return &MockBrokerSession_Expecter{mock: &_m.Mock}
}

// AddHost provides a mock function for the type MockBrokerSession
func (_mock *MockBrokerSession) AddHost(ctx context.Context, endpoint string, policy ports.BrokerPolicy) (domain.RemoteRegistration, error) {
	ret := _mock.Called(ctx, endpoint, policy)

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

	var r0 domain.RemoteRegistration
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, ports.BrokerPolicy) (domain.RemoteRegistration, error)); ok {
		return returnFunc(ctx, endpoint, policy)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, ports.BrokerPolicy) domain.RemoteRegistration); ok {
		r0 = returnFunc(ctx, endpoint, policy)
	} else {
		r0 = ret.Get(0).(domain.RemoteRegistration)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, ports.BrokerPolicy) error); ok {
		r1 = returnFunc(ctx, endpoint, policy)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddHost is a helper method to define mock.On call
//   - ctx context.Context
//   - endpoint string
//   - policy ports.BrokerPolicy
func (_e *MockBrokerSession_Expecter) AddHost(ctx any, endpoint any, policy any) *MockBrokerSession_AddHost_Call {
	return &MockBrokerSession_AddHost_Call{Call: _e.mock.On("AddHost", ctx, endpoint, policy)}
}

func (_c *MockBrokerSession_AddHost_Call) Run(run func(ctx context.Context, endpoint string, policy ports.BrokerPolicy)) *MockBrokerSession_AddHost_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 ports.BrokerPolicy
		if args[2] != nil {
			arg2 = args[2].(ports.BrokerPolicy)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockBrokerSession_AddHost_Call) Return(remoteRegistration domain.RemoteRegistration, err error) *MockBrokerSession_AddHost_Call {
	_c.Call.Return(remoteRegistration, err)
	return _c
}

func (_c *MockBrokerSession_AddHost_Call) RunAndReturn(run func(ctx context.Context, endpoint string, policy ports.BrokerPolicy) (domain.RemoteRegistration, error)) *MockBrokerSession_AddHost_Call {
	_c.Call.Return(run)
	return _c
}

// Close provides a mock function for the type MockBrokerSession
func (_mock *MockBrokerSession) Close() error {
	ret := _mock.Called()

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

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

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

// Close is a helper method to define mock.On call
func (_e *MockBrokerSession_Expecter) Close() *MockBrokerSession_Close_Call {
	return &MockBrokerSession_Close_Call{Call: _e.mock.On("Close")}
}

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

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

func (_c *MockBrokerSession_Close_Call) RunAndReturn(run func() error) *MockBrokerSession_Close_Call {
	_c.Call.Return(run)
	return _c
}

// CloseStream provides a mock function for the type MockBrokerSession
func (_mock *MockBrokerSession) CloseStream(connection ports.BrokerConnectionID, stream ports.BrokerStreamID) error {
	ret := _mock.Called(connection, stream)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(ports.BrokerConnectionID, ports.BrokerStreamID) error); ok {
		r0 = returnFunc(connection, stream)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// CloseStream is a helper method to define mock.On call
//   - connection ports.BrokerConnectionID
//   - stream ports.BrokerStreamID
func (_e *MockBrokerSession_Expecter) CloseStream(connection any, stream any) *MockBrokerSession_CloseStream_Call {
	return &MockBrokerSession_CloseStream_Call{Call: _e.mock.On("CloseStream", connection, stream)}
}

func (_c *MockBrokerSession_CloseStream_Call) Run(run func(connection ports.BrokerConnectionID, stream ports.BrokerStreamID)) *MockBrokerSession_CloseStream_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 ports.BrokerConnectionID
		if args[0] != nil {
			arg0 = args[0].(ports.BrokerConnectionID)
		}
		var arg1 ports.BrokerStreamID
		if args[1] != nil {
			arg1 = args[1].(ports.BrokerStreamID)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockBrokerSession_CloseStream_Call) RunAndReturn(run func(connection ports.BrokerConnectionID, stream ports.BrokerStreamID) error) *MockBrokerSession_CloseStream_Call {
	_c.Call.Return(run)
	return _c
}

// ConnectionID provides a mock function for the type MockBrokerSession
func (_mock *MockBrokerSession) ConnectionID() ports.BrokerConnectionID {
	ret := _mock.Called()

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

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

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

// ConnectionID is a helper method to define mock.On call
func (_e *MockBrokerSession_Expecter) ConnectionID() *MockBrokerSession_ConnectionID_Call {
	return &MockBrokerSession_ConnectionID_Call{Call: _e.mock.On("ConnectionID")}
}

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

func (_c *MockBrokerSession_ConnectionID_Call) Return(brokerConnectionID ports.BrokerConnectionID) *MockBrokerSession_ConnectionID_Call {
	_c.Call.Return(brokerConnectionID)
	return _c
}

func (_c *MockBrokerSession_ConnectionID_Call) RunAndReturn(run func() ports.BrokerConnectionID) *MockBrokerSession_ConnectionID_Call {
	_c.Call.Return(run)
	return _c
}

// Done provides a mock function for the type MockBrokerSession
func (_mock *MockBrokerSession) Done() <-chan struct{} {
	ret := _mock.Called()

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

	var r0 <-chan struct{}
	if returnFunc, ok := ret.Get(0).(func() <-chan struct{}); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan struct{})
		}
	}
	return r0
}

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

// Done is a helper method to define mock.On call
func (_e *MockBrokerSession_Expecter) Done() *MockBrokerSession_Done_Call {
	return &MockBrokerSession_Done_Call{Call: _e.mock.On("Done")}
}

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

func (_c *MockBrokerSession_Done_Call) Return(valCh <-chan struct{}) *MockBrokerSession_Done_Call {
	_c.Call.Return(valCh)
	return _c
}

func (_c *MockBrokerSession_Done_Call) RunAndReturn(run func() <-chan struct{}) *MockBrokerSession_Done_Call {
	_c.Call.Return(run)
	return _c
}

// Err provides a mock function for the type MockBrokerSession
func (_mock *MockBrokerSession) Err() error {
	ret := _mock.Called()

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

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

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

// Err is a helper method to define mock.On call
func (_e *MockBrokerSession_Expecter) Err() *MockBrokerSession_Err_Call {
	return &MockBrokerSession_Err_Call{Call: _e.mock.On("Err")}
}

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

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

func (_c *MockBrokerSession_Err_Call) RunAndReturn(run func() error) *MockBrokerSession_Err_Call {
	_c.Call.Return(run)
	return _c
}

// NextStreamID provides a mock function for the type MockBrokerSession
func (_mock *MockBrokerSession) NextStreamID() (ports.BrokerStreamID, error) {
	ret := _mock.Called()

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

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

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

// NextStreamID is a helper method to define mock.On call
func (_e *MockBrokerSession_Expecter) NextStreamID() *MockBrokerSession_NextStreamID_Call {
	return &MockBrokerSession_NextStreamID_Call{Call: _e.mock.On("NextStreamID")}
}

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

func (_c *MockBrokerSession_NextStreamID_Call) Return(brokerStreamID ports.BrokerStreamID, err error) *MockBrokerSession_NextStreamID_Call {
	_c.Call.Return(brokerStreamID, err)
	return _c
}

func (_c *MockBrokerSession_NextStreamID_Call) RunAndReturn(run func() (ports.BrokerStreamID, error)) *MockBrokerSession_NextStreamID_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveHost provides a mock function for the type MockBrokerSession
func (_mock *MockBrokerSession) RemoveHost(ctx context.Context, expected domain.RemoteRegistration) (bool, error) {
	ret := _mock.Called(ctx, expected)

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

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

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

// RemoveHost is a helper method to define mock.On call
//   - ctx context.Context
//   - expected domain.RemoteRegistration
func (_e *MockBrokerSession_Expecter) RemoveHost(ctx any, expected any) *MockBrokerSession_RemoveHost_Call {
	return &MockBrokerSession_RemoveHost_Call{Call: _e.mock.On("RemoveHost", ctx, expected)}
}

func (_c *MockBrokerSession_RemoveHost_Call) Run(run func(ctx context.Context, expected domain.RemoteRegistration)) *MockBrokerSession_RemoveHost_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.RemoteRegistration
		if args[1] != nil {
			arg1 = args[1].(domain.RemoteRegistration)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockBrokerSession_RemoveHost_Call) RunAndReturn(run func(ctx context.Context, expected domain.RemoteRegistration) (bool, error)) *MockBrokerSession_RemoveHost_Call {
	_c.Call.Return(run)
	return _c
}

// RequestReconcile provides a mock function for the type MockBrokerSession
func (_mock *MockBrokerSession) RequestReconcile(endpoint string) {
	_mock.Called(endpoint)
	return
}

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

// RequestReconcile is a helper method to define mock.On call
//   - endpoint string
func (_e *MockBrokerSession_Expecter) RequestReconcile(endpoint any) *MockBrokerSession_RequestReconcile_Call {
	return &MockBrokerSession_RequestReconcile_Call{Call: _e.mock.On("RequestReconcile", endpoint)}
}

func (_c *MockBrokerSession_RequestReconcile_Call) Run(run func(endpoint string)) *MockBrokerSession_RequestReconcile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockBrokerSession_RequestReconcile_Call) RunAndReturn(run func(endpoint string)) *MockBrokerSession_RequestReconcile_Call {
	_c.Run(run)
	return _c
}

// Snapshot provides a mock function for the type MockBrokerSession
func (_mock *MockBrokerSession) Snapshot() ports.BrokerSnapshot {
	ret := _mock.Called()

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

	var r0 ports.BrokerSnapshot
	if returnFunc, ok := ret.Get(0).(func() ports.BrokerSnapshot); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(ports.BrokerSnapshot)
	}
	return r0
}

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

// Snapshot is a helper method to define mock.On call
func (_e *MockBrokerSession_Expecter) Snapshot() *MockBrokerSession_Snapshot_Call {
	return &MockBrokerSession_Snapshot_Call{Call: _e.mock.On("Snapshot")}
}

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

func (_c *MockBrokerSession_Snapshot_Call) Return(brokerSnapshot ports.BrokerSnapshot) *MockBrokerSession_Snapshot_Call {
	_c.Call.Return(brokerSnapshot)
	return _c
}

func (_c *MockBrokerSession_Snapshot_Call) RunAndReturn(run func() ports.BrokerSnapshot) *MockBrokerSession_Snapshot_Call {
	_c.Call.Return(run)
	return _c
}

// Subscribe provides a mock function for the type MockBrokerSession
func (_mock *MockBrokerSession) Subscribe() (ports.BrokerSubscription, error) {
	ret := _mock.Called()

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

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

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

// Subscribe is a helper method to define mock.On call
func (_e *MockBrokerSession_Expecter) Subscribe() *MockBrokerSession_Subscribe_Call {
	return &MockBrokerSession_Subscribe_Call{Call: _e.mock.On("Subscribe")}
}

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

func (_c *MockBrokerSession_Subscribe_Call) Return(brokerSubscription ports.BrokerSubscription, err error) *MockBrokerSession_Subscribe_Call {
	_c.Call.Return(brokerSubscription, err)
	return _c
}

func (_c *MockBrokerSession_Subscribe_Call) RunAndReturn(run func() (ports.BrokerSubscription, error)) *MockBrokerSession_Subscribe_Call {
	_c.Call.Return(run)
	return _c
}

// SubscribePreview provides a mock function for the type MockBrokerSession
func (_mock *MockBrokerSession) SubscribePreview(request ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error) {
	ret := _mock.Called(request)

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

	var r0 ports.BrokerPreviewSubscription
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error)); ok {
		return returnFunc(request)
	}
	if returnFunc, ok := ret.Get(0).(func(ports.BrokerPreviewRequest) ports.BrokerPreviewSubscription); ok {
		r0 = returnFunc(request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(ports.BrokerPreviewSubscription)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(ports.BrokerPreviewRequest) error); ok {
		r1 = returnFunc(request)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SubscribePreview is a helper method to define mock.On call
//   - request ports.BrokerPreviewRequest
func (_e *MockBrokerSession_Expecter) SubscribePreview(request any) *MockBrokerSession_SubscribePreview_Call {
	return &MockBrokerSession_SubscribePreview_Call{Call: _e.mock.On("SubscribePreview", request)}
}

func (_c *MockBrokerSession_SubscribePreview_Call) Run(run func(request ports.BrokerPreviewRequest)) *MockBrokerSession_SubscribePreview_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 ports.BrokerPreviewRequest
		if args[0] != nil {
			arg0 = args[0].(ports.BrokerPreviewRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBrokerSession_SubscribePreview_Call) Return(brokerPreviewSubscription ports.BrokerPreviewSubscription, err error) *MockBrokerSession_SubscribePreview_Call {
	_c.Call.Return(brokerPreviewSubscription, err)
	return _c
}

func (_c *MockBrokerSession_SubscribePreview_Call) RunAndReturn(run func(request ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error)) *MockBrokerSession_SubscribePreview_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateHostPolicy provides a mock function for the type MockBrokerSession
func (_mock *MockBrokerSession) UpdateHostPolicy(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy) (domain.RemoteRegistration, error) {
	ret := _mock.Called(ctx, expected, policy)

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

	var r0 domain.RemoteRegistration
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) (domain.RemoteRegistration, error)); ok {
		return returnFunc(ctx, expected, policy)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) domain.RemoteRegistration); ok {
		r0 = returnFunc(ctx, expected, policy)
	} else {
		r0 = ret.Get(0).(domain.RemoteRegistration)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) error); ok {
		r1 = returnFunc(ctx, expected, policy)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateHostPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - expected domain.RemoteRegistration
//   - policy ports.BrokerPolicy
func (_e *MockBrokerSession_Expecter) UpdateHostPolicy(ctx any, expected any, policy any) *MockBrokerSession_UpdateHostPolicy_Call {
	return &MockBrokerSession_UpdateHostPolicy_Call{Call: _e.mock.On("UpdateHostPolicy", ctx, expected, policy)}
}

func (_c *MockBrokerSession_UpdateHostPolicy_Call) Run(run func(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy)) *MockBrokerSession_UpdateHostPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.RemoteRegistration
		if args[1] != nil {
			arg1 = args[1].(domain.RemoteRegistration)
		}
		var arg2 ports.BrokerPolicy
		if args[2] != nil {
			arg2 = args[2].(ports.BrokerPolicy)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockBrokerSession_UpdateHostPolicy_Call) Return(remoteRegistration domain.RemoteRegistration, err error) *MockBrokerSession_UpdateHostPolicy_Call {
	_c.Call.Return(remoteRegistration, err)
	return _c
}

func (_c *MockBrokerSession_UpdateHostPolicy_Call) RunAndReturn(run func(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy) (domain.RemoteRegistration, error)) *MockBrokerSession_UpdateHostPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockBrokerService creates a new instance of MockBrokerService. 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 NewMockBrokerService(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBrokerService {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockBrokerService{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockBrokerService is an autogenerated mock type for the BrokerService type
type MockBrokerService struct {
	mock.Mock
}

type MockBrokerService_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBrokerService) EXPECT() *MockBrokerService_Expecter {
	return &MockBrokerService_Expecter{mock: &_m.Mock}
}

// AddHost provides a mock function for the type MockBrokerService
func (_mock *MockBrokerService) AddHost(ctx context.Context, endpoint string, policy ports.BrokerPolicy) (domain.RemoteRegistration, error) {
	ret := _mock.Called(ctx, endpoint, policy)

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

	var r0 domain.RemoteRegistration
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, ports.BrokerPolicy) (domain.RemoteRegistration, error)); ok {
		return returnFunc(ctx, endpoint, policy)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, ports.BrokerPolicy) domain.RemoteRegistration); ok {
		r0 = returnFunc(ctx, endpoint, policy)
	} else {
		r0 = ret.Get(0).(domain.RemoteRegistration)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, ports.BrokerPolicy) error); ok {
		r1 = returnFunc(ctx, endpoint, policy)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddHost is a helper method to define mock.On call
//   - ctx context.Context
//   - endpoint string
//   - policy ports.BrokerPolicy
func (_e *MockBrokerService_Expecter) AddHost(ctx any, endpoint any, policy any) *MockBrokerService_AddHost_Call {
	return &MockBrokerService_AddHost_Call{Call: _e.mock.On("AddHost", ctx, endpoint, policy)}
}

func (_c *MockBrokerService_AddHost_Call) Run(run func(ctx context.Context, endpoint string, policy ports.BrokerPolicy)) *MockBrokerService_AddHost_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 ports.BrokerPolicy
		if args[2] != nil {
			arg2 = args[2].(ports.BrokerPolicy)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockBrokerService_AddHost_Call) Return(remoteRegistration domain.RemoteRegistration, err error) *MockBrokerService_AddHost_Call {
	_c.Call.Return(remoteRegistration, err)
	return _c
}

func (_c *MockBrokerService_AddHost_Call) RunAndReturn(run func(ctx context.Context, endpoint string, policy ports.BrokerPolicy) (domain.RemoteRegistration, error)) *MockBrokerService_AddHost_Call {
	_c.Call.Return(run)
	return _c
}

// Close provides a mock function for the type MockBrokerService
func (_mock *MockBrokerService) Close() error {
	ret := _mock.Called()

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

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

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

// Close is a helper method to define mock.On call
func (_e *MockBrokerService_Expecter) Close() *MockBrokerService_Close_Call {
	return &MockBrokerService_Close_Call{Call: _e.mock.On("Close")}
}

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

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

func (_c *MockBrokerService_Close_Call) RunAndReturn(run func() error) *MockBrokerService_Close_Call {
	_c.Call.Return(run)
	return _c
}

// CloseStream provides a mock function for the type MockBrokerService
func (_mock *MockBrokerService) CloseStream(connection ports.BrokerConnectionID, stream ports.BrokerStreamID) error {
	ret := _mock.Called(connection, stream)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(ports.BrokerConnectionID, ports.BrokerStreamID) error); ok {
		r0 = returnFunc(connection, stream)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// CloseStream is a helper method to define mock.On call
//   - connection ports.BrokerConnectionID
//   - stream ports.BrokerStreamID
func (_e *MockBrokerService_Expecter) CloseStream(connection any, stream any) *MockBrokerService_CloseStream_Call {
	return &MockBrokerService_CloseStream_Call{Call: _e.mock.On("CloseStream", connection, stream)}
}

func (_c *MockBrokerService_CloseStream_Call) Run(run func(connection ports.BrokerConnectionID, stream ports.BrokerStreamID)) *MockBrokerService_CloseStream_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 ports.BrokerConnectionID
		if args[0] != nil {
			arg0 = args[0].(ports.BrokerConnectionID)
		}
		var arg1 ports.BrokerStreamID
		if args[1] != nil {
			arg1 = args[1].(ports.BrokerStreamID)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockBrokerService_CloseStream_Call) RunAndReturn(run func(connection ports.BrokerConnectionID, stream ports.BrokerStreamID) error) *MockBrokerService_CloseStream_Call {
	_c.Call.Return(run)
	return _c
}

// ConnectionID provides a mock function for the type MockBrokerService
func (_mock *MockBrokerService) ConnectionID() ports.BrokerConnectionID {
	ret := _mock.Called()

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

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

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

// ConnectionID is a helper method to define mock.On call
func (_e *MockBrokerService_Expecter) ConnectionID() *MockBrokerService_ConnectionID_Call {
	return &MockBrokerService_ConnectionID_Call{Call: _e.mock.On("ConnectionID")}
}

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

func (_c *MockBrokerService_ConnectionID_Call) Return(brokerConnectionID ports.BrokerConnectionID) *MockBrokerService_ConnectionID_Call {
	_c.Call.Return(brokerConnectionID)
	return _c
}

func (_c *MockBrokerService_ConnectionID_Call) RunAndReturn(run func() ports.BrokerConnectionID) *MockBrokerService_ConnectionID_Call {
	_c.Call.Return(run)
	return _c
}

// Done provides a mock function for the type MockBrokerService
func (_mock *MockBrokerService) Done() <-chan struct{} {
	ret := _mock.Called()

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

	var r0 <-chan struct{}
	if returnFunc, ok := ret.Get(0).(func() <-chan struct{}); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan struct{})
		}
	}
	return r0
}

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

// Done is a helper method to define mock.On call
func (_e *MockBrokerService_Expecter) Done() *MockBrokerService_Done_Call {
	return &MockBrokerService_Done_Call{Call: _e.mock.On("Done")}
}

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

func (_c *MockBrokerService_Done_Call) Return(valCh <-chan struct{}) *MockBrokerService_Done_Call {
	_c.Call.Return(valCh)
	return _c
}

func (_c *MockBrokerService_Done_Call) RunAndReturn(run func() <-chan struct{}) *MockBrokerService_Done_Call {
	_c.Call.Return(run)
	return _c
}

// Err provides a mock function for the type MockBrokerService
func (_mock *MockBrokerService) Err() error {
	ret := _mock.Called()

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

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

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

// Err is a helper method to define mock.On call
func (_e *MockBrokerService_Expecter) Err() *MockBrokerService_Err_Call {
	return &MockBrokerService_Err_Call{Call: _e.mock.On("Err")}
}

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

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

func (_c *MockBrokerService_Err_Call) RunAndReturn(run func() error) *MockBrokerService_Err_Call {
	_c.Call.Return(run)
	return _c
}

// NextStreamID provides a mock function for the type MockBrokerService
func (_mock *MockBrokerService) NextStreamID() (ports.BrokerStreamID, error) {
	ret := _mock.Called()

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

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

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

// NextStreamID is a helper method to define mock.On call
func (_e *MockBrokerService_Expecter) NextStreamID() *MockBrokerService_NextStreamID_Call {
	return &MockBrokerService_NextStreamID_Call{Call: _e.mock.On("NextStreamID")}
}

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

func (_c *MockBrokerService_NextStreamID_Call) Return(brokerStreamID ports.BrokerStreamID, err error) *MockBrokerService_NextStreamID_Call {
	_c.Call.Return(brokerStreamID, err)
	return _c
}

func (_c *MockBrokerService_NextStreamID_Call) RunAndReturn(run func() (ports.BrokerStreamID, error)) *MockBrokerService_NextStreamID_Call {
	_c.Call.Return(run)
	return _c
}

// OpenStream provides a mock function for the type MockBrokerService
func (_mock *MockBrokerService) OpenStream(ctx context.Context, request ports.BrokerOpenStreamRequest) (ports.BrokerLogicalConnection, error) {
	ret := _mock.Called(ctx, request)

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

	var r0 ports.BrokerLogicalConnection
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, ports.BrokerOpenStreamRequest) (ports.BrokerLogicalConnection, error)); ok {
		return returnFunc(ctx, request)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, ports.BrokerOpenStreamRequest) ports.BrokerLogicalConnection); ok {
		r0 = returnFunc(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(ports.BrokerLogicalConnection)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, ports.BrokerOpenStreamRequest) error); ok {
		r1 = returnFunc(ctx, request)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OpenStream is a helper method to define mock.On call
//   - ctx context.Context
//   - request ports.BrokerOpenStreamRequest
func (_e *MockBrokerService_Expecter) OpenStream(ctx any, request any) *MockBrokerService_OpenStream_Call {
	return &MockBrokerService_OpenStream_Call{Call: _e.mock.On("OpenStream", ctx, request)}
}

func (_c *MockBrokerService_OpenStream_Call) Run(run func(ctx context.Context, request ports.BrokerOpenStreamRequest)) *MockBrokerService_OpenStream_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 ports.BrokerOpenStreamRequest
		if args[1] != nil {
			arg1 = args[1].(ports.BrokerOpenStreamRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockBrokerService_OpenStream_Call) Return(brokerLogicalConnection ports.BrokerLogicalConnection, err error) *MockBrokerService_OpenStream_Call {
	_c.Call.Return(brokerLogicalConnection, err)
	return _c
}

func (_c *MockBrokerService_OpenStream_Call) RunAndReturn(run func(ctx context.Context, request ports.BrokerOpenStreamRequest) (ports.BrokerLogicalConnection, error)) *MockBrokerService_OpenStream_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveHost provides a mock function for the type MockBrokerService
func (_mock *MockBrokerService) RemoveHost(ctx context.Context, expected domain.RemoteRegistration) (bool, error) {
	ret := _mock.Called(ctx, expected)

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

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

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

// RemoveHost is a helper method to define mock.On call
//   - ctx context.Context
//   - expected domain.RemoteRegistration
func (_e *MockBrokerService_Expecter) RemoveHost(ctx any, expected any) *MockBrokerService_RemoveHost_Call {
	return &MockBrokerService_RemoveHost_Call{Call: _e.mock.On("RemoveHost", ctx, expected)}
}

func (_c *MockBrokerService_RemoveHost_Call) Run(run func(ctx context.Context, expected domain.RemoteRegistration)) *MockBrokerService_RemoveHost_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.RemoteRegistration
		if args[1] != nil {
			arg1 = args[1].(domain.RemoteRegistration)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockBrokerService_RemoveHost_Call) RunAndReturn(run func(ctx context.Context, expected domain.RemoteRegistration) (bool, error)) *MockBrokerService_RemoveHost_Call {
	_c.Call.Return(run)
	return _c
}

// RequestReconcile provides a mock function for the type MockBrokerService
func (_mock *MockBrokerService) RequestReconcile(endpoint string) {
	_mock.Called(endpoint)
	return
}

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

// RequestReconcile is a helper method to define mock.On call
//   - endpoint string
func (_e *MockBrokerService_Expecter) RequestReconcile(endpoint any) *MockBrokerService_RequestReconcile_Call {
	return &MockBrokerService_RequestReconcile_Call{Call: _e.mock.On("RequestReconcile", endpoint)}
}

func (_c *MockBrokerService_RequestReconcile_Call) Run(run func(endpoint string)) *MockBrokerService_RequestReconcile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockBrokerService_RequestReconcile_Call) RunAndReturn(run func(endpoint string)) *MockBrokerService_RequestReconcile_Call {
	_c.Run(run)
	return _c
}

// Snapshot provides a mock function for the type MockBrokerService
func (_mock *MockBrokerService) Snapshot() ports.BrokerSnapshot {
	ret := _mock.Called()

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

	var r0 ports.BrokerSnapshot
	if returnFunc, ok := ret.Get(0).(func() ports.BrokerSnapshot); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(ports.BrokerSnapshot)
	}
	return r0
}

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

// Snapshot is a helper method to define mock.On call
func (_e *MockBrokerService_Expecter) Snapshot() *MockBrokerService_Snapshot_Call {
	return &MockBrokerService_Snapshot_Call{Call: _e.mock.On("Snapshot")}
}

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

func (_c *MockBrokerService_Snapshot_Call) Return(brokerSnapshot ports.BrokerSnapshot) *MockBrokerService_Snapshot_Call {
	_c.Call.Return(brokerSnapshot)
	return _c
}

func (_c *MockBrokerService_Snapshot_Call) RunAndReturn(run func() ports.BrokerSnapshot) *MockBrokerService_Snapshot_Call {
	_c.Call.Return(run)
	return _c
}

// Subscribe provides a mock function for the type MockBrokerService
func (_mock *MockBrokerService) Subscribe() (ports.BrokerSubscription, error) {
	ret := _mock.Called()

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

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

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

// Subscribe is a helper method to define mock.On call
func (_e *MockBrokerService_Expecter) Subscribe() *MockBrokerService_Subscribe_Call {
	return &MockBrokerService_Subscribe_Call{Call: _e.mock.On("Subscribe")}
}

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

func (_c *MockBrokerService_Subscribe_Call) Return(brokerSubscription ports.BrokerSubscription, err error) *MockBrokerService_Subscribe_Call {
	_c.Call.Return(brokerSubscription, err)
	return _c
}

func (_c *MockBrokerService_Subscribe_Call) RunAndReturn(run func() (ports.BrokerSubscription, error)) *MockBrokerService_Subscribe_Call {
	_c.Call.Return(run)
	return _c
}

// SubscribePreview provides a mock function for the type MockBrokerService
func (_mock *MockBrokerService) SubscribePreview(request ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error) {
	ret := _mock.Called(request)

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

	var r0 ports.BrokerPreviewSubscription
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error)); ok {
		return returnFunc(request)
	}
	if returnFunc, ok := ret.Get(0).(func(ports.BrokerPreviewRequest) ports.BrokerPreviewSubscription); ok {
		r0 = returnFunc(request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(ports.BrokerPreviewSubscription)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(ports.BrokerPreviewRequest) error); ok {
		r1 = returnFunc(request)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SubscribePreview is a helper method to define mock.On call
//   - request ports.BrokerPreviewRequest
func (_e *MockBrokerService_Expecter) SubscribePreview(request any) *MockBrokerService_SubscribePreview_Call {
	return &MockBrokerService_SubscribePreview_Call{Call: _e.mock.On("SubscribePreview", request)}
}

func (_c *MockBrokerService_SubscribePreview_Call) Run(run func(request ports.BrokerPreviewRequest)) *MockBrokerService_SubscribePreview_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 ports.BrokerPreviewRequest
		if args[0] != nil {
			arg0 = args[0].(ports.BrokerPreviewRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBrokerService_SubscribePreview_Call) Return(brokerPreviewSubscription ports.BrokerPreviewSubscription, err error) *MockBrokerService_SubscribePreview_Call {
	_c.Call.Return(brokerPreviewSubscription, err)
	return _c
}

func (_c *MockBrokerService_SubscribePreview_Call) RunAndReturn(run func(request ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error)) *MockBrokerService_SubscribePreview_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateHostPolicy provides a mock function for the type MockBrokerService
func (_mock *MockBrokerService) UpdateHostPolicy(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy) (domain.RemoteRegistration, error) {
	ret := _mock.Called(ctx, expected, policy)

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

	var r0 domain.RemoteRegistration
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) (domain.RemoteRegistration, error)); ok {
		return returnFunc(ctx, expected, policy)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) domain.RemoteRegistration); ok {
		r0 = returnFunc(ctx, expected, policy)
	} else {
		r0 = ret.Get(0).(domain.RemoteRegistration)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) error); ok {
		r1 = returnFunc(ctx, expected, policy)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateHostPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - expected domain.RemoteRegistration
//   - policy ports.BrokerPolicy
func (_e *MockBrokerService_Expecter) UpdateHostPolicy(ctx any, expected any, policy any) *MockBrokerService_UpdateHostPolicy_Call {
	return &MockBrokerService_UpdateHostPolicy_Call{Call: _e.mock.On("UpdateHostPolicy", ctx, expected, policy)}
}

func (_c *MockBrokerService_UpdateHostPolicy_Call) Run(run func(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy)) *MockBrokerService_UpdateHostPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.RemoteRegistration
		if args[1] != nil {
			arg1 = args[1].(domain.RemoteRegistration)
		}
		var arg2 ports.BrokerPolicy
		if args[2] != nil {
			arg2 = args[2].(ports.BrokerPolicy)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockBrokerService_UpdateHostPolicy_Call) Return(remoteRegistration domain.RemoteRegistration, err error) *MockBrokerService_UpdateHostPolicy_Call {
	_c.Call.Return(remoteRegistration, err)
	return _c
}

func (_c *MockBrokerService_UpdateHostPolicy_Call) RunAndReturn(run func(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy) (domain.RemoteRegistration, error)) *MockBrokerService_UpdateHostPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockBrokerNavigator creates a new instance of MockBrokerNavigator. 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 NewMockBrokerNavigator(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBrokerNavigator {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockBrokerNavigator{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockBrokerNavigator is an autogenerated mock type for the BrokerNavigator type
type MockBrokerNavigator struct {
	mock.Mock
}

type MockBrokerNavigator_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBrokerNavigator) EXPECT() *MockBrokerNavigator_Expecter {
	return &MockBrokerNavigator_Expecter{mock: &_m.Mock}
}

// Close provides a mock function for the type MockBrokerNavigator
func (_mock *MockBrokerNavigator) Close() error {
	ret := _mock.Called()

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

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

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

// Close is a helper method to define mock.On call
func (_e *MockBrokerNavigator_Expecter) Close() *MockBrokerNavigator_Close_Call {
	return &MockBrokerNavigator_Close_Call{Call: _e.mock.On("Close")}
}

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

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

func (_c *MockBrokerNavigator_Close_Call) RunAndReturn(run func() error) *MockBrokerNavigator_Close_Call {
	_c.Call.Return(run)
	return _c
}

// ConnectionID provides a mock function for the type MockBrokerNavigator
func (_mock *MockBrokerNavigator) ConnectionID() ports.BrokerConnectionID {
	ret := _mock.Called()

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

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

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

// ConnectionID is a helper method to define mock.On call
func (_e *MockBrokerNavigator_Expecter) ConnectionID() *MockBrokerNavigator_ConnectionID_Call {
	return &MockBrokerNavigator_ConnectionID_Call{Call: _e.mock.On("ConnectionID")}
}

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

func (_c *MockBrokerNavigator_ConnectionID_Call) Return(brokerConnectionID ports.BrokerConnectionID) *MockBrokerNavigator_ConnectionID_Call {
	_c.Call.Return(brokerConnectionID)
	return _c
}

func (_c *MockBrokerNavigator_ConnectionID_Call) RunAndReturn(run func() ports.BrokerConnectionID) *MockBrokerNavigator_ConnectionID_Call {
	_c.Call.Return(run)
	return _c
}

// Done provides a mock function for the type MockBrokerNavigator
func (_mock *MockBrokerNavigator) Done() <-chan struct{} {
	ret := _mock.Called()

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

	var r0 <-chan struct{}
	if returnFunc, ok := ret.Get(0).(func() <-chan struct{}); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan struct{})
		}
	}
	return r0
}

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

// Done is a helper method to define mock.On call
func (_e *MockBrokerNavigator_Expecter) Done() *MockBrokerNavigator_Done_Call {
	return &MockBrokerNavigator_Done_Call{Call: _e.mock.On("Done")}
}

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

func (_c *MockBrokerNavigator_Done_Call) Return(valCh <-chan struct{}) *MockBrokerNavigator_Done_Call {
	_c.Call.Return(valCh)
	return _c
}

func (_c *MockBrokerNavigator_Done_Call) RunAndReturn(run func() <-chan struct{}) *MockBrokerNavigator_Done_Call {
	_c.Call.Return(run)
	return _c
}

// Err provides a mock function for the type MockBrokerNavigator
func (_mock *MockBrokerNavigator) Err() error {
	ret := _mock.Called()

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

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

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

// Err is a helper method to define mock.On call
func (_e *MockBrokerNavigator_Expecter) Err() *MockBrokerNavigator_Err_Call {
	return &MockBrokerNavigator_Err_Call{Call: _e.mock.On("Err")}
}

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

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

func (_c *MockBrokerNavigator_Err_Call) RunAndReturn(run func() error) *MockBrokerNavigator_Err_Call {
	_c.Call.Return(run)
	return _c
}

// NextStreamID provides a mock function for the type MockBrokerNavigator
func (_mock *MockBrokerNavigator) NextStreamID() (ports.BrokerStreamID, error) {
	ret := _mock.Called()

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

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

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

// NextStreamID is a helper method to define mock.On call
func (_e *MockBrokerNavigator_Expecter) NextStreamID() *MockBrokerNavigator_NextStreamID_Call {
	return &MockBrokerNavigator_NextStreamID_Call{Call: _e.mock.On("NextStreamID")}
}

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

func (_c *MockBrokerNavigator_NextStreamID_Call) Return(brokerStreamID ports.BrokerStreamID, err error) *MockBrokerNavigator_NextStreamID_Call {
	_c.Call.Return(brokerStreamID, err)
	return _c
}

func (_c *MockBrokerNavigator_NextStreamID_Call) RunAndReturn(run func() (ports.BrokerStreamID, error)) *MockBrokerNavigator_NextStreamID_Call {
	_c.Call.Return(run)
	return _c
}

// OpenStream provides a mock function for the type MockBrokerNavigator
func (_mock *MockBrokerNavigator) OpenStream(ctx context.Context, request ports.BrokerOpenStreamRequest) (ports.BrokerLogicalConnection, error) {
	ret := _mock.Called(ctx, request)

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

	var r0 ports.BrokerLogicalConnection
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, ports.BrokerOpenStreamRequest) (ports.BrokerLogicalConnection, error)); ok {
		return returnFunc(ctx, request)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, ports.BrokerOpenStreamRequest) ports.BrokerLogicalConnection); ok {
		r0 = returnFunc(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(ports.BrokerLogicalConnection)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, ports.BrokerOpenStreamRequest) error); ok {
		r1 = returnFunc(ctx, request)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OpenStream is a helper method to define mock.On call
//   - ctx context.Context
//   - request ports.BrokerOpenStreamRequest
func (_e *MockBrokerNavigator_Expecter) OpenStream(ctx any, request any) *MockBrokerNavigator_OpenStream_Call {
	return &MockBrokerNavigator_OpenStream_Call{Call: _e.mock.On("OpenStream", ctx, request)}
}

func (_c *MockBrokerNavigator_OpenStream_Call) Run(run func(ctx context.Context, request ports.BrokerOpenStreamRequest)) *MockBrokerNavigator_OpenStream_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 ports.BrokerOpenStreamRequest
		if args[1] != nil {
			arg1 = args[1].(ports.BrokerOpenStreamRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockBrokerNavigator_OpenStream_Call) Return(brokerLogicalConnection ports.BrokerLogicalConnection, err error) *MockBrokerNavigator_OpenStream_Call {
	_c.Call.Return(brokerLogicalConnection, err)
	return _c
}

func (_c *MockBrokerNavigator_OpenStream_Call) RunAndReturn(run func(ctx context.Context, request ports.BrokerOpenStreamRequest) (ports.BrokerLogicalConnection, error)) *MockBrokerNavigator_OpenStream_Call {
	_c.Call.Return(run)
	return _c
}

// RequestReconcile provides a mock function for the type MockBrokerNavigator
func (_mock *MockBrokerNavigator) RequestReconcile(endpoint string) {
	_mock.Called(endpoint)
	return
}

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

// RequestReconcile is a helper method to define mock.On call
//   - endpoint string
func (_e *MockBrokerNavigator_Expecter) RequestReconcile(endpoint any) *MockBrokerNavigator_RequestReconcile_Call {
	return &MockBrokerNavigator_RequestReconcile_Call{Call: _e.mock.On("RequestReconcile", endpoint)}
}

func (_c *MockBrokerNavigator_RequestReconcile_Call) Run(run func(endpoint string)) *MockBrokerNavigator_RequestReconcile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockBrokerNavigator_RequestReconcile_Call) RunAndReturn(run func(endpoint string)) *MockBrokerNavigator_RequestReconcile_Call {
	_c.Run(run)
	return _c
}

// Snapshot provides a mock function for the type MockBrokerNavigator
func (_mock *MockBrokerNavigator) Snapshot() ports.BrokerSnapshot {
	ret := _mock.Called()

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

	var r0 ports.BrokerSnapshot
	if returnFunc, ok := ret.Get(0).(func() ports.BrokerSnapshot); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(ports.BrokerSnapshot)
	}
	return r0
}

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

// Snapshot is a helper method to define mock.On call
func (_e *MockBrokerNavigator_Expecter) Snapshot() *MockBrokerNavigator_Snapshot_Call {
	return &MockBrokerNavigator_Snapshot_Call{Call: _e.mock.On("Snapshot")}
}

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

func (_c *MockBrokerNavigator_Snapshot_Call) Return(brokerSnapshot ports.BrokerSnapshot) *MockBrokerNavigator_Snapshot_Call {
	_c.Call.Return(brokerSnapshot)
	return _c
}

func (_c *MockBrokerNavigator_Snapshot_Call) RunAndReturn(run func() ports.BrokerSnapshot) *MockBrokerNavigator_Snapshot_Call {
	_c.Call.Return(run)
	return _c
}

// Subscribe provides a mock function for the type MockBrokerNavigator
func (_mock *MockBrokerNavigator) Subscribe() (ports.BrokerSubscription, error) {
	ret := _mock.Called()

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

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

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

// Subscribe is a helper method to define mock.On call
func (_e *MockBrokerNavigator_Expecter) Subscribe() *MockBrokerNavigator_Subscribe_Call {
	return &MockBrokerNavigator_Subscribe_Call{Call: _e.mock.On("Subscribe")}
}

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

func (_c *MockBrokerNavigator_Subscribe_Call) Return(brokerSubscription ports.BrokerSubscription, err error) *MockBrokerNavigator_Subscribe_Call {
	_c.Call.Return(brokerSubscription, err)
	return _c
}

func (_c *MockBrokerNavigator_Subscribe_Call) RunAndReturn(run func() (ports.BrokerSubscription, error)) *MockBrokerNavigator_Subscribe_Call {
	_c.Call.Return(run)
	return _c
}

// SubscribePreview provides a mock function for the type MockBrokerNavigator
func (_mock *MockBrokerNavigator) SubscribePreview(request ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error) {
	ret := _mock.Called(request)

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

	var r0 ports.BrokerPreviewSubscription
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error)); ok {
		return returnFunc(request)
	}
	if returnFunc, ok := ret.Get(0).(func(ports.BrokerPreviewRequest) ports.BrokerPreviewSubscription); ok {
		r0 = returnFunc(request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(ports.BrokerPreviewSubscription)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(ports.BrokerPreviewRequest) error); ok {
		r1 = returnFunc(request)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SubscribePreview is a helper method to define mock.On call
//   - request ports.BrokerPreviewRequest
func (_e *MockBrokerNavigator_Expecter) SubscribePreview(request any) *MockBrokerNavigator_SubscribePreview_Call {
	return &MockBrokerNavigator_SubscribePreview_Call{Call: _e.mock.On("SubscribePreview", request)}
}

func (_c *MockBrokerNavigator_SubscribePreview_Call) Run(run func(request ports.BrokerPreviewRequest)) *MockBrokerNavigator_SubscribePreview_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 ports.BrokerPreviewRequest
		if args[0] != nil {
			arg0 = args[0].(ports.BrokerPreviewRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBrokerNavigator_SubscribePreview_Call) Return(brokerPreviewSubscription ports.BrokerPreviewSubscription, err error) *MockBrokerNavigator_SubscribePreview_Call {
	_c.Call.Return(brokerPreviewSubscription, err)
	return _c
}

func (_c *MockBrokerNavigator_SubscribePreview_Call) RunAndReturn(run func(request ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error)) *MockBrokerNavigator_SubscribePreview_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockBrokerEnvelopeStream creates a new instance of MockBrokerEnvelopeStream. 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 NewMockBrokerEnvelopeStream(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBrokerEnvelopeStream {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockBrokerEnvelopeStream{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockBrokerEnvelopeStream is an autogenerated mock type for the BrokerEnvelopeStream type
type MockBrokerEnvelopeStream struct {
	mock.Mock
}

type MockBrokerEnvelopeStream_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBrokerEnvelopeStream) EXPECT() *MockBrokerEnvelopeStream_Expecter {
	return &MockBrokerEnvelopeStream_Expecter{mock: &_m.Mock}
}

// Close provides a mock function for the type MockBrokerEnvelopeStream
func (_mock *MockBrokerEnvelopeStream) Close() error {
	ret := _mock.Called()

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

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

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

// Close is a helper method to define mock.On call
func (_e *MockBrokerEnvelopeStream_Expecter) Close() *MockBrokerEnvelopeStream_Close_Call {
	return &MockBrokerEnvelopeStream_Close_Call{Call: _e.mock.On("Close")}
}

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

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

func (_c *MockBrokerEnvelopeStream_Close_Call) RunAndReturn(run func() error) *MockBrokerEnvelopeStream_Close_Call {
	_c.Call.Return(run)
	return _c
}

// Done provides a mock function for the type MockBrokerEnvelopeStream
func (_mock *MockBrokerEnvelopeStream) Done() <-chan struct{} {
	ret := _mock.Called()

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

	var r0 <-chan struct{}
	if returnFunc, ok := ret.Get(0).(func() <-chan struct{}); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan struct{})
		}
	}
	return r0
}

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

// Done is a helper method to define mock.On call
func (_e *MockBrokerEnvelopeStream_Expecter) Done() *MockBrokerEnvelopeStream_Done_Call {
	return &MockBrokerEnvelopeStream_Done_Call{Call: _e.mock.On("Done")}
}

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

func (_c *MockBrokerEnvelopeStream_Done_Call) Return(valCh <-chan struct{}) *MockBrokerEnvelopeStream_Done_Call {
	_c.Call.Return(valCh)
	return _c
}

func (_c *MockBrokerEnvelopeStream_Done_Call) RunAndReturn(run func() <-chan struct{}) *MockBrokerEnvelopeStream_Done_Call {
	_c.Call.Return(run)
	return _c
}

// Err provides a mock function for the type MockBrokerEnvelopeStream
func (_mock *MockBrokerEnvelopeStream) Err() error {
	ret := _mock.Called()

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

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

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

// Err is a helper method to define mock.On call
func (_e *MockBrokerEnvelopeStream_Expecter) Err() *MockBrokerEnvelopeStream_Err_Call {
	return &MockBrokerEnvelopeStream_Err_Call{Call: _e.mock.On("Err")}
}

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

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

func (_c *MockBrokerEnvelopeStream_Err_Call) RunAndReturn(run func() error) *MockBrokerEnvelopeStream_Err_Call {
	_c.Call.Return(run)
	return _c
}

// RecvEnvelope provides a mock function for the type MockBrokerEnvelopeStream
func (_mock *MockBrokerEnvelopeStream) RecvEnvelope() ([]byte, error) {
	ret := _mock.Called()

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

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

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

// RecvEnvelope is a helper method to define mock.On call
func (_e *MockBrokerEnvelopeStream_Expecter) RecvEnvelope() *MockBrokerEnvelopeStream_RecvEnvelope_Call {
	return &MockBrokerEnvelopeStream_RecvEnvelope_Call{Call: _e.mock.On("RecvEnvelope")}
}

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

func (_c *MockBrokerEnvelopeStream_RecvEnvelope_Call) Return(bytes []byte, err error) *MockBrokerEnvelopeStream_RecvEnvelope_Call {
	_c.Call.Return(bytes, err)
	return _c
}

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

// SendEnvelope provides a mock function for the type MockBrokerEnvelopeStream
func (_mock *MockBrokerEnvelopeStream) SendEnvelope(bytes []byte) error {
	ret := _mock.Called(bytes)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func([]byte) error); ok {
		r0 = returnFunc(bytes)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SendEnvelope is a helper method to define mock.On call
//   - bytes []byte
func (_e *MockBrokerEnvelopeStream_Expecter) SendEnvelope(bytes any) *MockBrokerEnvelopeStream_SendEnvelope_Call {
	return &MockBrokerEnvelopeStream_SendEnvelope_Call{Call: _e.mock.On("SendEnvelope", bytes)}
}

func (_c *MockBrokerEnvelopeStream_SendEnvelope_Call) Run(run func(bytes []byte)) *MockBrokerEnvelopeStream_SendEnvelope_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []byte
		if args[0] != nil {
			arg0 = args[0].([]byte)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockBrokerEnvelopeStream_SendEnvelope_Call) RunAndReturn(run func(bytes []byte) error) *MockBrokerEnvelopeStream_SendEnvelope_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockBrokerCoreService creates a new instance of MockBrokerCoreService. 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 NewMockBrokerCoreService(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBrokerCoreService {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockBrokerCoreService{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockBrokerCoreService is an autogenerated mock type for the BrokerCoreService type
type MockBrokerCoreService struct {
	mock.Mock
}

type MockBrokerCoreService_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBrokerCoreService) EXPECT() *MockBrokerCoreService_Expecter {
	return &MockBrokerCoreService_Expecter{mock: &_m.Mock}
}

// AddHost provides a mock function for the type MockBrokerCoreService
func (_mock *MockBrokerCoreService) AddHost(ctx context.Context, endpoint string, policy ports.BrokerPolicy) (domain.RemoteRegistration, error) {
	ret := _mock.Called(ctx, endpoint, policy)

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

	var r0 domain.RemoteRegistration
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, ports.BrokerPolicy) (domain.RemoteRegistration, error)); ok {
		return returnFunc(ctx, endpoint, policy)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, ports.BrokerPolicy) domain.RemoteRegistration); ok {
		r0 = returnFunc(ctx, endpoint, policy)
	} else {
		r0 = ret.Get(0).(domain.RemoteRegistration)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, ports.BrokerPolicy) error); ok {
		r1 = returnFunc(ctx, endpoint, policy)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddHost is a helper method to define mock.On call
//   - ctx context.Context
//   - endpoint string
//   - policy ports.BrokerPolicy
func (_e *MockBrokerCoreService_Expecter) AddHost(ctx any, endpoint any, policy any) *MockBrokerCoreService_AddHost_Call {
	return &MockBrokerCoreService_AddHost_Call{Call: _e.mock.On("AddHost", ctx, endpoint, policy)}
}

func (_c *MockBrokerCoreService_AddHost_Call) Run(run func(ctx context.Context, endpoint string, policy ports.BrokerPolicy)) *MockBrokerCoreService_AddHost_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 ports.BrokerPolicy
		if args[2] != nil {
			arg2 = args[2].(ports.BrokerPolicy)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockBrokerCoreService_AddHost_Call) Return(remoteRegistration domain.RemoteRegistration, err error) *MockBrokerCoreService_AddHost_Call {
	_c.Call.Return(remoteRegistration, err)
	return _c
}

func (_c *MockBrokerCoreService_AddHost_Call) RunAndReturn(run func(ctx context.Context, endpoint string, policy ports.BrokerPolicy) (domain.RemoteRegistration, error)) *MockBrokerCoreService_AddHost_Call {
	_c.Call.Return(run)
	return _c
}

// Close provides a mock function for the type MockBrokerCoreService
func (_mock *MockBrokerCoreService) Close() error {
	ret := _mock.Called()

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

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

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

// Close is a helper method to define mock.On call
func (_e *MockBrokerCoreService_Expecter) Close() *MockBrokerCoreService_Close_Call {
	return &MockBrokerCoreService_Close_Call{Call: _e.mock.On("Close")}
}

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

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

func (_c *MockBrokerCoreService_Close_Call) RunAndReturn(run func() error) *MockBrokerCoreService_Close_Call {
	_c.Call.Return(run)
	return _c
}

// CloseStream provides a mock function for the type MockBrokerCoreService
func (_mock *MockBrokerCoreService) CloseStream(connection ports.BrokerConnectionID, stream ports.BrokerStreamID) error {
	ret := _mock.Called(connection, stream)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(ports.BrokerConnectionID, ports.BrokerStreamID) error); ok {
		r0 = returnFunc(connection, stream)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// CloseStream is a helper method to define mock.On call
//   - connection ports.BrokerConnectionID
//   - stream ports.BrokerStreamID
func (_e *MockBrokerCoreService_Expecter) CloseStream(connection any, stream any) *MockBrokerCoreService_CloseStream_Call {
	return &MockBrokerCoreService_CloseStream_Call{Call: _e.mock.On("CloseStream", connection, stream)}
}

func (_c *MockBrokerCoreService_CloseStream_Call) Run(run func(connection ports.BrokerConnectionID, stream ports.BrokerStreamID)) *MockBrokerCoreService_CloseStream_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 ports.BrokerConnectionID
		if args[0] != nil {
			arg0 = args[0].(ports.BrokerConnectionID)
		}
		var arg1 ports.BrokerStreamID
		if args[1] != nil {
			arg1 = args[1].(ports.BrokerStreamID)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockBrokerCoreService_CloseStream_Call) RunAndReturn(run func(connection ports.BrokerConnectionID, stream ports.BrokerStreamID) error) *MockBrokerCoreService_CloseStream_Call {
	_c.Call.Return(run)
	return _c
}

// ConnectionID provides a mock function for the type MockBrokerCoreService
func (_mock *MockBrokerCoreService) ConnectionID() ports.BrokerConnectionID {
	ret := _mock.Called()

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

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

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

// ConnectionID is a helper method to define mock.On call
func (_e *MockBrokerCoreService_Expecter) ConnectionID() *MockBrokerCoreService_ConnectionID_Call {
	return &MockBrokerCoreService_ConnectionID_Call{Call: _e.mock.On("ConnectionID")}
}

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

func (_c *MockBrokerCoreService_ConnectionID_Call) Return(brokerConnectionID ports.BrokerConnectionID) *MockBrokerCoreService_ConnectionID_Call {
	_c.Call.Return(brokerConnectionID)
	return _c
}

func (_c *MockBrokerCoreService_ConnectionID_Call) RunAndReturn(run func() ports.BrokerConnectionID) *MockBrokerCoreService_ConnectionID_Call {
	_c.Call.Return(run)
	return _c
}

// Done provides a mock function for the type MockBrokerCoreService
func (_mock *MockBrokerCoreService) Done() <-chan struct{} {
	ret := _mock.Called()

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

	var r0 <-chan struct{}
	if returnFunc, ok := ret.Get(0).(func() <-chan struct{}); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan struct{})
		}
	}
	return r0
}

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

// Done is a helper method to define mock.On call
func (_e *MockBrokerCoreService_Expecter) Done() *MockBrokerCoreService_Done_Call {
	return &MockBrokerCoreService_Done_Call{Call: _e.mock.On("Done")}
}

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

func (_c *MockBrokerCoreService_Done_Call) Return(valCh <-chan struct{}) *MockBrokerCoreService_Done_Call {
	_c.Call.Return(valCh)
	return _c
}

func (_c *MockBrokerCoreService_Done_Call) RunAndReturn(run func() <-chan struct{}) *MockBrokerCoreService_Done_Call {
	_c.Call.Return(run)
	return _c
}

// Err provides a mock function for the type MockBrokerCoreService
func (_mock *MockBrokerCoreService) Err() error {
	ret := _mock.Called()

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

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

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

// Err is a helper method to define mock.On call
func (_e *MockBrokerCoreService_Expecter) Err() *MockBrokerCoreService_Err_Call {
	return &MockBrokerCoreService_Err_Call{Call: _e.mock.On("Err")}
}

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

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

func (_c *MockBrokerCoreService_Err_Call) RunAndReturn(run func() error) *MockBrokerCoreService_Err_Call {
	_c.Call.Return(run)
	return _c
}

// NextStreamID provides a mock function for the type MockBrokerCoreService
func (_mock *MockBrokerCoreService) NextStreamID() (ports.BrokerStreamID, error) {
	ret := _mock.Called()

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

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

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

// NextStreamID is a helper method to define mock.On call
func (_e *MockBrokerCoreService_Expecter) NextStreamID() *MockBrokerCoreService_NextStreamID_Call {
	return &MockBrokerCoreService_NextStreamID_Call{Call: _e.mock.On("NextStreamID")}
}

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

func (_c *MockBrokerCoreService_NextStreamID_Call) Return(brokerStreamID ports.BrokerStreamID, err error) *MockBrokerCoreService_NextStreamID_Call {
	_c.Call.Return(brokerStreamID, err)
	return _c
}

func (_c *MockBrokerCoreService_NextStreamID_Call) RunAndReturn(run func() (ports.BrokerStreamID, error)) *MockBrokerCoreService_NextStreamID_Call {
	_c.Call.Return(run)
	return _c
}

// OpenEnvelopeStream provides a mock function for the type MockBrokerCoreService
func (_mock *MockBrokerCoreService) OpenEnvelopeStream(ctx context.Context, request ports.BrokerOpenStreamRequest) (ports.BrokerEnvelopeStream, error) {
	ret := _mock.Called(ctx, request)

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

	var r0 ports.BrokerEnvelopeStream
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, ports.BrokerOpenStreamRequest) (ports.BrokerEnvelopeStream, error)); ok {
		return returnFunc(ctx, request)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, ports.BrokerOpenStreamRequest) ports.BrokerEnvelopeStream); ok {
		r0 = returnFunc(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(ports.BrokerEnvelopeStream)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, ports.BrokerOpenStreamRequest) error); ok {
		r1 = returnFunc(ctx, request)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OpenEnvelopeStream is a helper method to define mock.On call
//   - ctx context.Context
//   - request ports.BrokerOpenStreamRequest
func (_e *MockBrokerCoreService_Expecter) OpenEnvelopeStream(ctx any, request any) *MockBrokerCoreService_OpenEnvelopeStream_Call {
	return &MockBrokerCoreService_OpenEnvelopeStream_Call{Call: _e.mock.On("OpenEnvelopeStream", ctx, request)}
}

func (_c *MockBrokerCoreService_OpenEnvelopeStream_Call) Run(run func(ctx context.Context, request ports.BrokerOpenStreamRequest)) *MockBrokerCoreService_OpenEnvelopeStream_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 ports.BrokerOpenStreamRequest
		if args[1] != nil {
			arg1 = args[1].(ports.BrokerOpenStreamRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockBrokerCoreService_OpenEnvelopeStream_Call) Return(brokerEnvelopeStream ports.BrokerEnvelopeStream, err error) *MockBrokerCoreService_OpenEnvelopeStream_Call {
	_c.Call.Return(brokerEnvelopeStream, err)
	return _c
}

func (_c *MockBrokerCoreService_OpenEnvelopeStream_Call) RunAndReturn(run func(ctx context.Context, request ports.BrokerOpenStreamRequest) (ports.BrokerEnvelopeStream, error)) *MockBrokerCoreService_OpenEnvelopeStream_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveHost provides a mock function for the type MockBrokerCoreService
func (_mock *MockBrokerCoreService) RemoveHost(ctx context.Context, expected domain.RemoteRegistration) (bool, error) {
	ret := _mock.Called(ctx, expected)

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

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

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

// RemoveHost is a helper method to define mock.On call
//   - ctx context.Context
//   - expected domain.RemoteRegistration
func (_e *MockBrokerCoreService_Expecter) RemoveHost(ctx any, expected any) *MockBrokerCoreService_RemoveHost_Call {
	return &MockBrokerCoreService_RemoveHost_Call{Call: _e.mock.On("RemoveHost", ctx, expected)}
}

func (_c *MockBrokerCoreService_RemoveHost_Call) Run(run func(ctx context.Context, expected domain.RemoteRegistration)) *MockBrokerCoreService_RemoveHost_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.RemoteRegistration
		if args[1] != nil {
			arg1 = args[1].(domain.RemoteRegistration)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockBrokerCoreService_RemoveHost_Call) RunAndReturn(run func(ctx context.Context, expected domain.RemoteRegistration) (bool, error)) *MockBrokerCoreService_RemoveHost_Call {
	_c.Call.Return(run)
	return _c
}

// RequestReconcile provides a mock function for the type MockBrokerCoreService
func (_mock *MockBrokerCoreService) RequestReconcile(endpoint string) {
	_mock.Called(endpoint)
	return
}

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

// RequestReconcile is a helper method to define mock.On call
//   - endpoint string
func (_e *MockBrokerCoreService_Expecter) RequestReconcile(endpoint any) *MockBrokerCoreService_RequestReconcile_Call {
	return &MockBrokerCoreService_RequestReconcile_Call{Call: _e.mock.On("RequestReconcile", endpoint)}
}

func (_c *MockBrokerCoreService_RequestReconcile_Call) Run(run func(endpoint string)) *MockBrokerCoreService_RequestReconcile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockBrokerCoreService_RequestReconcile_Call) RunAndReturn(run func(endpoint string)) *MockBrokerCoreService_RequestReconcile_Call {
	_c.Run(run)
	return _c
}

// Snapshot provides a mock function for the type MockBrokerCoreService
func (_mock *MockBrokerCoreService) Snapshot() ports.BrokerSnapshot {
	ret := _mock.Called()

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

	var r0 ports.BrokerSnapshot
	if returnFunc, ok := ret.Get(0).(func() ports.BrokerSnapshot); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(ports.BrokerSnapshot)
	}
	return r0
}

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

// Snapshot is a helper method to define mock.On call
func (_e *MockBrokerCoreService_Expecter) Snapshot() *MockBrokerCoreService_Snapshot_Call {
	return &MockBrokerCoreService_Snapshot_Call{Call: _e.mock.On("Snapshot")}
}

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

func (_c *MockBrokerCoreService_Snapshot_Call) Return(brokerSnapshot ports.BrokerSnapshot) *MockBrokerCoreService_Snapshot_Call {
	_c.Call.Return(brokerSnapshot)
	return _c
}

func (_c *MockBrokerCoreService_Snapshot_Call) RunAndReturn(run func() ports.BrokerSnapshot) *MockBrokerCoreService_Snapshot_Call {
	_c.Call.Return(run)
	return _c
}

// Subscribe provides a mock function for the type MockBrokerCoreService
func (_mock *MockBrokerCoreService) Subscribe() (ports.BrokerSubscription, error) {
	ret := _mock.Called()

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

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

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

// Subscribe is a helper method to define mock.On call
func (_e *MockBrokerCoreService_Expecter) Subscribe() *MockBrokerCoreService_Subscribe_Call {
	return &MockBrokerCoreService_Subscribe_Call{Call: _e.mock.On("Subscribe")}
}

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

func (_c *MockBrokerCoreService_Subscribe_Call) Return(brokerSubscription ports.BrokerSubscription, err error) *MockBrokerCoreService_Subscribe_Call {
	_c.Call.Return(brokerSubscription, err)
	return _c
}

func (_c *MockBrokerCoreService_Subscribe_Call) RunAndReturn(run func() (ports.BrokerSubscription, error)) *MockBrokerCoreService_Subscribe_Call {
	_c.Call.Return(run)
	return _c
}

// SubscribePreview provides a mock function for the type MockBrokerCoreService
func (_mock *MockBrokerCoreService) SubscribePreview(request ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error) {
	ret := _mock.Called(request)

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

	var r0 ports.BrokerPreviewSubscription
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error)); ok {
		return returnFunc(request)
	}
	if returnFunc, ok := ret.Get(0).(func(ports.BrokerPreviewRequest) ports.BrokerPreviewSubscription); ok {
		r0 = returnFunc(request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(ports.BrokerPreviewSubscription)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(ports.BrokerPreviewRequest) error); ok {
		r1 = returnFunc(request)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SubscribePreview is a helper method to define mock.On call
//   - request ports.BrokerPreviewRequest
func (_e *MockBrokerCoreService_Expecter) SubscribePreview(request any) *MockBrokerCoreService_SubscribePreview_Call {
	return &MockBrokerCoreService_SubscribePreview_Call{Call: _e.mock.On("SubscribePreview", request)}
}

func (_c *MockBrokerCoreService_SubscribePreview_Call) Run(run func(request ports.BrokerPreviewRequest)) *MockBrokerCoreService_SubscribePreview_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 ports.BrokerPreviewRequest
		if args[0] != nil {
			arg0 = args[0].(ports.BrokerPreviewRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBrokerCoreService_SubscribePreview_Call) Return(brokerPreviewSubscription ports.BrokerPreviewSubscription, err error) *MockBrokerCoreService_SubscribePreview_Call {
	_c.Call.Return(brokerPreviewSubscription, err)
	return _c
}

func (_c *MockBrokerCoreService_SubscribePreview_Call) RunAndReturn(run func(request ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error)) *MockBrokerCoreService_SubscribePreview_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateHostPolicy provides a mock function for the type MockBrokerCoreService
func (_mock *MockBrokerCoreService) UpdateHostPolicy(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy) (domain.RemoteRegistration, error) {
	ret := _mock.Called(ctx, expected, policy)

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

	var r0 domain.RemoteRegistration
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) (domain.RemoteRegistration, error)); ok {
		return returnFunc(ctx, expected, policy)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) domain.RemoteRegistration); ok {
		r0 = returnFunc(ctx, expected, policy)
	} else {
		r0 = ret.Get(0).(domain.RemoteRegistration)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) error); ok {
		r1 = returnFunc(ctx, expected, policy)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateHostPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - expected domain.RemoteRegistration
//   - policy ports.BrokerPolicy
func (_e *MockBrokerCoreService_Expecter) UpdateHostPolicy(ctx any, expected any, policy any) *MockBrokerCoreService_UpdateHostPolicy_Call {
	return &MockBrokerCoreService_UpdateHostPolicy_Call{Call: _e.mock.On("UpdateHostPolicy", ctx, expected, policy)}
}

func (_c *MockBrokerCoreService_UpdateHostPolicy_Call) Run(run func(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy)) *MockBrokerCoreService_UpdateHostPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.RemoteRegistration
		if args[1] != nil {
			arg1 = args[1].(domain.RemoteRegistration)
		}
		var arg2 ports.BrokerPolicy
		if args[2] != nil {
			arg2 = args[2].(ports.BrokerPolicy)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockBrokerCoreService_UpdateHostPolicy_Call) Return(remoteRegistration domain.RemoteRegistration, err error) *MockBrokerCoreService_UpdateHostPolicy_Call {
	_c.Call.Return(remoteRegistration, err)
	return _c
}

func (_c *MockBrokerCoreService_UpdateHostPolicy_Call) RunAndReturn(run func(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy) (domain.RemoteRegistration, error)) *MockBrokerCoreService_UpdateHostPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockSessionCodec creates a new instance of MockSessionCodec. 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 NewMockSessionCodec(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockSessionCodec {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockSessionCodec{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockSessionCodec is an autogenerated mock type for the SessionCodec type
type MockSessionCodec struct {
	mock.Mock
}

type MockSessionCodec_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSessionCodec) EXPECT() *MockSessionCodec_Expecter {
	return &MockSessionCodec_Expecter{mock: &_m.Mock}
}

// Client provides a mock function for the type MockSessionCodec
func (_mock *MockSessionCodec) Client(brokerEnvelopeStream ports.BrokerEnvelopeStream) ports.ClientConnection {
	ret := _mock.Called(brokerEnvelopeStream)

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

	var r0 ports.ClientConnection
	if returnFunc, ok := ret.Get(0).(func(ports.BrokerEnvelopeStream) ports.ClientConnection); ok {
		r0 = returnFunc(brokerEnvelopeStream)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(ports.ClientConnection)
		}
	}
	return r0
}

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

// Client is a helper method to define mock.On call
//   - brokerEnvelopeStream ports.BrokerEnvelopeStream
func (_e *MockSessionCodec_Expecter) Client(brokerEnvelopeStream any) *MockSessionCodec_Client_Call {
	return &MockSessionCodec_Client_Call{Call: _e.mock.On("Client", brokerEnvelopeStream)}
}

func (_c *MockSessionCodec_Client_Call) Run(run func(brokerEnvelopeStream ports.BrokerEnvelopeStream)) *MockSessionCodec_Client_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 ports.BrokerEnvelopeStream
		if args[0] != nil {
			arg0 = args[0].(ports.BrokerEnvelopeStream)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockSessionCodec_Client_Call) Return(clientConnection ports.ClientConnection) *MockSessionCodec_Client_Call {
	_c.Call.Return(clientConnection)
	return _c
}

func (_c *MockSessionCodec_Client_Call) RunAndReturn(run func(brokerEnvelopeStream ports.BrokerEnvelopeStream) ports.ClientConnection) *MockSessionCodec_Client_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockBrokerSnapshotStore creates a new instance of MockBrokerSnapshotStore. 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 NewMockBrokerSnapshotStore(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBrokerSnapshotStore {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockBrokerSnapshotStore{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockBrokerSnapshotStore is an autogenerated mock type for the BrokerSnapshotStore type
type MockBrokerSnapshotStore struct {
	mock.Mock
}

type MockBrokerSnapshotStore_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBrokerSnapshotStore) EXPECT() *MockBrokerSnapshotStore_Expecter {
	return &MockBrokerSnapshotStore_Expecter{mock: &_m.Mock}
}

// Load provides a mock function for the type MockBrokerSnapshotStore
func (_mock *MockBrokerSnapshotStore) Load() (ports.BrokerSnapshot, error) {
	ret := _mock.Called()

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

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

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

// Load is a helper method to define mock.On call
func (_e *MockBrokerSnapshotStore_Expecter) Load() *MockBrokerSnapshotStore_Load_Call {
	return &MockBrokerSnapshotStore_Load_Call{Call: _e.mock.On("Load")}
}

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

func (_c *MockBrokerSnapshotStore_Load_Call) Return(brokerSnapshot ports.BrokerSnapshot, err error) *MockBrokerSnapshotStore_Load_Call {
	_c.Call.Return(brokerSnapshot, err)
	return _c
}

func (_c *MockBrokerSnapshotStore_Load_Call) RunAndReturn(run func() (ports.BrokerSnapshot, error)) *MockBrokerSnapshotStore_Load_Call {
	_c.Call.Return(run)
	return _c
}

// Store provides a mock function for the type MockBrokerSnapshotStore
func (_mock *MockBrokerSnapshotStore) Store(brokerSnapshot ports.BrokerSnapshot) error {
	ret := _mock.Called(brokerSnapshot)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(ports.BrokerSnapshot) error); ok {
		r0 = returnFunc(brokerSnapshot)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Store is a helper method to define mock.On call
//   - brokerSnapshot ports.BrokerSnapshot
func (_e *MockBrokerSnapshotStore_Expecter) Store(brokerSnapshot any) *MockBrokerSnapshotStore_Store_Call {
	return &MockBrokerSnapshotStore_Store_Call{Call: _e.mock.On("Store", brokerSnapshot)}
}

func (_c *MockBrokerSnapshotStore_Store_Call) Run(run func(brokerSnapshot ports.BrokerSnapshot)) *MockBrokerSnapshotStore_Store_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 ports.BrokerSnapshot
		if args[0] != nil {
			arg0 = args[0].(ports.BrokerSnapshot)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockBrokerSnapshotStore_Store_Call) RunAndReturn(run func(brokerSnapshot ports.BrokerSnapshot) error) *MockBrokerSnapshotStore_Store_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockBrokerHostProbe creates a new instance of MockBrokerHostProbe. 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 NewMockBrokerHostProbe(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBrokerHostProbe {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockBrokerHostProbe{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockBrokerHostProbe is an autogenerated mock type for the BrokerHostProbe type
type MockBrokerHostProbe struct {
	mock.Mock
}

type MockBrokerHostProbe_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBrokerHostProbe) EXPECT() *MockBrokerHostProbe_Expecter {
	return &MockBrokerHostProbe_Expecter{mock: &_m.Mock}
}

// Probe provides a mock function for the type MockBrokerHostProbe
func (_mock *MockBrokerHostProbe) Probe(ctx context.Context, registration domain.RemoteRegistration) (ports.BrokerDaemonObservation, error) {
	ret := _mock.Called(ctx, registration)

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

	var r0 ports.BrokerDaemonObservation
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration) (ports.BrokerDaemonObservation, error)); ok {
		return returnFunc(ctx, registration)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration) ports.BrokerDaemonObservation); ok {
		r0 = returnFunc(ctx, registration)
	} else {
		r0 = ret.Get(0).(ports.BrokerDaemonObservation)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RemoteRegistration) error); ok {
		r1 = returnFunc(ctx, registration)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Probe is a helper method to define mock.On call
//   - ctx context.Context
//   - registration domain.RemoteRegistration
func (_e *MockBrokerHostProbe_Expecter) Probe(ctx any, registration any) *MockBrokerHostProbe_Probe_Call {
	return &MockBrokerHostProbe_Probe_Call{Call: _e.mock.On("Probe", ctx, registration)}
}

func (_c *MockBrokerHostProbe_Probe_Call) Run(run func(ctx context.Context, registration domain.RemoteRegistration)) *MockBrokerHostProbe_Probe_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.RemoteRegistration
		if args[1] != nil {
			arg1 = args[1].(domain.RemoteRegistration)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockBrokerHostProbe_Probe_Call) Return(brokerDaemonObservation ports.BrokerDaemonObservation, err error) *MockBrokerHostProbe_Probe_Call {
	_c.Call.Return(brokerDaemonObservation, err)
	return _c
}

func (_c *MockBrokerHostProbe_Probe_Call) RunAndReturn(run func(ctx context.Context, registration domain.RemoteRegistration) (ports.BrokerDaemonObservation, error)) *MockBrokerHostProbe_Probe_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockBrokerPhysicalConnection creates a new instance of MockBrokerPhysicalConnection. 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 NewMockBrokerPhysicalConnection(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBrokerPhysicalConnection {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockBrokerPhysicalConnection{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockBrokerPhysicalConnection is an autogenerated mock type for the BrokerPhysicalConnection type
type MockBrokerPhysicalConnection struct {
	mock.Mock
}

type MockBrokerPhysicalConnection_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBrokerPhysicalConnection) EXPECT() *MockBrokerPhysicalConnection_Expecter {
	return &MockBrokerPhysicalConnection_Expecter{mock: &_m.Mock}
}

// Close provides a mock function for the type MockBrokerPhysicalConnection
func (_mock *MockBrokerPhysicalConnection) Close() error {
	ret := _mock.Called()

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

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

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

// Close is a helper method to define mock.On call
func (_e *MockBrokerPhysicalConnection_Expecter) Close() *MockBrokerPhysicalConnection_Close_Call {
	return &MockBrokerPhysicalConnection_Close_Call{Call: _e.mock.On("Close")}
}

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

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

func (_c *MockBrokerPhysicalConnection_Close_Call) RunAndReturn(run func() error) *MockBrokerPhysicalConnection_Close_Call {
	_c.Call.Return(run)
	return _c
}

// Done provides a mock function for the type MockBrokerPhysicalConnection
func (_mock *MockBrokerPhysicalConnection) Done() <-chan struct{} {
	ret := _mock.Called()

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

	var r0 <-chan struct{}
	if returnFunc, ok := ret.Get(0).(func() <-chan struct{}); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan struct{})
		}
	}
	return r0
}

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

// Done is a helper method to define mock.On call
func (_e *MockBrokerPhysicalConnection_Expecter) Done() *MockBrokerPhysicalConnection_Done_Call {
	return &MockBrokerPhysicalConnection_Done_Call{Call: _e.mock.On("Done")}
}

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

func (_c *MockBrokerPhysicalConnection_Done_Call) Return(valCh <-chan struct{}) *MockBrokerPhysicalConnection_Done_Call {
	_c.Call.Return(valCh)
	return _c
}

func (_c *MockBrokerPhysicalConnection_Done_Call) RunAndReturn(run func() <-chan struct{}) *MockBrokerPhysicalConnection_Done_Call {
	_c.Call.Return(run)
	return _c
}

// Err provides a mock function for the type MockBrokerPhysicalConnection
func (_mock *MockBrokerPhysicalConnection) Err() error {
	ret := _mock.Called()

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

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

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

// Err is a helper method to define mock.On call
func (_e *MockBrokerPhysicalConnection_Expecter) Err() *MockBrokerPhysicalConnection_Err_Call {
	return &MockBrokerPhysicalConnection_Err_Call{Call: _e.mock.On("Err")}
}

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

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

func (_c *MockBrokerPhysicalConnection_Err_Call) RunAndReturn(run func() error) *MockBrokerPhysicalConnection_Err_Call {
	_c.Call.Return(run)
	return _c
}

// FailureKind provides a mock function for the type MockBrokerPhysicalConnection
func (_mock *MockBrokerPhysicalConnection) FailureKind() domain.RemoteFailureKind {
	ret := _mock.Called()

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

	var r0 domain.RemoteFailureKind
	if returnFunc, ok := ret.Get(0).(func() domain.RemoteFailureKind); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(domain.RemoteFailureKind)
	}
	return r0
}

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

// FailureKind is a helper method to define mock.On call
func (_e *MockBrokerPhysicalConnection_Expecter) FailureKind() *MockBrokerPhysicalConnection_FailureKind_Call {
	return &MockBrokerPhysicalConnection_FailureKind_Call{Call: _e.mock.On("FailureKind")}
}

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

func (_c *MockBrokerPhysicalConnection_FailureKind_Call) Return(remoteFailureKind domain.RemoteFailureKind) *MockBrokerPhysicalConnection_FailureKind_Call {
	_c.Call.Return(remoteFailureKind)
	return _c
}

func (_c *MockBrokerPhysicalConnection_FailureKind_Call) RunAndReturn(run func() domain.RemoteFailureKind) *MockBrokerPhysicalConnection_FailureKind_Call {
	_c.Call.Return(run)
	return _c
}

// Identity provides a mock function for the type MockBrokerPhysicalConnection
func (_mock *MockBrokerPhysicalConnection) Identity() ports.BrokerDaemonIdentity {
	ret := _mock.Called()

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

	var r0 ports.BrokerDaemonIdentity
	if returnFunc, ok := ret.Get(0).(func() ports.BrokerDaemonIdentity); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(ports.BrokerDaemonIdentity)
	}
	return r0
}

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

// Identity is a helper method to define mock.On call
func (_e *MockBrokerPhysicalConnection_Expecter) Identity() *MockBrokerPhysicalConnection_Identity_Call {
	return &MockBrokerPhysicalConnection_Identity_Call{Call: _e.mock.On("Identity")}
}

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

func (_c *MockBrokerPhysicalConnection_Identity_Call) Return(brokerDaemonIdentity ports.BrokerDaemonIdentity) *MockBrokerPhysicalConnection_Identity_Call {
	_c.Call.Return(brokerDaemonIdentity)
	return _c
}

func (_c *MockBrokerPhysicalConnection_Identity_Call) RunAndReturn(run func() ports.BrokerDaemonIdentity) *MockBrokerPhysicalConnection_Identity_Call {
	_c.Call.Return(run)
	return _c
}

// Incarnation provides a mock function for the type MockBrokerPhysicalConnection
func (_mock *MockBrokerPhysicalConnection) Incarnation() ports.BrokerDaemonIncarnation {
	ret := _mock.Called()

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

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

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

// Incarnation is a helper method to define mock.On call
func (_e *MockBrokerPhysicalConnection_Expecter) Incarnation() *MockBrokerPhysicalConnection_Incarnation_Call {
	return &MockBrokerPhysicalConnection_Incarnation_Call{Call: _e.mock.On("Incarnation")}
}

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

func (_c *MockBrokerPhysicalConnection_Incarnation_Call) Return(brokerDaemonIncarnation ports.BrokerDaemonIncarnation) *MockBrokerPhysicalConnection_Incarnation_Call {
	_c.Call.Return(brokerDaemonIncarnation)
	return _c
}

func (_c *MockBrokerPhysicalConnection_Incarnation_Call) RunAndReturn(run func() ports.BrokerDaemonIncarnation) *MockBrokerPhysicalConnection_Incarnation_Call {
	_c.Call.Return(run)
	return _c
}

// OpenStream provides a mock function for the type MockBrokerPhysicalConnection
func (_mock *MockBrokerPhysicalConnection) OpenStream(ctx context.Context, request ports.BrokerOpenStreamRequest) (ports.BrokerEnvelopeStream, error) {
	ret := _mock.Called(ctx, request)

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

	var r0 ports.BrokerEnvelopeStream
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, ports.BrokerOpenStreamRequest) (ports.BrokerEnvelopeStream, error)); ok {
		return returnFunc(ctx, request)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, ports.BrokerOpenStreamRequest) ports.BrokerEnvelopeStream); ok {
		r0 = returnFunc(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(ports.BrokerEnvelopeStream)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, ports.BrokerOpenStreamRequest) error); ok {
		r1 = returnFunc(ctx, request)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OpenStream is a helper method to define mock.On call
//   - ctx context.Context
//   - request ports.BrokerOpenStreamRequest
func (_e *MockBrokerPhysicalConnection_Expecter) OpenStream(ctx any, request any) *MockBrokerPhysicalConnection_OpenStream_Call {
	return &MockBrokerPhysicalConnection_OpenStream_Call{Call: _e.mock.On("OpenStream", ctx, request)}
}

func (_c *MockBrokerPhysicalConnection_OpenStream_Call) Run(run func(ctx context.Context, request ports.BrokerOpenStreamRequest)) *MockBrokerPhysicalConnection_OpenStream_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 ports.BrokerOpenStreamRequest
		if args[1] != nil {
			arg1 = args[1].(ports.BrokerOpenStreamRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockBrokerPhysicalConnection_OpenStream_Call) Return(brokerEnvelopeStream ports.BrokerEnvelopeStream, err error) *MockBrokerPhysicalConnection_OpenStream_Call {
	_c.Call.Return(brokerEnvelopeStream, err)
	return _c
}

func (_c *MockBrokerPhysicalConnection_OpenStream_Call) RunAndReturn(run func(ctx context.Context, request ports.BrokerOpenStreamRequest) (ports.BrokerEnvelopeStream, error)) *MockBrokerPhysicalConnection_OpenStream_Call {
	_c.Call.Return(run)
	return _c
}

// Policy provides a mock function for the type MockBrokerPhysicalConnection
func (_mock *MockBrokerPhysicalConnection) Policy() ports.BrokerPolicy {
	ret := _mock.Called()

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

	var r0 ports.BrokerPolicy
	if returnFunc, ok := ret.Get(0).(func() ports.BrokerPolicy); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(ports.BrokerPolicy)
	}
	return r0
}

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

// Policy is a helper method to define mock.On call
func (_e *MockBrokerPhysicalConnection_Expecter) Policy() *MockBrokerPhysicalConnection_Policy_Call {
	return &MockBrokerPhysicalConnection_Policy_Call{Call: _e.mock.On("Policy")}
}

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

func (_c *MockBrokerPhysicalConnection_Policy_Call) Return(brokerPolicy ports.BrokerPolicy) *MockBrokerPhysicalConnection_Policy_Call {
	_c.Call.Return(brokerPolicy)
	return _c
}

func (_c *MockBrokerPhysicalConnection_Policy_Call) RunAndReturn(run func() ports.BrokerPolicy) *MockBrokerPhysicalConnection_Policy_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockBrokerEndpointConnector creates a new instance of MockBrokerEndpointConnector. 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 NewMockBrokerEndpointConnector(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBrokerEndpointConnector {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockBrokerEndpointConnector{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockBrokerEndpointConnector is an autogenerated mock type for the BrokerEndpointConnector type
type MockBrokerEndpointConnector struct {
	mock.Mock
}

type MockBrokerEndpointConnector_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBrokerEndpointConnector) EXPECT() *MockBrokerEndpointConnector_Expecter {
	return &MockBrokerEndpointConnector_Expecter{mock: &_m.Mock}
}

// Connect provides a mock function for the type MockBrokerEndpointConnector
func (_mock *MockBrokerEndpointConnector) Connect(ctx context.Context, target ports.BrokerDialTarget) (ports.BrokerPhysicalConnection, error) {
	ret := _mock.Called(ctx, target)

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

	var r0 ports.BrokerPhysicalConnection
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, ports.BrokerDialTarget) (ports.BrokerPhysicalConnection, error)); ok {
		return returnFunc(ctx, target)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, ports.BrokerDialTarget) ports.BrokerPhysicalConnection); ok {
		r0 = returnFunc(ctx, target)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(ports.BrokerPhysicalConnection)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, ports.BrokerDialTarget) error); ok {
		r1 = returnFunc(ctx, target)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Connect is a helper method to define mock.On call
//   - ctx context.Context
//   - target ports.BrokerDialTarget
func (_e *MockBrokerEndpointConnector_Expecter) Connect(ctx any, target any) *MockBrokerEndpointConnector_Connect_Call {
	return &MockBrokerEndpointConnector_Connect_Call{Call: _e.mock.On("Connect", ctx, target)}
}

func (_c *MockBrokerEndpointConnector_Connect_Call) Run(run func(ctx context.Context, target ports.BrokerDialTarget)) *MockBrokerEndpointConnector_Connect_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 ports.BrokerDialTarget
		if args[1] != nil {
			arg1 = args[1].(ports.BrokerDialTarget)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockBrokerEndpointConnector_Connect_Call) Return(brokerPhysicalConnection ports.BrokerPhysicalConnection, err error) *MockBrokerEndpointConnector_Connect_Call {
	_c.Call.Return(brokerPhysicalConnection, err)
	return _c
}

func (_c *MockBrokerEndpointConnector_Connect_Call) RunAndReturn(run func(ctx context.Context, target ports.BrokerDialTarget) (ports.BrokerPhysicalConnection, error)) *MockBrokerEndpointConnector_Connect_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockBrokerConnector creates a new instance of MockBrokerConnector. 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 NewMockBrokerConnector(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBrokerConnector {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockBrokerConnector{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockBrokerConnector is an autogenerated mock type for the BrokerConnector type
type MockBrokerConnector struct {
	mock.Mock
}

type MockBrokerConnector_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBrokerConnector) EXPECT() *MockBrokerConnector_Expecter {
	return &MockBrokerConnector_Expecter{mock: &_m.Mock}
}

// Connect provides a mock function for the type MockBrokerConnector
func (_mock *MockBrokerConnector) Connect(ctx context.Context) (ports.BrokerNavigator, error) {
	ret := _mock.Called(ctx)

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

	var r0 ports.BrokerNavigator
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (ports.BrokerNavigator, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) ports.BrokerNavigator); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(ports.BrokerNavigator)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Connect is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockBrokerConnector_Expecter) Connect(ctx any) *MockBrokerConnector_Connect_Call {
	return &MockBrokerConnector_Connect_Call{Call: _e.mock.On("Connect", ctx)}
}

func (_c *MockBrokerConnector_Connect_Call) Run(run func(ctx context.Context)) *MockBrokerConnector_Connect_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBrokerConnector_Connect_Call) Return(brokerNavigator ports.BrokerNavigator, err error) *MockBrokerConnector_Connect_Call {
	_c.Call.Return(brokerNavigator, err)
	return _c
}

func (_c *MockBrokerConnector_Connect_Call) RunAndReturn(run func(ctx context.Context) (ports.BrokerNavigator, error)) *MockBrokerConnector_Connect_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockBrokerAuthority creates a new instance of MockBrokerAuthority. 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 NewMockBrokerAuthority(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBrokerAuthority {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockBrokerAuthority{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockBrokerAuthority is an autogenerated mock type for the BrokerAuthority type
type MockBrokerAuthority struct {
	mock.Mock
}

type MockBrokerAuthority_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBrokerAuthority) EXPECT() *MockBrokerAuthority_Expecter {
	return &MockBrokerAuthority_Expecter{mock: &_m.Mock}
}

// AdmitClient provides a mock function for the type MockBrokerAuthority
func (_mock *MockBrokerAuthority) AdmitClient(ctx context.Context) (ports.BrokerCoreService, error) {
	ret := _mock.Called(ctx)

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

	var r0 ports.BrokerCoreService
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (ports.BrokerCoreService, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) ports.BrokerCoreService); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(ports.BrokerCoreService)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AdmitClient is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockBrokerAuthority_Expecter) AdmitClient(ctx any) *MockBrokerAuthority_AdmitClient_Call {
	return &MockBrokerAuthority_AdmitClient_Call{Call: _e.mock.On("AdmitClient", ctx)}
}

func (_c *MockBrokerAuthority_AdmitClient_Call) Run(run func(ctx context.Context)) *MockBrokerAuthority_AdmitClient_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBrokerAuthority_AdmitClient_Call) Return(brokerCoreService ports.BrokerCoreService, err error) *MockBrokerAuthority_AdmitClient_Call {
	_c.Call.Return(brokerCoreService, err)
	return _c
}

func (_c *MockBrokerAuthority_AdmitClient_Call) RunAndReturn(run func(ctx context.Context) (ports.BrokerCoreService, error)) *MockBrokerAuthority_AdmitClient_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockBrokerListener creates a new instance of MockBrokerListener. 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 NewMockBrokerListener(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBrokerListener {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockBrokerListener{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockBrokerListener is an autogenerated mock type for the BrokerListener type
type MockBrokerListener struct {
	mock.Mock
}

type MockBrokerListener_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBrokerListener) EXPECT() *MockBrokerListener_Expecter {
	return &MockBrokerListener_Expecter{mock: &_m.Mock}
}

// Accept provides a mock function for the type MockBrokerListener
func (_mock *MockBrokerListener) Accept() (ports.BrokerCoreService, error) {
	ret := _mock.Called()

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

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

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

// Accept is a helper method to define mock.On call
func (_e *MockBrokerListener_Expecter) Accept() *MockBrokerListener_Accept_Call {
	return &MockBrokerListener_Accept_Call{Call: _e.mock.On("Accept")}
}

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

func (_c *MockBrokerListener_Accept_Call) Return(brokerCoreService ports.BrokerCoreService, err error) *MockBrokerListener_Accept_Call {
	_c.Call.Return(brokerCoreService, err)
	return _c
}

func (_c *MockBrokerListener_Accept_Call) RunAndReturn(run func() (ports.BrokerCoreService, error)) *MockBrokerListener_Accept_Call {
	_c.Call.Return(run)
	return _c
}

// Addr provides a mock function for the type MockBrokerListener
func (_mock *MockBrokerListener) Addr() string {
	ret := _mock.Called()

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

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

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

// Addr is a helper method to define mock.On call
func (_e *MockBrokerListener_Expecter) Addr() *MockBrokerListener_Addr_Call {
	return &MockBrokerListener_Addr_Call{Call: _e.mock.On("Addr")}
}

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

func (_c *MockBrokerListener_Addr_Call) Return(s string) *MockBrokerListener_Addr_Call {
	_c.Call.Return(s)
	return _c
}

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

// Close provides a mock function for the type MockBrokerListener
func (_mock *MockBrokerListener) Close() error {
	ret := _mock.Called()

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

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

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

// Close is a helper method to define mock.On call
func (_e *MockBrokerListener_Expecter) Close() *MockBrokerListener_Close_Call {
	return &MockBrokerListener_Close_Call{Call: _e.mock.On("Close")}
}

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

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

func (_c *MockBrokerListener_Close_Call) RunAndReturn(run func() error) *MockBrokerListener_Close_Call {
	_c.Call.Return(run)
	return _c
}