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

package portsmocks

import (
	"context"

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

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

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

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

	return mock
}

// MockVisual is an autogenerated mock type for the Visual type
type MockVisual struct {
	mock.Mock
}

type MockVisual_Expecter struct {
	mock *mock.Mock
}

func (_m *MockVisual) EXPECT() *MockVisual_Expecter {
	return &MockVisual_Expecter{mock: &_m.Mock}
}

// Close provides a mock function for the type MockVisual
func (_mock *MockVisual) 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
}

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

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

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

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

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

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

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

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

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

// Detach is a helper method to define mock.On call
func (_e *MockVisual_Expecter) Detach() *MockVisual_Detach_Call {
	return &MockVisual_Detach_Call{Call: _e.mock.On("Detach")}
}

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

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

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

// Fade provides a mock function for the type MockVisual
func (_mock *MockVisual) Fade(ctx context.Context, req ports.VisualFade) error {
	ret := _mock.Called(ctx, req)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, ports.VisualFade) error); ok {
		r0 = returnFunc(ctx, req)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Fade is a helper method to define mock.On call
//   - ctx context.Context
//   - req ports.VisualFade
func (_e *MockVisual_Expecter) Fade(ctx any, req any) *MockVisual_Fade_Call {
	return &MockVisual_Fade_Call{Call: _e.mock.On("Fade", ctx, req)}
}

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

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

func (_c *MockVisual_Fade_Call) RunAndReturn(run func(ctx context.Context, req ports.VisualFade) error) *MockVisual_Fade_Call {
	_c.Call.Return(run)
	return _c
}

// Lock provides a mock function for the type MockVisual
func (_mock *MockVisual) Lock(ctx context.Context, req ports.VisualLock) error {
	ret := _mock.Called(ctx, req)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, ports.VisualLock) error); ok {
		r0 = returnFunc(ctx, req)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Lock is a helper method to define mock.On call
//   - ctx context.Context
//   - req ports.VisualLock
func (_e *MockVisual_Expecter) Lock(ctx any, req any) *MockVisual_Lock_Call {
	return &MockVisual_Lock_Call{Call: _e.mock.On("Lock", ctx, req)}
}

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

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

func (_c *MockVisual_Lock_Call) RunAndReturn(run func(ctx context.Context, req ports.VisualLock) error) *MockVisual_Lock_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return mock
}

// MockVisualLauncher is an autogenerated mock type for the VisualLauncher type
type MockVisualLauncher struct {
	mock.Mock
}

type MockVisualLauncher_Expecter struct {
	mock *mock.Mock
}

func (_m *MockVisualLauncher) EXPECT() *MockVisualLauncher_Expecter {
	return &MockVisualLauncher_Expecter{mock: &_m.Mock}
}

// Launch provides a mock function for the type MockVisualLauncher
func (_mock *MockVisualLauncher) Launch(ctx context.Context, spawn ports.VisualSpawn) (ports.VisualSession, error) {
	ret := _mock.Called(ctx, spawn)

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

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

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

// Launch is a helper method to define mock.On call
//   - ctx context.Context
//   - spawn ports.VisualSpawn
func (_e *MockVisualLauncher_Expecter) Launch(ctx any, spawn any) *MockVisualLauncher_Launch_Call {
	return &MockVisualLauncher_Launch_Call{Call: _e.mock.On("Launch", ctx, spawn)}
}

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

func (_c *MockVisualLauncher_Launch_Call) Return(visualSession ports.VisualSession, err error) *MockVisualLauncher_Launch_Call {
	_c.Call.Return(visualSession, err)
	return _c
}

func (_c *MockVisualLauncher_Launch_Call) RunAndReturn(run func(ctx context.Context, spawn ports.VisualSpawn) (ports.VisualSession, error)) *MockVisualLauncher_Launch_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return mock
}

// MockVisualSession is an autogenerated mock type for the VisualSession type
type MockVisualSession struct {
	mock.Mock
}

type MockVisualSession_Expecter struct {
	mock *mock.Mock
}

func (_m *MockVisualSession) EXPECT() *MockVisualSession_Expecter {
	return &MockVisualSession_Expecter{mock: &_m.Mock}
}

// Close provides a mock function for the type MockVisualSession
func (_mock *MockVisualSession) 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
}

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

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

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

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

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

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

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

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

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

// Detach is a helper method to define mock.On call
func (_e *MockVisualSession_Expecter) Detach() *MockVisualSession_Detach_Call {
	return &MockVisualSession_Detach_Call{Call: _e.mock.On("Detach")}
}

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

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

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

// Events provides a mock function for the type MockVisualSession
func (_mock *MockVisualSession) Events() <-chan ports.VisualEvent {
	ret := _mock.Called()

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

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

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

// Events is a helper method to define mock.On call
func (_e *MockVisualSession_Expecter) Events() *MockVisualSession_Events_Call {
	return &MockVisualSession_Events_Call{Call: _e.mock.On("Events")}
}

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

func (_c *MockVisualSession_Events_Call) Return(visualEventCh <-chan ports.VisualEvent) *MockVisualSession_Events_Call {
	_c.Call.Return(visualEventCh)
	return _c
}

func (_c *MockVisualSession_Events_Call) RunAndReturn(run func() <-chan ports.VisualEvent) *MockVisualSession_Events_Call {
	_c.Call.Return(run)
	return _c
}

// Send provides a mock function for the type MockVisualSession
func (_mock *MockVisualSession) Send(cmd ports.VisualCommand) error {
	ret := _mock.Called(cmd)

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

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

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

// Send is a helper method to define mock.On call
//   - cmd ports.VisualCommand
func (_e *MockVisualSession_Expecter) Send(cmd any) *MockVisualSession_Send_Call {
	return &MockVisualSession_Send_Call{Call: _e.mock.On("Send", cmd)}
}

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

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

func (_c *MockVisualSession_Send_Call) RunAndReturn(run func(cmd ports.VisualCommand) error) *MockVisualSession_Send_Call {
	_c.Call.Return(run)
	return _c
}