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

package mocks

import (
	"context"
	"database/sql"
	"time"

	"github.com/bnema/dumber/internal/application/port"
	"github.com/bnema/dumber/internal/domain/entity"
	"github.com/rs/zerolog"
	mock "github.com/stretchr/testify/mock"
)

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

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

	return mock
}

// MockAccentPickerUI is an autogenerated mock type for the AccentPickerUI type
type MockAccentPickerUI struct {
	mock.Mock
}

type MockAccentPickerUI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockAccentPickerUI) EXPECT() *MockAccentPickerUI_Expecter {
	return &MockAccentPickerUI_Expecter{mock: &_m.Mock}
}

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

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

// Hide is a helper method to define mock.On call
func (_e *MockAccentPickerUI_Expecter) Hide() *MockAccentPickerUI_Hide_Call {
	return &MockAccentPickerUI_Hide_Call{Call: _e.mock.On("Hide")}
}

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

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

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

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

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

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

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

// IsVisible is a helper method to define mock.On call
func (_e *MockAccentPickerUI_Expecter) IsVisible() *MockAccentPickerUI_IsVisible_Call {
	return &MockAccentPickerUI_IsVisible_Call{Call: _e.mock.On("IsVisible")}
}

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

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

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

// Show provides a mock function for the type MockAccentPickerUI
func (_mock *MockAccentPickerUI) Show(accents []rune, selectedCallback func(accent rune), cancelCallback func()) {
	_mock.Called(accents, selectedCallback, cancelCallback)
	return
}

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

// Show is a helper method to define mock.On call
//   - accents []rune
//   - selectedCallback func(accent rune)
//   - cancelCallback func()
func (_e *MockAccentPickerUI_Expecter) Show(accents interface{}, selectedCallback interface{}, cancelCallback interface{}) *MockAccentPickerUI_Show_Call {
	return &MockAccentPickerUI_Show_Call{Call: _e.mock.On("Show", accents, selectedCallback, cancelCallback)}
}

func (_c *MockAccentPickerUI_Show_Call) Run(run func(accents []rune, selectedCallback func(accent rune), cancelCallback func())) *MockAccentPickerUI_Show_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []rune
		if args[0] != nil {
			arg0 = args[0].([]rune)
		}
		var arg1 func(accent rune)
		if args[1] != nil {
			arg1 = args[1].(func(accent rune))
		}
		var arg2 func()
		if args[2] != nil {
			arg2 = args[2].(func())
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockAccentPickerUI_Show_Call) RunAndReturn(run func(accents []rune, selectedCallback func(accent rune), cancelCallback func())) *MockAccentPickerUI_Show_Call {
	_c.Run(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 {
	mock := &MockClipboard{}
	mock.Mock.Test(t)

	t.Cleanup(func() { 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}
}

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

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

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

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

// Clear is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockClipboard_Expecter) Clear(ctx interface{}) *MockClipboard_Clear_Call {
	return &MockClipboard_Clear_Call{Call: _e.mock.On("Clear", ctx)}
}

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

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

// HasText provides a mock function for the type MockClipboard
func (_mock *MockClipboard) HasText(ctx context.Context) (bool, error) {
	ret := _mock.Called(ctx)

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

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

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

// HasText is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockClipboard_Expecter) HasText(ctx interface{}) *MockClipboard_HasText_Call {
	return &MockClipboard_HasText_Call{Call: _e.mock.On("HasText", ctx)}
}

func (_c *MockClipboard_HasText_Call) Run(run func(ctx context.Context)) *MockClipboard_HasText_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 *MockClipboard_HasText_Call) Return(b bool, err error) *MockClipboard_HasText_Call {
	_c.Call.Return(b, err)
	return _c
}

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

// ReadText provides a mock function for the type MockClipboard
func (_mock *MockClipboard) ReadText(ctx context.Context) (string, error) {
	ret := _mock.Called(ctx)

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

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

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

// ReadText is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockClipboard_Expecter) ReadText(ctx interface{}) *MockClipboard_ReadText_Call {
	return &MockClipboard_ReadText_Call{Call: _e.mock.On("ReadText", ctx)}
}

func (_c *MockClipboard_ReadText_Call) Run(run func(ctx context.Context)) *MockClipboard_ReadText_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 *MockClipboard_ReadText_Call) Return(s string, err error) *MockClipboard_ReadText_Call {
	_c.Call.Return(s, err)
	return _c
}

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

// WriteText provides a mock function for the type MockClipboard
func (_mock *MockClipboard) WriteText(ctx context.Context, text string) error {
	ret := _mock.Called(ctx, text)

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

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

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

// WriteText is a helper method to define mock.On call
//   - ctx context.Context
//   - text string
func (_e *MockClipboard_Expecter) WriteText(ctx interface{}, text interface{}) *MockClipboard_WriteText_Call {
	return &MockClipboard_WriteText_Call{Call: _e.mock.On("WriteText", ctx, text)}
}

func (_c *MockClipboard_WriteText_Call) Run(run func(ctx context.Context, text string)) *MockClipboard_WriteText_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)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockClipboard_WriteText_Call) RunAndReturn(run func(ctx context.Context, text string) error) *MockClipboard_WriteText_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockColorSchemeDetector is an autogenerated mock type for the ColorSchemeDetector type
type MockColorSchemeDetector struct {
	mock.Mock
}

type MockColorSchemeDetector_Expecter struct {
	mock *mock.Mock
}

func (_m *MockColorSchemeDetector) EXPECT() *MockColorSchemeDetector_Expecter {
	return &MockColorSchemeDetector_Expecter{mock: &_m.Mock}
}

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

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

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

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

// Available is a helper method to define mock.On call
func (_e *MockColorSchemeDetector_Expecter) Available() *MockColorSchemeDetector_Available_Call {
	return &MockColorSchemeDetector_Available_Call{Call: _e.mock.On("Available")}
}

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

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

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

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

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

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

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

// Detect is a helper method to define mock.On call
func (_e *MockColorSchemeDetector_Expecter) Detect() *MockColorSchemeDetector_Detect_Call {
	return &MockColorSchemeDetector_Detect_Call{Call: _e.mock.On("Detect")}
}

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

func (_c *MockColorSchemeDetector_Detect_Call) Return(prefersDark bool, ok bool) *MockColorSchemeDetector_Detect_Call {
	_c.Call.Return(prefersDark, ok)
	return _c
}

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

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

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

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

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

// Name is a helper method to define mock.On call
func (_e *MockColorSchemeDetector_Expecter) Name() *MockColorSchemeDetector_Name_Call {
	return &MockColorSchemeDetector_Name_Call{Call: _e.mock.On("Name")}
}

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

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

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

// Priority provides a mock function for the type MockColorSchemeDetector
func (_mock *MockColorSchemeDetector) Priority() int {
	ret := _mock.Called()

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

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

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

// Priority is a helper method to define mock.On call
func (_e *MockColorSchemeDetector_Expecter) Priority() *MockColorSchemeDetector_Priority_Call {
	return &MockColorSchemeDetector_Priority_Call{Call: _e.mock.On("Priority")}
}

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

func (_c *MockColorSchemeDetector_Priority_Call) Return(n int) *MockColorSchemeDetector_Priority_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockColorSchemeDetector_Priority_Call) RunAndReturn(run func() int) *MockColorSchemeDetector_Priority_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockToolkitAvailabilityNotifier is an autogenerated mock type for the ToolkitAvailabilityNotifier type
type MockToolkitAvailabilityNotifier struct {
	mock.Mock
}

type MockToolkitAvailabilityNotifier_Expecter struct {
	mock *mock.Mock
}

func (_m *MockToolkitAvailabilityNotifier) EXPECT() *MockToolkitAvailabilityNotifier_Expecter {
	return &MockToolkitAvailabilityNotifier_Expecter{mock: &_m.Mock}
}

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

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

// MarkAvailable is a helper method to define mock.On call
func (_e *MockToolkitAvailabilityNotifier_Expecter) MarkAvailable() *MockToolkitAvailabilityNotifier_MarkAvailable_Call {
	return &MockToolkitAvailabilityNotifier_MarkAvailable_Call{Call: _e.mock.On("MarkAvailable")}
}

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

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

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

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

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

	return mock
}

// MockColorSchemeResolver is an autogenerated mock type for the ColorSchemeResolver type
type MockColorSchemeResolver struct {
	mock.Mock
}

type MockColorSchemeResolver_Expecter struct {
	mock *mock.Mock
}

func (_m *MockColorSchemeResolver) EXPECT() *MockColorSchemeResolver_Expecter {
	return &MockColorSchemeResolver_Expecter{mock: &_m.Mock}
}

// OnChange provides a mock function for the type MockColorSchemeResolver
func (_mock *MockColorSchemeResolver) OnChange(callback func(port.ColorSchemePreference)) func() {
	ret := _mock.Called(callback)

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

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

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

// OnChange is a helper method to define mock.On call
//   - callback func(port.ColorSchemePreference)
func (_e *MockColorSchemeResolver_Expecter) OnChange(callback interface{}) *MockColorSchemeResolver_OnChange_Call {
	return &MockColorSchemeResolver_OnChange_Call{Call: _e.mock.On("OnChange", callback)}
}

func (_c *MockColorSchemeResolver_OnChange_Call) Run(run func(callback func(port.ColorSchemePreference))) *MockColorSchemeResolver_OnChange_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 func(port.ColorSchemePreference)
		if args[0] != nil {
			arg0 = args[0].(func(port.ColorSchemePreference))
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockColorSchemeResolver_OnChange_Call) Return(fn func()) *MockColorSchemeResolver_OnChange_Call {
	_c.Call.Return(fn)
	return _c
}

func (_c *MockColorSchemeResolver_OnChange_Call) RunAndReturn(run func(callback func(port.ColorSchemePreference)) func()) *MockColorSchemeResolver_OnChange_Call {
	_c.Call.Return(run)
	return _c
}

// Refresh provides a mock function for the type MockColorSchemeResolver
func (_mock *MockColorSchemeResolver) Refresh() port.ColorSchemePreference {
	ret := _mock.Called()

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

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

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

// Refresh is a helper method to define mock.On call
func (_e *MockColorSchemeResolver_Expecter) Refresh() *MockColorSchemeResolver_Refresh_Call {
	return &MockColorSchemeResolver_Refresh_Call{Call: _e.mock.On("Refresh")}
}

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

func (_c *MockColorSchemeResolver_Refresh_Call) Return(colorSchemePreference port.ColorSchemePreference) *MockColorSchemeResolver_Refresh_Call {
	_c.Call.Return(colorSchemePreference)
	return _c
}

func (_c *MockColorSchemeResolver_Refresh_Call) RunAndReturn(run func() port.ColorSchemePreference) *MockColorSchemeResolver_Refresh_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterDetector provides a mock function for the type MockColorSchemeResolver
func (_mock *MockColorSchemeResolver) RegisterDetector(detector port.ColorSchemeDetector) {
	_mock.Called(detector)
	return
}

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

// RegisterDetector is a helper method to define mock.On call
//   - detector port.ColorSchemeDetector
func (_e *MockColorSchemeResolver_Expecter) RegisterDetector(detector interface{}) *MockColorSchemeResolver_RegisterDetector_Call {
	return &MockColorSchemeResolver_RegisterDetector_Call{Call: _e.mock.On("RegisterDetector", detector)}
}

func (_c *MockColorSchemeResolver_RegisterDetector_Call) Run(run func(detector port.ColorSchemeDetector)) *MockColorSchemeResolver_RegisterDetector_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 port.ColorSchemeDetector
		if args[0] != nil {
			arg0 = args[0].(port.ColorSchemeDetector)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockColorSchemeResolver_RegisterDetector_Call) RunAndReturn(run func(detector port.ColorSchemeDetector)) *MockColorSchemeResolver_RegisterDetector_Call {
	_c.Run(run)
	return _c
}

// Resolve provides a mock function for the type MockColorSchemeResolver
func (_mock *MockColorSchemeResolver) Resolve() port.ColorSchemePreference {
	ret := _mock.Called()

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

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

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

// Resolve is a helper method to define mock.On call
func (_e *MockColorSchemeResolver_Expecter) Resolve() *MockColorSchemeResolver_Resolve_Call {
	return &MockColorSchemeResolver_Resolve_Call{Call: _e.mock.On("Resolve")}
}

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

func (_c *MockColorSchemeResolver_Resolve_Call) Return(colorSchemePreference port.ColorSchemePreference) *MockColorSchemeResolver_Resolve_Call {
	_c.Call.Return(colorSchemePreference)
	return _c
}

func (_c *MockColorSchemeResolver_Resolve_Call) RunAndReturn(run func() port.ColorSchemePreference) *MockColorSchemeResolver_Resolve_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockConfigMigrator is an autogenerated mock type for the ConfigMigrator type
type MockConfigMigrator struct {
	mock.Mock
}

type MockConfigMigrator_Expecter struct {
	mock *mock.Mock
}

func (_m *MockConfigMigrator) EXPECT() *MockConfigMigrator_Expecter {
	return &MockConfigMigrator_Expecter{mock: &_m.Mock}
}

// CheckMigration provides a mock function for the type MockConfigMigrator
func (_mock *MockConfigMigrator) CheckMigration() (*port.MigrationResult, error) {
	ret := _mock.Called()

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

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

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

// CheckMigration is a helper method to define mock.On call
func (_e *MockConfigMigrator_Expecter) CheckMigration() *MockConfigMigrator_CheckMigration_Call {
	return &MockConfigMigrator_CheckMigration_Call{Call: _e.mock.On("CheckMigration")}
}

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

func (_c *MockConfigMigrator_CheckMigration_Call) Return(migrationResult *port.MigrationResult, err error) *MockConfigMigrator_CheckMigration_Call {
	_c.Call.Return(migrationResult, err)
	return _c
}

func (_c *MockConfigMigrator_CheckMigration_Call) RunAndReturn(run func() (*port.MigrationResult, error)) *MockConfigMigrator_CheckMigration_Call {
	_c.Call.Return(run)
	return _c
}

// DetectChanges provides a mock function for the type MockConfigMigrator
func (_mock *MockConfigMigrator) DetectChanges() ([]port.KeyChange, error) {
	ret := _mock.Called()

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

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

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

// DetectChanges is a helper method to define mock.On call
func (_e *MockConfigMigrator_Expecter) DetectChanges() *MockConfigMigrator_DetectChanges_Call {
	return &MockConfigMigrator_DetectChanges_Call{Call: _e.mock.On("DetectChanges")}
}

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

func (_c *MockConfigMigrator_DetectChanges_Call) Return(keyChanges []port.KeyChange, err error) *MockConfigMigrator_DetectChanges_Call {
	_c.Call.Return(keyChanges, err)
	return _c
}

func (_c *MockConfigMigrator_DetectChanges_Call) RunAndReturn(run func() ([]port.KeyChange, error)) *MockConfigMigrator_DetectChanges_Call {
	_c.Call.Return(run)
	return _c
}

// GetConfigFile provides a mock function for the type MockConfigMigrator
func (_mock *MockConfigMigrator) GetConfigFile() (string, error) {
	ret := _mock.Called()

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

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

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

// GetConfigFile is a helper method to define mock.On call
func (_e *MockConfigMigrator_Expecter) GetConfigFile() *MockConfigMigrator_GetConfigFile_Call {
	return &MockConfigMigrator_GetConfigFile_Call{Call: _e.mock.On("GetConfigFile")}
}

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

func (_c *MockConfigMigrator_GetConfigFile_Call) Return(s string, err error) *MockConfigMigrator_GetConfigFile_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockConfigMigrator_GetConfigFile_Call) RunAndReturn(run func() (string, error)) *MockConfigMigrator_GetConfigFile_Call {
	_c.Call.Return(run)
	return _c
}

// GetKeyInfo provides a mock function for the type MockConfigMigrator
func (_mock *MockConfigMigrator) GetKeyInfo(key string) port.KeyInfo {
	ret := _mock.Called(key)

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

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

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

// GetKeyInfo is a helper method to define mock.On call
//   - key string
func (_e *MockConfigMigrator_Expecter) GetKeyInfo(key interface{}) *MockConfigMigrator_GetKeyInfo_Call {
	return &MockConfigMigrator_GetKeyInfo_Call{Call: _e.mock.On("GetKeyInfo", key)}
}

func (_c *MockConfigMigrator_GetKeyInfo_Call) Run(run func(key string)) *MockConfigMigrator_GetKeyInfo_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 *MockConfigMigrator_GetKeyInfo_Call) Return(keyInfo port.KeyInfo) *MockConfigMigrator_GetKeyInfo_Call {
	_c.Call.Return(keyInfo)
	return _c
}

func (_c *MockConfigMigrator_GetKeyInfo_Call) RunAndReturn(run func(key string) port.KeyInfo) *MockConfigMigrator_GetKeyInfo_Call {
	_c.Call.Return(run)
	return _c
}

// Migrate provides a mock function for the type MockConfigMigrator
func (_mock *MockConfigMigrator) Migrate() ([]string, error) {
	ret := _mock.Called()

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

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

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

// Migrate is a helper method to define mock.On call
func (_e *MockConfigMigrator_Expecter) Migrate() *MockConfigMigrator_Migrate_Call {
	return &MockConfigMigrator_Migrate_Call{Call: _e.mock.On("Migrate")}
}

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

func (_c *MockConfigMigrator_Migrate_Call) Return(strings []string, err error) *MockConfigMigrator_Migrate_Call {
	_c.Call.Return(strings, err)
	return _c
}

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

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

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

	return mock
}

// MockDiffFormatter is an autogenerated mock type for the DiffFormatter type
type MockDiffFormatter struct {
	mock.Mock
}

type MockDiffFormatter_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDiffFormatter) EXPECT() *MockDiffFormatter_Expecter {
	return &MockDiffFormatter_Expecter{mock: &_m.Mock}
}

// FormatChangesAsDiff provides a mock function for the type MockDiffFormatter
func (_mock *MockDiffFormatter) FormatChangesAsDiff(changes []port.KeyChange) string {
	ret := _mock.Called(changes)

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

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

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

// FormatChangesAsDiff is a helper method to define mock.On call
//   - changes []port.KeyChange
func (_e *MockDiffFormatter_Expecter) FormatChangesAsDiff(changes interface{}) *MockDiffFormatter_FormatChangesAsDiff_Call {
	return &MockDiffFormatter_FormatChangesAsDiff_Call{Call: _e.mock.On("FormatChangesAsDiff", changes)}
}

func (_c *MockDiffFormatter_FormatChangesAsDiff_Call) Run(run func(changes []port.KeyChange)) *MockDiffFormatter_FormatChangesAsDiff_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []port.KeyChange
		if args[0] != nil {
			arg0 = args[0].([]port.KeyChange)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockDiffFormatter_FormatChangesAsDiff_Call) RunAndReturn(run func(changes []port.KeyChange) string) *MockDiffFormatter_FormatChangesAsDiff_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockConfigSchemaProvider is an autogenerated mock type for the ConfigSchemaProvider type
type MockConfigSchemaProvider struct {
	mock.Mock
}

type MockConfigSchemaProvider_Expecter struct {
	mock *mock.Mock
}

func (_m *MockConfigSchemaProvider) EXPECT() *MockConfigSchemaProvider_Expecter {
	return &MockConfigSchemaProvider_Expecter{mock: &_m.Mock}
}

// GetSchema provides a mock function for the type MockConfigSchemaProvider
func (_mock *MockConfigSchemaProvider) GetSchema() []entity.ConfigKeyInfo {
	ret := _mock.Called()

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

	var r0 []entity.ConfigKeyInfo
	if returnFunc, ok := ret.Get(0).(func() []entity.ConfigKeyInfo); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]entity.ConfigKeyInfo)
		}
	}
	return r0
}

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

// GetSchema is a helper method to define mock.On call
func (_e *MockConfigSchemaProvider_Expecter) GetSchema() *MockConfigSchemaProvider_GetSchema_Call {
	return &MockConfigSchemaProvider_GetSchema_Call{Call: _e.mock.On("GetSchema")}
}

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

func (_c *MockConfigSchemaProvider_GetSchema_Call) Return(configKeyInfos []entity.ConfigKeyInfo) *MockConfigSchemaProvider_GetSchema_Call {
	_c.Call.Return(configKeyInfos)
	return _c
}

func (_c *MockConfigSchemaProvider_GetSchema_Call) RunAndReturn(run func() []entity.ConfigKeyInfo) *MockConfigSchemaProvider_GetSchema_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockConfigTransformer is an autogenerated mock type for the ConfigTransformer type
type MockConfigTransformer struct {
	mock.Mock
}

type MockConfigTransformer_Expecter struct {
	mock *mock.Mock
}

func (_m *MockConfigTransformer) EXPECT() *MockConfigTransformer_Expecter {
	return &MockConfigTransformer_Expecter{mock: &_m.Mock}
}

// TransformLegacyActions provides a mock function for the type MockConfigTransformer
func (_mock *MockConfigTransformer) TransformLegacyActions(rawConfig map[string]any) {
	_mock.Called(rawConfig)
	return
}

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

// TransformLegacyActions is a helper method to define mock.On call
//   - rawConfig map[string]any
func (_e *MockConfigTransformer_Expecter) TransformLegacyActions(rawConfig interface{}) *MockConfigTransformer_TransformLegacyActions_Call {
	return &MockConfigTransformer_TransformLegacyActions_Call{Call: _e.mock.On("TransformLegacyActions", rawConfig)}
}

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

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

func (_c *MockConfigTransformer_TransformLegacyActions_Call) RunAndReturn(run func(rawConfig map[string]any)) *MockConfigTransformer_TransformLegacyActions_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockContentInjector is an autogenerated mock type for the ContentInjector type
type MockContentInjector struct {
	mock.Mock
}

type MockContentInjector_Expecter struct {
	mock *mock.Mock
}

func (_m *MockContentInjector) EXPECT() *MockContentInjector_Expecter {
	return &MockContentInjector_Expecter{mock: &_m.Mock}
}

// InjectFindHighlightCSS provides a mock function for the type MockContentInjector
func (_mock *MockContentInjector) InjectFindHighlightCSS(ctx context.Context, css string) error {
	ret := _mock.Called(ctx, css)

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

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

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

// InjectFindHighlightCSS is a helper method to define mock.On call
//   - ctx context.Context
//   - css string
func (_e *MockContentInjector_Expecter) InjectFindHighlightCSS(ctx interface{}, css interface{}) *MockContentInjector_InjectFindHighlightCSS_Call {
	return &MockContentInjector_InjectFindHighlightCSS_Call{Call: _e.mock.On("InjectFindHighlightCSS", ctx, css)}
}

func (_c *MockContentInjector_InjectFindHighlightCSS_Call) Run(run func(ctx context.Context, css string)) *MockContentInjector_InjectFindHighlightCSS_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)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockContentInjector_InjectFindHighlightCSS_Call) RunAndReturn(run func(ctx context.Context, css string) error) *MockContentInjector_InjectFindHighlightCSS_Call {
	_c.Call.Return(run)
	return _c
}

// InjectThemeCSS provides a mock function for the type MockContentInjector
func (_mock *MockContentInjector) InjectThemeCSS(ctx context.Context, css string) error {
	ret := _mock.Called(ctx, css)

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

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

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

// InjectThemeCSS is a helper method to define mock.On call
//   - ctx context.Context
//   - css string
func (_e *MockContentInjector_Expecter) InjectThemeCSS(ctx interface{}, css interface{}) *MockContentInjector_InjectThemeCSS_Call {
	return &MockContentInjector_InjectThemeCSS_Call{Call: _e.mock.On("InjectThemeCSS", ctx, css)}
}

func (_c *MockContentInjector_InjectThemeCSS_Call) Run(run func(ctx context.Context, css string)) *MockContentInjector_InjectThemeCSS_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)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockContentInjector_InjectThemeCSS_Call) RunAndReturn(run func(ctx context.Context, css string) error) *MockContentInjector_InjectThemeCSS_Call {
	_c.Call.Return(run)
	return _c
}

// RefreshScripts provides a mock function for the type MockContentInjector
func (_mock *MockContentInjector) RefreshScripts(ctx context.Context, wv port.WebView) error {
	ret := _mock.Called(ctx, wv)

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

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

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

// RefreshScripts is a helper method to define mock.On call
//   - ctx context.Context
//   - wv port.WebView
func (_e *MockContentInjector_Expecter) RefreshScripts(ctx interface{}, wv interface{}) *MockContentInjector_RefreshScripts_Call {
	return &MockContentInjector_RefreshScripts_Call{Call: _e.mock.On("RefreshScripts", ctx, wv)}
}

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

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

func (_c *MockContentInjector_RefreshScripts_Call) RunAndReturn(run func(ctx context.Context, wv port.WebView) error) *MockContentInjector_RefreshScripts_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockDatabaseProvider is an autogenerated mock type for the DatabaseProvider type
type MockDatabaseProvider struct {
	mock.Mock
}

type MockDatabaseProvider_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDatabaseProvider) EXPECT() *MockDatabaseProvider_Expecter {
	return &MockDatabaseProvider_Expecter{mock: &_m.Mock}
}

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

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

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

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

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

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

// DB provides a mock function for the type MockDatabaseProvider
func (_mock *MockDatabaseProvider) DB(ctx context.Context) (*sql.DB, error) {
	ret := _mock.Called(ctx)

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

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

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

// DB is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockDatabaseProvider_Expecter) DB(ctx interface{}) *MockDatabaseProvider_DB_Call {
	return &MockDatabaseProvider_DB_Call{Call: _e.mock.On("DB", ctx)}
}

func (_c *MockDatabaseProvider_DB_Call) Run(run func(ctx context.Context)) *MockDatabaseProvider_DB_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 *MockDatabaseProvider_DB_Call) Return(dB *sql.DB, err error) *MockDatabaseProvider_DB_Call {
	_c.Call.Return(dB, err)
	return _c
}

func (_c *MockDatabaseProvider_DB_Call) RunAndReturn(run func(ctx context.Context) (*sql.DB, error)) *MockDatabaseProvider_DB_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// IsInitialized is a helper method to define mock.On call
func (_e *MockDatabaseProvider_Expecter) IsInitialized() *MockDatabaseProvider_IsInitialized_Call {
	return &MockDatabaseProvider_IsInitialized_Call{Call: _e.mock.On("IsInitialized")}
}

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

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

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

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

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

	return mock
}

// MockDesktopIntegration is an autogenerated mock type for the DesktopIntegration type
type MockDesktopIntegration struct {
	mock.Mock
}

type MockDesktopIntegration_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDesktopIntegration) EXPECT() *MockDesktopIntegration_Expecter {
	return &MockDesktopIntegration_Expecter{mock: &_m.Mock}
}

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

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

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

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

// GetStatus is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockDesktopIntegration_Expecter) GetStatus(ctx interface{}) *MockDesktopIntegration_GetStatus_Call {
	return &MockDesktopIntegration_GetStatus_Call{Call: _e.mock.On("GetStatus", ctx)}
}

func (_c *MockDesktopIntegration_GetStatus_Call) Run(run func(ctx context.Context)) *MockDesktopIntegration_GetStatus_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 *MockDesktopIntegration_GetStatus_Call) Return(desktopIntegrationStatus *port.DesktopIntegrationStatus, err error) *MockDesktopIntegration_GetStatus_Call {
	_c.Call.Return(desktopIntegrationStatus, err)
	return _c
}

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

// InstallDesktopFile provides a mock function for the type MockDesktopIntegration
func (_mock *MockDesktopIntegration) InstallDesktopFile(ctx context.Context) (string, error) {
	ret := _mock.Called(ctx)

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

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

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

// InstallDesktopFile is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockDesktopIntegration_Expecter) InstallDesktopFile(ctx interface{}) *MockDesktopIntegration_InstallDesktopFile_Call {
	return &MockDesktopIntegration_InstallDesktopFile_Call{Call: _e.mock.On("InstallDesktopFile", ctx)}
}

func (_c *MockDesktopIntegration_InstallDesktopFile_Call) Run(run func(ctx context.Context)) *MockDesktopIntegration_InstallDesktopFile_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 *MockDesktopIntegration_InstallDesktopFile_Call) Return(s string, err error) *MockDesktopIntegration_InstallDesktopFile_Call {
	_c.Call.Return(s, err)
	return _c
}

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

// InstallIcon provides a mock function for the type MockDesktopIntegration
func (_mock *MockDesktopIntegration) InstallIcon(ctx context.Context, svgData []byte) (string, error) {
	ret := _mock.Called(ctx, svgData)

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

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte) (string, error)); ok {
		return returnFunc(ctx, svgData)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte) string); ok {
		r0 = returnFunc(ctx, svgData)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []byte) error); ok {
		r1 = returnFunc(ctx, svgData)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// InstallIcon is a helper method to define mock.On call
//   - ctx context.Context
//   - svgData []byte
func (_e *MockDesktopIntegration_Expecter) InstallIcon(ctx interface{}, svgData interface{}) *MockDesktopIntegration_InstallIcon_Call {
	return &MockDesktopIntegration_InstallIcon_Call{Call: _e.mock.On("InstallIcon", ctx, svgData)}
}

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

func (_c *MockDesktopIntegration_InstallIcon_Call) Return(s string, err error) *MockDesktopIntegration_InstallIcon_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockDesktopIntegration_InstallIcon_Call) RunAndReturn(run func(ctx context.Context, svgData []byte) (string, error)) *MockDesktopIntegration_InstallIcon_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// RemoveDesktopFile is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockDesktopIntegration_Expecter) RemoveDesktopFile(ctx interface{}) *MockDesktopIntegration_RemoveDesktopFile_Call {
	return &MockDesktopIntegration_RemoveDesktopFile_Call{Call: _e.mock.On("RemoveDesktopFile", ctx)}
}

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

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

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

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

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

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

// RemoveIcon is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockDesktopIntegration_Expecter) RemoveIcon(ctx interface{}) *MockDesktopIntegration_RemoveIcon_Call {
	return &MockDesktopIntegration_RemoveIcon_Call{Call: _e.mock.On("RemoveIcon", ctx)}
}

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

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

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

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

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

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

// SetAsDefaultBrowser is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockDesktopIntegration_Expecter) SetAsDefaultBrowser(ctx interface{}) *MockDesktopIntegration_SetAsDefaultBrowser_Call {
	return &MockDesktopIntegration_SetAsDefaultBrowser_Call{Call: _e.mock.On("SetAsDefaultBrowser", ctx)}
}

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

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

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

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

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

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

// UnsetAsDefaultBrowser is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockDesktopIntegration_Expecter) UnsetAsDefaultBrowser(ctx interface{}) *MockDesktopIntegration_UnsetAsDefaultBrowser_Call {
	return &MockDesktopIntegration_UnsetAsDefaultBrowser_Call{Call: _e.mock.On("UnsetAsDefaultBrowser", ctx)}
}

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

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

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

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

	return mock
}

// MockDownloadEventHandler is an autogenerated mock type for the DownloadEventHandler type
type MockDownloadEventHandler struct {
	mock.Mock
}

type MockDownloadEventHandler_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDownloadEventHandler) EXPECT() *MockDownloadEventHandler_Expecter {
	return &MockDownloadEventHandler_Expecter{mock: &_m.Mock}
}

// OnDownloadEvent provides a mock function for the type MockDownloadEventHandler
func (_mock *MockDownloadEventHandler) OnDownloadEvent(ctx context.Context, event port.DownloadEvent) {
	_mock.Called(ctx, event)
	return
}

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

// OnDownloadEvent is a helper method to define mock.On call
//   - ctx context.Context
//   - event port.DownloadEvent
func (_e *MockDownloadEventHandler_Expecter) OnDownloadEvent(ctx interface{}, event interface{}) *MockDownloadEventHandler_OnDownloadEvent_Call {
	return &MockDownloadEventHandler_OnDownloadEvent_Call{Call: _e.mock.On("OnDownloadEvent", ctx, event)}
}

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

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

func (_c *MockDownloadEventHandler_OnDownloadEvent_Call) RunAndReturn(run func(ctx context.Context, event port.DownloadEvent)) *MockDownloadEventHandler_OnDownloadEvent_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockDownloadResponse is an autogenerated mock type for the DownloadResponse type
type MockDownloadResponse struct {
	mock.Mock
}

type MockDownloadResponse_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDownloadResponse) EXPECT() *MockDownloadResponse_Expecter {
	return &MockDownloadResponse_Expecter{mock: &_m.Mock}
}

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

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

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

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

// GetMimeType is a helper method to define mock.On call
func (_e *MockDownloadResponse_Expecter) GetMimeType() *MockDownloadResponse_GetMimeType_Call {
	return &MockDownloadResponse_GetMimeType_Call{Call: _e.mock.On("GetMimeType")}
}

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

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

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

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

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

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

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

// GetSuggestedFilename is a helper method to define mock.On call
func (_e *MockDownloadResponse_Expecter) GetSuggestedFilename() *MockDownloadResponse_GetSuggestedFilename_Call {
	return &MockDownloadResponse_GetSuggestedFilename_Call{Call: _e.mock.On("GetSuggestedFilename")}
}

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

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

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

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

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

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

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

// GetUri is a helper method to define mock.On call
func (_e *MockDownloadResponse_Expecter) GetUri() *MockDownloadResponse_GetUri_Call {
	return &MockDownloadResponse_GetUri_Call{Call: _e.mock.On("GetUri")}
}

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

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

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

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

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

	return mock
}

// MockMemoryPressureApplier is an autogenerated mock type for the MemoryPressureApplier type
type MockMemoryPressureApplier struct {
	mock.Mock
}

type MockMemoryPressureApplier_Expecter struct {
	mock *mock.Mock
}

func (_m *MockMemoryPressureApplier) EXPECT() *MockMemoryPressureApplier_Expecter {
	return &MockMemoryPressureApplier_Expecter{mock: &_m.Mock}
}

// ApplyNetworkProcessSettings provides a mock function for the type MockMemoryPressureApplier
func (_mock *MockMemoryPressureApplier) ApplyNetworkProcessSettings(ctx context.Context, cfg *port.MemoryPressureConfig) error {
	ret := _mock.Called(ctx, cfg)

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

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

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

// ApplyNetworkProcessSettings is a helper method to define mock.On call
//   - ctx context.Context
//   - cfg *port.MemoryPressureConfig
func (_e *MockMemoryPressureApplier_Expecter) ApplyNetworkProcessSettings(ctx interface{}, cfg interface{}) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
	return &MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call{Call: _e.mock.On("ApplyNetworkProcessSettings", ctx, cfg)}
}

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

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

func (_c *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call) RunAndReturn(run func(ctx context.Context, cfg *port.MemoryPressureConfig) error) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
	_c.Call.Return(run)
	return _c
}

// ApplyWebProcessSettings provides a mock function for the type MockMemoryPressureApplier
func (_mock *MockMemoryPressureApplier) ApplyWebProcessSettings(ctx context.Context, cfg *port.MemoryPressureConfig) (any, error) {
	ret := _mock.Called(ctx, cfg)

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

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

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

// ApplyWebProcessSettings is a helper method to define mock.On call
//   - ctx context.Context
//   - cfg *port.MemoryPressureConfig
func (_e *MockMemoryPressureApplier_Expecter) ApplyWebProcessSettings(ctx interface{}, cfg interface{}) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
	return &MockMemoryPressureApplier_ApplyWebProcessSettings_Call{Call: _e.mock.On("ApplyWebProcessSettings", ctx, cfg)}
}

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

func (_c *MockMemoryPressureApplier_ApplyWebProcessSettings_Call) Return(v any, err error) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *MockMemoryPressureApplier_ApplyWebProcessSettings_Call) RunAndReturn(run func(ctx context.Context, cfg *port.MemoryPressureConfig) (any, error)) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockEngine is an autogenerated mock type for the Engine type
type MockEngine struct {
	mock.Mock
}

type MockEngine_Expecter struct {
	mock *mock.Mock
}

func (_m *MockEngine) EXPECT() *MockEngine_Expecter {
	return &MockEngine_Expecter{mock: &_m.Mock}
}

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

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

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

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

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

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

// ConfigureDownloads provides a mock function for the type MockEngine
func (_mock *MockEngine) ConfigureDownloads(ctx context.Context, downloadPath string, eventHandler port.DownloadEventHandler, preparer port.DownloadPreparer) error {
	ret := _mock.Called(ctx, downloadPath, eventHandler, preparer)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, port.DownloadEventHandler, port.DownloadPreparer) error); ok {
		r0 = returnFunc(ctx, downloadPath, eventHandler, preparer)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ConfigureDownloads is a helper method to define mock.On call
//   - ctx context.Context
//   - downloadPath string
//   - eventHandler port.DownloadEventHandler
//   - preparer port.DownloadPreparer
func (_e *MockEngine_Expecter) ConfigureDownloads(ctx interface{}, downloadPath interface{}, eventHandler interface{}, preparer interface{}) *MockEngine_ConfigureDownloads_Call {
	return &MockEngine_ConfigureDownloads_Call{Call: _e.mock.On("ConfigureDownloads", ctx, downloadPath, eventHandler, preparer)}
}

func (_c *MockEngine_ConfigureDownloads_Call) Run(run func(ctx context.Context, downloadPath string, eventHandler port.DownloadEventHandler, preparer port.DownloadPreparer)) *MockEngine_ConfigureDownloads_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 port.DownloadEventHandler
		if args[2] != nil {
			arg2 = args[2].(port.DownloadEventHandler)
		}
		var arg3 port.DownloadPreparer
		if args[3] != nil {
			arg3 = args[3].(port.DownloadPreparer)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *MockEngine_ConfigureDownloads_Call) RunAndReturn(run func(ctx context.Context, downloadPath string, eventHandler port.DownloadEventHandler, preparer port.DownloadPreparer) error) *MockEngine_ConfigureDownloads_Call {
	_c.Call.Return(run)
	return _c
}

// ContentInjector provides a mock function for the type MockEngine
func (_mock *MockEngine) ContentInjector() port.ContentInjector {
	ret := _mock.Called()

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

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

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

// ContentInjector is a helper method to define mock.On call
func (_e *MockEngine_Expecter) ContentInjector() *MockEngine_ContentInjector_Call {
	return &MockEngine_ContentInjector_Call{Call: _e.mock.On("ContentInjector")}
}

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

func (_c *MockEngine_ContentInjector_Call) Return(contentInjector port.ContentInjector) *MockEngine_ContentInjector_Call {
	_c.Call.Return(contentInjector)
	return _c
}

func (_c *MockEngine_ContentInjector_Call) RunAndReturn(run func() port.ContentInjector) *MockEngine_ContentInjector_Call {
	_c.Call.Return(run)
	return _c
}

// Factory provides a mock function for the type MockEngine
func (_mock *MockEngine) Factory() port.WebViewFactory {
	ret := _mock.Called()

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

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

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

// Factory is a helper method to define mock.On call
func (_e *MockEngine_Expecter) Factory() *MockEngine_Factory_Call {
	return &MockEngine_Factory_Call{Call: _e.mock.On("Factory")}
}

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

func (_c *MockEngine_Factory_Call) Return(webViewFactory port.WebViewFactory) *MockEngine_Factory_Call {
	_c.Call.Return(webViewFactory)
	return _c
}

func (_c *MockEngine_Factory_Call) RunAndReturn(run func() port.WebViewFactory) *MockEngine_Factory_Call {
	_c.Call.Return(run)
	return _c
}

// FaviconDatabase provides a mock function for the type MockEngine
func (_mock *MockEngine) FaviconDatabase() port.FaviconDatabase {
	ret := _mock.Called()

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

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

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

// FaviconDatabase is a helper method to define mock.On call
func (_e *MockEngine_Expecter) FaviconDatabase() *MockEngine_FaviconDatabase_Call {
	return &MockEngine_FaviconDatabase_Call{Call: _e.mock.On("FaviconDatabase")}
}

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

func (_c *MockEngine_FaviconDatabase_Call) Return(faviconDatabase port.FaviconDatabase) *MockEngine_FaviconDatabase_Call {
	_c.Call.Return(faviconDatabase)
	return _c
}

func (_c *MockEngine_FaviconDatabase_Call) RunAndReturn(run func() port.FaviconDatabase) *MockEngine_FaviconDatabase_Call {
	_c.Call.Return(run)
	return _c
}

// FilterApplier provides a mock function for the type MockEngine
func (_mock *MockEngine) FilterApplier() port.FilterApplier {
	ret := _mock.Called()

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

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

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

// FilterApplier is a helper method to define mock.On call
func (_e *MockEngine_Expecter) FilterApplier() *MockEngine_FilterApplier_Call {
	return &MockEngine_FilterApplier_Call{Call: _e.mock.On("FilterApplier")}
}

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

func (_c *MockEngine_FilterApplier_Call) Return(filterApplier port.FilterApplier) *MockEngine_FilterApplier_Call {
	_c.Call.Return(filterApplier)
	return _c
}

func (_c *MockEngine_FilterApplier_Call) RunAndReturn(run func() port.FilterApplier) *MockEngine_FilterApplier_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// InternalSchemePath is a helper method to define mock.On call
func (_e *MockEngine_Expecter) InternalSchemePath() *MockEngine_InternalSchemePath_Call {
	return &MockEngine_InternalSchemePath_Call{Call: _e.mock.On("InternalSchemePath")}
}

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

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

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

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

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

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

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

// OnToolkitReady is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockEngine_Expecter) OnToolkitReady(ctx interface{}) *MockEngine_OnToolkitReady_Call {
	return &MockEngine_OnToolkitReady_Call{Call: _e.mock.On("OnToolkitReady", ctx)}
}

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

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

// Pool provides a mock function for the type MockEngine
func (_mock *MockEngine) Pool() port.WebViewPool {
	ret := _mock.Called()

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

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

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

// Pool is a helper method to define mock.On call
func (_e *MockEngine_Expecter) Pool() *MockEngine_Pool_Call {
	return &MockEngine_Pool_Call{Call: _e.mock.On("Pool")}
}

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

func (_c *MockEngine_Pool_Call) Return(webViewPool port.WebViewPool) *MockEngine_Pool_Call {
	_c.Call.Return(webViewPool)
	return _c
}

func (_c *MockEngine_Pool_Call) RunAndReturn(run func() port.WebViewPool) *MockEngine_Pool_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAccentHandlers provides a mock function for the type MockEngine
func (_mock *MockEngine) RegisterAccentHandlers(ctx context.Context, handler port.AccentKeyHandler) error {
	ret := _mock.Called(ctx, handler)

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

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

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

// RegisterAccentHandlers is a helper method to define mock.On call
//   - ctx context.Context
//   - handler port.AccentKeyHandler
func (_e *MockEngine_Expecter) RegisterAccentHandlers(ctx interface{}, handler interface{}) *MockEngine_RegisterAccentHandlers_Call {
	return &MockEngine_RegisterAccentHandlers_Call{Call: _e.mock.On("RegisterAccentHandlers", ctx, handler)}
}

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

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

func (_c *MockEngine_RegisterAccentHandlers_Call) RunAndReturn(run func(ctx context.Context, handler port.AccentKeyHandler) error) *MockEngine_RegisterAccentHandlers_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterHandlers provides a mock function for the type MockEngine
func (_mock *MockEngine) RegisterHandlers(ctx context.Context, deps port.HandlerDependencies) error {
	ret := _mock.Called(ctx, deps)

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

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

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

// RegisterHandlers is a helper method to define mock.On call
//   - ctx context.Context
//   - deps port.HandlerDependencies
func (_e *MockEngine_Expecter) RegisterHandlers(ctx interface{}, deps interface{}) *MockEngine_RegisterHandlers_Call {
	return &MockEngine_RegisterHandlers_Call{Call: _e.mock.On("RegisterHandlers", ctx, deps)}
}

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

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

func (_c *MockEngine_RegisterHandlers_Call) RunAndReturn(run func(ctx context.Context, deps port.HandlerDependencies) error) *MockEngine_RegisterHandlers_Call {
	_c.Call.Return(run)
	return _c
}

// SetHandlerContext provides a mock function for the type MockEngine
func (_mock *MockEngine) SetHandlerContext(ctx context.Context) {
	_mock.Called(ctx)
	return
}

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

// SetHandlerContext is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockEngine_Expecter) SetHandlerContext(ctx interface{}) *MockEngine_SetHandlerContext_Call {
	return &MockEngine_SetHandlerContext_Call{Call: _e.mock.On("SetHandlerContext", ctx)}
}

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

func (_c *MockEngine_SetHandlerContext_Call) RunAndReturn(run func(ctx context.Context)) *MockEngine_SetHandlerContext_Call {
	_c.Run(run)
	return _c
}

// SettingsApplier provides a mock function for the type MockEngine
func (_mock *MockEngine) SettingsApplier() port.SettingsApplier {
	ret := _mock.Called()

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

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

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

// SettingsApplier is a helper method to define mock.On call
func (_e *MockEngine_Expecter) SettingsApplier() *MockEngine_SettingsApplier_Call {
	return &MockEngine_SettingsApplier_Call{Call: _e.mock.On("SettingsApplier")}
}

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

func (_c *MockEngine_SettingsApplier_Call) Return(settingsApplier port.SettingsApplier) *MockEngine_SettingsApplier_Call {
	_c.Call.Return(settingsApplier)
	return _c
}

func (_c *MockEngine_SettingsApplier_Call) RunAndReturn(run func() port.SettingsApplier) *MockEngine_SettingsApplier_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateAppearance provides a mock function for the type MockEngine
func (_mock *MockEngine) UpdateAppearance(ctx context.Context, r float64, g float64, b float64, alpha float64) error {
	ret := _mock.Called(ctx, r, g, b, alpha)

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

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

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

// UpdateAppearance is a helper method to define mock.On call
//   - ctx context.Context
//   - r float64
//   - g float64
//   - b float64
//   - alpha float64
func (_e *MockEngine_Expecter) UpdateAppearance(ctx interface{}, r interface{}, g interface{}, b interface{}, alpha interface{}) *MockEngine_UpdateAppearance_Call {
	return &MockEngine_UpdateAppearance_Call{Call: _e.mock.On("UpdateAppearance", ctx, r, g, b, alpha)}
}

func (_c *MockEngine_UpdateAppearance_Call) Run(run func(ctx context.Context, r float64, g float64, b float64, alpha float64)) *MockEngine_UpdateAppearance_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 float64
		if args[1] != nil {
			arg1 = args[1].(float64)
		}
		var arg2 float64
		if args[2] != nil {
			arg2 = args[2].(float64)
		}
		var arg3 float64
		if args[3] != nil {
			arg3 = args[3].(float64)
		}
		var arg4 float64
		if args[4] != nil {
			arg4 = args[4].(float64)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *MockEngine_UpdateAppearance_Call) RunAndReturn(run func(ctx context.Context, r float64, g float64, b float64, alpha float64) error) *MockEngine_UpdateAppearance_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSettings provides a mock function for the type MockEngine
func (_mock *MockEngine) UpdateSettings(ctx context.Context, update port.EngineSettingsUpdate) error {
	ret := _mock.Called(ctx, update)

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

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

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

// UpdateSettings is a helper method to define mock.On call
//   - ctx context.Context
//   - update port.EngineSettingsUpdate
func (_e *MockEngine_Expecter) UpdateSettings(ctx interface{}, update interface{}) *MockEngine_UpdateSettings_Call {
	return &MockEngine_UpdateSettings_Call{Call: _e.mock.On("UpdateSettings", ctx, update)}
}

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

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

func (_c *MockEngine_UpdateSettings_Call) RunAndReturn(run func(ctx context.Context, update port.EngineSettingsUpdate) error) *MockEngine_UpdateSettings_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockSchemeHandler is an autogenerated mock type for the SchemeHandler type
type MockSchemeHandler struct {
	mock.Mock
}

type MockSchemeHandler_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSchemeHandler) EXPECT() *MockSchemeHandler_Expecter {
	return &MockSchemeHandler_Expecter{mock: &_m.Mock}
}

// RegisterScheme provides a mock function for the type MockSchemeHandler
func (_mock *MockSchemeHandler) RegisterScheme(scheme string, handler func(uri string) ([]byte, string, error)) {
	_mock.Called(scheme, handler)
	return
}

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

// RegisterScheme is a helper method to define mock.On call
//   - scheme string
//   - handler func(uri string) ([]byte, string, error)
func (_e *MockSchemeHandler_Expecter) RegisterScheme(scheme interface{}, handler interface{}) *MockSchemeHandler_RegisterScheme_Call {
	return &MockSchemeHandler_RegisterScheme_Call{Call: _e.mock.On("RegisterScheme", scheme, handler)}
}

func (_c *MockSchemeHandler_RegisterScheme_Call) Run(run func(scheme string, handler func(uri string) ([]byte, string, error))) *MockSchemeHandler_RegisterScheme_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 func(uri string) ([]byte, string, error)
		if args[1] != nil {
			arg1 = args[1].(func(uri string) ([]byte, string, error))
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockSchemeHandler_RegisterScheme_Call) RunAndReturn(run func(scheme string, handler func(uri string) ([]byte, string, error))) *MockSchemeHandler_RegisterScheme_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockMessageRouter is an autogenerated mock type for the MessageRouter type
type MockMessageRouter struct {
	mock.Mock
}

type MockMessageRouter_Expecter struct {
	mock *mock.Mock
}

func (_m *MockMessageRouter) EXPECT() *MockMessageRouter_Expecter {
	return &MockMessageRouter_Expecter{mock: &_m.Mock}
}

// PostMessage provides a mock function for the type MockMessageRouter
func (_mock *MockMessageRouter) PostMessage(webviewID port.WebViewID, message string) error {
	ret := _mock.Called(webviewID, message)

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

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

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

// PostMessage is a helper method to define mock.On call
//   - webviewID port.WebViewID
//   - message string
func (_e *MockMessageRouter_Expecter) PostMessage(webviewID interface{}, message interface{}) *MockMessageRouter_PostMessage_Call {
	return &MockMessageRouter_PostMessage_Call{Call: _e.mock.On("PostMessage", webviewID, message)}
}

func (_c *MockMessageRouter_PostMessage_Call) Run(run func(webviewID port.WebViewID, message string)) *MockMessageRouter_PostMessage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 port.WebViewID
		if args[0] != nil {
			arg0 = args[0].(port.WebViewID)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockMessageRouter_PostMessage_Call) RunAndReturn(run func(webviewID port.WebViewID, message string) error) *MockMessageRouter_PostMessage_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterHandler provides a mock function for the type MockMessageRouter
func (_mock *MockMessageRouter) RegisterHandler(name string, handler func(message string) (string, error)) {
	_mock.Called(name, handler)
	return
}

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

// RegisterHandler is a helper method to define mock.On call
//   - name string
//   - handler func(message string) (string, error)
func (_e *MockMessageRouter_Expecter) RegisterHandler(name interface{}, handler interface{}) *MockMessageRouter_RegisterHandler_Call {
	return &MockMessageRouter_RegisterHandler_Call{Call: _e.mock.On("RegisterHandler", name, handler)}
}

func (_c *MockMessageRouter_RegisterHandler_Call) Run(run func(name string, handler func(message string) (string, error))) *MockMessageRouter_RegisterHandler_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 func(message string) (string, error)
		if args[1] != nil {
			arg1 = args[1].(func(message string) (string, error))
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockMessageRouter_RegisterHandler_Call) RunAndReturn(run func(name string, handler func(message string) (string, error))) *MockMessageRouter_RegisterHandler_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockSettingsApplier is an autogenerated mock type for the SettingsApplier type
type MockSettingsApplier struct {
	mock.Mock
}

type MockSettingsApplier_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSettingsApplier) EXPECT() *MockSettingsApplier_Expecter {
	return &MockSettingsApplier_Expecter{mock: &_m.Mock}
}

// ApplyToAll provides a mock function for the type MockSettingsApplier
func (_mock *MockSettingsApplier) ApplyToAll(ctx context.Context, webviews []port.WebView) {
	_mock.Called(ctx, webviews)
	return
}

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

// ApplyToAll is a helper method to define mock.On call
//   - ctx context.Context
//   - webviews []port.WebView
func (_e *MockSettingsApplier_Expecter) ApplyToAll(ctx interface{}, webviews interface{}) *MockSettingsApplier_ApplyToAll_Call {
	return &MockSettingsApplier_ApplyToAll_Call{Call: _e.mock.On("ApplyToAll", ctx, webviews)}
}

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

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

func (_c *MockSettingsApplier_ApplyToAll_Call) RunAndReturn(run func(ctx context.Context, webviews []port.WebView)) *MockSettingsApplier_ApplyToAll_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockFilterApplier is an autogenerated mock type for the FilterApplier type
type MockFilterApplier struct {
	mock.Mock
}

type MockFilterApplier_Expecter struct {
	mock *mock.Mock
}

func (_m *MockFilterApplier) EXPECT() *MockFilterApplier_Expecter {
	return &MockFilterApplier_Expecter{mock: &_m.Mock}
}

// ApplyToAll provides a mock function for the type MockFilterApplier
func (_mock *MockFilterApplier) ApplyToAll(ctx context.Context, webviews []port.WebView) {
	_mock.Called(ctx, webviews)
	return
}

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

// ApplyToAll is a helper method to define mock.On call
//   - ctx context.Context
//   - webviews []port.WebView
func (_e *MockFilterApplier_Expecter) ApplyToAll(ctx interface{}, webviews interface{}) *MockFilterApplier_ApplyToAll_Call {
	return &MockFilterApplier_ApplyToAll_Call{Call: _e.mock.On("ApplyToAll", ctx, webviews)}
}

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

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

func (_c *MockFilterApplier_ApplyToAll_Call) RunAndReturn(run func(ctx context.Context, webviews []port.WebView)) *MockFilterApplier_ApplyToAll_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockFaviconDatabase is an autogenerated mock type for the FaviconDatabase type
type MockFaviconDatabase struct {
	mock.Mock
}

type MockFaviconDatabase_Expecter struct {
	mock *mock.Mock
}

func (_m *MockFaviconDatabase) EXPECT() *MockFaviconDatabase_Expecter {
	return &MockFaviconDatabase_Expecter{mock: &_m.Mock}
}

// GetFaviconAsync provides a mock function for the type MockFaviconDatabase
func (_mock *MockFaviconDatabase) GetFaviconAsync(pageURL string, callback func(port.Texture)) {
	_mock.Called(pageURL, callback)
	return
}

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

// GetFaviconAsync is a helper method to define mock.On call
//   - pageURL string
//   - callback func(port.Texture)
func (_e *MockFaviconDatabase_Expecter) GetFaviconAsync(pageURL interface{}, callback interface{}) *MockFaviconDatabase_GetFaviconAsync_Call {
	return &MockFaviconDatabase_GetFaviconAsync_Call{Call: _e.mock.On("GetFaviconAsync", pageURL, callback)}
}

func (_c *MockFaviconDatabase_GetFaviconAsync_Call) Run(run func(pageURL string, callback func(port.Texture))) *MockFaviconDatabase_GetFaviconAsync_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 func(port.Texture)
		if args[1] != nil {
			arg1 = args[1].(func(port.Texture))
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockFaviconDatabase_GetFaviconAsync_Call) RunAndReturn(run func(pageURL string, callback func(port.Texture))) *MockFaviconDatabase_GetFaviconAsync_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockScriptRefresher is an autogenerated mock type for the ScriptRefresher type
type MockScriptRefresher struct {
	mock.Mock
}

type MockScriptRefresher_Expecter struct {
	mock *mock.Mock
}

func (_m *MockScriptRefresher) EXPECT() *MockScriptRefresher_Expecter {
	return &MockScriptRefresher_Expecter{mock: &_m.Mock}
}

// RefreshAll provides a mock function for the type MockScriptRefresher
func (_mock *MockScriptRefresher) RefreshAll(ctx context.Context, webviews []port.WebView) {
	_mock.Called(ctx, webviews)
	return
}

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

// RefreshAll is a helper method to define mock.On call
//   - ctx context.Context
//   - webviews []port.WebView
func (_e *MockScriptRefresher_Expecter) RefreshAll(ctx interface{}, webviews interface{}) *MockScriptRefresher_RefreshAll_Call {
	return &MockScriptRefresher_RefreshAll_Call{Call: _e.mock.On("RefreshAll", ctx, webviews)}
}

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

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

func (_c *MockScriptRefresher_RefreshAll_Call) RunAndReturn(run func(ctx context.Context, webviews []port.WebView)) *MockScriptRefresher_RefreshAll_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockNativeWidgetProvider is an autogenerated mock type for the NativeWidgetProvider type
type MockNativeWidgetProvider struct {
	mock.Mock
}

type MockNativeWidgetProvider_Expecter struct {
	mock *mock.Mock
}

func (_m *MockNativeWidgetProvider) EXPECT() *MockNativeWidgetProvider_Expecter {
	return &MockNativeWidgetProvider_Expecter{mock: &_m.Mock}
}

// NativeWidget provides a mock function for the type MockNativeWidgetProvider
func (_mock *MockNativeWidgetProvider) NativeWidget() uintptr {
	ret := _mock.Called()

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

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

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

// NativeWidget is a helper method to define mock.On call
func (_e *MockNativeWidgetProvider_Expecter) NativeWidget() *MockNativeWidgetProvider_NativeWidget_Call {
	return &MockNativeWidgetProvider_NativeWidget_Call{Call: _e.mock.On("NativeWidget")}
}

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

func (_c *MockNativeWidgetProvider_NativeWidget_Call) Return(v uintptr) *MockNativeWidgetProvider_NativeWidget_Call {
	_c.Call.Return(v)
	return _c
}

func (_c *MockNativeWidgetProvider_NativeWidget_Call) RunAndReturn(run func() uintptr) *MockNativeWidgetProvider_NativeWidget_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockFaviconService is an autogenerated mock type for the FaviconService type
type MockFaviconService struct {
	mock.Mock
}

type MockFaviconService_Expecter struct {
	mock *mock.Mock
}

func (_m *MockFaviconService) EXPECT() *MockFaviconService_Expecter {
	return &MockFaviconService_Expecter{mock: &_m.Mock}
}

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

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

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

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

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

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

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

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

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

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

// DiskPathPNG is a helper method to define mock.On call
//   - domain string
func (_e *MockFaviconService_Expecter) DiskPathPNG(domain interface{}) *MockFaviconService_DiskPathPNG_Call {
	return &MockFaviconService_DiskPathPNG_Call{Call: _e.mock.On("DiskPathPNG", domain)}
}

func (_c *MockFaviconService_DiskPathPNG_Call) Run(run func(domain string)) *MockFaviconService_DiskPathPNG_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 *MockFaviconService_DiskPathPNG_Call) Return(s string) *MockFaviconService_DiskPathPNG_Call {
	_c.Call.Return(s)
	return _c
}

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

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

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

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

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

// EnsureCacheDir is a helper method to define mock.On call
func (_e *MockFaviconService_Expecter) EnsureCacheDir() *MockFaviconService_EnsureCacheDir_Call {
	return &MockFaviconService_EnsureCacheDir_Call{Call: _e.mock.On("EnsureCacheDir")}
}

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

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

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

// EnsureDiskCache provides a mock function for the type MockFaviconService
func (_mock *MockFaviconService) EnsureDiskCache(ctx context.Context, domain string) {
	_mock.Called(ctx, domain)
	return
}

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

// EnsureDiskCache is a helper method to define mock.On call
//   - ctx context.Context
//   - domain string
func (_e *MockFaviconService_Expecter) EnsureDiskCache(ctx interface{}, domain interface{}) *MockFaviconService_EnsureDiskCache_Call {
	return &MockFaviconService_EnsureDiskCache_Call{Call: _e.mock.On("EnsureDiskCache", ctx, domain)}
}

func (_c *MockFaviconService_EnsureDiskCache_Call) Run(run func(ctx context.Context, domain string)) *MockFaviconService_EnsureDiskCache_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)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockFaviconService_EnsureDiskCache_Call) RunAndReturn(run func(ctx context.Context, domain string)) *MockFaviconService_EnsureDiskCache_Call {
	_c.Run(run)
	return _c
}

// EnsureSizedPNG provides a mock function for the type MockFaviconService
func (_mock *MockFaviconService) EnsureSizedPNG(ctx context.Context, domain string, size int) error {
	ret := _mock.Called(ctx, domain, size)

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

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

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

// EnsureSizedPNG is a helper method to define mock.On call
//   - ctx context.Context
//   - domain string
//   - size int
func (_e *MockFaviconService_Expecter) EnsureSizedPNG(ctx interface{}, domain interface{}, size interface{}) *MockFaviconService_EnsureSizedPNG_Call {
	return &MockFaviconService_EnsureSizedPNG_Call{Call: _e.mock.On("EnsureSizedPNG", ctx, domain, size)}
}

func (_c *MockFaviconService_EnsureSizedPNG_Call) Run(run func(ctx context.Context, domain string, size int)) *MockFaviconService_EnsureSizedPNG_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 int
		if args[2] != nil {
			arg2 = args[2].(int)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockFaviconService_EnsureSizedPNG_Call) RunAndReturn(run func(ctx context.Context, domain string, size int) error) *MockFaviconService_EnsureSizedPNG_Call {
	_c.Call.Return(run)
	return _c
}

// Get provides a mock function for the type MockFaviconService
func (_mock *MockFaviconService) Get(ctx context.Context, domain string) ([]byte, error) {
	ret := _mock.Called(ctx, domain)

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

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

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

// Get is a helper method to define mock.On call
//   - ctx context.Context
//   - domain string
func (_e *MockFaviconService_Expecter) Get(ctx interface{}, domain interface{}) *MockFaviconService_Get_Call {
	return &MockFaviconService_Get_Call{Call: _e.mock.On("Get", ctx, domain)}
}

func (_c *MockFaviconService_Get_Call) Run(run func(ctx context.Context, domain string)) *MockFaviconService_Get_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)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockFaviconService_Get_Call) RunAndReturn(run func(ctx context.Context, domain string) ([]byte, error)) *MockFaviconService_Get_Call {
	_c.Call.Return(run)
	return _c
}

// GetCached provides a mock function for the type MockFaviconService
func (_mock *MockFaviconService) GetCached(domain string) ([]byte, bool) {
	ret := _mock.Called(domain)

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

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

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

// GetCached is a helper method to define mock.On call
//   - domain string
func (_e *MockFaviconService_Expecter) GetCached(domain interface{}) *MockFaviconService_GetCached_Call {
	return &MockFaviconService_GetCached_Call{Call: _e.mock.On("GetCached", domain)}
}

func (_c *MockFaviconService_GetCached_Call) Run(run func(domain string)) *MockFaviconService_GetCached_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 *MockFaviconService_GetCached_Call) Return(bytes []byte, b bool) *MockFaviconService_GetCached_Call {
	_c.Call.Return(bytes, b)
	return _c
}

func (_c *MockFaviconService_GetCached_Call) RunAndReturn(run func(domain string) ([]byte, bool)) *MockFaviconService_GetCached_Call {
	_c.Call.Return(run)
	return _c
}

// HasPNGOnDisk provides a mock function for the type MockFaviconService
func (_mock *MockFaviconService) HasPNGOnDisk(domain string) bool {
	ret := _mock.Called(domain)

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

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

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

// HasPNGOnDisk is a helper method to define mock.On call
//   - domain string
func (_e *MockFaviconService_Expecter) HasPNGOnDisk(domain interface{}) *MockFaviconService_HasPNGOnDisk_Call {
	return &MockFaviconService_HasPNGOnDisk_Call{Call: _e.mock.On("HasPNGOnDisk", domain)}
}

func (_c *MockFaviconService_HasPNGOnDisk_Call) Run(run func(domain string)) *MockFaviconService_HasPNGOnDisk_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 *MockFaviconService_HasPNGOnDisk_Call) Return(b bool) *MockFaviconService_HasPNGOnDisk_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockFaviconService_HasPNGOnDisk_Call) RunAndReturn(run func(domain string) bool) *MockFaviconService_HasPNGOnDisk_Call {
	_c.Call.Return(run)
	return _c
}

// HasPNGSizedOnDisk provides a mock function for the type MockFaviconService
func (_mock *MockFaviconService) HasPNGSizedOnDisk(domain string, size int) bool {
	ret := _mock.Called(domain, size)

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

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

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

// HasPNGSizedOnDisk is a helper method to define mock.On call
//   - domain string
//   - size int
func (_e *MockFaviconService_Expecter) HasPNGSizedOnDisk(domain interface{}, size interface{}) *MockFaviconService_HasPNGSizedOnDisk_Call {
	return &MockFaviconService_HasPNGSizedOnDisk_Call{Call: _e.mock.On("HasPNGSizedOnDisk", domain, size)}
}

func (_c *MockFaviconService_HasPNGSizedOnDisk_Call) Run(run func(domain string, size int)) *MockFaviconService_HasPNGSizedOnDisk_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockFaviconService_HasPNGSizedOnDisk_Call) RunAndReturn(run func(domain string, size int) bool) *MockFaviconService_HasPNGSizedOnDisk_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockFileSystem is an autogenerated mock type for the FileSystem type
type MockFileSystem struct {
	mock.Mock
}

type MockFileSystem_Expecter struct {
	mock *mock.Mock
}

func (_m *MockFileSystem) EXPECT() *MockFileSystem_Expecter {
	return &MockFileSystem_Expecter{mock: &_m.Mock}
}

// Exists provides a mock function for the type MockFileSystem
func (_mock *MockFileSystem) Exists(ctx context.Context, path string) (bool, error) {
	ret := _mock.Called(ctx, path)

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

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

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

// Exists is a helper method to define mock.On call
//   - ctx context.Context
//   - path string
func (_e *MockFileSystem_Expecter) Exists(ctx interface{}, path interface{}) *MockFileSystem_Exists_Call {
	return &MockFileSystem_Exists_Call{Call: _e.mock.On("Exists", ctx, path)}
}

func (_c *MockFileSystem_Exists_Call) Run(run func(ctx context.Context, path string)) *MockFileSystem_Exists_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)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockFileSystem_Exists_Call) RunAndReturn(run func(ctx context.Context, path string) (bool, error)) *MockFileSystem_Exists_Call {
	_c.Call.Return(run)
	return _c
}

// GetSize provides a mock function for the type MockFileSystem
func (_mock *MockFileSystem) GetSize(ctx context.Context, path string) (int64, error) {
	ret := _mock.Called(ctx, path)

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

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

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

// GetSize is a helper method to define mock.On call
//   - ctx context.Context
//   - path string
func (_e *MockFileSystem_Expecter) GetSize(ctx interface{}, path interface{}) *MockFileSystem_GetSize_Call {
	return &MockFileSystem_GetSize_Call{Call: _e.mock.On("GetSize", ctx, path)}
}

func (_c *MockFileSystem_GetSize_Call) Run(run func(ctx context.Context, path string)) *MockFileSystem_GetSize_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)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockFileSystem_GetSize_Call) Return(n int64, err error) *MockFileSystem_GetSize_Call {
	_c.Call.Return(n, err)
	return _c
}

func (_c *MockFileSystem_GetSize_Call) RunAndReturn(run func(ctx context.Context, path string) (int64, error)) *MockFileSystem_GetSize_Call {
	_c.Call.Return(run)
	return _c
}

// IsDirectory provides a mock function for the type MockFileSystem
func (_mock *MockFileSystem) IsDirectory(ctx context.Context, path string) (bool, error) {
	ret := _mock.Called(ctx, path)

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

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

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

// IsDirectory is a helper method to define mock.On call
//   - ctx context.Context
//   - path string
func (_e *MockFileSystem_Expecter) IsDirectory(ctx interface{}, path interface{}) *MockFileSystem_IsDirectory_Call {
	return &MockFileSystem_IsDirectory_Call{Call: _e.mock.On("IsDirectory", ctx, path)}
}

func (_c *MockFileSystem_IsDirectory_Call) Run(run func(ctx context.Context, path string)) *MockFileSystem_IsDirectory_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)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockFileSystem_IsDirectory_Call) RunAndReturn(run func(ctx context.Context, path string) (bool, error)) *MockFileSystem_IsDirectory_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveAll provides a mock function for the type MockFileSystem
func (_mock *MockFileSystem) RemoveAll(ctx context.Context, path string) error {
	ret := _mock.Called(ctx, path)

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

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

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

// RemoveAll is a helper method to define mock.On call
//   - ctx context.Context
//   - path string
func (_e *MockFileSystem_Expecter) RemoveAll(ctx interface{}, path interface{}) *MockFileSystem_RemoveAll_Call {
	return &MockFileSystem_RemoveAll_Call{Call: _e.mock.On("RemoveAll", ctx, path)}
}

func (_c *MockFileSystem_RemoveAll_Call) Run(run func(ctx context.Context, path string)) *MockFileSystem_RemoveAll_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)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockFileSystem_RemoveAll_Call) RunAndReturn(run func(ctx context.Context, path string) error) *MockFileSystem_RemoveAll_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockFilterManager is an autogenerated mock type for the FilterManager type
type MockFilterManager struct {
	mock.Mock
}

type MockFilterManager_Expecter struct {
	mock *mock.Mock
}

func (_m *MockFilterManager) EXPECT() *MockFilterManager_Expecter {
	return &MockFilterManager_Expecter{mock: &_m.Mock}
}

// LoadAsync provides a mock function for the type MockFilterManager
func (_mock *MockFilterManager) LoadAsync(ctx context.Context) {
	_mock.Called(ctx)
	return
}

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

// LoadAsync is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockFilterManager_Expecter) LoadAsync(ctx interface{}) *MockFilterManager_LoadAsync_Call {
	return &MockFilterManager_LoadAsync_Call{Call: _e.mock.On("LoadAsync", ctx)}
}

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

func (_c *MockFilterManager_LoadAsync_Call) RunAndReturn(run func(ctx context.Context)) *MockFilterManager_LoadAsync_Call {
	_c.Run(run)
	return _c
}

// SetStatusCallback provides a mock function for the type MockFilterManager
func (_mock *MockFilterManager) SetStatusCallback(fn func(port.FilterStatus)) {
	_mock.Called(fn)
	return
}

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

// SetStatusCallback is a helper method to define mock.On call
//   - fn func(port.FilterStatus)
func (_e *MockFilterManager_Expecter) SetStatusCallback(fn interface{}) *MockFilterManager_SetStatusCallback_Call {
	return &MockFilterManager_SetStatusCallback_Call{Call: _e.mock.On("SetStatusCallback", fn)}
}

func (_c *MockFilterManager_SetStatusCallback_Call) Run(run func(fn func(port.FilterStatus))) *MockFilterManager_SetStatusCallback_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 func(port.FilterStatus)
		if args[0] != nil {
			arg0 = args[0].(func(port.FilterStatus))
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockFilterManager_SetStatusCallback_Call) RunAndReturn(run func(fn func(port.FilterStatus))) *MockFilterManager_SetStatusCallback_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockFontDetector is an autogenerated mock type for the FontDetector type
type MockFontDetector struct {
	mock.Mock
}

type MockFontDetector_Expecter struct {
	mock *mock.Mock
}

func (_m *MockFontDetector) EXPECT() *MockFontDetector_Expecter {
	return &MockFontDetector_Expecter{mock: &_m.Mock}
}

// GetAvailableFonts provides a mock function for the type MockFontDetector
func (_mock *MockFontDetector) GetAvailableFonts(ctx context.Context) ([]string, error) {
	ret := _mock.Called(ctx)

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

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

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

// GetAvailableFonts is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockFontDetector_Expecter) GetAvailableFonts(ctx interface{}) *MockFontDetector_GetAvailableFonts_Call {
	return &MockFontDetector_GetAvailableFonts_Call{Call: _e.mock.On("GetAvailableFonts", ctx)}
}

func (_c *MockFontDetector_GetAvailableFonts_Call) Run(run func(ctx context.Context)) *MockFontDetector_GetAvailableFonts_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 *MockFontDetector_GetAvailableFonts_Call) Return(strings []string, err error) *MockFontDetector_GetAvailableFonts_Call {
	_c.Call.Return(strings, err)
	return _c
}

func (_c *MockFontDetector_GetAvailableFonts_Call) RunAndReturn(run func(ctx context.Context) ([]string, error)) *MockFontDetector_GetAvailableFonts_Call {
	_c.Call.Return(run)
	return _c
}

// IsAvailable provides a mock function for the type MockFontDetector
func (_mock *MockFontDetector) IsAvailable(ctx context.Context) bool {
	ret := _mock.Called(ctx)

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

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

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

// IsAvailable is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockFontDetector_Expecter) IsAvailable(ctx interface{}) *MockFontDetector_IsAvailable_Call {
	return &MockFontDetector_IsAvailable_Call{Call: _e.mock.On("IsAvailable", ctx)}
}

func (_c *MockFontDetector_IsAvailable_Call) Run(run func(ctx context.Context)) *MockFontDetector_IsAvailable_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 *MockFontDetector_IsAvailable_Call) Return(b bool) *MockFontDetector_IsAvailable_Call {
	_c.Call.Return(b)
	return _c
}

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

// SelectBestFont provides a mock function for the type MockFontDetector
func (_mock *MockFontDetector) SelectBestFont(ctx context.Context, category port.FontCategory, fallbackChain []string) string {
	ret := _mock.Called(ctx, category, fallbackChain)

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func(context.Context, port.FontCategory, []string) string); ok {
		r0 = returnFunc(ctx, category, fallbackChain)
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

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

// SelectBestFont is a helper method to define mock.On call
//   - ctx context.Context
//   - category port.FontCategory
//   - fallbackChain []string
func (_e *MockFontDetector_Expecter) SelectBestFont(ctx interface{}, category interface{}, fallbackChain interface{}) *MockFontDetector_SelectBestFont_Call {
	return &MockFontDetector_SelectBestFont_Call{Call: _e.mock.On("SelectBestFont", ctx, category, fallbackChain)}
}

func (_c *MockFontDetector_SelectBestFont_Call) Run(run func(ctx context.Context, category port.FontCategory, fallbackChain []string)) *MockFontDetector_SelectBestFont_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 port.FontCategory
		if args[1] != nil {
			arg1 = args[1].(port.FontCategory)
		}
		var arg2 []string
		if args[2] != nil {
			arg2 = args[2].([]string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockFontDetector_SelectBestFont_Call) RunAndReturn(run func(ctx context.Context, category port.FontCategory, fallbackChain []string) string) *MockFontDetector_SelectBestFont_Call {
	_c.Call.Return(run)
	return _c
}

// 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 interface{}, char interface{}, shiftHeld interface{}) *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 interface{}, char interface{}) *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 interface{}, input interface{}) *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
}

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

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

	return mock
}

// MockHardwareSurveyor is an autogenerated mock type for the HardwareSurveyor type
type MockHardwareSurveyor struct {
	mock.Mock
}

type MockHardwareSurveyor_Expecter struct {
	mock *mock.Mock
}

func (_m *MockHardwareSurveyor) EXPECT() *MockHardwareSurveyor_Expecter {
	return &MockHardwareSurveyor_Expecter{mock: &_m.Mock}
}

// Survey provides a mock function for the type MockHardwareSurveyor
func (_mock *MockHardwareSurveyor) Survey(ctx context.Context) port.HardwareInfo {
	ret := _mock.Called(ctx)

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

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

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

// Survey is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockHardwareSurveyor_Expecter) Survey(ctx interface{}) *MockHardwareSurveyor_Survey_Call {
	return &MockHardwareSurveyor_Survey_Call{Call: _e.mock.On("Survey", ctx)}
}

func (_c *MockHardwareSurveyor_Survey_Call) Run(run func(ctx context.Context)) *MockHardwareSurveyor_Survey_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 *MockHardwareSurveyor_Survey_Call) Return(hardwareInfo port.HardwareInfo) *MockHardwareSurveyor_Survey_Call {
	_c.Call.Return(hardwareInfo)
	return _c
}

func (_c *MockHardwareSurveyor_Survey_Call) RunAndReturn(run func(ctx context.Context) port.HardwareInfo) *MockHardwareSurveyor_Survey_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockHomepageHistory is an autogenerated mock type for the HomepageHistory type
type MockHomepageHistory struct {
	mock.Mock
}

type MockHomepageHistory_Expecter struct {
	mock *mock.Mock
}

func (_m *MockHomepageHistory) EXPECT() *MockHomepageHistory_Expecter {
	return &MockHomepageHistory_Expecter{mock: &_m.Mock}
}

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

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

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

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

// ClearAll is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockHomepageHistory_Expecter) ClearAll(ctx interface{}) *MockHomepageHistory_ClearAll_Call {
	return &MockHomepageHistory_ClearAll_Call{Call: _e.mock.On("ClearAll", ctx)}
}

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

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

// ClearOlderThan provides a mock function for the type MockHomepageHistory
func (_mock *MockHomepageHistory) ClearOlderThan(ctx context.Context, before time.Time) error {
	ret := _mock.Called(ctx, before)

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

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

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

// ClearOlderThan is a helper method to define mock.On call
//   - ctx context.Context
//   - before time.Time
func (_e *MockHomepageHistory_Expecter) ClearOlderThan(ctx interface{}, before interface{}) *MockHomepageHistory_ClearOlderThan_Call {
	return &MockHomepageHistory_ClearOlderThan_Call{Call: _e.mock.On("ClearOlderThan", ctx, before)}
}

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

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

func (_c *MockHomepageHistory_ClearOlderThan_Call) RunAndReturn(run func(ctx context.Context, before time.Time) error) *MockHomepageHistory_ClearOlderThan_Call {
	_c.Call.Return(run)
	return _c
}

// Delete provides a mock function for the type MockHomepageHistory
func (_mock *MockHomepageHistory) Delete(ctx context.Context, id int64) error {
	ret := _mock.Called(ctx, id)

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

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

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - id int64
func (_e *MockHomepageHistory_Expecter) Delete(ctx interface{}, id interface{}) *MockHomepageHistory_Delete_Call {
	return &MockHomepageHistory_Delete_Call{Call: _e.mock.On("Delete", ctx, id)}
}

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

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

func (_c *MockHomepageHistory_Delete_Call) RunAndReturn(run func(ctx context.Context, id int64) error) *MockHomepageHistory_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteByDomain provides a mock function for the type MockHomepageHistory
func (_mock *MockHomepageHistory) DeleteByDomain(ctx context.Context, domain string) error {
	ret := _mock.Called(ctx, domain)

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

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

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

// DeleteByDomain is a helper method to define mock.On call
//   - ctx context.Context
//   - domain string
func (_e *MockHomepageHistory_Expecter) DeleteByDomain(ctx interface{}, domain interface{}) *MockHomepageHistory_DeleteByDomain_Call {
	return &MockHomepageHistory_DeleteByDomain_Call{Call: _e.mock.On("DeleteByDomain", ctx, domain)}
}

func (_c *MockHomepageHistory_DeleteByDomain_Call) Run(run func(ctx context.Context, domain string)) *MockHomepageHistory_DeleteByDomain_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)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockHomepageHistory_DeleteByDomain_Call) RunAndReturn(run func(ctx context.Context, domain string) error) *MockHomepageHistory_DeleteByDomain_Call {
	_c.Call.Return(run)
	return _c
}

// GetAnalytics provides a mock function for the type MockHomepageHistory
func (_mock *MockHomepageHistory) GetAnalytics(ctx context.Context) (*entity.HistoryAnalytics, error) {
	ret := _mock.Called(ctx)

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

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

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

// GetAnalytics is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockHomepageHistory_Expecter) GetAnalytics(ctx interface{}) *MockHomepageHistory_GetAnalytics_Call {
	return &MockHomepageHistory_GetAnalytics_Call{Call: _e.mock.On("GetAnalytics", ctx)}
}

func (_c *MockHomepageHistory_GetAnalytics_Call) Run(run func(ctx context.Context)) *MockHomepageHistory_GetAnalytics_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 *MockHomepageHistory_GetAnalytics_Call) Return(historyAnalytics *entity.HistoryAnalytics, err error) *MockHomepageHistory_GetAnalytics_Call {
	_c.Call.Return(historyAnalytics, err)
	return _c
}

func (_c *MockHomepageHistory_GetAnalytics_Call) RunAndReturn(run func(ctx context.Context) (*entity.HistoryAnalytics, error)) *MockHomepageHistory_GetAnalytics_Call {
	_c.Call.Return(run)
	return _c
}

// GetDomainStats provides a mock function for the type MockHomepageHistory
func (_mock *MockHomepageHistory) GetDomainStats(ctx context.Context, limit int) ([]*entity.DomainStat, error) {
	ret := _mock.Called(ctx, limit)

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

	var r0 []*entity.DomainStat
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]*entity.DomainStat, error)); ok {
		return returnFunc(ctx, limit)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, int) []*entity.DomainStat); ok {
		r0 = returnFunc(ctx, limit)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.DomainStat)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
		r1 = returnFunc(ctx, limit)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetDomainStats is a helper method to define mock.On call
//   - ctx context.Context
//   - limit int
func (_e *MockHomepageHistory_Expecter) GetDomainStats(ctx interface{}, limit interface{}) *MockHomepageHistory_GetDomainStats_Call {
	return &MockHomepageHistory_GetDomainStats_Call{Call: _e.mock.On("GetDomainStats", ctx, limit)}
}

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

func (_c *MockHomepageHistory_GetDomainStats_Call) Return(domainStats []*entity.DomainStat, err error) *MockHomepageHistory_GetDomainStats_Call {
	_c.Call.Return(domainStats, err)
	return _c
}

func (_c *MockHomepageHistory_GetDomainStats_Call) RunAndReturn(run func(ctx context.Context, limit int) ([]*entity.DomainStat, error)) *MockHomepageHistory_GetDomainStats_Call {
	_c.Call.Return(run)
	return _c
}

// GetRecent provides a mock function for the type MockHomepageHistory
func (_mock *MockHomepageHistory) GetRecent(ctx context.Context, limit int, offset int) ([]*entity.HistoryEntry, error) {
	ret := _mock.Called(ctx, limit, offset)

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

	var r0 []*entity.HistoryEntry
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, int, int) ([]*entity.HistoryEntry, error)); ok {
		return returnFunc(ctx, limit, offset)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, int, int) []*entity.HistoryEntry); ok {
		r0 = returnFunc(ctx, limit, offset)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.HistoryEntry)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, int, int) error); ok {
		r1 = returnFunc(ctx, limit, offset)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetRecent is a helper method to define mock.On call
//   - ctx context.Context
//   - limit int
//   - offset int
func (_e *MockHomepageHistory_Expecter) GetRecent(ctx interface{}, limit interface{}, offset interface{}) *MockHomepageHistory_GetRecent_Call {
	return &MockHomepageHistory_GetRecent_Call{Call: _e.mock.On("GetRecent", ctx, limit, offset)}
}

func (_c *MockHomepageHistory_GetRecent_Call) Run(run func(ctx context.Context, limit int, offset int)) *MockHomepageHistory_GetRecent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		var arg2 int
		if args[2] != nil {
			arg2 = args[2].(int)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockHomepageHistory_GetRecent_Call) Return(historyEntrys []*entity.HistoryEntry, err error) *MockHomepageHistory_GetRecent_Call {
	_c.Call.Return(historyEntrys, err)
	return _c
}

func (_c *MockHomepageHistory_GetRecent_Call) RunAndReturn(run func(ctx context.Context, limit int, offset int) ([]*entity.HistoryEntry, error)) *MockHomepageHistory_GetRecent_Call {
	_c.Call.Return(run)
	return _c
}

// Search provides a mock function for the type MockHomepageHistory
func (_mock *MockHomepageHistory) Search(ctx context.Context, input port.HistorySearchInput) (*port.HistorySearchOutput, error) {
	ret := _mock.Called(ctx, input)

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

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

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

// Search is a helper method to define mock.On call
//   - ctx context.Context
//   - input port.HistorySearchInput
func (_e *MockHomepageHistory_Expecter) Search(ctx interface{}, input interface{}) *MockHomepageHistory_Search_Call {
	return &MockHomepageHistory_Search_Call{Call: _e.mock.On("Search", ctx, input)}
}

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

func (_c *MockHomepageHistory_Search_Call) Return(historySearchOutput *port.HistorySearchOutput, err error) *MockHomepageHistory_Search_Call {
	_c.Call.Return(historySearchOutput, err)
	return _c
}

func (_c *MockHomepageHistory_Search_Call) RunAndReturn(run func(ctx context.Context, input port.HistorySearchInput) (*port.HistorySearchOutput, error)) *MockHomepageHistory_Search_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockHomepageFavorites is an autogenerated mock type for the HomepageFavorites type
type MockHomepageFavorites struct {
	mock.Mock
}

type MockHomepageFavorites_Expecter struct {
	mock *mock.Mock
}

func (_m *MockHomepageFavorites) EXPECT() *MockHomepageFavorites_Expecter {
	return &MockHomepageFavorites_Expecter{mock: &_m.Mock}
}

// AddTag provides a mock function for the type MockHomepageFavorites
func (_mock *MockHomepageFavorites) AddTag(ctx context.Context, name string, color string) (*entity.Tag, error) {
	ret := _mock.Called(ctx, name, color)

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

	var r0 *entity.Tag
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*entity.Tag, error)); ok {
		return returnFunc(ctx, name, color)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *entity.Tag); ok {
		r0 = returnFunc(ctx, name, color)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.Tag)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, name, color)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddTag is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
//   - color string
func (_e *MockHomepageFavorites_Expecter) AddTag(ctx interface{}, name interface{}, color interface{}) *MockHomepageFavorites_AddTag_Call {
	return &MockHomepageFavorites_AddTag_Call{Call: _e.mock.On("AddTag", ctx, name, color)}
}

func (_c *MockHomepageFavorites_AddTag_Call) Run(run func(ctx context.Context, name string, color string)) *MockHomepageFavorites_AddTag_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockHomepageFavorites_AddTag_Call) Return(tag *entity.Tag, err error) *MockHomepageFavorites_AddTag_Call {
	_c.Call.Return(tag, err)
	return _c
}

func (_c *MockHomepageFavorites_AddTag_Call) RunAndReturn(run func(ctx context.Context, name string, color string) (*entity.Tag, error)) *MockHomepageFavorites_AddTag_Call {
	_c.Call.Return(run)
	return _c
}

// CreateFolder provides a mock function for the type MockHomepageFavorites
func (_mock *MockHomepageFavorites) CreateFolder(ctx context.Context, name string, parentID *entity.FolderID) (*entity.Folder, error) {
	ret := _mock.Called(ctx, name, parentID)

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

	var r0 *entity.Folder
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *entity.FolderID) (*entity.Folder, error)); ok {
		return returnFunc(ctx, name, parentID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *entity.FolderID) *entity.Folder); ok {
		r0 = returnFunc(ctx, name, parentID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.Folder)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *entity.FolderID) error); ok {
		r1 = returnFunc(ctx, name, parentID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreateFolder is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
//   - parentID *entity.FolderID
func (_e *MockHomepageFavorites_Expecter) CreateFolder(ctx interface{}, name interface{}, parentID interface{}) *MockHomepageFavorites_CreateFolder_Call {
	return &MockHomepageFavorites_CreateFolder_Call{Call: _e.mock.On("CreateFolder", ctx, name, parentID)}
}

func (_c *MockHomepageFavorites_CreateFolder_Call) Run(run func(ctx context.Context, name string, parentID *entity.FolderID)) *MockHomepageFavorites_CreateFolder_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 *entity.FolderID
		if args[2] != nil {
			arg2 = args[2].(*entity.FolderID)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockHomepageFavorites_CreateFolder_Call) Return(folder *entity.Folder, err error) *MockHomepageFavorites_CreateFolder_Call {
	_c.Call.Return(folder, err)
	return _c
}

func (_c *MockHomepageFavorites_CreateFolder_Call) RunAndReturn(run func(ctx context.Context, name string, parentID *entity.FolderID) (*entity.Folder, error)) *MockHomepageFavorites_CreateFolder_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteFolder provides a mock function for the type MockHomepageFavorites
func (_mock *MockHomepageFavorites) DeleteFolder(ctx context.Context, id entity.FolderID) error {
	ret := _mock.Called(ctx, id)

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

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

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

// DeleteFolder is a helper method to define mock.On call
//   - ctx context.Context
//   - id entity.FolderID
func (_e *MockHomepageFavorites_Expecter) DeleteFolder(ctx interface{}, id interface{}) *MockHomepageFavorites_DeleteFolder_Call {
	return &MockHomepageFavorites_DeleteFolder_Call{Call: _e.mock.On("DeleteFolder", ctx, id)}
}

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

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

func (_c *MockHomepageFavorites_DeleteFolder_Call) RunAndReturn(run func(ctx context.Context, id entity.FolderID) error) *MockHomepageFavorites_DeleteFolder_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTag provides a mock function for the type MockHomepageFavorites
func (_mock *MockHomepageFavorites) DeleteTag(ctx context.Context, id entity.TagID) error {
	ret := _mock.Called(ctx, id)

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

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

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

// DeleteTag is a helper method to define mock.On call
//   - ctx context.Context
//   - id entity.TagID
func (_e *MockHomepageFavorites_Expecter) DeleteTag(ctx interface{}, id interface{}) *MockHomepageFavorites_DeleteTag_Call {
	return &MockHomepageFavorites_DeleteTag_Call{Call: _e.mock.On("DeleteTag", ctx, id)}
}

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

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

func (_c *MockHomepageFavorites_DeleteTag_Call) RunAndReturn(run func(ctx context.Context, id entity.TagID) error) *MockHomepageFavorites_DeleteTag_Call {
	_c.Call.Return(run)
	return _c
}

// GetAll provides a mock function for the type MockHomepageFavorites
func (_mock *MockHomepageFavorites) GetAll(ctx context.Context) ([]*entity.Favorite, error) {
	ret := _mock.Called(ctx)

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

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

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

// GetAll is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockHomepageFavorites_Expecter) GetAll(ctx interface{}) *MockHomepageFavorites_GetAll_Call {
	return &MockHomepageFavorites_GetAll_Call{Call: _e.mock.On("GetAll", ctx)}
}

func (_c *MockHomepageFavorites_GetAll_Call) Run(run func(ctx context.Context)) *MockHomepageFavorites_GetAll_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 *MockHomepageFavorites_GetAll_Call) Return(favorites []*entity.Favorite, err error) *MockHomepageFavorites_GetAll_Call {
	_c.Call.Return(favorites, err)
	return _c
}

func (_c *MockHomepageFavorites_GetAll_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.Favorite, error)) *MockHomepageFavorites_GetAll_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllFolders provides a mock function for the type MockHomepageFavorites
func (_mock *MockHomepageFavorites) GetAllFolders(ctx context.Context) ([]*entity.Folder, error) {
	ret := _mock.Called(ctx)

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

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

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

// GetAllFolders is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockHomepageFavorites_Expecter) GetAllFolders(ctx interface{}) *MockHomepageFavorites_GetAllFolders_Call {
	return &MockHomepageFavorites_GetAllFolders_Call{Call: _e.mock.On("GetAllFolders", ctx)}
}

func (_c *MockHomepageFavorites_GetAllFolders_Call) Run(run func(ctx context.Context)) *MockHomepageFavorites_GetAllFolders_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 *MockHomepageFavorites_GetAllFolders_Call) Return(folders []*entity.Folder, err error) *MockHomepageFavorites_GetAllFolders_Call {
	_c.Call.Return(folders, err)
	return _c
}

func (_c *MockHomepageFavorites_GetAllFolders_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.Folder, error)) *MockHomepageFavorites_GetAllFolders_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllTags provides a mock function for the type MockHomepageFavorites
func (_mock *MockHomepageFavorites) GetAllTags(ctx context.Context) ([]*entity.Tag, error) {
	ret := _mock.Called(ctx)

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

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

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

// GetAllTags is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockHomepageFavorites_Expecter) GetAllTags(ctx interface{}) *MockHomepageFavorites_GetAllTags_Call {
	return &MockHomepageFavorites_GetAllTags_Call{Call: _e.mock.On("GetAllTags", ctx)}
}

func (_c *MockHomepageFavorites_GetAllTags_Call) Run(run func(ctx context.Context)) *MockHomepageFavorites_GetAllTags_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 *MockHomepageFavorites_GetAllTags_Call) Return(tags []*entity.Tag, err error) *MockHomepageFavorites_GetAllTags_Call {
	_c.Call.Return(tags, err)
	return _c
}

func (_c *MockHomepageFavorites_GetAllTags_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.Tag, error)) *MockHomepageFavorites_GetAllTags_Call {
	_c.Call.Return(run)
	return _c
}

// GetByShortcut provides a mock function for the type MockHomepageFavorites
func (_mock *MockHomepageFavorites) GetByShortcut(ctx context.Context, key int) (*entity.Favorite, error) {
	ret := _mock.Called(ctx, key)

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

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

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

// GetByShortcut is a helper method to define mock.On call
//   - ctx context.Context
//   - key int
func (_e *MockHomepageFavorites_Expecter) GetByShortcut(ctx interface{}, key interface{}) *MockHomepageFavorites_GetByShortcut_Call {
	return &MockHomepageFavorites_GetByShortcut_Call{Call: _e.mock.On("GetByShortcut", ctx, key)}
}

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

func (_c *MockHomepageFavorites_GetByShortcut_Call) Return(favorite *entity.Favorite, err error) *MockHomepageFavorites_GetByShortcut_Call {
	_c.Call.Return(favorite, err)
	return _c
}

func (_c *MockHomepageFavorites_GetByShortcut_Call) RunAndReturn(run func(ctx context.Context, key int) (*entity.Favorite, error)) *MockHomepageFavorites_GetByShortcut_Call {
	_c.Call.Return(run)
	return _c
}

// Move provides a mock function for the type MockHomepageFavorites
func (_mock *MockHomepageFavorites) Move(ctx context.Context, id entity.FavoriteID, folderID *entity.FolderID) error {
	ret := _mock.Called(ctx, id, folderID)

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

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

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

// Move is a helper method to define mock.On call
//   - ctx context.Context
//   - id entity.FavoriteID
//   - folderID *entity.FolderID
func (_e *MockHomepageFavorites_Expecter) Move(ctx interface{}, id interface{}, folderID interface{}) *MockHomepageFavorites_Move_Call {
	return &MockHomepageFavorites_Move_Call{Call: _e.mock.On("Move", ctx, id, folderID)}
}

func (_c *MockHomepageFavorites_Move_Call) Run(run func(ctx context.Context, id entity.FavoriteID, folderID *entity.FolderID)) *MockHomepageFavorites_Move_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 entity.FavoriteID
		if args[1] != nil {
			arg1 = args[1].(entity.FavoriteID)
		}
		var arg2 *entity.FolderID
		if args[2] != nil {
			arg2 = args[2].(*entity.FolderID)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockHomepageFavorites_Move_Call) RunAndReturn(run func(ctx context.Context, id entity.FavoriteID, folderID *entity.FolderID) error) *MockHomepageFavorites_Move_Call {
	_c.Call.Return(run)
	return _c
}

// SetShortcut provides a mock function for the type MockHomepageFavorites
func (_mock *MockHomepageFavorites) SetShortcut(ctx context.Context, id entity.FavoriteID, key *int) error {
	ret := _mock.Called(ctx, id, key)

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

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

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

// SetShortcut is a helper method to define mock.On call
//   - ctx context.Context
//   - id entity.FavoriteID
//   - key *int
func (_e *MockHomepageFavorites_Expecter) SetShortcut(ctx interface{}, id interface{}, key interface{}) *MockHomepageFavorites_SetShortcut_Call {
	return &MockHomepageFavorites_SetShortcut_Call{Call: _e.mock.On("SetShortcut", ctx, id, key)}
}

func (_c *MockHomepageFavorites_SetShortcut_Call) Run(run func(ctx context.Context, id entity.FavoriteID, key *int)) *MockHomepageFavorites_SetShortcut_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 entity.FavoriteID
		if args[1] != nil {
			arg1 = args[1].(entity.FavoriteID)
		}
		var arg2 *int
		if args[2] != nil {
			arg2 = args[2].(*int)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockHomepageFavorites_SetShortcut_Call) RunAndReturn(run func(ctx context.Context, id entity.FavoriteID, key *int) error) *MockHomepageFavorites_SetShortcut_Call {
	_c.Call.Return(run)
	return _c
}

// TagFavorite provides a mock function for the type MockHomepageFavorites
func (_mock *MockHomepageFavorites) TagFavorite(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID) error {
	ret := _mock.Called(ctx, favID, tagID)

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

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

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

// TagFavorite is a helper method to define mock.On call
//   - ctx context.Context
//   - favID entity.FavoriteID
//   - tagID entity.TagID
func (_e *MockHomepageFavorites_Expecter) TagFavorite(ctx interface{}, favID interface{}, tagID interface{}) *MockHomepageFavorites_TagFavorite_Call {
	return &MockHomepageFavorites_TagFavorite_Call{Call: _e.mock.On("TagFavorite", ctx, favID, tagID)}
}

func (_c *MockHomepageFavorites_TagFavorite_Call) Run(run func(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID)) *MockHomepageFavorites_TagFavorite_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 entity.FavoriteID
		if args[1] != nil {
			arg1 = args[1].(entity.FavoriteID)
		}
		var arg2 entity.TagID
		if args[2] != nil {
			arg2 = args[2].(entity.TagID)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockHomepageFavorites_TagFavorite_Call) RunAndReturn(run func(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID) error) *MockHomepageFavorites_TagFavorite_Call {
	_c.Call.Return(run)
	return _c
}

// UntagFavorite provides a mock function for the type MockHomepageFavorites
func (_mock *MockHomepageFavorites) UntagFavorite(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID) error {
	ret := _mock.Called(ctx, favID, tagID)

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

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

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

// UntagFavorite is a helper method to define mock.On call
//   - ctx context.Context
//   - favID entity.FavoriteID
//   - tagID entity.TagID
func (_e *MockHomepageFavorites_Expecter) UntagFavorite(ctx interface{}, favID interface{}, tagID interface{}) *MockHomepageFavorites_UntagFavorite_Call {
	return &MockHomepageFavorites_UntagFavorite_Call{Call: _e.mock.On("UntagFavorite", ctx, favID, tagID)}
}

func (_c *MockHomepageFavorites_UntagFavorite_Call) Run(run func(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID)) *MockHomepageFavorites_UntagFavorite_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 entity.FavoriteID
		if args[1] != nil {
			arg1 = args[1].(entity.FavoriteID)
		}
		var arg2 entity.TagID
		if args[2] != nil {
			arg2 = args[2].(entity.TagID)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockHomepageFavorites_UntagFavorite_Call) RunAndReturn(run func(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID) error) *MockHomepageFavorites_UntagFavorite_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateFolder provides a mock function for the type MockHomepageFavorites
func (_mock *MockHomepageFavorites) UpdateFolder(ctx context.Context, id entity.FolderID, name string, icon string) error {
	ret := _mock.Called(ctx, id, name, icon)

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

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

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

// UpdateFolder is a helper method to define mock.On call
//   - ctx context.Context
//   - id entity.FolderID
//   - name string
//   - icon string
func (_e *MockHomepageFavorites_Expecter) UpdateFolder(ctx interface{}, id interface{}, name interface{}, icon interface{}) *MockHomepageFavorites_UpdateFolder_Call {
	return &MockHomepageFavorites_UpdateFolder_Call{Call: _e.mock.On("UpdateFolder", ctx, id, name, icon)}
}

func (_c *MockHomepageFavorites_UpdateFolder_Call) Run(run func(ctx context.Context, id entity.FolderID, name string, icon string)) *MockHomepageFavorites_UpdateFolder_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 entity.FolderID
		if args[1] != nil {
			arg1 = args[1].(entity.FolderID)
		}
		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 *MockHomepageFavorites_UpdateFolder_Call) Return(err error) *MockHomepageFavorites_UpdateFolder_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockHomepageFavorites_UpdateFolder_Call) RunAndReturn(run func(ctx context.Context, id entity.FolderID, name string, icon string) error) *MockHomepageFavorites_UpdateFolder_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTag provides a mock function for the type MockHomepageFavorites
func (_mock *MockHomepageFavorites) UpdateTag(ctx context.Context, id entity.TagID, name string, color string) error {
	ret := _mock.Called(ctx, id, name, color)

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

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

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

// UpdateTag is a helper method to define mock.On call
//   - ctx context.Context
//   - id entity.TagID
//   - name string
//   - color string
func (_e *MockHomepageFavorites_Expecter) UpdateTag(ctx interface{}, id interface{}, name interface{}, color interface{}) *MockHomepageFavorites_UpdateTag_Call {
	return &MockHomepageFavorites_UpdateTag_Call{Call: _e.mock.On("UpdateTag", ctx, id, name, color)}
}

func (_c *MockHomepageFavorites_UpdateTag_Call) Run(run func(ctx context.Context, id entity.TagID, name string, color string)) *MockHomepageFavorites_UpdateTag_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 entity.TagID
		if args[1] != nil {
			arg1 = args[1].(entity.TagID)
		}
		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 *MockHomepageFavorites_UpdateTag_Call) Return(err error) *MockHomepageFavorites_UpdateTag_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockHomepageFavorites_UpdateTag_Call) RunAndReturn(run func(ctx context.Context, id entity.TagID, name string, color string) error) *MockHomepageFavorites_UpdateTag_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockIdleInhibitor is an autogenerated mock type for the IdleInhibitor type
type MockIdleInhibitor struct {
	mock.Mock
}

type MockIdleInhibitor_Expecter struct {
	mock *mock.Mock
}

func (_m *MockIdleInhibitor) EXPECT() *MockIdleInhibitor_Expecter {
	return &MockIdleInhibitor_Expecter{mock: &_m.Mock}
}

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

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

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

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

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

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

// Inhibit provides a mock function for the type MockIdleInhibitor
func (_mock *MockIdleInhibitor) Inhibit(ctx context.Context, reason string) error {
	ret := _mock.Called(ctx, reason)

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

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

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

// Inhibit is a helper method to define mock.On call
//   - ctx context.Context
//   - reason string
func (_e *MockIdleInhibitor_Expecter) Inhibit(ctx interface{}, reason interface{}) *MockIdleInhibitor_Inhibit_Call {
	return &MockIdleInhibitor_Inhibit_Call{Call: _e.mock.On("Inhibit", ctx, reason)}
}

func (_c *MockIdleInhibitor_Inhibit_Call) Run(run func(ctx context.Context, reason string)) *MockIdleInhibitor_Inhibit_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)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockIdleInhibitor_Inhibit_Call) RunAndReturn(run func(ctx context.Context, reason string) error) *MockIdleInhibitor_Inhibit_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// IsInhibited is a helper method to define mock.On call
func (_e *MockIdleInhibitor_Expecter) IsInhibited() *MockIdleInhibitor_IsInhibited_Call {
	return &MockIdleInhibitor_IsInhibited_Call{Call: _e.mock.On("IsInhibited")}
}

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

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

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

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

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

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

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

// Uninhibit is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockIdleInhibitor_Expecter) Uninhibit(ctx interface{}) *MockIdleInhibitor_Uninhibit_Call {
	return &MockIdleInhibitor_Uninhibit_Call{Call: _e.mock.On("Uninhibit", ctx)}
}

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

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

// 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 interface{}, mode interface{}, action interface{}, keys interface{}) *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 interface{}) *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 interface{}) *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 interface{}) *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 interface{}, req interface{}) *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 interface{}, req interface{}) *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 interface{}) *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 interface{}, req interface{}) *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 interface{}, req interface{}) *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 interface{}) *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
}

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

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

	return mock
}

// MockMediaDiagnostics is an autogenerated mock type for the MediaDiagnostics type
type MockMediaDiagnostics struct {
	mock.Mock
}

type MockMediaDiagnostics_Expecter struct {
	mock *mock.Mock
}

func (_m *MockMediaDiagnostics) EXPECT() *MockMediaDiagnostics_Expecter {
	return &MockMediaDiagnostics_Expecter{mock: &_m.Mock}
}

// RunDiagnostics provides a mock function for the type MockMediaDiagnostics
func (_mock *MockMediaDiagnostics) RunDiagnostics(ctx context.Context) *port.MediaDiagnosticsResult {
	ret := _mock.Called(ctx)

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

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

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

// RunDiagnostics is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockMediaDiagnostics_Expecter) RunDiagnostics(ctx interface{}) *MockMediaDiagnostics_RunDiagnostics_Call {
	return &MockMediaDiagnostics_RunDiagnostics_Call{Call: _e.mock.On("RunDiagnostics", ctx)}
}

func (_c *MockMediaDiagnostics_RunDiagnostics_Call) Run(run func(ctx context.Context)) *MockMediaDiagnostics_RunDiagnostics_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 *MockMediaDiagnostics_RunDiagnostics_Call) Return(mediaDiagnosticsResult *port.MediaDiagnosticsResult) *MockMediaDiagnostics_RunDiagnostics_Call {
	_c.Call.Return(mediaDiagnosticsResult)
	return _c
}

func (_c *MockMediaDiagnostics_RunDiagnostics_Call) RunAndReturn(run func(ctx context.Context) *port.MediaDiagnosticsResult) *MockMediaDiagnostics_RunDiagnostics_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockNotification is an autogenerated mock type for the Notification type
type MockNotification struct {
	mock.Mock
}

type MockNotification_Expecter struct {
	mock *mock.Mock
}

func (_m *MockNotification) EXPECT() *MockNotification_Expecter {
	return &MockNotification_Expecter{mock: &_m.Mock}
}

// Clear provides a mock function for the type MockNotification
func (_mock *MockNotification) Clear(ctx context.Context) {
	_mock.Called(ctx)
	return
}

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

// Clear is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockNotification_Expecter) Clear(ctx interface{}) *MockNotification_Clear_Call {
	return &MockNotification_Clear_Call{Call: _e.mock.On("Clear", ctx)}
}

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

func (_c *MockNotification_Clear_Call) RunAndReturn(run func(ctx context.Context)) *MockNotification_Clear_Call {
	_c.Run(run)
	return _c
}

// Dismiss provides a mock function for the type MockNotification
func (_mock *MockNotification) Dismiss(ctx context.Context, id port.NotificationID) {
	_mock.Called(ctx, id)
	return
}

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

// Dismiss is a helper method to define mock.On call
//   - ctx context.Context
//   - id port.NotificationID
func (_e *MockNotification_Expecter) Dismiss(ctx interface{}, id interface{}) *MockNotification_Dismiss_Call {
	return &MockNotification_Dismiss_Call{Call: _e.mock.On("Dismiss", ctx, id)}
}

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

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

func (_c *MockNotification_Dismiss_Call) RunAndReturn(run func(ctx context.Context, id port.NotificationID)) *MockNotification_Dismiss_Call {
	_c.Run(run)
	return _c
}

// Show provides a mock function for the type MockNotification
func (_mock *MockNotification) Show(ctx context.Context, message string, notifType port.NotificationType, durationMs int) port.NotificationID {
	ret := _mock.Called(ctx, message, notifType, durationMs)

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

	var r0 port.NotificationID
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, port.NotificationType, int) port.NotificationID); ok {
		r0 = returnFunc(ctx, message, notifType, durationMs)
	} else {
		r0 = ret.Get(0).(port.NotificationID)
	}
	return r0
}

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

// Show is a helper method to define mock.On call
//   - ctx context.Context
//   - message string
//   - notifType port.NotificationType
//   - durationMs int
func (_e *MockNotification_Expecter) Show(ctx interface{}, message interface{}, notifType interface{}, durationMs interface{}) *MockNotification_Show_Call {
	return &MockNotification_Show_Call{Call: _e.mock.On("Show", ctx, message, notifType, durationMs)}
}

func (_c *MockNotification_Show_Call) Run(run func(ctx context.Context, message string, notifType port.NotificationType, durationMs int)) *MockNotification_Show_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 port.NotificationType
		if args[2] != nil {
			arg2 = args[2].(port.NotificationType)
		}
		var arg3 int
		if args[3] != nil {
			arg3 = args[3].(int)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockNotification_Show_Call) Return(notificationID port.NotificationID) *MockNotification_Show_Call {
	_c.Call.Return(notificationID)
	return _c
}

func (_c *MockNotification_Show_Call) RunAndReturn(run func(ctx context.Context, message string, notifType port.NotificationType, durationMs int) port.NotificationID) *MockNotification_Show_Call {
	_c.Call.Return(run)
	return _c
}

// ShowZoom provides a mock function for the type MockNotification
func (_mock *MockNotification) ShowZoom(ctx context.Context, zoomPercent int) port.NotificationID {
	ret := _mock.Called(ctx, zoomPercent)

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

	var r0 port.NotificationID
	if returnFunc, ok := ret.Get(0).(func(context.Context, int) port.NotificationID); ok {
		r0 = returnFunc(ctx, zoomPercent)
	} else {
		r0 = ret.Get(0).(port.NotificationID)
	}
	return r0
}

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

// ShowZoom is a helper method to define mock.On call
//   - ctx context.Context
//   - zoomPercent int
func (_e *MockNotification_Expecter) ShowZoom(ctx interface{}, zoomPercent interface{}) *MockNotification_ShowZoom_Call {
	return &MockNotification_ShowZoom_Call{Call: _e.mock.On("ShowZoom", ctx, zoomPercent)}
}

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

func (_c *MockNotification_ShowZoom_Call) Return(notificationID port.NotificationID) *MockNotification_ShowZoom_Call {
	_c.Call.Return(notificationID)
	return _c
}

func (_c *MockNotification_ShowZoom_Call) RunAndReturn(run func(ctx context.Context, zoomPercent int) port.NotificationID) *MockNotification_ShowZoom_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockPermissionDialogPresenter is an autogenerated mock type for the PermissionDialogPresenter type
type MockPermissionDialogPresenter struct {
	mock.Mock
}

type MockPermissionDialogPresenter_Expecter struct {
	mock *mock.Mock
}

func (_m *MockPermissionDialogPresenter) EXPECT() *MockPermissionDialogPresenter_Expecter {
	return &MockPermissionDialogPresenter_Expecter{mock: &_m.Mock}
}

// ShowPermissionDialog provides a mock function for the type MockPermissionDialogPresenter
func (_mock *MockPermissionDialogPresenter) ShowPermissionDialog(ctx context.Context, origin string, permTypes []entity.PermissionType, metadata entity.PermissionMetadata, callback func(result port.PermissionDialogResult)) {
	_mock.Called(ctx, origin, permTypes, metadata, callback)
	return
}

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

// ShowPermissionDialog is a helper method to define mock.On call
//   - ctx context.Context
//   - origin string
//   - permTypes []entity.PermissionType
//   - metadata entity.PermissionMetadata
//   - callback func(result port.PermissionDialogResult)
func (_e *MockPermissionDialogPresenter_Expecter) ShowPermissionDialog(ctx interface{}, origin interface{}, permTypes interface{}, metadata interface{}, callback interface{}) *MockPermissionDialogPresenter_ShowPermissionDialog_Call {
	return &MockPermissionDialogPresenter_ShowPermissionDialog_Call{Call: _e.mock.On("ShowPermissionDialog", ctx, origin, permTypes, metadata, callback)}
}

func (_c *MockPermissionDialogPresenter_ShowPermissionDialog_Call) Run(run func(ctx context.Context, origin string, permTypes []entity.PermissionType, metadata entity.PermissionMetadata, callback func(result port.PermissionDialogResult))) *MockPermissionDialogPresenter_ShowPermissionDialog_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 []entity.PermissionType
		if args[2] != nil {
			arg2 = args[2].([]entity.PermissionType)
		}
		var arg3 entity.PermissionMetadata
		if args[3] != nil {
			arg3 = args[3].(entity.PermissionMetadata)
		}
		var arg4 func(result port.PermissionDialogResult)
		if args[4] != nil {
			arg4 = args[4].(func(result port.PermissionDialogResult))
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *MockPermissionDialogPresenter_ShowPermissionDialog_Call) RunAndReturn(run func(ctx context.Context, origin string, permTypes []entity.PermissionType, metadata entity.PermissionMetadata, callback func(result port.PermissionDialogResult))) *MockPermissionDialogPresenter_ShowPermissionDialog_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockPermissionRepository is an autogenerated mock type for the PermissionRepository type
type MockPermissionRepository struct {
	mock.Mock
}

type MockPermissionRepository_Expecter struct {
	mock *mock.Mock
}

func (_m *MockPermissionRepository) EXPECT() *MockPermissionRepository_Expecter {
	return &MockPermissionRepository_Expecter{mock: &_m.Mock}
}

// Delete provides a mock function for the type MockPermissionRepository
func (_mock *MockPermissionRepository) Delete(ctx context.Context, origin string, permType entity.PermissionType) error {
	ret := _mock.Called(ctx, origin, permType)

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

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

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - origin string
//   - permType entity.PermissionType
func (_e *MockPermissionRepository_Expecter) Delete(ctx interface{}, origin interface{}, permType interface{}) *MockPermissionRepository_Delete_Call {
	return &MockPermissionRepository_Delete_Call{Call: _e.mock.On("Delete", ctx, origin, permType)}
}

func (_c *MockPermissionRepository_Delete_Call) Run(run func(ctx context.Context, origin string, permType entity.PermissionType)) *MockPermissionRepository_Delete_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 entity.PermissionType
		if args[2] != nil {
			arg2 = args[2].(entity.PermissionType)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockPermissionRepository_Delete_Call) RunAndReturn(run func(ctx context.Context, origin string, permType entity.PermissionType) error) *MockPermissionRepository_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// Get provides a mock function for the type MockPermissionRepository
func (_mock *MockPermissionRepository) Get(ctx context.Context, origin string, permType entity.PermissionType) (*entity.PermissionRecord, error) {
	ret := _mock.Called(ctx, origin, permType)

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

	var r0 *entity.PermissionRecord
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.PermissionType) (*entity.PermissionRecord, error)); ok {
		return returnFunc(ctx, origin, permType)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.PermissionType) *entity.PermissionRecord); ok {
		r0 = returnFunc(ctx, origin, permType)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.PermissionRecord)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, entity.PermissionType) error); ok {
		r1 = returnFunc(ctx, origin, permType)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Get is a helper method to define mock.On call
//   - ctx context.Context
//   - origin string
//   - permType entity.PermissionType
func (_e *MockPermissionRepository_Expecter) Get(ctx interface{}, origin interface{}, permType interface{}) *MockPermissionRepository_Get_Call {
	return &MockPermissionRepository_Get_Call{Call: _e.mock.On("Get", ctx, origin, permType)}
}

func (_c *MockPermissionRepository_Get_Call) Run(run func(ctx context.Context, origin string, permType entity.PermissionType)) *MockPermissionRepository_Get_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 entity.PermissionType
		if args[2] != nil {
			arg2 = args[2].(entity.PermissionType)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockPermissionRepository_Get_Call) Return(permissionRecord *entity.PermissionRecord, err error) *MockPermissionRepository_Get_Call {
	_c.Call.Return(permissionRecord, err)
	return _c
}

func (_c *MockPermissionRepository_Get_Call) RunAndReturn(run func(ctx context.Context, origin string, permType entity.PermissionType) (*entity.PermissionRecord, error)) *MockPermissionRepository_Get_Call {
	_c.Call.Return(run)
	return _c
}

// GetAll provides a mock function for the type MockPermissionRepository
func (_mock *MockPermissionRepository) GetAll(ctx context.Context, origin string) ([]*entity.PermissionRecord, error) {
	ret := _mock.Called(ctx, origin)

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

	var r0 []*entity.PermissionRecord
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*entity.PermissionRecord, error)); ok {
		return returnFunc(ctx, origin)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*entity.PermissionRecord); ok {
		r0 = returnFunc(ctx, origin)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.PermissionRecord)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, origin)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetAll is a helper method to define mock.On call
//   - ctx context.Context
//   - origin string
func (_e *MockPermissionRepository_Expecter) GetAll(ctx interface{}, origin interface{}) *MockPermissionRepository_GetAll_Call {
	return &MockPermissionRepository_GetAll_Call{Call: _e.mock.On("GetAll", ctx, origin)}
}

func (_c *MockPermissionRepository_GetAll_Call) Run(run func(ctx context.Context, origin string)) *MockPermissionRepository_GetAll_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)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockPermissionRepository_GetAll_Call) Return(permissionRecords []*entity.PermissionRecord, err error) *MockPermissionRepository_GetAll_Call {
	_c.Call.Return(permissionRecords, err)
	return _c
}

func (_c *MockPermissionRepository_GetAll_Call) RunAndReturn(run func(ctx context.Context, origin string) ([]*entity.PermissionRecord, error)) *MockPermissionRepository_GetAll_Call {
	_c.Call.Return(run)
	return _c
}

// Set provides a mock function for the type MockPermissionRepository
func (_mock *MockPermissionRepository) Set(ctx context.Context, record *entity.PermissionRecord) error {
	ret := _mock.Called(ctx, record)

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

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

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

// Set is a helper method to define mock.On call
//   - ctx context.Context
//   - record *entity.PermissionRecord
func (_e *MockPermissionRepository_Expecter) Set(ctx interface{}, record interface{}) *MockPermissionRepository_Set_Call {
	return &MockPermissionRepository_Set_Call{Call: _e.mock.On("Set", ctx, record)}
}

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

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

func (_c *MockPermissionRepository_Set_Call) RunAndReturn(run func(ctx context.Context, record *entity.PermissionRecord) error) *MockPermissionRepository_Set_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockRenderingEnvManager is an autogenerated mock type for the RenderingEnvManager type
type MockRenderingEnvManager struct {
	mock.Mock
}

type MockRenderingEnvManager_Expecter struct {
	mock *mock.Mock
}

func (_m *MockRenderingEnvManager) EXPECT() *MockRenderingEnvManager_Expecter {
	return &MockRenderingEnvManager_Expecter{mock: &_m.Mock}
}

// DetectGPUVendor provides a mock function for the type MockRenderingEnvManager
func (_mock *MockRenderingEnvManager) DetectGPUVendor(ctx context.Context) port.GPUVendor {
	ret := _mock.Called(ctx)

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

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

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

// DetectGPUVendor is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockRenderingEnvManager_Expecter) DetectGPUVendor(ctx interface{}) *MockRenderingEnvManager_DetectGPUVendor_Call {
	return &MockRenderingEnvManager_DetectGPUVendor_Call{Call: _e.mock.On("DetectGPUVendor", ctx)}
}

func (_c *MockRenderingEnvManager_DetectGPUVendor_Call) Run(run func(ctx context.Context)) *MockRenderingEnvManager_DetectGPUVendor_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 *MockRenderingEnvManager_DetectGPUVendor_Call) Return(gPUVendor port.GPUVendor) *MockRenderingEnvManager_DetectGPUVendor_Call {
	_c.Call.Return(gPUVendor)
	return _c
}

func (_c *MockRenderingEnvManager_DetectGPUVendor_Call) RunAndReturn(run func(ctx context.Context) port.GPUVendor) *MockRenderingEnvManager_DetectGPUVendor_Call {
	_c.Call.Return(run)
	return _c
}

// GetAppliedVars provides a mock function for the type MockRenderingEnvManager
func (_mock *MockRenderingEnvManager) GetAppliedVars() map[string]string {
	ret := _mock.Called()

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

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

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

// GetAppliedVars is a helper method to define mock.On call
func (_e *MockRenderingEnvManager_Expecter) GetAppliedVars() *MockRenderingEnvManager_GetAppliedVars_Call {
	return &MockRenderingEnvManager_GetAppliedVars_Call{Call: _e.mock.On("GetAppliedVars")}
}

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

func (_c *MockRenderingEnvManager_GetAppliedVars_Call) Return(stringToString map[string]string) *MockRenderingEnvManager_GetAppliedVars_Call {
	_c.Call.Return(stringToString)
	return _c
}

func (_c *MockRenderingEnvManager_GetAppliedVars_Call) RunAndReturn(run func() map[string]string) *MockRenderingEnvManager_GetAppliedVars_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockRuntimeVersionProbe is an autogenerated mock type for the RuntimeVersionProbe type
type MockRuntimeVersionProbe struct {
	mock.Mock
}

type MockRuntimeVersionProbe_Expecter struct {
	mock *mock.Mock
}

func (_m *MockRuntimeVersionProbe) EXPECT() *MockRuntimeVersionProbe_Expecter {
	return &MockRuntimeVersionProbe_Expecter{mock: &_m.Mock}
}

// PkgConfigModVersion provides a mock function for the type MockRuntimeVersionProbe
func (_mock *MockRuntimeVersionProbe) PkgConfigModVersion(ctx context.Context, pkgName string, prefix string) (string, error) {
	ret := _mock.Called(ctx, pkgName, prefix)

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

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

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

// PkgConfigModVersion is a helper method to define mock.On call
//   - ctx context.Context
//   - pkgName string
//   - prefix string
func (_e *MockRuntimeVersionProbe_Expecter) PkgConfigModVersion(ctx interface{}, pkgName interface{}, prefix interface{}) *MockRuntimeVersionProbe_PkgConfigModVersion_Call {
	return &MockRuntimeVersionProbe_PkgConfigModVersion_Call{Call: _e.mock.On("PkgConfigModVersion", ctx, pkgName, prefix)}
}

func (_c *MockRuntimeVersionProbe_PkgConfigModVersion_Call) Run(run func(ctx context.Context, pkgName string, prefix string)) *MockRuntimeVersionProbe_PkgConfigModVersion_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockRuntimeVersionProbe_PkgConfigModVersion_Call) Return(s string, err error) *MockRuntimeVersionProbe_PkgConfigModVersion_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockRuntimeVersionProbe_PkgConfigModVersion_Call) RunAndReturn(run func(ctx context.Context, pkgName string, prefix string) (string, error)) *MockRuntimeVersionProbe_PkgConfigModVersion_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockSessionLogger is an autogenerated mock type for the SessionLogger type
type MockSessionLogger struct {
	mock.Mock
}

type MockSessionLogger_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSessionLogger) EXPECT() *MockSessionLogger_Expecter {
	return &MockSessionLogger_Expecter{mock: &_m.Mock}
}

// CreateLogger provides a mock function for the type MockSessionLogger
func (_mock *MockSessionLogger) CreateLogger(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig) (zerolog.Logger, func(), error) {
	ret := _mock.Called(ctx, sessionID, cfg)

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

	var r0 zerolog.Logger
	var r1 func()
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID, port.SessionLogConfig) (zerolog.Logger, func(), error)); ok {
		return returnFunc(ctx, sessionID, cfg)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID, port.SessionLogConfig) zerolog.Logger); ok {
		r0 = returnFunc(ctx, sessionID, cfg)
	} else {
		r0 = ret.Get(0).(zerolog.Logger)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, entity.SessionID, port.SessionLogConfig) func()); ok {
		r1 = returnFunc(ctx, sessionID, cfg)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(func())
		}
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, entity.SessionID, port.SessionLogConfig) error); ok {
		r2 = returnFunc(ctx, sessionID, cfg)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// CreateLogger is a helper method to define mock.On call
//   - ctx context.Context
//   - sessionID entity.SessionID
//   - cfg port.SessionLogConfig
func (_e *MockSessionLogger_Expecter) CreateLogger(ctx interface{}, sessionID interface{}, cfg interface{}) *MockSessionLogger_CreateLogger_Call {
	return &MockSessionLogger_CreateLogger_Call{Call: _e.mock.On("CreateLogger", ctx, sessionID, cfg)}
}

func (_c *MockSessionLogger_CreateLogger_Call) Run(run func(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig)) *MockSessionLogger_CreateLogger_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 entity.SessionID
		if args[1] != nil {
			arg1 = args[1].(entity.SessionID)
		}
		var arg2 port.SessionLogConfig
		if args[2] != nil {
			arg2 = args[2].(port.SessionLogConfig)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockSessionLogger_CreateLogger_Call) Return(logger zerolog.Logger, fn func(), err error) *MockSessionLogger_CreateLogger_Call {
	_c.Call.Return(logger, fn, err)
	return _c
}

func (_c *MockSessionLogger_CreateLogger_Call) RunAndReturn(run func(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig) (zerolog.Logger, func(), error)) *MockSessionLogger_CreateLogger_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockTabListProvider is an autogenerated mock type for the TabListProvider type
type MockTabListProvider struct {
	mock.Mock
}

type MockTabListProvider_Expecter struct {
	mock *mock.Mock
}

func (_m *MockTabListProvider) EXPECT() *MockTabListProvider_Expecter {
	return &MockTabListProvider_Expecter{mock: &_m.Mock}
}

// GetSessionID provides a mock function for the type MockTabListProvider
func (_mock *MockTabListProvider) GetSessionID() entity.SessionID {
	ret := _mock.Called()

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

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

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

// GetSessionID is a helper method to define mock.On call
func (_e *MockTabListProvider_Expecter) GetSessionID() *MockTabListProvider_GetSessionID_Call {
	return &MockTabListProvider_GetSessionID_Call{Call: _e.mock.On("GetSessionID")}
}

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

func (_c *MockTabListProvider_GetSessionID_Call) Return(sessionID entity.SessionID) *MockTabListProvider_GetSessionID_Call {
	_c.Call.Return(sessionID)
	return _c
}

func (_c *MockTabListProvider_GetSessionID_Call) RunAndReturn(run func() entity.SessionID) *MockTabListProvider_GetSessionID_Call {
	_c.Call.Return(run)
	return _c
}

// GetTabList provides a mock function for the type MockTabListProvider
func (_mock *MockTabListProvider) GetTabList() *entity.TabList {
	ret := _mock.Called()

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

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

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

// GetTabList is a helper method to define mock.On call
func (_e *MockTabListProvider_Expecter) GetTabList() *MockTabListProvider_GetTabList_Call {
	return &MockTabListProvider_GetTabList_Call{Call: _e.mock.On("GetTabList")}
}

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

func (_c *MockTabListProvider_GetTabList_Call) Return(tabList *entity.TabList) *MockTabListProvider_GetTabList_Call {
	_c.Call.Return(tabList)
	return _c
}

func (_c *MockTabListProvider_GetTabList_Call) RunAndReturn(run func() *entity.TabList) *MockTabListProvider_GetTabList_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockSessionSpawner is an autogenerated mock type for the SessionSpawner type
type MockSessionSpawner struct {
	mock.Mock
}

type MockSessionSpawner_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSessionSpawner) EXPECT() *MockSessionSpawner_Expecter {
	return &MockSessionSpawner_Expecter{mock: &_m.Mock}
}

// SpawnWithSession provides a mock function for the type MockSessionSpawner
func (_mock *MockSessionSpawner) SpawnWithSession(sessionID entity.SessionID) error {
	ret := _mock.Called(sessionID)

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

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

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

// SpawnWithSession is a helper method to define mock.On call
//   - sessionID entity.SessionID
func (_e *MockSessionSpawner_Expecter) SpawnWithSession(sessionID interface{}) *MockSessionSpawner_SpawnWithSession_Call {
	return &MockSessionSpawner_SpawnWithSession_Call{Call: _e.mock.On("SpawnWithSession", sessionID)}
}

func (_c *MockSessionSpawner_SpawnWithSession_Call) Run(run func(sessionID entity.SessionID)) *MockSessionSpawner_SpawnWithSession_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 entity.SessionID
		if args[0] != nil {
			arg0 = args[0].(entity.SessionID)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockSessionSpawner_SpawnWithSession_Call) RunAndReturn(run func(sessionID entity.SessionID) error) *MockSessionSpawner_SpawnWithSession_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockSnapshotService is an autogenerated mock type for the SnapshotService type
type MockSnapshotService struct {
	mock.Mock
}

type MockSnapshotService_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSnapshotService) EXPECT() *MockSnapshotService_Expecter {
	return &MockSnapshotService_Expecter{mock: &_m.Mock}
}

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

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

// MarkDirty is a helper method to define mock.On call
func (_e *MockSnapshotService_Expecter) MarkDirty() *MockSnapshotService_MarkDirty_Call {
	return &MockSnapshotService_MarkDirty_Call{Call: _e.mock.On("MarkDirty")}
}

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

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

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

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

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

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

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

// SaveNow is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockSnapshotService_Expecter) SaveNow(ctx interface{}) *MockSnapshotService_SaveNow_Call {
	return &MockSnapshotService_SaveNow_Call{Call: _e.mock.On("SaveNow", ctx)}
}

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

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

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

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

// SetReady is a helper method to define mock.On call
func (_e *MockSnapshotService_Expecter) SetReady() *MockSnapshotService_SetReady_Call {
	return &MockSnapshotService_SetReady_Call{Call: _e.mock.On("SetReady")}
}

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

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

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

// Start provides a mock function for the type MockSnapshotService
func (_mock *MockSnapshotService) Start(ctx context.Context) {
	_mock.Called(ctx)
	return
}

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

// Start is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockSnapshotService_Expecter) Start(ctx interface{}) *MockSnapshotService_Start_Call {
	return &MockSnapshotService_Start_Call{Call: _e.mock.On("Start", ctx)}
}

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

func (_c *MockSnapshotService_Start_Call) RunAndReturn(run func(ctx context.Context)) *MockSnapshotService_Start_Call {
	_c.Run(run)
	return _c
}

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

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

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

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

// Stop is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockSnapshotService_Expecter) Stop(ctx interface{}) *MockSnapshotService_Stop_Call {
	return &MockSnapshotService_Stop_Call{Call: _e.mock.On("Stop", ctx)}
}

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

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

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

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

	return mock
}

// MockTextInputTarget is an autogenerated mock type for the TextInputTarget type
type MockTextInputTarget struct {
	mock.Mock
}

type MockTextInputTarget_Expecter struct {
	mock *mock.Mock
}

func (_m *MockTextInputTarget) EXPECT() *MockTextInputTarget_Expecter {
	return &MockTextInputTarget_Expecter{mock: &_m.Mock}
}

// DeleteBeforeCursor provides a mock function for the type MockTextInputTarget
func (_mock *MockTextInputTarget) DeleteBeforeCursor(ctx context.Context, n int) error {
	ret := _mock.Called(ctx, n)

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

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

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

// DeleteBeforeCursor is a helper method to define mock.On call
//   - ctx context.Context
//   - n int
func (_e *MockTextInputTarget_Expecter) DeleteBeforeCursor(ctx interface{}, n interface{}) *MockTextInputTarget_DeleteBeforeCursor_Call {
	return &MockTextInputTarget_DeleteBeforeCursor_Call{Call: _e.mock.On("DeleteBeforeCursor", ctx, n)}
}

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

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

func (_c *MockTextInputTarget_DeleteBeforeCursor_Call) RunAndReturn(run func(ctx context.Context, n int) error) *MockTextInputTarget_DeleteBeforeCursor_Call {
	_c.Call.Return(run)
	return _c
}

// InsertText provides a mock function for the type MockTextInputTarget
func (_mock *MockTextInputTarget) InsertText(ctx context.Context, text string) error {
	ret := _mock.Called(ctx, text)

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

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

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

// InsertText is a helper method to define mock.On call
//   - ctx context.Context
//   - text string
func (_e *MockTextInputTarget_Expecter) InsertText(ctx interface{}, text interface{}) *MockTextInputTarget_InsertText_Call {
	return &MockTextInputTarget_InsertText_Call{Call: _e.mock.On("InsertText", ctx, text)}
}

func (_c *MockTextInputTarget_InsertText_Call) Run(run func(ctx context.Context, text string)) *MockTextInputTarget_InsertText_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)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockTextInputTarget_InsertText_Call) RunAndReturn(run func(ctx context.Context, text string) error) *MockTextInputTarget_InsertText_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockFocusable is an autogenerated mock type for the Focusable type
type MockFocusable struct {
	mock.Mock
}

type MockFocusable_Expecter struct {
	mock *mock.Mock
}

func (_m *MockFocusable) EXPECT() *MockFocusable_Expecter {
	return &MockFocusable_Expecter{mock: &_m.Mock}
}

// Focus provides a mock function for the type MockFocusable
func (_mock *MockFocusable) Focus(ctx context.Context) {
	_mock.Called(ctx)
	return
}

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

// Focus is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockFocusable_Expecter) Focus(ctx interface{}) *MockFocusable_Focus_Call {
	return &MockFocusable_Focus_Call{Call: _e.mock.On("Focus", ctx)}
}

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

func (_c *MockFocusable_Focus_Call) RunAndReturn(run func(ctx context.Context)) *MockFocusable_Focus_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockEntryInputTarget is an autogenerated mock type for the EntryInputTarget type
type MockEntryInputTarget struct {
	mock.Mock
}

type MockEntryInputTarget_Expecter struct {
	mock *mock.Mock
}

func (_m *MockEntryInputTarget) EXPECT() *MockEntryInputTarget_Expecter {
	return &MockEntryInputTarget_Expecter{mock: &_m.Mock}
}

// DeleteBeforeCursor provides a mock function for the type MockEntryInputTarget
func (_mock *MockEntryInputTarget) DeleteBeforeCursor(ctx context.Context, n int) error {
	ret := _mock.Called(ctx, n)

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

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

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

// DeleteBeforeCursor is a helper method to define mock.On call
//   - ctx context.Context
//   - n int
func (_e *MockEntryInputTarget_Expecter) DeleteBeforeCursor(ctx interface{}, n interface{}) *MockEntryInputTarget_DeleteBeforeCursor_Call {
	return &MockEntryInputTarget_DeleteBeforeCursor_Call{Call: _e.mock.On("DeleteBeforeCursor", ctx, n)}
}

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

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

func (_c *MockEntryInputTarget_DeleteBeforeCursor_Call) RunAndReturn(run func(ctx context.Context, n int) error) *MockEntryInputTarget_DeleteBeforeCursor_Call {
	_c.Call.Return(run)
	return _c
}

// InsertText provides a mock function for the type MockEntryInputTarget
func (_mock *MockEntryInputTarget) InsertText(ctx context.Context, text string) error {
	ret := _mock.Called(ctx, text)

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

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

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

// InsertText is a helper method to define mock.On call
//   - ctx context.Context
//   - text string
func (_e *MockEntryInputTarget_Expecter) InsertText(ctx interface{}, text interface{}) *MockEntryInputTarget_InsertText_Call {
	return &MockEntryInputTarget_InsertText_Call{Call: _e.mock.On("InsertText", ctx, text)}
}

func (_c *MockEntryInputTarget_InsertText_Call) Run(run func(ctx context.Context, text string)) *MockEntryInputTarget_InsertText_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)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockEntryInputTarget_InsertText_Call) RunAndReturn(run func(ctx context.Context, text string) error) *MockEntryInputTarget_InsertText_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// IsGTKEntryTarget is a helper method to define mock.On call
func (_e *MockEntryInputTarget_Expecter) IsGTKEntryTarget() *MockEntryInputTarget_IsGTKEntryTarget_Call {
	return &MockEntryInputTarget_IsGTKEntryTarget_Call{Call: _e.mock.On("IsGTKEntryTarget")}
}

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

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

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

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

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

	return mock
}

// MockFocusedInputProvider is an autogenerated mock type for the FocusedInputProvider type
type MockFocusedInputProvider struct {
	mock.Mock
}

type MockFocusedInputProvider_Expecter struct {
	mock *mock.Mock
}

func (_m *MockFocusedInputProvider) EXPECT() *MockFocusedInputProvider_Expecter {
	return &MockFocusedInputProvider_Expecter{mock: &_m.Mock}
}

// GetFocusedInput provides a mock function for the type MockFocusedInputProvider
func (_mock *MockFocusedInputProvider) GetFocusedInput() port.TextInputTarget {
	ret := _mock.Called()

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

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

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

// GetFocusedInput is a helper method to define mock.On call
func (_e *MockFocusedInputProvider_Expecter) GetFocusedInput() *MockFocusedInputProvider_GetFocusedInput_Call {
	return &MockFocusedInputProvider_GetFocusedInput_Call{Call: _e.mock.On("GetFocusedInput")}
}

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

func (_c *MockFocusedInputProvider_GetFocusedInput_Call) Return(textInputTarget port.TextInputTarget) *MockFocusedInputProvider_GetFocusedInput_Call {
	_c.Call.Return(textInputTarget)
	return _c
}

func (_c *MockFocusedInputProvider_GetFocusedInput_Call) RunAndReturn(run func() port.TextInputTarget) *MockFocusedInputProvider_GetFocusedInput_Call {
	_c.Call.Return(run)
	return _c
}

// SetFocusedInput provides a mock function for the type MockFocusedInputProvider
func (_mock *MockFocusedInputProvider) SetFocusedInput(target port.TextInputTarget) {
	_mock.Called(target)
	return
}

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

// SetFocusedInput is a helper method to define mock.On call
//   - target port.TextInputTarget
func (_e *MockFocusedInputProvider_Expecter) SetFocusedInput(target interface{}) *MockFocusedInputProvider_SetFocusedInput_Call {
	return &MockFocusedInputProvider_SetFocusedInput_Call{Call: _e.mock.On("SetFocusedInput", target)}
}

func (_c *MockFocusedInputProvider_SetFocusedInput_Call) Run(run func(target port.TextInputTarget)) *MockFocusedInputProvider_SetFocusedInput_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 port.TextInputTarget
		if args[0] != nil {
			arg0 = args[0].(port.TextInputTarget)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockFocusedInputProvider_SetFocusedInput_Call) RunAndReturn(run func(target port.TextInputTarget)) *MockFocusedInputProvider_SetFocusedInput_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockUpdateChecker is an autogenerated mock type for the UpdateChecker type
type MockUpdateChecker struct {
	mock.Mock
}

type MockUpdateChecker_Expecter struct {
	mock *mock.Mock
}

func (_m *MockUpdateChecker) EXPECT() *MockUpdateChecker_Expecter {
	return &MockUpdateChecker_Expecter{mock: &_m.Mock}
}

// CheckForUpdate provides a mock function for the type MockUpdateChecker
func (_mock *MockUpdateChecker) CheckForUpdate(ctx context.Context, currentVersion string) (*entity.UpdateInfo, error) {
	ret := _mock.Called(ctx, currentVersion)

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

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

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

// CheckForUpdate is a helper method to define mock.On call
//   - ctx context.Context
//   - currentVersion string
func (_e *MockUpdateChecker_Expecter) CheckForUpdate(ctx interface{}, currentVersion interface{}) *MockUpdateChecker_CheckForUpdate_Call {
	return &MockUpdateChecker_CheckForUpdate_Call{Call: _e.mock.On("CheckForUpdate", ctx, currentVersion)}
}

func (_c *MockUpdateChecker_CheckForUpdate_Call) Run(run func(ctx context.Context, currentVersion string)) *MockUpdateChecker_CheckForUpdate_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)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockUpdateChecker_CheckForUpdate_Call) Return(updateInfo *entity.UpdateInfo, err error) *MockUpdateChecker_CheckForUpdate_Call {
	_c.Call.Return(updateInfo, err)
	return _c
}

func (_c *MockUpdateChecker_CheckForUpdate_Call) RunAndReturn(run func(ctx context.Context, currentVersion string) (*entity.UpdateInfo, error)) *MockUpdateChecker_CheckForUpdate_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockUpdateDownloader is an autogenerated mock type for the UpdateDownloader type
type MockUpdateDownloader struct {
	mock.Mock
}

type MockUpdateDownloader_Expecter struct {
	mock *mock.Mock
}

func (_m *MockUpdateDownloader) EXPECT() *MockUpdateDownloader_Expecter {
	return &MockUpdateDownloader_Expecter{mock: &_m.Mock}
}

// Download provides a mock function for the type MockUpdateDownloader
func (_mock *MockUpdateDownloader) Download(ctx context.Context, downloadURL string, destDir string) (string, error) {
	ret := _mock.Called(ctx, downloadURL, destDir)

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

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

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

// Download is a helper method to define mock.On call
//   - ctx context.Context
//   - downloadURL string
//   - destDir string
func (_e *MockUpdateDownloader_Expecter) Download(ctx interface{}, downloadURL interface{}, destDir interface{}) *MockUpdateDownloader_Download_Call {
	return &MockUpdateDownloader_Download_Call{Call: _e.mock.On("Download", ctx, downloadURL, destDir)}
}

func (_c *MockUpdateDownloader_Download_Call) Run(run func(ctx context.Context, downloadURL string, destDir string)) *MockUpdateDownloader_Download_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockUpdateDownloader_Download_Call) Return(archivePath string, err error) *MockUpdateDownloader_Download_Call {
	_c.Call.Return(archivePath, err)
	return _c
}

func (_c *MockUpdateDownloader_Download_Call) RunAndReturn(run func(ctx context.Context, downloadURL string, destDir string) (string, error)) *MockUpdateDownloader_Download_Call {
	_c.Call.Return(run)
	return _c
}

// Extract provides a mock function for the type MockUpdateDownloader
func (_mock *MockUpdateDownloader) Extract(ctx context.Context, archivePath string, destDir string) (string, error) {
	ret := _mock.Called(ctx, archivePath, destDir)

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

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

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

// Extract is a helper method to define mock.On call
//   - ctx context.Context
//   - archivePath string
//   - destDir string
func (_e *MockUpdateDownloader_Expecter) Extract(ctx interface{}, archivePath interface{}, destDir interface{}) *MockUpdateDownloader_Extract_Call {
	return &MockUpdateDownloader_Extract_Call{Call: _e.mock.On("Extract", ctx, archivePath, destDir)}
}

func (_c *MockUpdateDownloader_Extract_Call) Run(run func(ctx context.Context, archivePath string, destDir string)) *MockUpdateDownloader_Extract_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockUpdateDownloader_Extract_Call) Return(binaryPath string, err error) *MockUpdateDownloader_Extract_Call {
	_c.Call.Return(binaryPath, err)
	return _c
}

func (_c *MockUpdateDownloader_Extract_Call) RunAndReturn(run func(ctx context.Context, archivePath string, destDir string) (string, error)) *MockUpdateDownloader_Extract_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockUpdateApplier is an autogenerated mock type for the UpdateApplier type
type MockUpdateApplier struct {
	mock.Mock
}

type MockUpdateApplier_Expecter struct {
	mock *mock.Mock
}

func (_m *MockUpdateApplier) EXPECT() *MockUpdateApplier_Expecter {
	return &MockUpdateApplier_Expecter{mock: &_m.Mock}
}

// ApplyOnExit provides a mock function for the type MockUpdateApplier
func (_mock *MockUpdateApplier) ApplyOnExit(ctx context.Context) (string, error) {
	ret := _mock.Called(ctx)

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

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

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

// ApplyOnExit is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUpdateApplier_Expecter) ApplyOnExit(ctx interface{}) *MockUpdateApplier_ApplyOnExit_Call {
	return &MockUpdateApplier_ApplyOnExit_Call{Call: _e.mock.On("ApplyOnExit", ctx)}
}

func (_c *MockUpdateApplier_ApplyOnExit_Call) Run(run func(ctx context.Context)) *MockUpdateApplier_ApplyOnExit_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 *MockUpdateApplier_ApplyOnExit_Call) Return(backupPath string, err error) *MockUpdateApplier_ApplyOnExit_Call {
	_c.Call.Return(backupPath, err)
	return _c
}

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

// CanSelfUpdate provides a mock function for the type MockUpdateApplier
func (_mock *MockUpdateApplier) CanSelfUpdate(ctx context.Context) bool {
	ret := _mock.Called(ctx)

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

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

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

// CanSelfUpdate is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUpdateApplier_Expecter) CanSelfUpdate(ctx interface{}) *MockUpdateApplier_CanSelfUpdate_Call {
	return &MockUpdateApplier_CanSelfUpdate_Call{Call: _e.mock.On("CanSelfUpdate", ctx)}
}

func (_c *MockUpdateApplier_CanSelfUpdate_Call) Run(run func(ctx context.Context)) *MockUpdateApplier_CanSelfUpdate_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 *MockUpdateApplier_CanSelfUpdate_Call) Return(b bool) *MockUpdateApplier_CanSelfUpdate_Call {
	_c.Call.Return(b)
	return _c
}

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

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

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

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

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

// ClearStagedUpdate is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUpdateApplier_Expecter) ClearStagedUpdate(ctx interface{}) *MockUpdateApplier_ClearStagedUpdate_Call {
	return &MockUpdateApplier_ClearStagedUpdate_Call{Call: _e.mock.On("ClearStagedUpdate", ctx)}
}

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

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

// GetBinaryPath provides a mock function for the type MockUpdateApplier
func (_mock *MockUpdateApplier) GetBinaryPath() (string, error) {
	ret := _mock.Called()

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

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

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

// GetBinaryPath is a helper method to define mock.On call
func (_e *MockUpdateApplier_Expecter) GetBinaryPath() *MockUpdateApplier_GetBinaryPath_Call {
	return &MockUpdateApplier_GetBinaryPath_Call{Call: _e.mock.On("GetBinaryPath")}
}

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

func (_c *MockUpdateApplier_GetBinaryPath_Call) Return(s string, err error) *MockUpdateApplier_GetBinaryPath_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockUpdateApplier_GetBinaryPath_Call) RunAndReturn(run func() (string, error)) *MockUpdateApplier_GetBinaryPath_Call {
	_c.Call.Return(run)
	return _c
}

// HasStagedUpdate provides a mock function for the type MockUpdateApplier
func (_mock *MockUpdateApplier) HasStagedUpdate(ctx context.Context) bool {
	ret := _mock.Called(ctx)

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

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

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

// HasStagedUpdate is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUpdateApplier_Expecter) HasStagedUpdate(ctx interface{}) *MockUpdateApplier_HasStagedUpdate_Call {
	return &MockUpdateApplier_HasStagedUpdate_Call{Call: _e.mock.On("HasStagedUpdate", ctx)}
}

func (_c *MockUpdateApplier_HasStagedUpdate_Call) Run(run func(ctx context.Context)) *MockUpdateApplier_HasStagedUpdate_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 *MockUpdateApplier_HasStagedUpdate_Call) Return(b bool) *MockUpdateApplier_HasStagedUpdate_Call {
	_c.Call.Return(b)
	return _c
}

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

// SelfUpdateBlockedReason provides a mock function for the type MockUpdateApplier
func (_mock *MockUpdateApplier) SelfUpdateBlockedReason(ctx context.Context) port.SelfUpdateBlockedReason {
	ret := _mock.Called(ctx)

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

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

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

// SelfUpdateBlockedReason is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUpdateApplier_Expecter) SelfUpdateBlockedReason(ctx interface{}) *MockUpdateApplier_SelfUpdateBlockedReason_Call {
	return &MockUpdateApplier_SelfUpdateBlockedReason_Call{Call: _e.mock.On("SelfUpdateBlockedReason", ctx)}
}

func (_c *MockUpdateApplier_SelfUpdateBlockedReason_Call) Run(run func(ctx context.Context)) *MockUpdateApplier_SelfUpdateBlockedReason_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 *MockUpdateApplier_SelfUpdateBlockedReason_Call) Return(selfUpdateBlockedReason port.SelfUpdateBlockedReason) *MockUpdateApplier_SelfUpdateBlockedReason_Call {
	_c.Call.Return(selfUpdateBlockedReason)
	return _c
}

func (_c *MockUpdateApplier_SelfUpdateBlockedReason_Call) RunAndReturn(run func(ctx context.Context) port.SelfUpdateBlockedReason) *MockUpdateApplier_SelfUpdateBlockedReason_Call {
	_c.Call.Return(run)
	return _c
}

// StageUpdate provides a mock function for the type MockUpdateApplier
func (_mock *MockUpdateApplier) StageUpdate(ctx context.Context, newBinaryPath string) error {
	ret := _mock.Called(ctx, newBinaryPath)

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

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

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

// StageUpdate is a helper method to define mock.On call
//   - ctx context.Context
//   - newBinaryPath string
func (_e *MockUpdateApplier_Expecter) StageUpdate(ctx interface{}, newBinaryPath interface{}) *MockUpdateApplier_StageUpdate_Call {
	return &MockUpdateApplier_StageUpdate_Call{Call: _e.mock.On("StageUpdate", ctx, newBinaryPath)}
}

func (_c *MockUpdateApplier_StageUpdate_Call) Run(run func(ctx context.Context, newBinaryPath string)) *MockUpdateApplier_StageUpdate_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)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockUpdateApplier_StageUpdate_Call) RunAndReturn(run func(ctx context.Context, newBinaryPath string) error) *MockUpdateApplier_StageUpdate_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockWebUIConfigSaver is an autogenerated mock type for the WebUIConfigSaver type
type MockWebUIConfigSaver struct {
	mock.Mock
}

type MockWebUIConfigSaver_Expecter struct {
	mock *mock.Mock
}

func (_m *MockWebUIConfigSaver) EXPECT() *MockWebUIConfigSaver_Expecter {
	return &MockWebUIConfigSaver_Expecter{mock: &_m.Mock}
}

// SaveWebUIConfig provides a mock function for the type MockWebUIConfigSaver
func (_mock *MockWebUIConfigSaver) SaveWebUIConfig(ctx context.Context, cfg port.WebUIConfig) error {
	ret := _mock.Called(ctx, cfg)

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

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

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

// SaveWebUIConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - cfg port.WebUIConfig
func (_e *MockWebUIConfigSaver_Expecter) SaveWebUIConfig(ctx interface{}, cfg interface{}) *MockWebUIConfigSaver_SaveWebUIConfig_Call {
	return &MockWebUIConfigSaver_SaveWebUIConfig_Call{Call: _e.mock.On("SaveWebUIConfig", ctx, cfg)}
}

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

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

func (_c *MockWebUIConfigSaver_SaveWebUIConfig_Call) RunAndReturn(run func(ctx context.Context, cfg port.WebUIConfig) error) *MockWebUIConfigSaver_SaveWebUIConfig_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockTexture is an autogenerated mock type for the Texture type
type MockTexture struct {
	mock.Mock
}

type MockTexture_Expecter struct {
	mock *mock.Mock
}

func (_m *MockTexture) EXPECT() *MockTexture_Expecter {
	return &MockTexture_Expecter{mock: &_m.Mock}
}

// GoPointer provides a mock function for the type MockTexture
func (_mock *MockTexture) GoPointer() uintptr {
	ret := _mock.Called()

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

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

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

// GoPointer is a helper method to define mock.On call
func (_e *MockTexture_Expecter) GoPointer() *MockTexture_GoPointer_Call {
	return &MockTexture_GoPointer_Call{Call: _e.mock.On("GoPointer")}
}

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

func (_c *MockTexture_GoPointer_Call) Return(v uintptr) *MockTexture_GoPointer_Call {
	_c.Call.Return(v)
	return _c
}

func (_c *MockTexture_GoPointer_Call) RunAndReturn(run func() uintptr) *MockTexture_GoPointer_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockFindController is an autogenerated mock type for the FindController type
type MockFindController struct {
	mock.Mock
}

type MockFindController_Expecter struct {
	mock *mock.Mock
}

func (_m *MockFindController) EXPECT() *MockFindController_Expecter {
	return &MockFindController_Expecter{mock: &_m.Mock}
}

// CountMatches provides a mock function for the type MockFindController
func (_mock *MockFindController) CountMatches(text string, options port.FindOptions, maxMatches uint) {
	_mock.Called(text, options, maxMatches)
	return
}

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

// CountMatches is a helper method to define mock.On call
//   - text string
//   - options port.FindOptions
//   - maxMatches uint
func (_e *MockFindController_Expecter) CountMatches(text interface{}, options interface{}, maxMatches interface{}) *MockFindController_CountMatches_Call {
	return &MockFindController_CountMatches_Call{Call: _e.mock.On("CountMatches", text, options, maxMatches)}
}

func (_c *MockFindController_CountMatches_Call) Run(run func(text string, options port.FindOptions, maxMatches uint)) *MockFindController_CountMatches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 port.FindOptions
		if args[1] != nil {
			arg1 = args[1].(port.FindOptions)
		}
		var arg2 uint
		if args[2] != nil {
			arg2 = args[2].(uint)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockFindController_CountMatches_Call) RunAndReturn(run func(text string, options port.FindOptions, maxMatches uint)) *MockFindController_CountMatches_Call {
	_c.Run(run)
	return _c
}

// DisconnectSignal provides a mock function for the type MockFindController
func (_mock *MockFindController) DisconnectSignal(id uint) {
	_mock.Called(id)
	return
}

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

// DisconnectSignal is a helper method to define mock.On call
//   - id uint
func (_e *MockFindController_Expecter) DisconnectSignal(id interface{}) *MockFindController_DisconnectSignal_Call {
	return &MockFindController_DisconnectSignal_Call{Call: _e.mock.On("DisconnectSignal", id)}
}

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

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

func (_c *MockFindController_DisconnectSignal_Call) RunAndReturn(run func(id uint)) *MockFindController_DisconnectSignal_Call {
	_c.Run(run)
	return _c
}

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

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

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

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

// GetSearchText is a helper method to define mock.On call
func (_e *MockFindController_Expecter) GetSearchText() *MockFindController_GetSearchText_Call {
	return &MockFindController_GetSearchText_Call{Call: _e.mock.On("GetSearchText")}
}

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

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

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

// OnCountedMatches provides a mock function for the type MockFindController
func (_mock *MockFindController) OnCountedMatches(callback func(matchCount uint)) uint {
	ret := _mock.Called(callback)

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

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

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

// OnCountedMatches is a helper method to define mock.On call
//   - callback func(matchCount uint)
func (_e *MockFindController_Expecter) OnCountedMatches(callback interface{}) *MockFindController_OnCountedMatches_Call {
	return &MockFindController_OnCountedMatches_Call{Call: _e.mock.On("OnCountedMatches", callback)}
}

func (_c *MockFindController_OnCountedMatches_Call) Run(run func(callback func(matchCount uint))) *MockFindController_OnCountedMatches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 func(matchCount uint)
		if args[0] != nil {
			arg0 = args[0].(func(matchCount uint))
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockFindController_OnCountedMatches_Call) Return(v uint) *MockFindController_OnCountedMatches_Call {
	_c.Call.Return(v)
	return _c
}

func (_c *MockFindController_OnCountedMatches_Call) RunAndReturn(run func(callback func(matchCount uint)) uint) *MockFindController_OnCountedMatches_Call {
	_c.Call.Return(run)
	return _c
}

// OnFailedToFindText provides a mock function for the type MockFindController
func (_mock *MockFindController) OnFailedToFindText(callback func()) uint {
	ret := _mock.Called(callback)

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

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

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

// OnFailedToFindText is a helper method to define mock.On call
//   - callback func()
func (_e *MockFindController_Expecter) OnFailedToFindText(callback interface{}) *MockFindController_OnFailedToFindText_Call {
	return &MockFindController_OnFailedToFindText_Call{Call: _e.mock.On("OnFailedToFindText", callback)}
}

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

func (_c *MockFindController_OnFailedToFindText_Call) Return(v uint) *MockFindController_OnFailedToFindText_Call {
	_c.Call.Return(v)
	return _c
}

func (_c *MockFindController_OnFailedToFindText_Call) RunAndReturn(run func(callback func()) uint) *MockFindController_OnFailedToFindText_Call {
	_c.Call.Return(run)
	return _c
}

// OnFoundText provides a mock function for the type MockFindController
func (_mock *MockFindController) OnFoundText(callback func(matchCount uint)) uint {
	ret := _mock.Called(callback)

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

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

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

// OnFoundText is a helper method to define mock.On call
//   - callback func(matchCount uint)
func (_e *MockFindController_Expecter) OnFoundText(callback interface{}) *MockFindController_OnFoundText_Call {
	return &MockFindController_OnFoundText_Call{Call: _e.mock.On("OnFoundText", callback)}
}

func (_c *MockFindController_OnFoundText_Call) Run(run func(callback func(matchCount uint))) *MockFindController_OnFoundText_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 func(matchCount uint)
		if args[0] != nil {
			arg0 = args[0].(func(matchCount uint))
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockFindController_OnFoundText_Call) Return(v uint) *MockFindController_OnFoundText_Call {
	_c.Call.Return(v)
	return _c
}

func (_c *MockFindController_OnFoundText_Call) RunAndReturn(run func(callback func(matchCount uint)) uint) *MockFindController_OnFoundText_Call {
	_c.Call.Return(run)
	return _c
}

// Search provides a mock function for the type MockFindController
func (_mock *MockFindController) Search(text string, options port.FindOptions, maxMatches uint) {
	_mock.Called(text, options, maxMatches)
	return
}

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

// Search is a helper method to define mock.On call
//   - text string
//   - options port.FindOptions
//   - maxMatches uint
func (_e *MockFindController_Expecter) Search(text interface{}, options interface{}, maxMatches interface{}) *MockFindController_Search_Call {
	return &MockFindController_Search_Call{Call: _e.mock.On("Search", text, options, maxMatches)}
}

func (_c *MockFindController_Search_Call) Run(run func(text string, options port.FindOptions, maxMatches uint)) *MockFindController_Search_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 port.FindOptions
		if args[1] != nil {
			arg1 = args[1].(port.FindOptions)
		}
		var arg2 uint
		if args[2] != nil {
			arg2 = args[2].(uint)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockFindController_Search_Call) RunAndReturn(run func(text string, options port.FindOptions, maxMatches uint)) *MockFindController_Search_Call {
	_c.Run(run)
	return _c
}

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

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

// SearchFinish is a helper method to define mock.On call
func (_e *MockFindController_Expecter) SearchFinish() *MockFindController_SearchFinish_Call {
	return &MockFindController_SearchFinish_Call{Call: _e.mock.On("SearchFinish")}
}

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

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

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

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

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

// SearchNext is a helper method to define mock.On call
func (_e *MockFindController_Expecter) SearchNext() *MockFindController_SearchNext_Call {
	return &MockFindController_SearchNext_Call{Call: _e.mock.On("SearchNext")}
}

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

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

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

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

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

// SearchPrevious is a helper method to define mock.On call
func (_e *MockFindController_Expecter) SearchPrevious() *MockFindController_SearchPrevious_Call {
	return &MockFindController_SearchPrevious_Call{Call: _e.mock.On("SearchPrevious")}
}

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

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

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

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

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

	return mock
}

// MockWebView is an autogenerated mock type for the WebView type
type MockWebView struct {
	mock.Mock
}

type MockWebView_Expecter struct {
	mock *mock.Mock
}

func (_m *MockWebView) EXPECT() *MockWebView_Expecter {
	return &MockWebView_Expecter{mock: &_m.Mock}
}

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

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

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

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

// CanGoBack is a helper method to define mock.On call
func (_e *MockWebView_Expecter) CanGoBack() *MockWebView_CanGoBack_Call {
	return &MockWebView_CanGoBack_Call{Call: _e.mock.On("CanGoBack")}
}

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

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

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

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

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

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

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

// CanGoForward is a helper method to define mock.On call
func (_e *MockWebView_Expecter) CanGoForward() *MockWebView_CanGoForward_Call {
	return &MockWebView_CanGoForward_Call{Call: _e.mock.On("CanGoForward")}
}

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

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

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

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

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

// Destroy is a helper method to define mock.On call
func (_e *MockWebView_Expecter) Destroy() *MockWebView_Destroy_Call {
	return &MockWebView_Destroy_Call{Call: _e.mock.On("Destroy")}
}

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

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

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

// EstimatedProgress provides a mock function for the type MockWebView
func (_mock *MockWebView) EstimatedProgress() float64 {
	ret := _mock.Called()

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

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

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

// EstimatedProgress is a helper method to define mock.On call
func (_e *MockWebView_Expecter) EstimatedProgress() *MockWebView_EstimatedProgress_Call {
	return &MockWebView_EstimatedProgress_Call{Call: _e.mock.On("EstimatedProgress")}
}

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

func (_c *MockWebView_EstimatedProgress_Call) Return(f float64) *MockWebView_EstimatedProgress_Call {
	_c.Call.Return(f)
	return _c
}

func (_c *MockWebView_EstimatedProgress_Call) RunAndReturn(run func() float64) *MockWebView_EstimatedProgress_Call {
	_c.Call.Return(run)
	return _c
}

// Favicon provides a mock function for the type MockWebView
func (_mock *MockWebView) Favicon() port.Texture {
	ret := _mock.Called()

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

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

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

// Favicon is a helper method to define mock.On call
func (_e *MockWebView_Expecter) Favicon() *MockWebView_Favicon_Call {
	return &MockWebView_Favicon_Call{Call: _e.mock.On("Favicon")}
}

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

func (_c *MockWebView_Favicon_Call) Return(texture port.Texture) *MockWebView_Favicon_Call {
	_c.Call.Return(texture)
	return _c
}

func (_c *MockWebView_Favicon_Call) RunAndReturn(run func() port.Texture) *MockWebView_Favicon_Call {
	_c.Call.Return(run)
	return _c
}

// Generation provides a mock function for the type MockWebView
func (_mock *MockWebView) Generation() uint64 {
	ret := _mock.Called()

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

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

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

// Generation is a helper method to define mock.On call
func (_e *MockWebView_Expecter) Generation() *MockWebView_Generation_Call {
	return &MockWebView_Generation_Call{Call: _e.mock.On("Generation")}
}

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

func (_c *MockWebView_Generation_Call) Return(v uint64) *MockWebView_Generation_Call {
	_c.Call.Return(v)
	return _c
}

func (_c *MockWebView_Generation_Call) RunAndReturn(run func() uint64) *MockWebView_Generation_Call {
	_c.Call.Return(run)
	return _c
}

// GetFindController provides a mock function for the type MockWebView
func (_mock *MockWebView) GetFindController() port.FindController {
	ret := _mock.Called()

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

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

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

// GetFindController is a helper method to define mock.On call
func (_e *MockWebView_Expecter) GetFindController() *MockWebView_GetFindController_Call {
	return &MockWebView_GetFindController_Call{Call: _e.mock.On("GetFindController")}
}

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

func (_c *MockWebView_GetFindController_Call) Return(findController port.FindController) *MockWebView_GetFindController_Call {
	_c.Call.Return(findController)
	return _c
}

func (_c *MockWebView_GetFindController_Call) RunAndReturn(run func() port.FindController) *MockWebView_GetFindController_Call {
	_c.Call.Return(run)
	return _c
}

// GetZoomLevel provides a mock function for the type MockWebView
func (_mock *MockWebView) GetZoomLevel() float64 {
	ret := _mock.Called()

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

	var r0 float64
	if returnFunc, ok := ret.Get(0).(func() float64); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(float64)
	}
	return r0
}

// MockWebView_GetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetZoomLevel'
type MockWebView_GetZoomLevel_Call struct {
	*mock.Call
}

// GetZoomLevel is a helper method to define mock.On call
func (_e *MockWebView_Expecter) GetZoomLevel() *MockWebView_GetZoomLevel_Call {
	return &MockWebView_GetZoomLevel_Call{Call: _e.mock.On("GetZoomLevel")}
}

func (_c *MockWebView_GetZoomLevel_Call) Run(run func()) *MockWebView_GetZoomLevel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWebView_GetZoomLevel_Call) Return(f float64) *MockWebView_GetZoomLevel_Call {
	_c.Call.Return(f)
	return _c
}

func (_c *MockWebView_GetZoomLevel_Call) RunAndReturn(run func() float64) *MockWebView_GetZoomLevel_Call {
	_c.Call.Return(run)
	return _c
}

// GoBack provides a mock function for the type MockWebView
func (_mock *MockWebView) GoBack(ctx context.Context) error {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GoBack")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockWebView_GoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoBack'
type MockWebView_GoBack_Call struct {
	*mock.Call
}

// GoBack is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockWebView_Expecter) GoBack(ctx interface{}) *MockWebView_GoBack_Call {
	return &MockWebView_GoBack_Call{Call: _e.mock.On("GoBack", ctx)}
}

func (_c *MockWebView_GoBack_Call) Run(run func(ctx context.Context)) *MockWebView_GoBack_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 *MockWebView_GoBack_Call) Return(err error) *MockWebView_GoBack_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockWebView_GoBack_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_GoBack_Call {
	_c.Call.Return(run)
	return _c
}

// GoForward provides a mock function for the type MockWebView
func (_mock *MockWebView) GoForward(ctx context.Context) error {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GoForward")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockWebView_GoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoForward'
type MockWebView_GoForward_Call struct {
	*mock.Call
}

// GoForward is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockWebView_Expecter) GoForward(ctx interface{}) *MockWebView_GoForward_Call {
	return &MockWebView_GoForward_Call{Call: _e.mock.On("GoForward", ctx)}
}

func (_c *MockWebView_GoForward_Call) Run(run func(ctx context.Context)) *MockWebView_GoForward_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 *MockWebView_GoForward_Call) Return(err error) *MockWebView_GoForward_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockWebView_GoForward_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_GoForward_Call {
	_c.Call.Return(run)
	return _c
}

// ID provides a mock function for the type MockWebView
func (_mock *MockWebView) ID() port.WebViewID {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for ID")
	}

	var r0 port.WebViewID
	if returnFunc, ok := ret.Get(0).(func() port.WebViewID); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(port.WebViewID)
	}
	return r0
}

// MockWebView_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID'
type MockWebView_ID_Call struct {
	*mock.Call
}

// ID is a helper method to define mock.On call
func (_e *MockWebView_Expecter) ID() *MockWebView_ID_Call {
	return &MockWebView_ID_Call{Call: _e.mock.On("ID")}
}

func (_c *MockWebView_ID_Call) Run(run func()) *MockWebView_ID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWebView_ID_Call) Return(webViewID port.WebViewID) *MockWebView_ID_Call {
	_c.Call.Return(webViewID)
	return _c
}

func (_c *MockWebView_ID_Call) RunAndReturn(run func() port.WebViewID) *MockWebView_ID_Call {
	_c.Call.Return(run)
	return _c
}

// IsDestroyed provides a mock function for the type MockWebView
func (_mock *MockWebView) IsDestroyed() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for IsDestroyed")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockWebView_IsDestroyed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsDestroyed'
type MockWebView_IsDestroyed_Call struct {
	*mock.Call
}

// IsDestroyed is a helper method to define mock.On call
func (_e *MockWebView_Expecter) IsDestroyed() *MockWebView_IsDestroyed_Call {
	return &MockWebView_IsDestroyed_Call{Call: _e.mock.On("IsDestroyed")}
}

func (_c *MockWebView_IsDestroyed_Call) Run(run func()) *MockWebView_IsDestroyed_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWebView_IsDestroyed_Call) Return(b bool) *MockWebView_IsDestroyed_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockWebView_IsDestroyed_Call) RunAndReturn(run func() bool) *MockWebView_IsDestroyed_Call {
	_c.Call.Return(run)
	return _c
}

// IsFullscreen provides a mock function for the type MockWebView
func (_mock *MockWebView) IsFullscreen() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for IsFullscreen")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockWebView_IsFullscreen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsFullscreen'
type MockWebView_IsFullscreen_Call struct {
	*mock.Call
}

// IsFullscreen is a helper method to define mock.On call
func (_e *MockWebView_Expecter) IsFullscreen() *MockWebView_IsFullscreen_Call {
	return &MockWebView_IsFullscreen_Call{Call: _e.mock.On("IsFullscreen")}
}

func (_c *MockWebView_IsFullscreen_Call) Run(run func()) *MockWebView_IsFullscreen_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWebView_IsFullscreen_Call) Return(b bool) *MockWebView_IsFullscreen_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockWebView_IsFullscreen_Call) RunAndReturn(run func() bool) *MockWebView_IsFullscreen_Call {
	_c.Call.Return(run)
	return _c
}

// IsLoading provides a mock function for the type MockWebView
func (_mock *MockWebView) IsLoading() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for IsLoading")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockWebView_IsLoading_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsLoading'
type MockWebView_IsLoading_Call struct {
	*mock.Call
}

// IsLoading is a helper method to define mock.On call
func (_e *MockWebView_Expecter) IsLoading() *MockWebView_IsLoading_Call {
	return &MockWebView_IsLoading_Call{Call: _e.mock.On("IsLoading")}
}

func (_c *MockWebView_IsLoading_Call) Run(run func()) *MockWebView_IsLoading_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWebView_IsLoading_Call) Return(b bool) *MockWebView_IsLoading_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockWebView_IsLoading_Call) RunAndReturn(run func() bool) *MockWebView_IsLoading_Call {
	_c.Call.Return(run)
	return _c
}

// IsPlayingAudio provides a mock function for the type MockWebView
func (_mock *MockWebView) IsPlayingAudio() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for IsPlayingAudio")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockWebView_IsPlayingAudio_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsPlayingAudio'
type MockWebView_IsPlayingAudio_Call struct {
	*mock.Call
}

// IsPlayingAudio is a helper method to define mock.On call
func (_e *MockWebView_Expecter) IsPlayingAudio() *MockWebView_IsPlayingAudio_Call {
	return &MockWebView_IsPlayingAudio_Call{Call: _e.mock.On("IsPlayingAudio")}
}

func (_c *MockWebView_IsPlayingAudio_Call) Run(run func()) *MockWebView_IsPlayingAudio_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWebView_IsPlayingAudio_Call) Return(b bool) *MockWebView_IsPlayingAudio_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockWebView_IsPlayingAudio_Call) RunAndReturn(run func() bool) *MockWebView_IsPlayingAudio_Call {
	_c.Call.Return(run)
	return _c
}

// LoadHTML provides a mock function for the type MockWebView
func (_mock *MockWebView) LoadHTML(ctx context.Context, content string, baseURI string) error {
	ret := _mock.Called(ctx, content, baseURI)

	if len(ret) == 0 {
		panic("no return value specified for LoadHTML")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, content, baseURI)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockWebView_LoadHTML_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadHTML'
type MockWebView_LoadHTML_Call struct {
	*mock.Call
}

// LoadHTML is a helper method to define mock.On call
//   - ctx context.Context
//   - content string
//   - baseURI string
func (_e *MockWebView_Expecter) LoadHTML(ctx interface{}, content interface{}, baseURI interface{}) *MockWebView_LoadHTML_Call {
	return &MockWebView_LoadHTML_Call{Call: _e.mock.On("LoadHTML", ctx, content, baseURI)}
}

func (_c *MockWebView_LoadHTML_Call) Run(run func(ctx context.Context, content string, baseURI string)) *MockWebView_LoadHTML_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockWebView_LoadHTML_Call) Return(err error) *MockWebView_LoadHTML_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockWebView_LoadHTML_Call) RunAndReturn(run func(ctx context.Context, content string, baseURI string) error) *MockWebView_LoadHTML_Call {
	_c.Call.Return(run)
	return _c
}

// LoadURI provides a mock function for the type MockWebView
func (_mock *MockWebView) LoadURI(ctx context.Context, uri string) error {
	ret := _mock.Called(ctx, uri)

	if len(ret) == 0 {
		panic("no return value specified for LoadURI")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(ctx, uri)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockWebView_LoadURI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadURI'
type MockWebView_LoadURI_Call struct {
	*mock.Call
}

// LoadURI is a helper method to define mock.On call
//   - ctx context.Context
//   - uri string
func (_e *MockWebView_Expecter) LoadURI(ctx interface{}, uri interface{}) *MockWebView_LoadURI_Call {
	return &MockWebView_LoadURI_Call{Call: _e.mock.On("LoadURI", ctx, uri)}
}

func (_c *MockWebView_LoadURI_Call) Run(run func(ctx context.Context, uri string)) *MockWebView_LoadURI_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)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockWebView_LoadURI_Call) Return(err error) *MockWebView_LoadURI_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockWebView_LoadURI_Call) RunAndReturn(run func(ctx context.Context, uri string) error) *MockWebView_LoadURI_Call {
	_c.Call.Return(run)
	return _c
}

// Reload provides a mock function for the type MockWebView
func (_mock *MockWebView) Reload(ctx context.Context) error {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for Reload")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockWebView_Reload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reload'
type MockWebView_Reload_Call struct {
	*mock.Call
}

// Reload is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockWebView_Expecter) Reload(ctx interface{}) *MockWebView_Reload_Call {
	return &MockWebView_Reload_Call{Call: _e.mock.On("Reload", ctx)}
}

func (_c *MockWebView_Reload_Call) Run(run func(ctx context.Context)) *MockWebView_Reload_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 *MockWebView_Reload_Call) Return(err error) *MockWebView_Reload_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockWebView_Reload_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_Reload_Call {
	_c.Call.Return(run)
	return _c
}

// ReloadBypassCache provides a mock function for the type MockWebView
func (_mock *MockWebView) ReloadBypassCache(ctx context.Context) error {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for ReloadBypassCache")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockWebView_ReloadBypassCache_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReloadBypassCache'
type MockWebView_ReloadBypassCache_Call struct {
	*mock.Call
}

// ReloadBypassCache is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockWebView_Expecter) ReloadBypassCache(ctx interface{}) *MockWebView_ReloadBypassCache_Call {
	return &MockWebView_ReloadBypassCache_Call{Call: _e.mock.On("ReloadBypassCache", ctx)}
}

func (_c *MockWebView_ReloadBypassCache_Call) Run(run func(ctx context.Context)) *MockWebView_ReloadBypassCache_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 *MockWebView_ReloadBypassCache_Call) Return(err error) *MockWebView_ReloadBypassCache_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockWebView_ReloadBypassCache_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_ReloadBypassCache_Call {
	_c.Call.Return(run)
	return _c
}

// ResetBackgroundToDefault provides a mock function for the type MockWebView
func (_mock *MockWebView) ResetBackgroundToDefault() {
	_mock.Called()
	return
}

// MockWebView_ResetBackgroundToDefault_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetBackgroundToDefault'
type MockWebView_ResetBackgroundToDefault_Call struct {
	*mock.Call
}

// ResetBackgroundToDefault is a helper method to define mock.On call
func (_e *MockWebView_Expecter) ResetBackgroundToDefault() *MockWebView_ResetBackgroundToDefault_Call {
	return &MockWebView_ResetBackgroundToDefault_Call{Call: _e.mock.On("ResetBackgroundToDefault")}
}

func (_c *MockWebView_ResetBackgroundToDefault_Call) Run(run func()) *MockWebView_ResetBackgroundToDefault_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWebView_ResetBackgroundToDefault_Call) Return() *MockWebView_ResetBackgroundToDefault_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWebView_ResetBackgroundToDefault_Call) RunAndReturn(run func()) *MockWebView_ResetBackgroundToDefault_Call {
	_c.Run(run)
	return _c
}

// RunJavaScript provides a mock function for the type MockWebView
func (_mock *MockWebView) RunJavaScript(ctx context.Context, script string) {
	_mock.Called(ctx, script)
	return
}

// MockWebView_RunJavaScript_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunJavaScript'
type MockWebView_RunJavaScript_Call struct {
	*mock.Call
}

// RunJavaScript is a helper method to define mock.On call
//   - ctx context.Context
//   - script string
func (_e *MockWebView_Expecter) RunJavaScript(ctx interface{}, script interface{}) *MockWebView_RunJavaScript_Call {
	return &MockWebView_RunJavaScript_Call{Call: _e.mock.On("RunJavaScript", ctx, script)}
}

func (_c *MockWebView_RunJavaScript_Call) Run(run func(ctx context.Context, script string)) *MockWebView_RunJavaScript_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)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockWebView_RunJavaScript_Call) Return() *MockWebView_RunJavaScript_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWebView_RunJavaScript_Call) RunAndReturn(run func(ctx context.Context, script string)) *MockWebView_RunJavaScript_Call {
	_c.Run(run)
	return _c
}

// SetBackgroundColor provides a mock function for the type MockWebView
func (_mock *MockWebView) SetBackgroundColor(r float64, g float64, b float64, a float64) {
	_mock.Called(r, g, b, a)
	return
}

// MockWebView_SetBackgroundColor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetBackgroundColor'
type MockWebView_SetBackgroundColor_Call struct {
	*mock.Call
}

// SetBackgroundColor is a helper method to define mock.On call
//   - r float64
//   - g float64
//   - b float64
//   - a float64
func (_e *MockWebView_Expecter) SetBackgroundColor(r interface{}, g interface{}, b interface{}, a interface{}) *MockWebView_SetBackgroundColor_Call {
	return &MockWebView_SetBackgroundColor_Call{Call: _e.mock.On("SetBackgroundColor", r, g, b, a)}
}

func (_c *MockWebView_SetBackgroundColor_Call) Run(run func(r float64, g float64, b float64, a float64)) *MockWebView_SetBackgroundColor_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 float64
		if args[0] != nil {
			arg0 = args[0].(float64)
		}
		var arg1 float64
		if args[1] != nil {
			arg1 = args[1].(float64)
		}
		var arg2 float64
		if args[2] != nil {
			arg2 = args[2].(float64)
		}
		var arg3 float64
		if args[3] != nil {
			arg3 = args[3].(float64)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockWebView_SetBackgroundColor_Call) Return() *MockWebView_SetBackgroundColor_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWebView_SetBackgroundColor_Call) RunAndReturn(run func(r float64, g float64, b float64, a float64)) *MockWebView_SetBackgroundColor_Call {
	_c.Run(run)
	return _c
}

// SetCallbacks provides a mock function for the type MockWebView
func (_mock *MockWebView) SetCallbacks(callbacks *port.WebViewCallbacks) {
	_mock.Called(callbacks)
	return
}

// MockWebView_SetCallbacks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCallbacks'
type MockWebView_SetCallbacks_Call struct {
	*mock.Call
}

// SetCallbacks is a helper method to define mock.On call
//   - callbacks *port.WebViewCallbacks
func (_e *MockWebView_Expecter) SetCallbacks(callbacks interface{}) *MockWebView_SetCallbacks_Call {
	return &MockWebView_SetCallbacks_Call{Call: _e.mock.On("SetCallbacks", callbacks)}
}

func (_c *MockWebView_SetCallbacks_Call) Run(run func(callbacks *port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *port.WebViewCallbacks
		if args[0] != nil {
			arg0 = args[0].(*port.WebViewCallbacks)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWebView_SetCallbacks_Call) Return() *MockWebView_SetCallbacks_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWebView_SetCallbacks_Call) RunAndReturn(run func(callbacks *port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
	_c.Run(run)
	return _c
}

// SetZoomLevel provides a mock function for the type MockWebView
func (_mock *MockWebView) SetZoomLevel(ctx context.Context, level float64) error {
	ret := _mock.Called(ctx, level)

	if len(ret) == 0 {
		panic("no return value specified for SetZoomLevel")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, float64) error); ok {
		r0 = returnFunc(ctx, level)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockWebView_SetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetZoomLevel'
type MockWebView_SetZoomLevel_Call struct {
	*mock.Call
}

// SetZoomLevel is a helper method to define mock.On call
//   - ctx context.Context
//   - level float64
func (_e *MockWebView_Expecter) SetZoomLevel(ctx interface{}, level interface{}) *MockWebView_SetZoomLevel_Call {
	return &MockWebView_SetZoomLevel_Call{Call: _e.mock.On("SetZoomLevel", ctx, level)}
}

func (_c *MockWebView_SetZoomLevel_Call) Run(run func(ctx context.Context, level float64)) *MockWebView_SetZoomLevel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 float64
		if args[1] != nil {
			arg1 = args[1].(float64)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockWebView_SetZoomLevel_Call) Return(err error) *MockWebView_SetZoomLevel_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockWebView_SetZoomLevel_Call) RunAndReturn(run func(ctx context.Context, level float64) error) *MockWebView_SetZoomLevel_Call {
	_c.Call.Return(run)
	return _c
}

// State provides a mock function for the type MockWebView
func (_mock *MockWebView) State() port.WebViewState {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for State")
	}

	var r0 port.WebViewState
	if returnFunc, ok := ret.Get(0).(func() port.WebViewState); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(port.WebViewState)
	}
	return r0
}

// MockWebView_State_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'State'
type MockWebView_State_Call struct {
	*mock.Call
}

// State is a helper method to define mock.On call
func (_e *MockWebView_Expecter) State() *MockWebView_State_Call {
	return &MockWebView_State_Call{Call: _e.mock.On("State")}
}

func (_c *MockWebView_State_Call) Run(run func()) *MockWebView_State_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWebView_State_Call) Return(webViewState port.WebViewState) *MockWebView_State_Call {
	_c.Call.Return(webViewState)
	return _c
}

func (_c *MockWebView_State_Call) RunAndReturn(run func() port.WebViewState) *MockWebView_State_Call {
	_c.Call.Return(run)
	return _c
}

// Stop provides a mock function for the type MockWebView
func (_mock *MockWebView) Stop(ctx context.Context) error {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for Stop")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockWebView_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
type MockWebView_Stop_Call struct {
	*mock.Call
}

// Stop is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockWebView_Expecter) Stop(ctx interface{}) *MockWebView_Stop_Call {
	return &MockWebView_Stop_Call{Call: _e.mock.On("Stop", ctx)}
}

func (_c *MockWebView_Stop_Call) Run(run func(ctx context.Context)) *MockWebView_Stop_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 *MockWebView_Stop_Call) Return(err error) *MockWebView_Stop_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockWebView_Stop_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_Stop_Call {
	_c.Call.Return(run)
	return _c
}

// Title provides a mock function for the type MockWebView
func (_mock *MockWebView) Title() string {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for Title")
	}

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

// MockWebView_Title_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Title'
type MockWebView_Title_Call struct {
	*mock.Call
}

// Title is a helper method to define mock.On call
func (_e *MockWebView_Expecter) Title() *MockWebView_Title_Call {
	return &MockWebView_Title_Call{Call: _e.mock.On("Title")}
}

func (_c *MockWebView_Title_Call) Run(run func()) *MockWebView_Title_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWebView_Title_Call) Return(s string) *MockWebView_Title_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockWebView_Title_Call) RunAndReturn(run func() string) *MockWebView_Title_Call {
	_c.Call.Return(run)
	return _c
}

// URI provides a mock function for the type MockWebView
func (_mock *MockWebView) URI() string {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for URI")
	}

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

// MockWebView_URI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'URI'
type MockWebView_URI_Call struct {
	*mock.Call
}

// URI is a helper method to define mock.On call
func (_e *MockWebView_Expecter) URI() *MockWebView_URI_Call {
	return &MockWebView_URI_Call{Call: _e.mock.On("URI")}
}

func (_c *MockWebView_URI_Call) Run(run func()) *MockWebView_URI_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWebView_URI_Call) Return(s string) *MockWebView_URI_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockWebView_URI_Call) RunAndReturn(run func() string) *MockWebView_URI_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockWebViewPool creates a new instance of MockWebViewPool. 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 NewMockWebViewPool(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockWebViewPool {
	mock := &MockWebViewPool{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockWebViewPool is an autogenerated mock type for the WebViewPool type
type MockWebViewPool struct {
	mock.Mock
}

type MockWebViewPool_Expecter struct {
	mock *mock.Mock
}

func (_m *MockWebViewPool) EXPECT() *MockWebViewPool_Expecter {
	return &MockWebViewPool_Expecter{mock: &_m.Mock}
}

// Acquire provides a mock function for the type MockWebViewPool
func (_mock *MockWebViewPool) Acquire(ctx context.Context) (port.WebView, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for Acquire")
	}

	var r0 port.WebView
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(port.WebView)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockWebViewPool_Acquire_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Acquire'
type MockWebViewPool_Acquire_Call struct {
	*mock.Call
}

// Acquire is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockWebViewPool_Expecter) Acquire(ctx interface{}) *MockWebViewPool_Acquire_Call {
	return &MockWebViewPool_Acquire_Call{Call: _e.mock.On("Acquire", ctx)}
}

func (_c *MockWebViewPool_Acquire_Call) Run(run func(ctx context.Context)) *MockWebViewPool_Acquire_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 *MockWebViewPool_Acquire_Call) Return(webView port.WebView, err error) *MockWebViewPool_Acquire_Call {
	_c.Call.Return(webView, err)
	return _c
}

func (_c *MockWebViewPool_Acquire_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) *MockWebViewPool_Acquire_Call {
	_c.Call.Return(run)
	return _c
}

// Close provides a mock function for the type MockWebViewPool
func (_mock *MockWebViewPool) Close() {
	_mock.Called()
	return
}

// MockWebViewPool_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
type MockWebViewPool_Close_Call struct {
	*mock.Call
}

// Close is a helper method to define mock.On call
func (_e *MockWebViewPool_Expecter) Close() *MockWebViewPool_Close_Call {
	return &MockWebViewPool_Close_Call{Call: _e.mock.On("Close")}
}

func (_c *MockWebViewPool_Close_Call) Run(run func()) *MockWebViewPool_Close_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWebViewPool_Close_Call) Return() *MockWebViewPool_Close_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWebViewPool_Close_Call) RunAndReturn(run func()) *MockWebViewPool_Close_Call {
	_c.Run(run)
	return _c
}

// Prewarm provides a mock function for the type MockWebViewPool
func (_mock *MockWebViewPool) Prewarm(count int) {
	_mock.Called(count)
	return
}

// MockWebViewPool_Prewarm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Prewarm'
type MockWebViewPool_Prewarm_Call struct {
	*mock.Call
}

// Prewarm is a helper method to define mock.On call
//   - count int
func (_e *MockWebViewPool_Expecter) Prewarm(count interface{}) *MockWebViewPool_Prewarm_Call {
	return &MockWebViewPool_Prewarm_Call{Call: _e.mock.On("Prewarm", count)}
}

func (_c *MockWebViewPool_Prewarm_Call) Run(run func(count int)) *MockWebViewPool_Prewarm_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWebViewPool_Prewarm_Call) Return() *MockWebViewPool_Prewarm_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWebViewPool_Prewarm_Call) RunAndReturn(run func(count int)) *MockWebViewPool_Prewarm_Call {
	_c.Run(run)
	return _c
}

// PrewarmAsync provides a mock function for the type MockWebViewPool
func (_mock *MockWebViewPool) PrewarmAsync(ctx context.Context, count int) {
	_mock.Called(ctx, count)
	return
}

// MockWebViewPool_PrewarmAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrewarmAsync'
type MockWebViewPool_PrewarmAsync_Call struct {
	*mock.Call
}

// PrewarmAsync is a helper method to define mock.On call
//   - ctx context.Context
//   - count int
func (_e *MockWebViewPool_Expecter) PrewarmAsync(ctx interface{}, count interface{}) *MockWebViewPool_PrewarmAsync_Call {
	return &MockWebViewPool_PrewarmAsync_Call{Call: _e.mock.On("PrewarmAsync", ctx, count)}
}

func (_c *MockWebViewPool_PrewarmAsync_Call) Run(run func(ctx context.Context, count int)) *MockWebViewPool_PrewarmAsync_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockWebViewPool_PrewarmAsync_Call) Return() *MockWebViewPool_PrewarmAsync_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWebViewPool_PrewarmAsync_Call) RunAndReturn(run func(ctx context.Context, count int)) *MockWebViewPool_PrewarmAsync_Call {
	_c.Run(run)
	return _c
}

// Release provides a mock function for the type MockWebViewPool
func (_mock *MockWebViewPool) Release(wv port.WebView) {
	_mock.Called(wv)
	return
}

// MockWebViewPool_Release_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Release'
type MockWebViewPool_Release_Call struct {
	*mock.Call
}

// Release is a helper method to define mock.On call
//   - wv port.WebView
func (_e *MockWebViewPool_Expecter) Release(wv interface{}) *MockWebViewPool_Release_Call {
	return &MockWebViewPool_Release_Call{Call: _e.mock.On("Release", wv)}
}

func (_c *MockWebViewPool_Release_Call) Run(run func(wv port.WebView)) *MockWebViewPool_Release_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 port.WebView
		if args[0] != nil {
			arg0 = args[0].(port.WebView)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWebViewPool_Release_Call) Return() *MockWebViewPool_Release_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWebViewPool_Release_Call) RunAndReturn(run func(wv port.WebView)) *MockWebViewPool_Release_Call {
	_c.Run(run)
	return _c
}

// Size provides a mock function for the type MockWebViewPool
func (_mock *MockWebViewPool) Size() int {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for Size")
	}

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

// MockWebViewPool_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size'
type MockWebViewPool_Size_Call struct {
	*mock.Call
}

// Size is a helper method to define mock.On call
func (_e *MockWebViewPool_Expecter) Size() *MockWebViewPool_Size_Call {
	return &MockWebViewPool_Size_Call{Call: _e.mock.On("Size")}
}

func (_c *MockWebViewPool_Size_Call) Run(run func()) *MockWebViewPool_Size_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWebViewPool_Size_Call) Return(n int) *MockWebViewPool_Size_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockWebViewPool_Size_Call) RunAndReturn(run func() int) *MockWebViewPool_Size_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockWebViewFactory creates a new instance of MockWebViewFactory. 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 NewMockWebViewFactory(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockWebViewFactory {
	mock := &MockWebViewFactory{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockWebViewFactory is an autogenerated mock type for the WebViewFactory type
type MockWebViewFactory struct {
	mock.Mock
}

type MockWebViewFactory_Expecter struct {
	mock *mock.Mock
}

func (_m *MockWebViewFactory) EXPECT() *MockWebViewFactory_Expecter {
	return &MockWebViewFactory_Expecter{mock: &_m.Mock}
}

// Create provides a mock function for the type MockWebViewFactory
func (_mock *MockWebViewFactory) Create(ctx context.Context) (port.WebView, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for Create")
	}

	var r0 port.WebView
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(port.WebView)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockWebViewFactory_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
type MockWebViewFactory_Create_Call struct {
	*mock.Call
}

// Create is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockWebViewFactory_Expecter) Create(ctx interface{}) *MockWebViewFactory_Create_Call {
	return &MockWebViewFactory_Create_Call{Call: _e.mock.On("Create", ctx)}
}

func (_c *MockWebViewFactory_Create_Call) Run(run func(ctx context.Context)) *MockWebViewFactory_Create_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 *MockWebViewFactory_Create_Call) Return(webView port.WebView, err error) *MockWebViewFactory_Create_Call {
	_c.Call.Return(webView, err)
	return _c
}

func (_c *MockWebViewFactory_Create_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) *MockWebViewFactory_Create_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRelated provides a mock function for the type MockWebViewFactory
func (_mock *MockWebViewFactory) CreateRelated(ctx context.Context, parentID port.WebViewID) (port.WebView, error) {
	ret := _mock.Called(ctx, parentID)

	if len(ret) == 0 {
		panic("no return value specified for CreateRelated")
	}

	var r0 port.WebView
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) (port.WebView, error)); ok {
		return returnFunc(ctx, parentID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) port.WebView); ok {
		r0 = returnFunc(ctx, parentID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(port.WebView)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, port.WebViewID) error); ok {
		r1 = returnFunc(ctx, parentID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockWebViewFactory_CreateRelated_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRelated'
type MockWebViewFactory_CreateRelated_Call struct {
	*mock.Call
}

// CreateRelated is a helper method to define mock.On call
//   - ctx context.Context
//   - parentID port.WebViewID
func (_e *MockWebViewFactory_Expecter) CreateRelated(ctx interface{}, parentID interface{}) *MockWebViewFactory_CreateRelated_Call {
	return &MockWebViewFactory_CreateRelated_Call{Call: _e.mock.On("CreateRelated", ctx, parentID)}
}

func (_c *MockWebViewFactory_CreateRelated_Call) Run(run func(ctx context.Context, parentID port.WebViewID)) *MockWebViewFactory_CreateRelated_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 port.WebViewID
		if args[1] != nil {
			arg1 = args[1].(port.WebViewID)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockWebViewFactory_CreateRelated_Call) Return(webView port.WebView, err error) *MockWebViewFactory_CreateRelated_Call {
	_c.Call.Return(webView, err)
	return _c
}

func (_c *MockWebViewFactory_CreateRelated_Call) RunAndReturn(run func(ctx context.Context, parentID port.WebViewID) (port.WebView, error)) *MockWebViewFactory_CreateRelated_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockDevToolsOpener creates a new instance of MockDevToolsOpener. 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 NewMockDevToolsOpener(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockDevToolsOpener {
	mock := &MockDevToolsOpener{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockDevToolsOpener is an autogenerated mock type for the DevToolsOpener type
type MockDevToolsOpener struct {
	mock.Mock
}

type MockDevToolsOpener_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDevToolsOpener) EXPECT() *MockDevToolsOpener_Expecter {
	return &MockDevToolsOpener_Expecter{mock: &_m.Mock}
}

// OpenDevTools provides a mock function for the type MockDevToolsOpener
func (_mock *MockDevToolsOpener) OpenDevTools() {
	_mock.Called()
	return
}

// MockDevToolsOpener_OpenDevTools_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenDevTools'
type MockDevToolsOpener_OpenDevTools_Call struct {
	*mock.Call
}

// OpenDevTools is a helper method to define mock.On call
func (_e *MockDevToolsOpener_Expecter) OpenDevTools() *MockDevToolsOpener_OpenDevTools_Call {
	return &MockDevToolsOpener_OpenDevTools_Call{Call: _e.mock.On("OpenDevTools")}
}

func (_c *MockDevToolsOpener_OpenDevTools_Call) Run(run func()) *MockDevToolsOpener_OpenDevTools_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockDevToolsOpener_OpenDevTools_Call) Return() *MockDevToolsOpener_OpenDevTools_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockDevToolsOpener_OpenDevTools_Call) RunAndReturn(run func()) *MockDevToolsOpener_OpenDevTools_Call {
	_c.Run(run)
	return _c
}

// NewMockPrinter creates a new instance of MockPrinter. 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 NewMockPrinter(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockPrinter {
	mock := &MockPrinter{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockPrinter is an autogenerated mock type for the Printer type
type MockPrinter struct {
	mock.Mock
}

type MockPrinter_Expecter struct {
	mock *mock.Mock
}

func (_m *MockPrinter) EXPECT() *MockPrinter_Expecter {
	return &MockPrinter_Expecter{mock: &_m.Mock}
}

// PrintPage provides a mock function for the type MockPrinter
func (_mock *MockPrinter) PrintPage() {
	_mock.Called()
	return
}

// MockPrinter_PrintPage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrintPage'
type MockPrinter_PrintPage_Call struct {
	*mock.Call
}

// PrintPage is a helper method to define mock.On call
func (_e *MockPrinter_Expecter) PrintPage() *MockPrinter_PrintPage_Call {
	return &MockPrinter_PrintPage_Call{Call: _e.mock.On("PrintPage")}
}

func (_c *MockPrinter_PrintPage_Call) Run(run func()) *MockPrinter_PrintPage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPrinter_PrintPage_Call) Return() *MockPrinter_PrintPage_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPrinter_PrintPage_Call) RunAndReturn(run func()) *MockPrinter_PrintPage_Call {
	_c.Run(run)
	return _c
}

// NewMockPopupCapable creates a new instance of MockPopupCapable. 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 NewMockPopupCapable(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockPopupCapable {
	mock := &MockPopupCapable{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockPopupCapable is an autogenerated mock type for the PopupCapable type
type MockPopupCapable struct {
	mock.Mock
}

type MockPopupCapable_Expecter struct {
	mock *mock.Mock
}

func (_m *MockPopupCapable) EXPECT() *MockPopupCapable_Expecter {
	return &MockPopupCapable_Expecter{mock: &_m.Mock}
}

// SetOnClose provides a mock function for the type MockPopupCapable
func (_mock *MockPopupCapable) SetOnClose(fn func()) {
	_mock.Called(fn)
	return
}

// MockPopupCapable_SetOnClose_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetOnClose'
type MockPopupCapable_SetOnClose_Call struct {
	*mock.Call
}

// SetOnClose is a helper method to define mock.On call
//   - fn func()
func (_e *MockPopupCapable_Expecter) SetOnClose(fn interface{}) *MockPopupCapable_SetOnClose_Call {
	return &MockPopupCapable_SetOnClose_Call{Call: _e.mock.On("SetOnClose", fn)}
}

func (_c *MockPopupCapable_SetOnClose_Call) Run(run func(fn func())) *MockPopupCapable_SetOnClose_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 func()
		if args[0] != nil {
			arg0 = args[0].(func())
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPopupCapable_SetOnClose_Call) Return() *MockPopupCapable_SetOnClose_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPopupCapable_SetOnClose_Call) RunAndReturn(run func(fn func())) *MockPopupCapable_SetOnClose_Call {
	_c.Run(run)
	return _c
}

// SetOnReadyToShow provides a mock function for the type MockPopupCapable
func (_mock *MockPopupCapable) SetOnReadyToShow(fn func()) {
	_mock.Called(fn)
	return
}

// MockPopupCapable_SetOnReadyToShow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetOnReadyToShow'
type MockPopupCapable_SetOnReadyToShow_Call struct {
	*mock.Call
}

// SetOnReadyToShow is a helper method to define mock.On call
//   - fn func()
func (_e *MockPopupCapable_Expecter) SetOnReadyToShow(fn interface{}) *MockPopupCapable_SetOnReadyToShow_Call {
	return &MockPopupCapable_SetOnReadyToShow_Call{Call: _e.mock.On("SetOnReadyToShow", fn)}
}

func (_c *MockPopupCapable_SetOnReadyToShow_Call) Run(run func(fn func())) *MockPopupCapable_SetOnReadyToShow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 func()
		if args[0] != nil {
			arg0 = args[0].(func())
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPopupCapable_SetOnReadyToShow_Call) Return() *MockPopupCapable_SetOnReadyToShow_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPopupCapable_SetOnReadyToShow_Call) RunAndReturn(run func(fn func())) *MockPopupCapable_SetOnReadyToShow_Call {
	_c.Run(run)
	return _c
}

// Show provides a mock function for the type MockPopupCapable
func (_mock *MockPopupCapable) Show() {
	_mock.Called()
	return
}

// MockPopupCapable_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
type MockPopupCapable_Show_Call struct {
	*mock.Call
}

// Show is a helper method to define mock.On call
func (_e *MockPopupCapable_Expecter) Show() *MockPopupCapable_Show_Call {
	return &MockPopupCapable_Show_Call{Call: _e.mock.On("Show")}
}

func (_c *MockPopupCapable_Show_Call) Run(run func()) *MockPopupCapable_Show_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPopupCapable_Show_Call) Return() *MockPopupCapable_Show_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPopupCapable_Show_Call) RunAndReturn(run func()) *MockPopupCapable_Show_Call {
	_c.Run(run)
	return _c
}

// NewMockOAuthCallbackCapable creates a new instance of MockOAuthCallbackCapable. 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 NewMockOAuthCallbackCapable(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockOAuthCallbackCapable {
	mock := &MockOAuthCallbackCapable{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockOAuthCallbackCapable is an autogenerated mock type for the OAuthCallbackCapable type
type MockOAuthCallbackCapable struct {
	mock.Mock
}

type MockOAuthCallbackCapable_Expecter struct {
	mock *mock.Mock
}

func (_m *MockOAuthCallbackCapable) EXPECT() *MockOAuthCallbackCapable_Expecter {
	return &MockOAuthCallbackCapable_Expecter{mock: &_m.Mock}
}

// AddCloseCallback provides a mock function for the type MockOAuthCallbackCapable
func (_mock *MockOAuthCallbackCapable) AddCloseCallback(fn func()) {
	_mock.Called(fn)
	return
}

// MockOAuthCallbackCapable_AddCloseCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCloseCallback'
type MockOAuthCallbackCapable_AddCloseCallback_Call struct {
	*mock.Call
}

// AddCloseCallback is a helper method to define mock.On call
//   - fn func()
func (_e *MockOAuthCallbackCapable_Expecter) AddCloseCallback(fn interface{}) *MockOAuthCallbackCapable_AddCloseCallback_Call {
	return &MockOAuthCallbackCapable_AddCloseCallback_Call{Call: _e.mock.On("AddCloseCallback", fn)}
}

func (_c *MockOAuthCallbackCapable_AddCloseCallback_Call) Run(run func(fn func())) *MockOAuthCallbackCapable_AddCloseCallback_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 func()
		if args[0] != nil {
			arg0 = args[0].(func())
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockOAuthCallbackCapable_AddCloseCallback_Call) Return() *MockOAuthCallbackCapable_AddCloseCallback_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOAuthCallbackCapable_AddCloseCallback_Call) RunAndReturn(run func(fn func())) *MockOAuthCallbackCapable_AddCloseCallback_Call {
	_c.Run(run)
	return _c
}

// AddNavigationCallback provides a mock function for the type MockOAuthCallbackCapable
func (_mock *MockOAuthCallbackCapable) AddNavigationCallback(fn func(uri string)) {
	_mock.Called(fn)
	return
}

// MockOAuthCallbackCapable_AddNavigationCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddNavigationCallback'
type MockOAuthCallbackCapable_AddNavigationCallback_Call struct {
	*mock.Call
}

// AddNavigationCallback is a helper method to define mock.On call
//   - fn func(uri string)
func (_e *MockOAuthCallbackCapable_Expecter) AddNavigationCallback(fn interface{}) *MockOAuthCallbackCapable_AddNavigationCallback_Call {
	return &MockOAuthCallbackCapable_AddNavigationCallback_Call{Call: _e.mock.On("AddNavigationCallback", fn)}
}

func (_c *MockOAuthCallbackCapable_AddNavigationCallback_Call) Run(run func(fn func(uri string))) *MockOAuthCallbackCapable_AddNavigationCallback_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 func(uri string)
		if args[0] != nil {
			arg0 = args[0].(func(uri string))
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockOAuthCallbackCapable_AddNavigationCallback_Call) Return() *MockOAuthCallbackCapable_AddNavigationCallback_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOAuthCallbackCapable_AddNavigationCallback_Call) RunAndReturn(run func(fn func(uri string))) *MockOAuthCallbackCapable_AddNavigationCallback_Call {
	_c.Run(run)
	return _c
}

// Close provides a mock function for the type MockOAuthCallbackCapable
func (_mock *MockOAuthCallbackCapable) Close() {
	_mock.Called()
	return
}

// MockOAuthCallbackCapable_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
type MockOAuthCallbackCapable_Close_Call struct {
	*mock.Call
}

// Close is a helper method to define mock.On call
func (_e *MockOAuthCallbackCapable_Expecter) Close() *MockOAuthCallbackCapable_Close_Call {
	return &MockOAuthCallbackCapable_Close_Call{Call: _e.mock.On("Close")}
}

func (_c *MockOAuthCallbackCapable_Close_Call) Run(run func()) *MockOAuthCallbackCapable_Close_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockOAuthCallbackCapable_Close_Call) Return() *MockOAuthCallbackCapable_Close_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOAuthCallbackCapable_Close_Call) RunAndReturn(run func()) *MockOAuthCallbackCapable_Close_Call {
	_c.Run(run)
	return _c
}

// NewMockTextInputTargetProvider creates a new instance of MockTextInputTargetProvider. 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 NewMockTextInputTargetProvider(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockTextInputTargetProvider {
	mock := &MockTextInputTargetProvider{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockTextInputTargetProvider is an autogenerated mock type for the TextInputTargetProvider type
type MockTextInputTargetProvider struct {
	mock.Mock
}

type MockTextInputTargetProvider_Expecter struct {
	mock *mock.Mock
}

func (_m *MockTextInputTargetProvider) EXPECT() *MockTextInputTargetProvider_Expecter {
	return &MockTextInputTargetProvider_Expecter{mock: &_m.Mock}
}

// TextInputTarget provides a mock function for the type MockTextInputTargetProvider
func (_mock *MockTextInputTargetProvider) TextInputTarget() port.TextInputTarget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for TextInputTarget")
	}

	var r0 port.TextInputTarget
	if returnFunc, ok := ret.Get(0).(func() port.TextInputTarget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(port.TextInputTarget)
		}
	}
	return r0
}

// MockTextInputTargetProvider_TextInputTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TextInputTarget'
type MockTextInputTargetProvider_TextInputTarget_Call struct {
	*mock.Call
}

// TextInputTarget is a helper method to define mock.On call
func (_e *MockTextInputTargetProvider_Expecter) TextInputTarget() *MockTextInputTargetProvider_TextInputTarget_Call {
	return &MockTextInputTargetProvider_TextInputTarget_Call{Call: _e.mock.On("TextInputTarget")}
}

func (_c *MockTextInputTargetProvider_TextInputTarget_Call) Run(run func()) *MockTextInputTargetProvider_TextInputTarget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockTextInputTargetProvider_TextInputTarget_Call) Return(textInputTarget port.TextInputTarget) *MockTextInputTargetProvider_TextInputTarget_Call {
	_c.Call.Return(textInputTarget)
	return _c
}

func (_c *MockTextInputTargetProvider_TextInputTarget_Call) RunAndReturn(run func() port.TextInputTarget) *MockTextInputTargetProvider_TextInputTarget_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockXDGPaths creates a new instance of MockXDGPaths. 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 NewMockXDGPaths(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockXDGPaths {
	mock := &MockXDGPaths{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockXDGPaths is an autogenerated mock type for the XDGPaths type
type MockXDGPaths struct {
	mock.Mock
}

type MockXDGPaths_Expecter struct {
	mock *mock.Mock
}

func (_m *MockXDGPaths) EXPECT() *MockXDGPaths_Expecter {
	return &MockXDGPaths_Expecter{mock: &_m.Mock}
}

// CacheDir provides a mock function for the type MockXDGPaths
func (_mock *MockXDGPaths) CacheDir() (string, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for CacheDir")
	}

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockXDGPaths_CacheDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CacheDir'
type MockXDGPaths_CacheDir_Call struct {
	*mock.Call
}

// CacheDir is a helper method to define mock.On call
func (_e *MockXDGPaths_Expecter) CacheDir() *MockXDGPaths_CacheDir_Call {
	return &MockXDGPaths_CacheDir_Call{Call: _e.mock.On("CacheDir")}
}

func (_c *MockXDGPaths_CacheDir_Call) Run(run func()) *MockXDGPaths_CacheDir_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockXDGPaths_CacheDir_Call) Return(s string, err error) *MockXDGPaths_CacheDir_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockXDGPaths_CacheDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_CacheDir_Call {
	_c.Call.Return(run)
	return _c
}

// ConfigDir provides a mock function for the type MockXDGPaths
func (_mock *MockXDGPaths) ConfigDir() (string, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for ConfigDir")
	}

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockXDGPaths_ConfigDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigDir'
type MockXDGPaths_ConfigDir_Call struct {
	*mock.Call
}

// ConfigDir is a helper method to define mock.On call
func (_e *MockXDGPaths_Expecter) ConfigDir() *MockXDGPaths_ConfigDir_Call {
	return &MockXDGPaths_ConfigDir_Call{Call: _e.mock.On("ConfigDir")}
}

func (_c *MockXDGPaths_ConfigDir_Call) Run(run func()) *MockXDGPaths_ConfigDir_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockXDGPaths_ConfigDir_Call) Return(s string, err error) *MockXDGPaths_ConfigDir_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockXDGPaths_ConfigDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_ConfigDir_Call {
	_c.Call.Return(run)
	return _c
}

// DataDir provides a mock function for the type MockXDGPaths
func (_mock *MockXDGPaths) DataDir() (string, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for DataDir")
	}

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockXDGPaths_DataDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DataDir'
type MockXDGPaths_DataDir_Call struct {
	*mock.Call
}

// DataDir is a helper method to define mock.On call
func (_e *MockXDGPaths_Expecter) DataDir() *MockXDGPaths_DataDir_Call {
	return &MockXDGPaths_DataDir_Call{Call: _e.mock.On("DataDir")}
}

func (_c *MockXDGPaths_DataDir_Call) Run(run func()) *MockXDGPaths_DataDir_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockXDGPaths_DataDir_Call) Return(s string, err error) *MockXDGPaths_DataDir_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockXDGPaths_DataDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_DataDir_Call {
	_c.Call.Return(run)
	return _c
}

// DownloadDir provides a mock function for the type MockXDGPaths
func (_mock *MockXDGPaths) DownloadDir() (string, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for DownloadDir")
	}

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockXDGPaths_DownloadDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadDir'
type MockXDGPaths_DownloadDir_Call struct {
	*mock.Call
}

// DownloadDir is a helper method to define mock.On call
func (_e *MockXDGPaths_Expecter) DownloadDir() *MockXDGPaths_DownloadDir_Call {
	return &MockXDGPaths_DownloadDir_Call{Call: _e.mock.On("DownloadDir")}
}

func (_c *MockXDGPaths_DownloadDir_Call) Run(run func()) *MockXDGPaths_DownloadDir_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockXDGPaths_DownloadDir_Call) Return(s string, err error) *MockXDGPaths_DownloadDir_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockXDGPaths_DownloadDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_DownloadDir_Call {
	_c.Call.Return(run)
	return _c
}

// FilterCacheDir provides a mock function for the type MockXDGPaths
func (_mock *MockXDGPaths) FilterCacheDir() (string, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for FilterCacheDir")
	}

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockXDGPaths_FilterCacheDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FilterCacheDir'
type MockXDGPaths_FilterCacheDir_Call struct {
	*mock.Call
}

// FilterCacheDir is a helper method to define mock.On call
func (_e *MockXDGPaths_Expecter) FilterCacheDir() *MockXDGPaths_FilterCacheDir_Call {
	return &MockXDGPaths_FilterCacheDir_Call{Call: _e.mock.On("FilterCacheDir")}
}

func (_c *MockXDGPaths_FilterCacheDir_Call) Run(run func()) *MockXDGPaths_FilterCacheDir_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockXDGPaths_FilterCacheDir_Call) Return(s string, err error) *MockXDGPaths_FilterCacheDir_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockXDGPaths_FilterCacheDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_FilterCacheDir_Call {
	_c.Call.Return(run)
	return _c
}

// FilterJSONDir provides a mock function for the type MockXDGPaths
func (_mock *MockXDGPaths) FilterJSONDir() (string, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for FilterJSONDir")
	}

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockXDGPaths_FilterJSONDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FilterJSONDir'
type MockXDGPaths_FilterJSONDir_Call struct {
	*mock.Call
}

// FilterJSONDir is a helper method to define mock.On call
func (_e *MockXDGPaths_Expecter) FilterJSONDir() *MockXDGPaths_FilterJSONDir_Call {
	return &MockXDGPaths_FilterJSONDir_Call{Call: _e.mock.On("FilterJSONDir")}
}

func (_c *MockXDGPaths_FilterJSONDir_Call) Run(run func()) *MockXDGPaths_FilterJSONDir_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockXDGPaths_FilterJSONDir_Call) Return(s string, err error) *MockXDGPaths_FilterJSONDir_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockXDGPaths_FilterJSONDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_FilterJSONDir_Call {
	_c.Call.Return(run)
	return _c
}

// FilterStoreDir provides a mock function for the type MockXDGPaths
func (_mock *MockXDGPaths) FilterStoreDir() (string, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for FilterStoreDir")
	}

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockXDGPaths_FilterStoreDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FilterStoreDir'
type MockXDGPaths_FilterStoreDir_Call struct {
	*mock.Call
}

// FilterStoreDir is a helper method to define mock.On call
func (_e *MockXDGPaths_Expecter) FilterStoreDir() *MockXDGPaths_FilterStoreDir_Call {
	return &MockXDGPaths_FilterStoreDir_Call{Call: _e.mock.On("FilterStoreDir")}
}

func (_c *MockXDGPaths_FilterStoreDir_Call) Run(run func()) *MockXDGPaths_FilterStoreDir_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockXDGPaths_FilterStoreDir_Call) Return(s string, err error) *MockXDGPaths_FilterStoreDir_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockXDGPaths_FilterStoreDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_FilterStoreDir_Call {
	_c.Call.Return(run)
	return _c
}

// ManDir provides a mock function for the type MockXDGPaths
func (_mock *MockXDGPaths) ManDir() (string, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for ManDir")
	}

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockXDGPaths_ManDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ManDir'
type MockXDGPaths_ManDir_Call struct {
	*mock.Call
}

// ManDir is a helper method to define mock.On call
func (_e *MockXDGPaths_Expecter) ManDir() *MockXDGPaths_ManDir_Call {
	return &MockXDGPaths_ManDir_Call{Call: _e.mock.On("ManDir")}
}

func (_c *MockXDGPaths_ManDir_Call) Run(run func()) *MockXDGPaths_ManDir_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockXDGPaths_ManDir_Call) Return(s string, err error) *MockXDGPaths_ManDir_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockXDGPaths_ManDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_ManDir_Call {
	_c.Call.Return(run)
	return _c
}

// StateDir provides a mock function for the type MockXDGPaths
func (_mock *MockXDGPaths) StateDir() (string, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for StateDir")
	}

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockXDGPaths_StateDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StateDir'
type MockXDGPaths_StateDir_Call struct {
	*mock.Call
}

// StateDir is a helper method to define mock.On call
func (_e *MockXDGPaths_Expecter) StateDir() *MockXDGPaths_StateDir_Call {
	return &MockXDGPaths_StateDir_Call{Call: _e.mock.On("StateDir")}
}

func (_c *MockXDGPaths_StateDir_Call) Run(run func()) *MockXDGPaths_StateDir_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockXDGPaths_StateDir_Call) Return(s string, err error) *MockXDGPaths_StateDir_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockXDGPaths_StateDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_StateDir_Call {
	_c.Call.Return(run)
	return _c
}