// 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"
)

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

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

	return mock
}

// MockKeybindingsProvider is an autogenerated mock type for the KeybindingsProvider type
type MockKeybindingsProvider struct {
	mock.Mock
}

type MockKeybindingsProvider_Expecter struct {
	mock *mock.Mock
}

func (_m *MockKeybindingsProvider) EXPECT() *MockKeybindingsProvider_Expecter {
	return &MockKeybindingsProvider_Expecter{mock: &_m.Mock}
}

// CheckConflicts provides a mock function for the type MockKeybindingsProvider
func (_mock *MockKeybindingsProvider) CheckConflicts(ctx context.Context, mode string, action string, keys []string) ([]port.KeybindingConflict, error) {
	ret := _mock.Called(ctx, mode, action, keys)

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

	var r0 []port.KeybindingConflict
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string) ([]port.KeybindingConflict, error)); ok {
		return returnFunc(ctx, mode, action, keys)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string) []port.KeybindingConflict); ok {
		r0 = returnFunc(ctx, mode, action, keys)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]port.KeybindingConflict)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, []string) error); ok {
		r1 = returnFunc(ctx, mode, action, keys)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CheckConflicts is a helper method to define mock.On call
//   - ctx context.Context
//   - mode string
//   - action string
//   - keys []string
func (_e *MockKeybindingsProvider_Expecter) CheckConflicts(ctx any, mode any, action any, keys any) *MockKeybindingsProvider_CheckConflicts_Call {
	return &MockKeybindingsProvider_CheckConflicts_Call{Call: _e.mock.On("CheckConflicts", ctx, mode, action, keys)}
}

func (_c *MockKeybindingsProvider_CheckConflicts_Call) Run(run func(ctx context.Context, mode string, action string, keys []string)) *MockKeybindingsProvider_CheckConflicts_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 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 []string
		if args[3] != nil {
			arg3 = args[3].([]string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockKeybindingsProvider_CheckConflicts_Call) Return(keybindingConflicts []port.KeybindingConflict, err error) *MockKeybindingsProvider_CheckConflicts_Call {
	_c.Call.Return(keybindingConflicts, err)
	return _c
}

func (_c *MockKeybindingsProvider_CheckConflicts_Call) RunAndReturn(run func(ctx context.Context, mode string, action string, keys []string) ([]port.KeybindingConflict, error)) *MockKeybindingsProvider_CheckConflicts_Call {
	_c.Call.Return(run)
	return _c
}

// GetDefaultKeybindings provides a mock function for the type MockKeybindingsProvider
func (_mock *MockKeybindingsProvider) GetDefaultKeybindings(ctx context.Context) (port.KeybindingsConfig, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockKeybindingsProvider_GetDefaultKeybindings_Call) Run(run func(ctx context.Context)) *MockKeybindingsProvider_GetDefaultKeybindings_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 *MockKeybindingsProvider_GetDefaultKeybindings_Call) Return(keybindingsConfig port.KeybindingsConfig, err error) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
	_c.Call.Return(keybindingsConfig, err)
	return _c
}

func (_c *MockKeybindingsProvider_GetDefaultKeybindings_Call) RunAndReturn(run func(ctx context.Context) (port.KeybindingsConfig, error)) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
	_c.Call.Return(run)
	return _c
}

// GetKeybindings provides a mock function for the type MockKeybindingsProvider
func (_mock *MockKeybindingsProvider) GetKeybindings(ctx context.Context) (port.KeybindingsConfig, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockKeybindingsProvider_GetKeybindings_Call) Run(run func(ctx context.Context)) *MockKeybindingsProvider_GetKeybindings_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 *MockKeybindingsProvider_GetKeybindings_Call) Return(keybindingsConfig port.KeybindingsConfig, err error) *MockKeybindingsProvider_GetKeybindings_Call {
	_c.Call.Return(keybindingsConfig, err)
	return _c
}

func (_c *MockKeybindingsProvider_GetKeybindings_Call) RunAndReturn(run func(ctx context.Context) (port.KeybindingsConfig, error)) *MockKeybindingsProvider_GetKeybindings_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockKeybindingsSaver is an autogenerated mock type for the KeybindingsSaver type
type MockKeybindingsSaver struct {
	mock.Mock
}

type MockKeybindingsSaver_Expecter struct {
	mock *mock.Mock
}

func (_m *MockKeybindingsSaver) EXPECT() *MockKeybindingsSaver_Expecter {
	return &MockKeybindingsSaver_Expecter{mock: &_m.Mock}
}

// ResetAllKeybindings provides a mock function for the type MockKeybindingsSaver
func (_mock *MockKeybindingsSaver) ResetAllKeybindings(ctx context.Context) error {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockKeybindingsSaver_ResetAllKeybindings_Call) Run(run func(ctx context.Context)) *MockKeybindingsSaver_ResetAllKeybindings_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 *MockKeybindingsSaver_ResetAllKeybindings_Call) Return(err error) *MockKeybindingsSaver_ResetAllKeybindings_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockKeybindingsSaver_ResetAllKeybindings_Call) RunAndReturn(run func(ctx context.Context) error) *MockKeybindingsSaver_ResetAllKeybindings_Call {
	_c.Call.Return(run)
	return _c
}

// ResetKeybinding provides a mock function for the type MockKeybindingsSaver
func (_mock *MockKeybindingsSaver) ResetKeybinding(ctx context.Context, req port.ResetKeybindingRequest) error {
	ret := _mock.Called(ctx, req)

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

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

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

// ResetKeybinding is a helper method to define mock.On call
//   - ctx context.Context
//   - req port.ResetKeybindingRequest
func (_e *MockKeybindingsSaver_Expecter) ResetKeybinding(ctx any, req any) *MockKeybindingsSaver_ResetKeybinding_Call {
	return &MockKeybindingsSaver_ResetKeybinding_Call{Call: _e.mock.On("ResetKeybinding", ctx, req)}
}

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

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

func (_c *MockKeybindingsSaver_ResetKeybinding_Call) RunAndReturn(run func(ctx context.Context, req port.ResetKeybindingRequest) error) *MockKeybindingsSaver_ResetKeybinding_Call {
	_c.Call.Return(run)
	return _c
}

// SetKeybinding provides a mock function for the type MockKeybindingsSaver
func (_mock *MockKeybindingsSaver) SetKeybinding(ctx context.Context, req port.SetKeybindingRequest) error {
	ret := _mock.Called(ctx, req)

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

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

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

// SetKeybinding is a helper method to define mock.On call
//   - ctx context.Context
//   - req port.SetKeybindingRequest
func (_e *MockKeybindingsSaver_Expecter) SetKeybinding(ctx any, req any) *MockKeybindingsSaver_SetKeybinding_Call {
	return &MockKeybindingsSaver_SetKeybinding_Call{Call: _e.mock.On("SetKeybinding", ctx, req)}
}

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

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

func (_c *MockKeybindingsSaver_SetKeybinding_Call) RunAndReturn(run func(ctx context.Context, req port.SetKeybindingRequest) error) *MockKeybindingsSaver_SetKeybinding_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockKeybindingsGetter is an autogenerated mock type for the KeybindingsGetter type
type MockKeybindingsGetter struct {
	mock.Mock
}

type MockKeybindingsGetter_Expecter struct {
	mock *mock.Mock
}

func (_m *MockKeybindingsGetter) EXPECT() *MockKeybindingsGetter_Expecter {
	return &MockKeybindingsGetter_Expecter{mock: &_m.Mock}
}

// Execute provides a mock function for the type MockKeybindingsGetter
func (_mock *MockKeybindingsGetter) Execute(ctx context.Context) (port.KeybindingsConfig, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockKeybindingsGetter_Execute_Call) Run(run func(ctx context.Context)) *MockKeybindingsGetter_Execute_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 *MockKeybindingsGetter_Execute_Call) Return(keybindingsConfig port.KeybindingsConfig, err error) *MockKeybindingsGetter_Execute_Call {
	_c.Call.Return(keybindingsConfig, err)
	return _c
}

func (_c *MockKeybindingsGetter_Execute_Call) RunAndReturn(run func(ctx context.Context) (port.KeybindingsConfig, error)) *MockKeybindingsGetter_Execute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockKeybindingSetter is an autogenerated mock type for the KeybindingSetter type
type MockKeybindingSetter struct {
	mock.Mock
}

type MockKeybindingSetter_Expecter struct {
	mock *mock.Mock
}

func (_m *MockKeybindingSetter) EXPECT() *MockKeybindingSetter_Expecter {
	return &MockKeybindingSetter_Expecter{mock: &_m.Mock}
}

// Execute provides a mock function for the type MockKeybindingSetter
func (_mock *MockKeybindingSetter) Execute(ctx context.Context, req port.SetKeybindingRequest) (port.SetKeybindingResponse, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 port.SetKeybindingResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, port.SetKeybindingRequest) (port.SetKeybindingResponse, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, port.SetKeybindingRequest) port.SetKeybindingResponse); ok {
		r0 = returnFunc(ctx, req)
	} else {
		r0 = ret.Get(0).(port.SetKeybindingResponse)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, port.SetKeybindingRequest) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Execute is a helper method to define mock.On call
//   - ctx context.Context
//   - req port.SetKeybindingRequest
func (_e *MockKeybindingSetter_Expecter) Execute(ctx any, req any) *MockKeybindingSetter_Execute_Call {
	return &MockKeybindingSetter_Execute_Call{Call: _e.mock.On("Execute", ctx, req)}
}

func (_c *MockKeybindingSetter_Execute_Call) Run(run func(ctx context.Context, req port.SetKeybindingRequest)) *MockKeybindingSetter_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.SetKeybindingRequest
		if args[1] != nil {
			arg1 = args[1].(port.SetKeybindingRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockKeybindingSetter_Execute_Call) Return(setKeybindingResponse port.SetKeybindingResponse, err error) *MockKeybindingSetter_Execute_Call {
	_c.Call.Return(setKeybindingResponse, err)
	return _c
}

func (_c *MockKeybindingSetter_Execute_Call) RunAndReturn(run func(ctx context.Context, req port.SetKeybindingRequest) (port.SetKeybindingResponse, error)) *MockKeybindingSetter_Execute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockKeybindingResetter is an autogenerated mock type for the KeybindingResetter type
type MockKeybindingResetter struct {
	mock.Mock
}

type MockKeybindingResetter_Expecter struct {
	mock *mock.Mock
}

func (_m *MockKeybindingResetter) EXPECT() *MockKeybindingResetter_Expecter {
	return &MockKeybindingResetter_Expecter{mock: &_m.Mock}
}

// Execute provides a mock function for the type MockKeybindingResetter
func (_mock *MockKeybindingResetter) Execute(ctx context.Context, req port.ResetKeybindingRequest) error {
	ret := _mock.Called(ctx, req)

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

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

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

// Execute is a helper method to define mock.On call
//   - ctx context.Context
//   - req port.ResetKeybindingRequest
func (_e *MockKeybindingResetter_Expecter) Execute(ctx any, req any) *MockKeybindingResetter_Execute_Call {
	return &MockKeybindingResetter_Execute_Call{Call: _e.mock.On("Execute", ctx, req)}
}

func (_c *MockKeybindingResetter_Execute_Call) Run(run func(ctx context.Context, req port.ResetKeybindingRequest)) *MockKeybindingResetter_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.ResetKeybindingRequest
		if args[1] != nil {
			arg1 = args[1].(port.ResetKeybindingRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockKeybindingResetter_Execute_Call) RunAndReturn(run func(ctx context.Context, req port.ResetKeybindingRequest) error) *MockKeybindingResetter_Execute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockAllKeybindingsResetter is an autogenerated mock type for the AllKeybindingsResetter type
type MockAllKeybindingsResetter struct {
	mock.Mock
}

type MockAllKeybindingsResetter_Expecter struct {
	mock *mock.Mock
}

func (_m *MockAllKeybindingsResetter) EXPECT() *MockAllKeybindingsResetter_Expecter {
	return &MockAllKeybindingsResetter_Expecter{mock: &_m.Mock}
}

// Execute provides a mock function for the type MockAllKeybindingsResetter
func (_mock *MockAllKeybindingsResetter) Execute(ctx context.Context) error {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockAllKeybindingsResetter_Execute_Call) Run(run func(ctx context.Context)) *MockAllKeybindingsResetter_Execute_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 *MockAllKeybindingsResetter_Execute_Call) Return(err error) *MockAllKeybindingsResetter_Execute_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAllKeybindingsResetter_Execute_Call) RunAndReturn(run func(ctx context.Context) error) *MockAllKeybindingsResetter_Execute_Call {
	_c.Call.Return(run)
	return _c
}