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

package mocks

import (
	"context"
	"database/sql"

	"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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

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

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

	return mock
}

// MockWebKitContextProvider is an autogenerated mock type for the WebKitContextProvider type
type MockWebKitContextProvider struct {
	mock.Mock
}

type MockWebKitContextProvider_Expecter struct {
	mock *mock.Mock
}

func (_m *MockWebKitContextProvider) EXPECT() *MockWebKitContextProvider_Expecter {
	return &MockWebKitContextProvider_Expecter{mock: &_m.Mock}
}

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

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

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

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

// CacheDir is a helper method to define mock.On call
func (_e *MockWebKitContextProvider_Expecter) CacheDir() *MockWebKitContextProvider_CacheDir_Call {
	return &MockWebKitContextProvider_CacheDir_Call{Call: _e.mock.On("CacheDir")}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// DataDir is a helper method to define mock.On call
func (_e *MockWebKitContextProvider_Expecter) DataDir() *MockWebKitContextProvider_DataDir_Call {
	return &MockWebKitContextProvider_DataDir_Call{Call: _e.mock.On("DataDir")}
}

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

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

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

// Initialize provides a mock function for the type MockWebKitContextProvider
func (_mock *MockWebKitContextProvider) Initialize(ctx context.Context, opts port.WebKitContextOptions) error {
	ret := _mock.Called(ctx, opts)

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

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

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

// Initialize is a helper method to define mock.On call
//   - ctx context.Context
//   - opts port.WebKitContextOptions
func (_e *MockWebKitContextProvider_Expecter) Initialize(ctx interface{}, opts interface{}) *MockWebKitContextProvider_Initialize_Call {
	return &MockWebKitContextProvider_Initialize_Call{Call: _e.mock.On("Initialize", ctx, opts)}
}

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

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

func (_c *MockWebKitContextProvider_Initialize_Call) RunAndReturn(run func(ctx context.Context, opts port.WebKitContextOptions) error) *MockWebKitContextProvider_Initialize_Call {
	_c.Call.Return(run)
	return _c
}

// PrefetchDNS provides a mock function for the type MockWebKitContextProvider
func (_mock *MockWebKitContextProvider) PrefetchDNS(hostname string) {
	_mock.Called(hostname)
	return
}

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

// PrefetchDNS is a helper method to define mock.On call
//   - hostname string
func (_e *MockWebKitContextProvider_Expecter) PrefetchDNS(hostname interface{}) *MockWebKitContextProvider_PrefetchDNS_Call {
	return &MockWebKitContextProvider_PrefetchDNS_Call{Call: _e.mock.On("PrefetchDNS", hostname)}
}

func (_c *MockWebKitContextProvider_PrefetchDNS_Call) Run(run func(hostname string)) *MockWebKitContextProvider_PrefetchDNS_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 *MockWebKitContextProvider_PrefetchDNS_Call) Return() *MockWebKitContextProvider_PrefetchDNS_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWebKitContextProvider_PrefetchDNS_Call) RunAndReturn(run func(hostname string)) *MockWebKitContextProvider_PrefetchDNS_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
}

// 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
}

// 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
}

// 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
}