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

package mocks

import (
	"context"
	"encoding/json"

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

// 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 any, cfg any) *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 any, cfg any) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
	return &MockMemoryPressureApplier_ApplyWebProcessSettings_Call{Call: _e.mock.On("ApplyWebProcessSettings", ctx, cfg)}
}

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

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

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

// NewMockEngine creates a new instance of MockEngine. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockEngine(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockEngine {
	mock := &MockEngine{}
	mock.Mock.Test(t)

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

	return mock
}

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

type MockEngine_Expecter struct {
	mock *mock.Mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (_c *MockEngine_ConfigureDownloads_Call) Run(run func(ctx context.Context, downloadPath string, eventHandler port.DownloadEventHandler, preparer port.DownloadPreparer)) *MockEngine_ConfigureDownloads_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 port.DownloadEventHandler
		if args[2] != nil {
			arg2 = args[2].(port.DownloadEventHandler)
		}
		var arg3 port.DownloadPreparer
		if args[3] != nil {
			arg3 = args[3].(port.DownloadPreparer)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return mock
}

// MockWebUIMessageHandler is an autogenerated mock type for the WebUIMessageHandler type
type MockWebUIMessageHandler struct {
	mock.Mock
}

type MockWebUIMessageHandler_Expecter struct {
	mock *mock.Mock
}

func (_m *MockWebUIMessageHandler) EXPECT() *MockWebUIMessageHandler_Expecter {
	return &MockWebUIMessageHandler_Expecter{mock: &_m.Mock}
}

// Handle provides a mock function for the type MockWebUIMessageHandler
func (_mock *MockWebUIMessageHandler) Handle(ctx context.Context, webviewID port.WebViewID, payload json.RawMessage) (any, error) {
	ret := _mock.Called(ctx, webviewID, payload)

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

	var r0 any
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID, json.RawMessage) (any, error)); ok {
		return returnFunc(ctx, webviewID, payload)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID, json.RawMessage) any); ok {
		r0 = returnFunc(ctx, webviewID, payload)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(any)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, port.WebViewID, json.RawMessage) error); ok {
		r1 = returnFunc(ctx, webviewID, payload)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Handle is a helper method to define mock.On call
//   - ctx context.Context
//   - webviewID port.WebViewID
//   - payload json.RawMessage
func (_e *MockWebUIMessageHandler_Expecter) Handle(ctx any, webviewID any, payload any) *MockWebUIMessageHandler_Handle_Call {
	return &MockWebUIMessageHandler_Handle_Call{Call: _e.mock.On("Handle", ctx, webviewID, payload)}
}

func (_c *MockWebUIMessageHandler_Handle_Call) Run(run func(ctx context.Context, webviewID port.WebViewID, payload json.RawMessage)) *MockWebUIMessageHandler_Handle_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)
		}
		var arg2 json.RawMessage
		if args[2] != nil {
			arg2 = args[2].(json.RawMessage)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockWebUIMessageHandler_Handle_Call) RunAndReturn(run func(ctx context.Context, webviewID port.WebViewID, payload json.RawMessage) (any, error)) *MockWebUIMessageHandler_Handle_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockWebUIHandlerRouter is an autogenerated mock type for the WebUIHandlerRouter type
type MockWebUIHandlerRouter struct {
	mock.Mock
}

type MockWebUIHandlerRouter_Expecter struct {
	mock *mock.Mock
}

func (_m *MockWebUIHandlerRouter) EXPECT() *MockWebUIHandlerRouter_Expecter {
	return &MockWebUIHandlerRouter_Expecter{mock: &_m.Mock}
}

// RegisterHandler provides a mock function for the type MockWebUIHandlerRouter
func (_mock *MockWebUIHandlerRouter) RegisterHandler(msgType string, handler port.WebUIMessageHandler) error {
	ret := _mock.Called(msgType, handler)

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

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

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

// RegisterHandler is a helper method to define mock.On call
//   - msgType string
//   - handler port.WebUIMessageHandler
func (_e *MockWebUIHandlerRouter_Expecter) RegisterHandler(msgType any, handler any) *MockWebUIHandlerRouter_RegisterHandler_Call {
	return &MockWebUIHandlerRouter_RegisterHandler_Call{Call: _e.mock.On("RegisterHandler", msgType, handler)}
}

func (_c *MockWebUIHandlerRouter_RegisterHandler_Call) Run(run func(msgType string, handler port.WebUIMessageHandler)) *MockWebUIHandlerRouter_RegisterHandler_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 port.WebUIMessageHandler
		if args[1] != nil {
			arg1 = args[1].(port.WebUIMessageHandler)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockWebUIHandlerRouter_RegisterHandler_Call) RunAndReturn(run func(msgType string, handler port.WebUIMessageHandler) error) *MockWebUIHandlerRouter_RegisterHandler_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterHandlerWithCallbacks provides a mock function for the type MockWebUIHandlerRouter
func (_mock *MockWebUIHandlerRouter) RegisterHandlerWithCallbacks(msgType string, callback string, errorCallback string, worldName string, handler port.WebUIMessageHandler) error {
	ret := _mock.Called(msgType, callback, errorCallback, worldName, handler)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, string, string, string, port.WebUIMessageHandler) error); ok {
		r0 = returnFunc(msgType, callback, errorCallback, worldName, handler)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// RegisterHandlerWithCallbacks is a helper method to define mock.On call
//   - msgType string
//   - callback string
//   - errorCallback string
//   - worldName string
//   - handler port.WebUIMessageHandler
func (_e *MockWebUIHandlerRouter_Expecter) RegisterHandlerWithCallbacks(msgType any, callback any, errorCallback any, worldName any, handler any) *MockWebUIHandlerRouter_RegisterHandlerWithCallbacks_Call {
	return &MockWebUIHandlerRouter_RegisterHandlerWithCallbacks_Call{Call: _e.mock.On("RegisterHandlerWithCallbacks", msgType, callback, errorCallback, worldName, handler)}
}

func (_c *MockWebUIHandlerRouter_RegisterHandlerWithCallbacks_Call) Run(run func(msgType string, callback string, errorCallback string, worldName string, handler port.WebUIMessageHandler)) *MockWebUIHandlerRouter_RegisterHandlerWithCallbacks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		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)
		}
		var arg4 port.WebUIMessageHandler
		if args[4] != nil {
			arg4 = args[4].(port.WebUIMessageHandler)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *MockWebUIHandlerRouter_RegisterHandlerWithCallbacks_Call) RunAndReturn(run func(msgType string, callback string, errorCallback string, worldName string, handler port.WebUIMessageHandler) error) *MockWebUIHandlerRouter_RegisterHandlerWithCallbacks_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockSchemeHandler creates a new instance of MockSchemeHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockSchemeHandler(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockSchemeHandler {
	mock := &MockSchemeHandler{}
	mock.Mock.Test(t)

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

	return mock
}

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

type MockSchemeHandler_Expecter struct {
	mock *mock.Mock
}

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

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

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

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

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

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

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

// NewMockSettingsApplier creates a new instance of MockSettingsApplier. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockSettingsApplier(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockSettingsApplier {
	mock := &MockSettingsApplier{}
	mock.Mock.Test(t)

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

	return mock
}

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

type MockSettingsApplier_Expecter struct {
	mock *mock.Mock
}

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

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

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

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

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

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

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

// NewMockFilterApplier creates a new instance of MockFilterApplier. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockFilterApplier(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFilterApplier {
	mock := &MockFilterApplier{}
	mock.Mock.Test(t)

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

	return mock
}

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

type MockFilterApplier_Expecter struct {
	mock *mock.Mock
}

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

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

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

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

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

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

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

// NewMockFaviconDatabase creates a new instance of MockFaviconDatabase. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockFaviconDatabase(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFaviconDatabase {
	mock := &MockFaviconDatabase{}
	mock.Mock.Test(t)

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

	return mock
}

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

type MockFaviconDatabase_Expecter struct {
	mock *mock.Mock
}

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

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

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

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

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

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

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

// NewMockScriptRefresher creates a new instance of MockScriptRefresher. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockScriptRefresher(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockScriptRefresher {
	mock := &MockScriptRefresher{}
	mock.Mock.Test(t)

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

	return mock
}

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

type MockScriptRefresher_Expecter struct {
	mock *mock.Mock
}

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

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

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

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

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

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

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

// NewMockNativeWidgetProvider creates a new instance of MockNativeWidgetProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockNativeWidgetProvider(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockNativeWidgetProvider {
	mock := &MockNativeWidgetProvider{}
	mock.Mock.Test(t)

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

	return mock
}

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

type MockNativeWidgetProvider_Expecter struct {
	mock *mock.Mock
}

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

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

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

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

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

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

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

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

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