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

package mocks

import (
	"context"

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

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

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

	return mock
}

// MockTexture is an autogenerated mock type for the Texture type
type MockTexture struct {
	mock.Mock
}

type MockTexture_Expecter struct {
	mock *mock.Mock
}

func (_m *MockTexture) EXPECT() *MockTexture_Expecter {
	return &MockTexture_Expecter{mock: &_m.Mock}
}

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

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

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

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

// GoPointer is a helper method to define mock.On call
func (_e *MockTexture_Expecter) GoPointer() *MockTexture_GoPointer_Call {
	return &MockTexture_GoPointer_Call{Call: _e.mock.On("GoPointer")}
}

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

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

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

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

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

	return mock
}

// MockFindController is an autogenerated mock type for the FindController type
type MockFindController struct {
	mock.Mock
}

type MockFindController_Expecter struct {
	mock *mock.Mock
}

func (_m *MockFindController) EXPECT() *MockFindController_Expecter {
	return &MockFindController_Expecter{mock: &_m.Mock}
}

// CountMatches provides a mock function for the type MockFindController
func (_mock *MockFindController) CountMatches(text string, options port.FindOptions, maxMatches uint) {
	_mock.Called(text, options, maxMatches)
	return
}

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

// CountMatches is a helper method to define mock.On call
//   - text string
//   - options port.FindOptions
//   - maxMatches uint
func (_e *MockFindController_Expecter) CountMatches(text any, options any, maxMatches any) *MockFindController_CountMatches_Call {
	return &MockFindController_CountMatches_Call{Call: _e.mock.On("CountMatches", text, options, maxMatches)}
}

func (_c *MockFindController_CountMatches_Call) Run(run func(text string, options port.FindOptions, maxMatches uint)) *MockFindController_CountMatches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 port.FindOptions
		if args[1] != nil {
			arg1 = args[1].(port.FindOptions)
		}
		var arg2 uint
		if args[2] != nil {
			arg2 = args[2].(uint)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockFindController_CountMatches_Call) RunAndReturn(run func(text string, options port.FindOptions, maxMatches uint)) *MockFindController_CountMatches_Call {
	_c.Run(run)
	return _c
}

// DisconnectSignal provides a mock function for the type MockFindController
func (_mock *MockFindController) DisconnectSignal(id uint) {
	_mock.Called(id)
	return
}

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

// DisconnectSignal is a helper method to define mock.On call
//   - id uint
func (_e *MockFindController_Expecter) DisconnectSignal(id any) *MockFindController_DisconnectSignal_Call {
	return &MockFindController_DisconnectSignal_Call{Call: _e.mock.On("DisconnectSignal", id)}
}

func (_c *MockFindController_DisconnectSignal_Call) Run(run func(id uint)) *MockFindController_DisconnectSignal_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 uint
		if args[0] != nil {
			arg0 = args[0].(uint)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockFindController_DisconnectSignal_Call) RunAndReturn(run func(id uint)) *MockFindController_DisconnectSignal_Call {
	_c.Run(run)
	return _c
}

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

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

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

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

// GetSearchText is a helper method to define mock.On call
func (_e *MockFindController_Expecter) GetSearchText() *MockFindController_GetSearchText_Call {
	return &MockFindController_GetSearchText_Call{Call: _e.mock.On("GetSearchText")}
}

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

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

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

// OnCountedMatches provides a mock function for the type MockFindController
func (_mock *MockFindController) OnCountedMatches(callback func(matchCount uint)) uint {
	ret := _mock.Called(callback)

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

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

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

// OnCountedMatches is a helper method to define mock.On call
//   - callback func(matchCount uint)
func (_e *MockFindController_Expecter) OnCountedMatches(callback any) *MockFindController_OnCountedMatches_Call {
	return &MockFindController_OnCountedMatches_Call{Call: _e.mock.On("OnCountedMatches", callback)}
}

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

func (_c *MockFindController_OnCountedMatches_Call) Return(v uint) *MockFindController_OnCountedMatches_Call {
	_c.Call.Return(v)
	return _c
}

func (_c *MockFindController_OnCountedMatches_Call) RunAndReturn(run func(callback func(matchCount uint)) uint) *MockFindController_OnCountedMatches_Call {
	_c.Call.Return(run)
	return _c
}

// OnFailedToFindText provides a mock function for the type MockFindController
func (_mock *MockFindController) OnFailedToFindText(callback func()) uint {
	ret := _mock.Called(callback)

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

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

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

// OnFailedToFindText is a helper method to define mock.On call
//   - callback func()
func (_e *MockFindController_Expecter) OnFailedToFindText(callback any) *MockFindController_OnFailedToFindText_Call {
	return &MockFindController_OnFailedToFindText_Call{Call: _e.mock.On("OnFailedToFindText", callback)}
}

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

func (_c *MockFindController_OnFailedToFindText_Call) Return(v uint) *MockFindController_OnFailedToFindText_Call {
	_c.Call.Return(v)
	return _c
}

func (_c *MockFindController_OnFailedToFindText_Call) RunAndReturn(run func(callback func()) uint) *MockFindController_OnFailedToFindText_Call {
	_c.Call.Return(run)
	return _c
}

// OnFoundText provides a mock function for the type MockFindController
func (_mock *MockFindController) OnFoundText(callback func(matchCount uint)) uint {
	ret := _mock.Called(callback)

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

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

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

// OnFoundText is a helper method to define mock.On call
//   - callback func(matchCount uint)
func (_e *MockFindController_Expecter) OnFoundText(callback any) *MockFindController_OnFoundText_Call {
	return &MockFindController_OnFoundText_Call{Call: _e.mock.On("OnFoundText", callback)}
}

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

func (_c *MockFindController_OnFoundText_Call) Return(v uint) *MockFindController_OnFoundText_Call {
	_c.Call.Return(v)
	return _c
}

func (_c *MockFindController_OnFoundText_Call) RunAndReturn(run func(callback func(matchCount uint)) uint) *MockFindController_OnFoundText_Call {
	_c.Call.Return(run)
	return _c
}

// Search provides a mock function for the type MockFindController
func (_mock *MockFindController) Search(text string, options port.FindOptions, maxMatches uint) {
	_mock.Called(text, options, maxMatches)
	return
}

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

// Search is a helper method to define mock.On call
//   - text string
//   - options port.FindOptions
//   - maxMatches uint
func (_e *MockFindController_Expecter) Search(text any, options any, maxMatches any) *MockFindController_Search_Call {
	return &MockFindController_Search_Call{Call: _e.mock.On("Search", text, options, maxMatches)}
}

func (_c *MockFindController_Search_Call) Run(run func(text string, options port.FindOptions, maxMatches uint)) *MockFindController_Search_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 port.FindOptions
		if args[1] != nil {
			arg1 = args[1].(port.FindOptions)
		}
		var arg2 uint
		if args[2] != nil {
			arg2 = args[2].(uint)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockFindController_Search_Call) RunAndReturn(run func(text string, options port.FindOptions, maxMatches uint)) *MockFindController_Search_Call {
	_c.Run(run)
	return _c
}

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

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

// SearchFinish is a helper method to define mock.On call
func (_e *MockFindController_Expecter) SearchFinish() *MockFindController_SearchFinish_Call {
	return &MockFindController_SearchFinish_Call{Call: _e.mock.On("SearchFinish")}
}

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

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

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

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

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

// SearchNext is a helper method to define mock.On call
func (_e *MockFindController_Expecter) SearchNext() *MockFindController_SearchNext_Call {
	return &MockFindController_SearchNext_Call{Call: _e.mock.On("SearchNext")}
}

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

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

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

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

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

// SearchPrevious is a helper method to define mock.On call
func (_e *MockFindController_Expecter) SearchPrevious() *MockFindController_SearchPrevious_Call {
	return &MockFindController_SearchPrevious_Call{Call: _e.mock.On("SearchPrevious")}
}

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

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

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

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

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

	return mock
}

// MockWebView is an autogenerated mock type for the WebView type
type MockWebView struct {
	mock.Mock
}

type MockWebView_Expecter struct {
	mock *mock.Mock
}

func (_m *MockWebView) EXPECT() *MockWebView_Expecter {
	return &MockWebView_Expecter{mock: &_m.Mock}
}

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

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

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

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

// CanGoBack is a helper method to define mock.On call
func (_e *MockWebView_Expecter) CanGoBack() *MockWebView_CanGoBack_Call {
	return &MockWebView_CanGoBack_Call{Call: _e.mock.On("CanGoBack")}
}

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

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

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

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

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

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

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

// CanGoForward is a helper method to define mock.On call
func (_e *MockWebView_Expecter) CanGoForward() *MockWebView_CanGoForward_Call {
	return &MockWebView_CanGoForward_Call{Call: _e.mock.On("CanGoForward")}
}

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

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

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

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

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

// Destroy is a helper method to define mock.On call
func (_e *MockWebView_Expecter) Destroy() *MockWebView_Destroy_Call {
	return &MockWebView_Destroy_Call{Call: _e.mock.On("Destroy")}
}

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

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

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

// EstimatedProgress provides a mock function for the type MockWebView
func (_mock *MockWebView) EstimatedProgress() float64 {
	ret := _mock.Called()

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

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

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

// EstimatedProgress is a helper method to define mock.On call
func (_e *MockWebView_Expecter) EstimatedProgress() *MockWebView_EstimatedProgress_Call {
	return &MockWebView_EstimatedProgress_Call{Call: _e.mock.On("EstimatedProgress")}
}

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

func (_c *MockWebView_EstimatedProgress_Call) Return(f float64) *MockWebView_EstimatedProgress_Call {
	_c.Call.Return(f)
	return _c
}

func (_c *MockWebView_EstimatedProgress_Call) RunAndReturn(run func() float64) *MockWebView_EstimatedProgress_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// Favicon is a helper method to define mock.On call
func (_e *MockWebView_Expecter) Favicon() *MockWebView_Favicon_Call {
	return &MockWebView_Favicon_Call{Call: _e.mock.On("Favicon")}
}

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

func (_c *MockWebView_Favicon_Call) Return(texture port.Texture) *MockWebView_Favicon_Call {
	_c.Call.Return(texture)
	return _c
}

func (_c *MockWebView_Favicon_Call) RunAndReturn(run func() port.Texture) *MockWebView_Favicon_Call {
	_c.Call.Return(run)
	return _c
}

// Generation provides a mock function for the type MockWebView
func (_mock *MockWebView) Generation() uint64 {
	ret := _mock.Called()

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

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

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

// Generation is a helper method to define mock.On call
func (_e *MockWebView_Expecter) Generation() *MockWebView_Generation_Call {
	return &MockWebView_Generation_Call{Call: _e.mock.On("Generation")}
}

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

func (_c *MockWebView_Generation_Call) Return(v uint64) *MockWebView_Generation_Call {
	_c.Call.Return(v)
	return _c
}

func (_c *MockWebView_Generation_Call) RunAndReturn(run func() uint64) *MockWebView_Generation_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// GetFindController is a helper method to define mock.On call
func (_e *MockWebView_Expecter) GetFindController() *MockWebView_GetFindController_Call {
	return &MockWebView_GetFindController_Call{Call: _e.mock.On("GetFindController")}
}

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

func (_c *MockWebView_GetFindController_Call) Return(findController port.FindController) *MockWebView_GetFindController_Call {
	_c.Call.Return(findController)
	return _c
}

func (_c *MockWebView_GetFindController_Call) RunAndReturn(run func() port.FindController) *MockWebView_GetFindController_Call {
	_c.Call.Return(run)
	return _c
}

// GetZoomLevel provides a mock function for the type MockWebView
func (_mock *MockWebView) GetZoomLevel() float64 {
	ret := _mock.Called()

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

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

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

// GetZoomLevel is a helper method to define mock.On call
func (_e *MockWebView_Expecter) GetZoomLevel() *MockWebView_GetZoomLevel_Call {
	return &MockWebView_GetZoomLevel_Call{Call: _e.mock.On("GetZoomLevel")}
}

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

func (_c *MockWebView_GetZoomLevel_Call) Return(f float64) *MockWebView_GetZoomLevel_Call {
	_c.Call.Return(f)
	return _c
}

func (_c *MockWebView_GetZoomLevel_Call) RunAndReturn(run func() float64) *MockWebView_GetZoomLevel_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// GoBack is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockWebView_Expecter) GoBack(ctx any) *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 any) *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 any, content any, baseURI any) *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 any, uri any) *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 any) *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 any) *MockWebView_ReloadBypassCache_Call {
	return &MockWebView_ReloadBypassCache_Call{Call: _e.mock.On("ReloadBypassCache", ctx)}
}

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

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

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

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

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

// ResetBackgroundToDefault is a helper method to define mock.On call
func (_e *MockWebView_Expecter) ResetBackgroundToDefault() *MockWebView_ResetBackgroundToDefault_Call {
	return &MockWebView_ResetBackgroundToDefault_Call{Call: _e.mock.On("ResetBackgroundToDefault")}
}

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

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

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

// RunJavaScript provides a mock function for the type MockWebView
func (_mock *MockWebView) RunJavaScript(ctx context.Context, script string) {
	_mock.Called(ctx, script)
	return
}

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

// RunJavaScript is a helper method to define mock.On call
//   - ctx context.Context
//   - script string
func (_e *MockWebView_Expecter) RunJavaScript(ctx any, script any) *MockWebView_RunJavaScript_Call {
	return &MockWebView_RunJavaScript_Call{Call: _e.mock.On("RunJavaScript", ctx, script)}
}

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

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

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

// SetBackgroundColor provides a mock function for the type MockWebView
func (_mock *MockWebView) SetBackgroundColor(r float64, g float64, b float64, a float64) {
	_mock.Called(r, g, b, a)
	return
}

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

// SetBackgroundColor is a helper method to define mock.On call
//   - r float64
//   - g float64
//   - b float64
//   - a float64
func (_e *MockWebView_Expecter) SetBackgroundColor(r any, g any, b any, a any) *MockWebView_SetBackgroundColor_Call {
	return &MockWebView_SetBackgroundColor_Call{Call: _e.mock.On("SetBackgroundColor", r, g, b, a)}
}

func (_c *MockWebView_SetBackgroundColor_Call) Run(run func(r float64, g float64, b float64, a float64)) *MockWebView_SetBackgroundColor_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 float64
		if args[0] != nil {
			arg0 = args[0].(float64)
		}
		var arg1 float64
		if args[1] != nil {
			arg1 = args[1].(float64)
		}
		var arg2 float64
		if args[2] != nil {
			arg2 = args[2].(float64)
		}
		var arg3 float64
		if args[3] != nil {
			arg3 = args[3].(float64)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *MockWebView_SetBackgroundColor_Call) RunAndReturn(run func(r float64, g float64, b float64, a float64)) *MockWebView_SetBackgroundColor_Call {
	_c.Run(run)
	return _c
}

// SetCallbacks provides a mock function for the type MockWebView
func (_mock *MockWebView) SetCallbacks(callbacks *port.WebViewCallbacks) {
	_mock.Called(callbacks)
	return
}

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

// SetCallbacks is a helper method to define mock.On call
//   - callbacks *port.WebViewCallbacks
func (_e *MockWebView_Expecter) SetCallbacks(callbacks any) *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 any, level any) *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 any) *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 any) *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 any) *MockWebViewPool_Prewarm_Call {
	return &MockWebViewPool_Prewarm_Call{Call: _e.mock.On("Prewarm", count)}
}

func (_c *MockWebViewPool_Prewarm_Call) Run(run func(count int)) *MockWebViewPool_Prewarm_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockWebViewPool_Prewarm_Call) RunAndReturn(run func(count int)) *MockWebViewPool_Prewarm_Call {
	_c.Run(run)
	return _c
}

// PrewarmAsync provides a mock function for the type MockWebViewPool
func (_mock *MockWebViewPool) PrewarmAsync(ctx context.Context, count int) {
	_mock.Called(ctx, count)
	return
}

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

// PrewarmAsync is a helper method to define mock.On call
//   - ctx context.Context
//   - count int
func (_e *MockWebViewPool_Expecter) PrewarmAsync(ctx any, count any) *MockWebViewPool_PrewarmAsync_Call {
	return &MockWebViewPool_PrewarmAsync_Call{Call: _e.mock.On("PrewarmAsync", ctx, count)}
}

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

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

func (_c *MockWebViewPool_PrewarmAsync_Call) RunAndReturn(run func(ctx context.Context, count int)) *MockWebViewPool_PrewarmAsync_Call {
	_c.Run(run)
	return _c
}

// Release provides a mock function for the type MockWebViewPool
func (_mock *MockWebViewPool) Release(wv port.WebView) {
	_mock.Called(wv)
	return
}

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

// Release is a helper method to define mock.On call
//   - wv port.WebView
func (_e *MockWebViewPool_Expecter) Release(wv any) *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 any) *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 any, parentID any) *MockWebViewFactory_CreateRelated_Call {
	return &MockWebViewFactory_CreateRelated_Call{Call: _e.mock.On("CreateRelated", ctx, parentID)}
}

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

func (_c *MockWebViewFactory_CreateRelated_Call) Return(webView port.WebView, err error) *MockWebViewFactory_CreateRelated_Call {
	_c.Call.Return(webView, err)
	return _c
}

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

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

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

	return mock
}

// MockDevToolsOpener is an autogenerated mock type for the DevToolsOpener type
type MockDevToolsOpener struct {
	mock.Mock
}

type MockDevToolsOpener_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDevToolsOpener) EXPECT() *MockDevToolsOpener_Expecter {
	return &MockDevToolsOpener_Expecter{mock: &_m.Mock}
}

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

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

// OpenDevTools is a helper method to define mock.On call
func (_e *MockDevToolsOpener_Expecter) OpenDevTools() *MockDevToolsOpener_OpenDevTools_Call {
	return &MockDevToolsOpener_OpenDevTools_Call{Call: _e.mock.On("OpenDevTools")}
}

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

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

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

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

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

	return mock
}

// MockPrinter is an autogenerated mock type for the Printer type
type MockPrinter struct {
	mock.Mock
}

type MockPrinter_Expecter struct {
	mock *mock.Mock
}

func (_m *MockPrinter) EXPECT() *MockPrinter_Expecter {
	return &MockPrinter_Expecter{mock: &_m.Mock}
}

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

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

// PrintPage is a helper method to define mock.On call
func (_e *MockPrinter_Expecter) PrintPage() *MockPrinter_PrintPage_Call {
	return &MockPrinter_PrintPage_Call{Call: _e.mock.On("PrintPage")}
}

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

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

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

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

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

	return mock
}

// MockPopupLifecycleCapable is an autogenerated mock type for the PopupLifecycleCapable type
type MockPopupLifecycleCapable struct {
	mock.Mock
}

type MockPopupLifecycleCapable_Expecter struct {
	mock *mock.Mock
}

func (_m *MockPopupLifecycleCapable) EXPECT() *MockPopupLifecycleCapable_Expecter {
	return &MockPopupLifecycleCapable_Expecter{mock: &_m.Mock}
}

// PrimePopupNavigation provides a mock function for the type MockPopupLifecycleCapable
func (_mock *MockPopupLifecycleCapable) PrimePopupNavigation(uri string) {
	_mock.Called(uri)
	return
}

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

// PrimePopupNavigation is a helper method to define mock.On call
//   - uri string
func (_e *MockPopupLifecycleCapable_Expecter) PrimePopupNavigation(uri any) *MockPopupLifecycleCapable_PrimePopupNavigation_Call {
	return &MockPopupLifecycleCapable_PrimePopupNavigation_Call{Call: _e.mock.On("PrimePopupNavigation", uri)}
}

func (_c *MockPopupLifecycleCapable_PrimePopupNavigation_Call) Run(run func(uri string)) *MockPopupLifecycleCapable_PrimePopupNavigation_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 *MockPopupLifecycleCapable_PrimePopupNavigation_Call) Return() *MockPopupLifecycleCapable_PrimePopupNavigation_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPopupLifecycleCapable_PrimePopupNavigation_Call) RunAndReturn(run func(uri string)) *MockPopupLifecycleCapable_PrimePopupNavigation_Call {
	_c.Run(run)
	return _c
}

// SetOnClose provides a mock function for the type MockPopupLifecycleCapable
func (_mock *MockPopupLifecycleCapable) SetOnClose(fn func()) {
	_mock.Called(fn)
	return
}

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

// SetOnClose is a helper method to define mock.On call
//   - fn func()
func (_e *MockPopupLifecycleCapable_Expecter) SetOnClose(fn any) *MockPopupLifecycleCapable_SetOnClose_Call {
	return &MockPopupLifecycleCapable_SetOnClose_Call{Call: _e.mock.On("SetOnClose", fn)}
}

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

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

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

// SetOnReadyToShow provides a mock function for the type MockPopupLifecycleCapable
func (_mock *MockPopupLifecycleCapable) SetOnReadyToShow(fn func()) {
	_mock.Called(fn)
	return
}

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

// SetOnReadyToShow is a helper method to define mock.On call
//   - fn func()
func (_e *MockPopupLifecycleCapable_Expecter) SetOnReadyToShow(fn any) *MockPopupLifecycleCapable_SetOnReadyToShow_Call {
	return &MockPopupLifecycleCapable_SetOnReadyToShow_Call{Call: _e.mock.On("SetOnReadyToShow", fn)}
}

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

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

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

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

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

// Show is a helper method to define mock.On call
func (_e *MockPopupLifecycleCapable_Expecter) Show() *MockPopupLifecycleCapable_Show_Call {
	return &MockPopupLifecycleCapable_Show_Call{Call: _e.mock.On("Show")}
}

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

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

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

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

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

	return mock
}

// MockPopupOpenerCapable is an autogenerated mock type for the PopupOpenerCapable type
type MockPopupOpenerCapable struct {
	mock.Mock
}

type MockPopupOpenerCapable_Expecter struct {
	mock *mock.Mock
}

func (_m *MockPopupOpenerCapable) EXPECT() *MockPopupOpenerCapable_Expecter {
	return &MockPopupOpenerCapable_Expecter{mock: &_m.Mock}
}

// AddOpenerMessageCallback provides a mock function for the type MockPopupOpenerCapable
func (_mock *MockPopupOpenerCapable) AddOpenerMessageCallback(fn func()) {
	_mock.Called(fn)
	return
}

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

// AddOpenerMessageCallback is a helper method to define mock.On call
//   - fn func()
func (_e *MockPopupOpenerCapable_Expecter) AddOpenerMessageCallback(fn any) *MockPopupOpenerCapable_AddOpenerMessageCallback_Call {
	return &MockPopupOpenerCapable_AddOpenerMessageCallback_Call{Call: _e.mock.On("AddOpenerMessageCallback", fn)}
}

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

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

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

// AddOpenerNavigationCallback provides a mock function for the type MockPopupOpenerCapable
func (_mock *MockPopupOpenerCapable) AddOpenerNavigationCallback(fn func(uri string)) {
	_mock.Called(fn)
	return
}

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

// AddOpenerNavigationCallback is a helper method to define mock.On call
//   - fn func(uri string)
func (_e *MockPopupOpenerCapable_Expecter) AddOpenerNavigationCallback(fn any) *MockPopupOpenerCapable_AddOpenerNavigationCallback_Call {
	return &MockPopupOpenerCapable_AddOpenerNavigationCallback_Call{Call: _e.mock.On("AddOpenerNavigationCallback", fn)}
}

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

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

func (_c *MockPopupOpenerCapable_AddOpenerNavigationCallback_Call) RunAndReturn(run func(fn func(uri string))) *MockPopupOpenerCapable_AddOpenerNavigationCallback_Call {
	_c.Run(run)
	return _c
}

// EnablePopupOpenerBridge provides a mock function for the type MockPopupOpenerCapable
func (_mock *MockPopupOpenerCapable) EnablePopupOpenerBridge(parent port.WebView, noJavaScriptAccess bool) {
	_mock.Called(parent, noJavaScriptAccess)
	return
}

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

// EnablePopupOpenerBridge is a helper method to define mock.On call
//   - parent port.WebView
//   - noJavaScriptAccess bool
func (_e *MockPopupOpenerCapable_Expecter) EnablePopupOpenerBridge(parent any, noJavaScriptAccess any) *MockPopupOpenerCapable_EnablePopupOpenerBridge_Call {
	return &MockPopupOpenerCapable_EnablePopupOpenerBridge_Call{Call: _e.mock.On("EnablePopupOpenerBridge", parent, noJavaScriptAccess)}
}

func (_c *MockPopupOpenerCapable_EnablePopupOpenerBridge_Call) Run(run func(parent port.WebView, noJavaScriptAccess bool)) *MockPopupOpenerCapable_EnablePopupOpenerBridge_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 port.WebView
		if args[0] != nil {
			arg0 = args[0].(port.WebView)
		}
		var arg1 bool
		if args[1] != nil {
			arg1 = args[1].(bool)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockPopupOpenerCapable_EnablePopupOpenerBridge_Call) RunAndReturn(run func(parent port.WebView, noJavaScriptAccess bool)) *MockPopupOpenerCapable_EnablePopupOpenerBridge_Call {
	_c.Run(run)
	return _c
}

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

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

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

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

// HasActivePopupOpenerBridge is a helper method to define mock.On call
func (_e *MockPopupOpenerCapable_Expecter) HasActivePopupOpenerBridge() *MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call {
	return &MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call{Call: _e.mock.On("HasActivePopupOpenerBridge")}
}

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

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

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

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

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

	return mock
}

// MockOAuthCallbackCapable is an autogenerated mock type for the OAuthCallbackCapable type
type MockOAuthCallbackCapable struct {
	mock.Mock
}

type MockOAuthCallbackCapable_Expecter struct {
	mock *mock.Mock
}

func (_m *MockOAuthCallbackCapable) EXPECT() *MockOAuthCallbackCapable_Expecter {
	return &MockOAuthCallbackCapable_Expecter{mock: &_m.Mock}
}

// AddCloseCallback provides a mock function for the type MockOAuthCallbackCapable
func (_mock *MockOAuthCallbackCapable) AddCloseCallback(fn func()) {
	_mock.Called(fn)
	return
}

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

// AddCloseCallback is a helper method to define mock.On call
//   - fn func()
func (_e *MockOAuthCallbackCapable_Expecter) AddCloseCallback(fn any) *MockOAuthCallbackCapable_AddCloseCallback_Call {
	return &MockOAuthCallbackCapable_AddCloseCallback_Call{Call: _e.mock.On("AddCloseCallback", fn)}
}

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

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

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

// AddNavigationCallback provides a mock function for the type MockOAuthCallbackCapable
func (_mock *MockOAuthCallbackCapable) AddNavigationCallback(fn func(uri string)) {
	_mock.Called(fn)
	return
}

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

// AddNavigationCallback is a helper method to define mock.On call
//   - fn func(uri string)
func (_e *MockOAuthCallbackCapable_Expecter) AddNavigationCallback(fn any) *MockOAuthCallbackCapable_AddNavigationCallback_Call {
	return &MockOAuthCallbackCapable_AddNavigationCallback_Call{Call: _e.mock.On("AddNavigationCallback", fn)}
}

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

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

func (_c *MockOAuthCallbackCapable_AddNavigationCallback_Call) RunAndReturn(run func(fn func(uri string))) *MockOAuthCallbackCapable_AddNavigationCallback_Call {
	_c.Run(run)
	return _c
}

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

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

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

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

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

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

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

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

	return mock
}

// MockTextInputTargetProvider is an autogenerated mock type for the TextInputTargetProvider type
type MockTextInputTargetProvider struct {
	mock.Mock
}

type MockTextInputTargetProvider_Expecter struct {
	mock *mock.Mock
}

func (_m *MockTextInputTargetProvider) EXPECT() *MockTextInputTargetProvider_Expecter {
	return &MockTextInputTargetProvider_Expecter{mock: &_m.Mock}
}

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

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

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

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

// TextInputTarget is a helper method to define mock.On call
func (_e *MockTextInputTargetProvider_Expecter) TextInputTarget() *MockTextInputTargetProvider_TextInputTarget_Call {
	return &MockTextInputTargetProvider_TextInputTarget_Call{Call: _e.mock.On("TextInputTarget")}
}

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

func (_c *MockTextInputTargetProvider_TextInputTarget_Call) Return(textInputTarget port.TextInputTarget) *MockTextInputTargetProvider_TextInputTarget_Call {
	_c.Call.Return(textInputTarget)
	return _c
}

func (_c *MockTextInputTargetProvider_TextInputTarget_Call) RunAndReturn(run func() port.TextInputTarget) *MockTextInputTargetProvider_TextInputTarget_Call {
	_c.Call.Return(run)
	return _c
}