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

package mocks

import (
	"context"

	"github.com/bnema/dumber/internal/application/port"
	mock "github.com/stretchr/testify/mock"
)

// NewMockAccentKeyHandler creates a new instance of MockAccentKeyHandler. 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 NewMockAccentKeyHandler(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockAccentKeyHandler {
	mock := &MockAccentKeyHandler{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockAccentKeyHandler is an autogenerated mock type for the AccentKeyHandler type
type MockAccentKeyHandler struct {
	mock.Mock
}

type MockAccentKeyHandler_Expecter struct {
	mock *mock.Mock
}

func (_m *MockAccentKeyHandler) EXPECT() *MockAccentKeyHandler_Expecter {
	return &MockAccentKeyHandler_Expecter{mock: &_m.Mock}
}

// OnKeyPressed provides a mock function for the type MockAccentKeyHandler
func (_mock *MockAccentKeyHandler) OnKeyPressed(ctx context.Context, char rune, shiftHeld bool) bool {
	ret := _mock.Called(ctx, char, shiftHeld)

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

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func(context.Context, rune, bool) bool); ok {
		r0 = returnFunc(ctx, char, shiftHeld)
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

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

// OnKeyPressed is a helper method to define mock.On call
//   - ctx context.Context
//   - char rune
//   - shiftHeld bool
func (_e *MockAccentKeyHandler_Expecter) OnKeyPressed(ctx any, char any, shiftHeld any) *MockAccentKeyHandler_OnKeyPressed_Call {
	return &MockAccentKeyHandler_OnKeyPressed_Call{Call: _e.mock.On("OnKeyPressed", ctx, char, shiftHeld)}
}

func (_c *MockAccentKeyHandler_OnKeyPressed_Call) Run(run func(ctx context.Context, char rune, shiftHeld bool)) *MockAccentKeyHandler_OnKeyPressed_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 rune
		if args[1] != nil {
			arg1 = args[1].(rune)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAccentKeyHandler_OnKeyPressed_Call) Return(b bool) *MockAccentKeyHandler_OnKeyPressed_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockAccentKeyHandler_OnKeyPressed_Call) RunAndReturn(run func(ctx context.Context, char rune, shiftHeld bool) bool) *MockAccentKeyHandler_OnKeyPressed_Call {
	_c.Call.Return(run)
	return _c
}

// OnKeyReleased provides a mock function for the type MockAccentKeyHandler
func (_mock *MockAccentKeyHandler) OnKeyReleased(ctx context.Context, char rune) {
	_mock.Called(ctx, char)
	return
}

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

// OnKeyReleased is a helper method to define mock.On call
//   - ctx context.Context
//   - char rune
func (_e *MockAccentKeyHandler_Expecter) OnKeyReleased(ctx any, char any) *MockAccentKeyHandler_OnKeyReleased_Call {
	return &MockAccentKeyHandler_OnKeyReleased_Call{Call: _e.mock.On("OnKeyReleased", ctx, char)}
}

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

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

func (_c *MockAccentKeyHandler_OnKeyReleased_Call) RunAndReturn(run func(ctx context.Context, char rune)) *MockAccentKeyHandler_OnKeyReleased_Call {
	_c.Run(run)
	return _c
}

// NewMockDownloadPreparer creates a new instance of MockDownloadPreparer. 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 NewMockDownloadPreparer(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockDownloadPreparer {
	mock := &MockDownloadPreparer{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockDownloadPreparer is an autogenerated mock type for the DownloadPreparer type
type MockDownloadPreparer struct {
	mock.Mock
}

type MockDownloadPreparer_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDownloadPreparer) EXPECT() *MockDownloadPreparer_Expecter {
	return &MockDownloadPreparer_Expecter{mock: &_m.Mock}
}

// Execute provides a mock function for the type MockDownloadPreparer
func (_mock *MockDownloadPreparer) Execute(ctx context.Context, input port.DownloadPrepareInput) *port.DownloadPrepareOutput {
	ret := _mock.Called(ctx, input)

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

	var r0 *port.DownloadPrepareOutput
	if returnFunc, ok := ret.Get(0).(func(context.Context, port.DownloadPrepareInput) *port.DownloadPrepareOutput); ok {
		r0 = returnFunc(ctx, input)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*port.DownloadPrepareOutput)
		}
	}
	return r0
}

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

// Execute is a helper method to define mock.On call
//   - ctx context.Context
//   - input port.DownloadPrepareInput
func (_e *MockDownloadPreparer_Expecter) Execute(ctx any, input any) *MockDownloadPreparer_Execute_Call {
	return &MockDownloadPreparer_Execute_Call{Call: _e.mock.On("Execute", ctx, input)}
}

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

func (_c *MockDownloadPreparer_Execute_Call) Return(downloadPrepareOutput *port.DownloadPrepareOutput) *MockDownloadPreparer_Execute_Call {
	_c.Call.Return(downloadPrepareOutput)
	return _c
}

func (_c *MockDownloadPreparer_Execute_Call) RunAndReturn(run func(ctx context.Context, input port.DownloadPrepareInput) *port.DownloadPrepareOutput) *MockDownloadPreparer_Execute_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockAutoCopyConfig creates a new instance of MockAutoCopyConfig. 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 NewMockAutoCopyConfig(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockAutoCopyConfig {
	mock := &MockAutoCopyConfig{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockAutoCopyConfig is an autogenerated mock type for the AutoCopyConfig type
type MockAutoCopyConfig struct {
	mock.Mock
}

type MockAutoCopyConfig_Expecter struct {
	mock *mock.Mock
}

func (_m *MockAutoCopyConfig) EXPECT() *MockAutoCopyConfig_Expecter {
	return &MockAutoCopyConfig_Expecter{mock: &_m.Mock}
}

// IsAutoCopyEnabled provides a mock function for the type MockAutoCopyConfig
func (_mock *MockAutoCopyConfig) IsAutoCopyEnabled() bool {
	ret := _mock.Called()

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

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

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

// IsAutoCopyEnabled is a helper method to define mock.On call
func (_e *MockAutoCopyConfig_Expecter) IsAutoCopyEnabled() *MockAutoCopyConfig_IsAutoCopyEnabled_Call {
	return &MockAutoCopyConfig_IsAutoCopyEnabled_Call{Call: _e.mock.On("IsAutoCopyEnabled")}
}

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

func (_c *MockAutoCopyConfig_IsAutoCopyEnabled_Call) Return(b bool) *MockAutoCopyConfig_IsAutoCopyEnabled_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockAutoCopyConfig_IsAutoCopyEnabled_Call) RunAndReturn(run func() bool) *MockAutoCopyConfig_IsAutoCopyEnabled_Call {
	_c.Call.Return(run)
	return _c
}