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

package portsmocks

import (
	"context"
	"io"

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

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

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

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

	return mock
}

// MockSource is an autogenerated mock type for the Source type
type MockSource struct {
	mock.Mock
}

type MockSource_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSource) EXPECT() *MockSource_Expecter {
	return &MockSource_Expecter{mock: &_m.Mock}
}

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

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

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

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

// Capabilities is a helper method to define mock.On call
func (_e *MockSource_Expecter) Capabilities() *MockSource_Capabilities_Call {
	return &MockSource_Capabilities_Call{Call: _e.mock.On("Capabilities")}
}

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

func (_c *MockSource_Capabilities_Call) Return(capabilities ports.Capabilities) *MockSource_Capabilities_Call {
	_c.Call.Return(capabilities)
	return _c
}

func (_c *MockSource_Capabilities_Call) RunAndReturn(run func() ports.Capabilities) *MockSource_Capabilities_Call {
	_c.Call.Return(run)
	return _c
}

// Capture provides a mock function for the type MockSource
func (_mock *MockSource) Capture(context1 context.Context, target ports.Target) (ports.Frame, error) {
	ret := _mock.Called(context1, target)

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

	var r0 ports.Frame
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, ports.Target) (ports.Frame, error)); ok {
		return returnFunc(context1, target)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, ports.Target) ports.Frame); ok {
		r0 = returnFunc(context1, target)
	} else {
		r0 = ret.Get(0).(ports.Frame)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, ports.Target) error); ok {
		r1 = returnFunc(context1, target)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Capture is a helper method to define mock.On call
//   - context1 context.Context
//   - target ports.Target
func (_e *MockSource_Expecter) Capture(context1 any, target any) *MockSource_Capture_Call {
	return &MockSource_Capture_Call{Call: _e.mock.On("Capture", context1, target)}
}

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

func (_c *MockSource_Capture_Call) Return(frame ports.Frame, err error) *MockSource_Capture_Call {
	_c.Call.Return(frame, err)
	return _c
}

func (_c *MockSource_Capture_Call) RunAndReturn(run func(context1 context.Context, target ports.Target) (ports.Frame, error)) *MockSource_Capture_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

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

// Outputs provides a mock function for the type MockSource
func (_mock *MockSource) Outputs(context1 context.Context) ([]ports.Output, error) {
	ret := _mock.Called(context1)

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

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

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

// Outputs is a helper method to define mock.On call
//   - context1 context.Context
func (_e *MockSource_Expecter) Outputs(context1 any) *MockSource_Outputs_Call {
	return &MockSource_Outputs_Call{Call: _e.mock.On("Outputs", context1)}
}

func (_c *MockSource_Outputs_Call) Run(run func(context1 context.Context)) *MockSource_Outputs_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 *MockSource_Outputs_Call) Return(outputs []ports.Output, err error) *MockSource_Outputs_Call {
	_c.Call.Return(outputs, err)
	return _c
}

func (_c *MockSource_Outputs_Call) RunAndReturn(run func(context1 context.Context) ([]ports.Output, error)) *MockSource_Outputs_Call {
	_c.Call.Return(run)
	return _c
}

// Workspaces provides a mock function for the type MockSource
func (_mock *MockSource) Workspaces(context1 context.Context) ([]ports.Workspace, error) {
	ret := _mock.Called(context1)

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

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

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

// Workspaces is a helper method to define mock.On call
//   - context1 context.Context
func (_e *MockSource_Expecter) Workspaces(context1 any) *MockSource_Workspaces_Call {
	return &MockSource_Workspaces_Call{Call: _e.mock.On("Workspaces", context1)}
}

func (_c *MockSource_Workspaces_Call) Run(run func(context1 context.Context)) *MockSource_Workspaces_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 *MockSource_Workspaces_Call) Return(workspaces []ports.Workspace, err error) *MockSource_Workspaces_Call {
	_c.Call.Return(workspaces, err)
	return _c
}

func (_c *MockSource_Workspaces_Call) RunAndReturn(run func(context1 context.Context) ([]ports.Workspace, error)) *MockSource_Workspaces_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return mock
}

// MockScreenshotWriter is an autogenerated mock type for the ScreenshotWriter type
type MockScreenshotWriter struct {
	mock.Mock
}

type MockScreenshotWriter_Expecter struct {
	mock *mock.Mock
}

func (_m *MockScreenshotWriter) EXPECT() *MockScreenshotWriter_Expecter {
	return &MockScreenshotWriter_Expecter{mock: &_m.Mock}
}

// Encode provides a mock function for the type MockScreenshotWriter
func (_mock *MockScreenshotWriter) Encode(context1 context.Context, writer io.Writer, frame ports.Frame) error {
	ret := _mock.Called(context1, writer, frame)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, io.Writer, ports.Frame) error); ok {
		r0 = returnFunc(context1, writer, frame)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Encode is a helper method to define mock.On call
//   - context1 context.Context
//   - writer io.Writer
//   - frame ports.Frame
func (_e *MockScreenshotWriter_Expecter) Encode(context1 any, writer any, frame any) *MockScreenshotWriter_Encode_Call {
	return &MockScreenshotWriter_Encode_Call{Call: _e.mock.On("Encode", context1, writer, frame)}
}

func (_c *MockScreenshotWriter_Encode_Call) Run(run func(context1 context.Context, writer io.Writer, frame ports.Frame)) *MockScreenshotWriter_Encode_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 io.Writer
		if args[1] != nil {
			arg1 = args[1].(io.Writer)
		}
		var arg2 ports.Frame
		if args[2] != nil {
			arg2 = args[2].(ports.Frame)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockScreenshotWriter_Encode_Call) RunAndReturn(run func(context1 context.Context, writer io.Writer, frame ports.Frame) error) *MockScreenshotWriter_Encode_Call {
	_c.Call.Return(run)
	return _c
}

// Save provides a mock function for the type MockScreenshotWriter
func (_mock *MockScreenshotWriter) Save(context1 context.Context, frame ports.Frame, s string) error {
	ret := _mock.Called(context1, frame, s)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, ports.Frame, string) error); ok {
		r0 = returnFunc(context1, frame, s)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Save is a helper method to define mock.On call
//   - context1 context.Context
//   - frame ports.Frame
//   - s string
func (_e *MockScreenshotWriter_Expecter) Save(context1 any, frame any, s any) *MockScreenshotWriter_Save_Call {
	return &MockScreenshotWriter_Save_Call{Call: _e.mock.On("Save", context1, frame, s)}
}

func (_c *MockScreenshotWriter_Save_Call) Run(run func(context1 context.Context, frame ports.Frame, s string)) *MockScreenshotWriter_Save_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 ports.Frame
		if args[1] != nil {
			arg1 = args[1].(ports.Frame)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockScreenshotWriter_Save_Call) RunAndReturn(run func(context1 context.Context, frame ports.Frame, s string) error) *MockScreenshotWriter_Save_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return mock
}

// MockClipboard is an autogenerated mock type for the Clipboard type
type MockClipboard struct {
	mock.Mock
}

type MockClipboard_Expecter struct {
	mock *mock.Mock
}

func (_m *MockClipboard) EXPECT() *MockClipboard_Expecter {
	return &MockClipboard_Expecter{mock: &_m.Mock}
}

// Copy provides a mock function for the type MockClipboard
func (_mock *MockClipboard) Copy(context1 context.Context, reader io.Reader) error {
	ret := _mock.Called(context1, reader)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, io.Reader) error); ok {
		r0 = returnFunc(context1, reader)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Copy is a helper method to define mock.On call
//   - context1 context.Context
//   - reader io.Reader
func (_e *MockClipboard_Expecter) Copy(context1 any, reader any) *MockClipboard_Copy_Call {
	return &MockClipboard_Copy_Call{Call: _e.mock.On("Copy", context1, reader)}
}

func (_c *MockClipboard_Copy_Call) Run(run func(context1 context.Context, reader io.Reader)) *MockClipboard_Copy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 io.Reader
		if args[1] != nil {
			arg1 = args[1].(io.Reader)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockClipboard_Copy_Call) RunAndReturn(run func(context1 context.Context, reader io.Reader) error) *MockClipboard_Copy_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return mock
}

// MockVideoWriter is an autogenerated mock type for the VideoWriter type
type MockVideoWriter struct {
	mock.Mock
}

type MockVideoWriter_Expecter struct {
	mock *mock.Mock
}

func (_m *MockVideoWriter) EXPECT() *MockVideoWriter_Expecter {
	return &MockVideoWriter_Expecter{mock: &_m.Mock}
}

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

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

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

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

// Abort is a helper method to define mock.On call
func (_e *MockVideoWriter_Expecter) Abort() *MockVideoWriter_Abort_Call {
	return &MockVideoWriter_Abort_Call{Call: _e.mock.On("Abort")}
}

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

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

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

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

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

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

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

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

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

// Start provides a mock function for the type MockVideoWriter
func (_mock *MockVideoWriter) Start(context1 context.Context, frame ports.Frame, s string, videoSettings ports.VideoSettings) error {
	ret := _mock.Called(context1, frame, s, videoSettings)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, ports.Frame, string, ports.VideoSettings) error); ok {
		r0 = returnFunc(context1, frame, s, videoSettings)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Start is a helper method to define mock.On call
//   - context1 context.Context
//   - frame ports.Frame
//   - s string
//   - videoSettings ports.VideoSettings
func (_e *MockVideoWriter_Expecter) Start(context1 any, frame any, s any, videoSettings any) *MockVideoWriter_Start_Call {
	return &MockVideoWriter_Start_Call{Call: _e.mock.On("Start", context1, frame, s, videoSettings)}
}

func (_c *MockVideoWriter_Start_Call) Run(run func(context1 context.Context, frame ports.Frame, s string, videoSettings ports.VideoSettings)) *MockVideoWriter_Start_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 ports.Frame
		if args[1] != nil {
			arg1 = args[1].(ports.Frame)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 ports.VideoSettings
		if args[3] != nil {
			arg3 = args[3].(ports.VideoSettings)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *MockVideoWriter_Start_Call) RunAndReturn(run func(context1 context.Context, frame ports.Frame, s string, videoSettings ports.VideoSettings) error) *MockVideoWriter_Start_Call {
	_c.Call.Return(run)
	return _c
}

// Write provides a mock function for the type MockVideoWriter
func (_mock *MockVideoWriter) Write(context1 context.Context, frame ports.Frame) error {
	ret := _mock.Called(context1, frame)

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

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

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

// Write is a helper method to define mock.On call
//   - context1 context.Context
//   - frame ports.Frame
func (_e *MockVideoWriter_Expecter) Write(context1 any, frame any) *MockVideoWriter_Write_Call {
	return &MockVideoWriter_Write_Call{Call: _e.mock.On("Write", context1, frame)}
}

func (_c *MockVideoWriter_Write_Call) Run(run func(context1 context.Context, frame ports.Frame)) *MockVideoWriter_Write_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 ports.Frame
		if args[1] != nil {
			arg1 = args[1].(ports.Frame)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockVideoWriter_Write_Call) RunAndReturn(run func(context1 context.Context, frame ports.Frame) error) *MockVideoWriter_Write_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return mock
}

// MockSelector is an autogenerated mock type for the Selector type
type MockSelector struct {
	mock.Mock
}

type MockSelector_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSelector) EXPECT() *MockSelector_Expecter {
	return &MockSelector_Expecter{mock: &_m.Mock}
}

// Select provides a mock function for the type MockSelector
func (_mock *MockSelector) Select(context1 context.Context, outputs []ports.Output) (ports.Selection, bool, error) {
	ret := _mock.Called(context1, outputs)

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

	var r0 ports.Selection
	var r1 bool
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []ports.Output) (ports.Selection, bool, error)); ok {
		return returnFunc(context1, outputs)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []ports.Output) ports.Selection); ok {
		r0 = returnFunc(context1, outputs)
	} else {
		r0 = ret.Get(0).(ports.Selection)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []ports.Output) bool); ok {
		r1 = returnFunc(context1, outputs)
	} else {
		r1 = ret.Get(1).(bool)
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, []ports.Output) error); ok {
		r2 = returnFunc(context1, outputs)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// Select is a helper method to define mock.On call
//   - context1 context.Context
//   - outputs []ports.Output
func (_e *MockSelector_Expecter) Select(context1 any, outputs any) *MockSelector_Select_Call {
	return &MockSelector_Select_Call{Call: _e.mock.On("Select", context1, outputs)}
}

func (_c *MockSelector_Select_Call) Run(run func(context1 context.Context, outputs []ports.Output)) *MockSelector_Select_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []ports.Output
		if args[1] != nil {
			arg1 = args[1].([]ports.Output)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockSelector_Select_Call) Return(selection ports.Selection, b bool, err error) *MockSelector_Select_Call {
	_c.Call.Return(selection, b, err)
	return _c
}

func (_c *MockSelector_Select_Call) RunAndReturn(run func(context1 context.Context, outputs []ports.Output) (ports.Selection, bool, error)) *MockSelector_Select_Call {
	_c.Call.Return(run)
	return _c
}