// Code generated by MockGen. DO NOT EDIT.
// Source: interfaces.go

// Package mock_browser is a generated GoMock package.
package mock_browser

import (
	reflect "reflect"

	browser "github.com/bnema/dumber/internal/app/browser"
	messaging "github.com/bnema/dumber/internal/app/messaging"
	webkit "github.com/bnema/dumber/pkg/webkit"
	gomock "github.com/golang/mock/gomock"
)

// MockWebViewInterface is a mock of WebViewInterface interface.
type MockWebViewInterface struct {
	ctrl     *gomock.Controller
	recorder *MockWebViewInterfaceMockRecorder
}

// MockWebViewInterfaceMockRecorder is the mock recorder for MockWebViewInterface.
type MockWebViewInterfaceMockRecorder struct {
	mock *MockWebViewInterface
}

// NewMockWebViewInterface creates a new mock instance.
func NewMockWebViewInterface(ctrl *gomock.Controller) *MockWebViewInterface {
	mock := &MockWebViewInterface{ctrl: ctrl}
	mock.recorder = &MockWebViewInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockWebViewInterface) EXPECT() *MockWebViewInterfaceMockRecorder {
	return m.recorder
}

// Destroy mocks base method.
func (m *MockWebViewInterface) Destroy() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Destroy")
	ret0, _ := ret[0].(error)
	return ret0
}

// Destroy indicates an expected call of Destroy.
func (mr *MockWebViewInterfaceMockRecorder) Destroy() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Destroy", reflect.TypeOf((*MockWebViewInterface)(nil).Destroy))
}

// DispatchCustomEvent mocks base method.
func (m *MockWebViewInterface) DispatchCustomEvent(event string, detail map[string]any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DispatchCustomEvent", event, detail)
	ret0, _ := ret[0].(error)
	return ret0
}

// DispatchCustomEvent indicates an expected call of DispatchCustomEvent.
func (mr *MockWebViewInterfaceMockRecorder) DispatchCustomEvent(event, detail interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DispatchCustomEvent", reflect.TypeOf((*MockWebViewInterface)(nil).DispatchCustomEvent), event, detail)
}

// GetCurrentURL mocks base method.
func (m *MockWebViewInterface) GetCurrentURL() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentURL")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetCurrentURL indicates an expected call of GetCurrentURL.
func (mr *MockWebViewInterfaceMockRecorder) GetCurrentURL() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentURL", reflect.TypeOf((*MockWebViewInterface)(nil).GetCurrentURL))
}

// Hide mocks base method.
func (m *MockWebViewInterface) Hide() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Hide")
	ret0, _ := ret[0].(error)
	return ret0
}

// Hide indicates an expected call of Hide.
func (mr *MockWebViewInterfaceMockRecorder) Hide() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Hide", reflect.TypeOf((*MockWebViewInterface)(nil).Hide))
}

// InjectScript mocks base method.
func (m *MockWebViewInterface) InjectScript(script string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InjectScript", script)
	ret0, _ := ret[0].(error)
	return ret0
}

// InjectScript indicates an expected call of InjectScript.
func (mr *MockWebViewInterfaceMockRecorder) InjectScript(script interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InjectScript", reflect.TypeOf((*MockWebViewInterface)(nil).InjectScript), script)
}

// LoadURL mocks base method.
func (m *MockWebViewInterface) LoadURL(url string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadURL", url)
	ret0, _ := ret[0].(error)
	return ret0
}

// LoadURL indicates an expected call of LoadURL.
func (mr *MockWebViewInterfaceMockRecorder) LoadURL(url interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadURL", reflect.TypeOf((*MockWebViewInterface)(nil).LoadURL), url)
}

// RegisterKeyboardShortcut mocks base method.
func (m *MockWebViewInterface) RegisterKeyboardShortcut(key string, handler func()) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterKeyboardShortcut", key, handler)
	ret0, _ := ret[0].(error)
	return ret0
}

// RegisterKeyboardShortcut indicates an expected call of RegisterKeyboardShortcut.
func (mr *MockWebViewInterfaceMockRecorder) RegisterKeyboardShortcut(key, handler interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterKeyboardShortcut", reflect.TypeOf((*MockWebViewInterface)(nil).RegisterKeyboardShortcut), key, handler)
}

// RegisterURIChangedHandler mocks base method.
func (m *MockWebViewInterface) RegisterURIChangedHandler(handler func(string)) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterURIChangedHandler", handler)
}

// RegisterURIChangedHandler indicates an expected call of RegisterURIChangedHandler.
func (mr *MockWebViewInterfaceMockRecorder) RegisterURIChangedHandler(handler interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterURIChangedHandler", reflect.TypeOf((*MockWebViewInterface)(nil).RegisterURIChangedHandler), handler)
}

// RootWidget mocks base method.
func (m *MockWebViewInterface) RootWidget() uintptr {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RootWidget")
	ret0, _ := ret[0].(uintptr)
	return ret0
}

// RootWidget indicates an expected call of RootWidget.
func (mr *MockWebViewInterfaceMockRecorder) RootWidget() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RootWidget", reflect.TypeOf((*MockWebViewInterface)(nil).RootWidget))
}

// Show mocks base method.
func (m *MockWebViewInterface) Show() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Show")
	ret0, _ := ret[0].(error)
	return ret0
}

// Show indicates an expected call of Show.
func (mr *MockWebViewInterfaceMockRecorder) Show() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Show", reflect.TypeOf((*MockWebViewInterface)(nil).Show))
}

// Widget mocks base method.
func (m *MockWebViewInterface) Widget() uintptr {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Widget")
	ret0, _ := ret[0].(uintptr)
	return ret0
}

// Widget indicates an expected call of Widget.
func (mr *MockWebViewInterfaceMockRecorder) Widget() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Widget", reflect.TypeOf((*MockWebViewInterface)(nil).Widget))
}

// Window mocks base method.
func (m *MockWebViewInterface) Window() *webkit.Window {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Window")
	ret0, _ := ret[0].(*webkit.Window)
	return ret0
}

// Window indicates an expected call of Window.
func (mr *MockWebViewInterfaceMockRecorder) Window() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Window", reflect.TypeOf((*MockWebViewInterface)(nil).Window))
}

// MockPaneInterface is a mock of PaneInterface interface.
type MockPaneInterface struct {
	ctrl     *gomock.Controller
	recorder *MockPaneInterfaceMockRecorder
}

// MockPaneInterfaceMockRecorder is the mock recorder for MockPaneInterface.
type MockPaneInterfaceMockRecorder struct {
	mock *MockPaneInterface
}

// NewMockPaneInterface creates a new mock instance.
func NewMockPaneInterface(ctrl *gomock.Controller) *MockPaneInterface {
	mock := &MockPaneInterface{ctrl: ctrl}
	mock.recorder = &MockPaneInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockPaneInterface) EXPECT() *MockPaneInterfaceMockRecorder {
	return m.recorder
}

// Cleanup mocks base method.
func (m *MockPaneInterface) Cleanup() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Cleanup")
}

// Cleanup indicates an expected call of Cleanup.
func (mr *MockPaneInterfaceMockRecorder) Cleanup() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cleanup", reflect.TypeOf((*MockPaneInterface)(nil).Cleanup))
}

// ClipboardController mocks base method.
func (m *MockPaneInterface) ClipboardController() browser.ClipboardControllerInterface {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClipboardController")
	ret0, _ := ret[0].(browser.ClipboardControllerInterface)
	return ret0
}

// ClipboardController indicates an expected call of ClipboardController.
func (mr *MockPaneInterfaceMockRecorder) ClipboardController() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClipboardController", reflect.TypeOf((*MockPaneInterface)(nil).ClipboardController))
}

// HasGUI mocks base method.
func (m *MockPaneInterface) HasGUI() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasGUI")
	ret0, _ := ret[0].(bool)
	return ret0
}

// HasGUI indicates an expected call of HasGUI.
func (mr *MockPaneInterfaceMockRecorder) HasGUI() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasGUI", reflect.TypeOf((*MockPaneInterface)(nil).HasGUI))
}

// HasGUIComponent mocks base method.
func (m *MockPaneInterface) HasGUIComponent(component string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasGUIComponent", component)
	ret0, _ := ret[0].(bool)
	return ret0
}

// HasGUIComponent indicates an expected call of HasGUIComponent.
func (mr *MockPaneInterfaceMockRecorder) HasGUIComponent(component interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasGUIComponent", reflect.TypeOf((*MockPaneInterface)(nil).HasGUIComponent), component)
}

// ID mocks base method.
func (m *MockPaneInterface) ID() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ID")
	ret0, _ := ret[0].(string)
	return ret0
}

// ID indicates an expected call of ID.
func (mr *MockPaneInterfaceMockRecorder) ID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockPaneInterface)(nil).ID))
}

// MessageHandler mocks base method.
func (m *MockPaneInterface) MessageHandler() browser.MessageHandlerInterface {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MessageHandler")
	ret0, _ := ret[0].(browser.MessageHandlerInterface)
	return ret0
}

// MessageHandler indicates an expected call of MessageHandler.
func (mr *MockPaneInterfaceMockRecorder) MessageHandler() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MessageHandler", reflect.TypeOf((*MockPaneInterface)(nil).MessageHandler))
}

// NavigationController mocks base method.
func (m *MockPaneInterface) NavigationController() browser.NavigationControllerInterface {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NavigationController")
	ret0, _ := ret[0].(browser.NavigationControllerInterface)
	return ret0
}

// NavigationController indicates an expected call of NavigationController.
func (mr *MockPaneInterfaceMockRecorder) NavigationController() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NavigationController", reflect.TypeOf((*MockPaneInterface)(nil).NavigationController))
}

// SetGUIComponent mocks base method.
func (m *MockPaneInterface) SetGUIComponent(component string, loaded bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetGUIComponent", component, loaded)
}

// SetGUIComponent indicates an expected call of SetGUIComponent.
func (mr *MockPaneInterfaceMockRecorder) SetGUIComponent(component, loaded interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGUIComponent", reflect.TypeOf((*MockPaneInterface)(nil).SetGUIComponent), component, loaded)
}

// SetHasGUI mocks base method.
func (m *MockPaneInterface) SetHasGUI(arg0 bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetHasGUI", arg0)
}

// SetHasGUI indicates an expected call of SetHasGUI.
func (mr *MockPaneInterfaceMockRecorder) SetHasGUI(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHasGUI", reflect.TypeOf((*MockPaneInterface)(nil).SetHasGUI), arg0)
}

// SetID mocks base method.
func (m *MockPaneInterface) SetID(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetID", arg0)
}

// SetID indicates an expected call of SetID.
func (mr *MockPaneInterfaceMockRecorder) SetID(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetID", reflect.TypeOf((*MockPaneInterface)(nil).SetID), arg0)
}

// ShortcutHandler mocks base method.
func (m *MockPaneInterface) ShortcutHandler() browser.ShortcutHandlerInterface {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ShortcutHandler")
	ret0, _ := ret[0].(browser.ShortcutHandlerInterface)
	return ret0
}

// ShortcutHandler indicates an expected call of ShortcutHandler.
func (mr *MockPaneInterfaceMockRecorder) ShortcutHandler() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShortcutHandler", reflect.TypeOf((*MockPaneInterface)(nil).ShortcutHandler))
}

// UpdateLastFocus mocks base method.
func (m *MockPaneInterface) UpdateLastFocus() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateLastFocus")
}

// UpdateLastFocus indicates an expected call of UpdateLastFocus.
func (mr *MockPaneInterfaceMockRecorder) UpdateLastFocus() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLastFocus", reflect.TypeOf((*MockPaneInterface)(nil).UpdateLastFocus))
}

// WebView mocks base method.
func (m *MockPaneInterface) WebView() browser.WebViewInterface {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WebView")
	ret0, _ := ret[0].(browser.WebViewInterface)
	return ret0
}

// WebView indicates an expected call of WebView.
func (mr *MockPaneInterfaceMockRecorder) WebView() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WebView", reflect.TypeOf((*MockPaneInterface)(nil).WebView))
}

// ZoomController mocks base method.
func (m *MockPaneInterface) ZoomController() browser.ZoomControllerInterface {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZoomController")
	ret0, _ := ret[0].(browser.ZoomControllerInterface)
	return ret0
}

// ZoomController indicates an expected call of ZoomController.
func (mr *MockPaneInterfaceMockRecorder) ZoomController() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZoomController", reflect.TypeOf((*MockPaneInterface)(nil).ZoomController))
}

// MockMessageHandlerInterface is a mock of MessageHandlerInterface interface.
type MockMessageHandlerInterface struct {
	ctrl     *gomock.Controller
	recorder *MockMessageHandlerInterfaceMockRecorder
}

// MockMessageHandlerInterfaceMockRecorder is the mock recorder for MockMessageHandlerInterface.
type MockMessageHandlerInterfaceMockRecorder struct {
	mock *MockMessageHandlerInterface
}

// NewMockMessageHandlerInterface creates a new mock instance.
func NewMockMessageHandlerInterface(ctrl *gomock.Controller) *MockMessageHandlerInterface {
	mock := &MockMessageHandlerInterface{ctrl: ctrl}
	mock.recorder = &MockMessageHandlerInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockMessageHandlerInterface) EXPECT() *MockMessageHandlerInterfaceMockRecorder {
	return m.recorder
}

// SetWorkspaceObserver mocks base method.
func (m *MockMessageHandlerInterface) SetWorkspaceObserver(observer messaging.WorkspaceObserver) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetWorkspaceObserver", observer)
}

// SetWorkspaceObserver indicates an expected call of SetWorkspaceObserver.
func (mr *MockMessageHandlerInterfaceMockRecorder) SetWorkspaceObserver(observer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWorkspaceObserver", reflect.TypeOf((*MockMessageHandlerInterface)(nil).SetWorkspaceObserver), observer)
}

// MockNavigationControllerInterface is a mock of NavigationControllerInterface interface.
type MockNavigationControllerInterface struct {
	ctrl     *gomock.Controller
	recorder *MockNavigationControllerInterfaceMockRecorder
}

// MockNavigationControllerInterfaceMockRecorder is the mock recorder for MockNavigationControllerInterface.
type MockNavigationControllerInterfaceMockRecorder struct {
	mock *MockNavigationControllerInterface
}

// NewMockNavigationControllerInterface creates a new mock instance.
func NewMockNavigationControllerInterface(ctrl *gomock.Controller) *MockNavigationControllerInterface {
	mock := &MockNavigationControllerInterface{ctrl: ctrl}
	mock.recorder = &MockNavigationControllerInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockNavigationControllerInterface) EXPECT() *MockNavigationControllerInterfaceMockRecorder {
	return m.recorder
}

// NavigateToURL mocks base method.
func (m *MockNavigationControllerInterface) NavigateToURL(url string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NavigateToURL", url)
	ret0, _ := ret[0].(error)
	return ret0
}

// NavigateToURL indicates an expected call of NavigateToURL.
func (mr *MockNavigationControllerInterfaceMockRecorder) NavigateToURL(url interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NavigateToURL", reflect.TypeOf((*MockNavigationControllerInterface)(nil).NavigateToURL), url)
}

// MockZoomControllerInterface is a mock of ZoomControllerInterface interface.
type MockZoomControllerInterface struct {
	ctrl     *gomock.Controller
	recorder *MockZoomControllerInterfaceMockRecorder
}

// MockZoomControllerInterfaceMockRecorder is the mock recorder for MockZoomControllerInterface.
type MockZoomControllerInterfaceMockRecorder struct {
	mock *MockZoomControllerInterface
}

// NewMockZoomControllerInterface creates a new mock instance.
func NewMockZoomControllerInterface(ctrl *gomock.Controller) *MockZoomControllerInterface {
	mock := &MockZoomControllerInterface{ctrl: ctrl}
	mock.recorder = &MockZoomControllerInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockZoomControllerInterface) EXPECT() *MockZoomControllerInterfaceMockRecorder {
	return m.recorder
}

// ApplyInitialZoom mocks base method.
func (m *MockZoomControllerInterface) ApplyInitialZoom() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ApplyInitialZoom")
}

// ApplyInitialZoom indicates an expected call of ApplyInitialZoom.
func (mr *MockZoomControllerInterfaceMockRecorder) ApplyInitialZoom() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyInitialZoom", reflect.TypeOf((*MockZoomControllerInterface)(nil).ApplyInitialZoom))
}

// MockClipboardControllerInterface is a mock of ClipboardControllerInterface interface.
type MockClipboardControllerInterface struct {
	ctrl     *gomock.Controller
	recorder *MockClipboardControllerInterfaceMockRecorder
}

// MockClipboardControllerInterfaceMockRecorder is the mock recorder for MockClipboardControllerInterface.
type MockClipboardControllerInterfaceMockRecorder struct {
	mock *MockClipboardControllerInterface
}

// NewMockClipboardControllerInterface creates a new mock instance.
func NewMockClipboardControllerInterface(ctrl *gomock.Controller) *MockClipboardControllerInterface {
	mock := &MockClipboardControllerInterface{ctrl: ctrl}
	mock.recorder = &MockClipboardControllerInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockClipboardControllerInterface) EXPECT() *MockClipboardControllerInterfaceMockRecorder {
	return m.recorder
}

// MockShortcutHandlerInterface is a mock of ShortcutHandlerInterface interface.
type MockShortcutHandlerInterface struct {
	ctrl     *gomock.Controller
	recorder *MockShortcutHandlerInterfaceMockRecorder
}

// MockShortcutHandlerInterfaceMockRecorder is the mock recorder for MockShortcutHandlerInterface.
type MockShortcutHandlerInterfaceMockRecorder struct {
	mock *MockShortcutHandlerInterface
}

// NewMockShortcutHandlerInterface creates a new mock instance.
func NewMockShortcutHandlerInterface(ctrl *gomock.Controller) *MockShortcutHandlerInterface {
	mock := &MockShortcutHandlerInterface{ctrl: ctrl}
	mock.recorder = &MockShortcutHandlerInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockShortcutHandlerInterface) EXPECT() *MockShortcutHandlerInterfaceMockRecorder {
	return m.recorder
}

// MockBrowserAppInterface is a mock of BrowserAppInterface interface.
type MockBrowserAppInterface struct {
	ctrl     *gomock.Controller
	recorder *MockBrowserAppInterfaceMockRecorder
}

// MockBrowserAppInterfaceMockRecorder is the mock recorder for MockBrowserAppInterface.
type MockBrowserAppInterfaceMockRecorder struct {
	mock *MockBrowserAppInterface
}

// NewMockBrowserAppInterface creates a new mock instance.
func NewMockBrowserAppInterface(ctrl *gomock.Controller) *MockBrowserAppInterface {
	mock := &MockBrowserAppInterface{ctrl: ctrl}
	mock.recorder = &MockBrowserAppInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockBrowserAppInterface) EXPECT() *MockBrowserAppInterfaceMockRecorder {
	return m.recorder
}

// AppendPane mocks base method.
func (m *MockBrowserAppInterface) AppendPane(pane *browser.BrowserPane) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendPane", pane)
}

// AppendPane indicates an expected call of AppendPane.
func (mr *MockBrowserAppInterfaceMockRecorder) AppendPane(pane interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendPane", reflect.TypeOf((*MockBrowserAppInterface)(nil).AppendPane), pane)
}

// BuildWebkitConfig mocks base method.
func (m *MockBrowserAppInterface) BuildWebkitConfig() (*webkit.Config, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuildWebkitConfig")
	ret0, _ := ret[0].(*webkit.Config)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BuildWebkitConfig indicates an expected call of BuildWebkitConfig.
func (mr *MockBrowserAppInterfaceMockRecorder) BuildWebkitConfig() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildWebkitConfig", reflect.TypeOf((*MockBrowserAppInterface)(nil).BuildWebkitConfig))
}

// CreatePaneForView mocks base method.
func (m *MockBrowserAppInterface) CreatePaneForView(view *webkit.WebView) (*browser.BrowserPane, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePaneForView", view)
	ret0, _ := ret[0].(*browser.BrowserPane)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePaneForView indicates an expected call of CreatePaneForView.
func (mr *MockBrowserAppInterfaceMockRecorder) CreatePaneForView(view interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePaneForView", reflect.TypeOf((*MockBrowserAppInterface)(nil).CreatePaneForView), view)
}

// GetActivePane mocks base method.
func (m *MockBrowserAppInterface) GetActivePane() *browser.BrowserPane {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetActivePane")
	ret0, _ := ret[0].(*browser.BrowserPane)
	return ret0
}

// GetActivePane indicates an expected call of GetActivePane.
func (mr *MockBrowserAppInterfaceMockRecorder) GetActivePane() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActivePane", reflect.TypeOf((*MockBrowserAppInterface)(nil).GetActivePane))
}

// GetPanes mocks base method.
func (m *MockBrowserAppInterface) GetPanes() []*browser.BrowserPane {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPanes")
	ret0, _ := ret[0].([]*browser.BrowserPane)
	return ret0
}

// GetPanes indicates an expected call of GetPanes.
func (mr *MockBrowserAppInterfaceMockRecorder) GetPanes() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPanes", reflect.TypeOf((*MockBrowserAppInterface)(nil).GetPanes))
}

// RemovePane mocks base method.
func (m *MockBrowserAppInterface) RemovePane(pane *browser.BrowserPane) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RemovePane", pane)
}

// RemovePane indicates an expected call of RemovePane.
func (mr *MockBrowserAppInterfaceMockRecorder) RemovePane(pane interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePane", reflect.TypeOf((*MockBrowserAppInterface)(nil).RemovePane), pane)
}

// SetActivePane mocks base method.
func (m *MockBrowserAppInterface) SetActivePane(pane *browser.BrowserPane) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetActivePane", pane)
}

// SetActivePane indicates an expected call of SetActivePane.
func (mr *MockBrowserAppInterfaceMockRecorder) SetActivePane(pane interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetActivePane", reflect.TypeOf((*MockBrowserAppInterface)(nil).SetActivePane), pane)
}

// MockWindowInterface is a mock of WindowInterface interface.
type MockWindowInterface struct {
	ctrl     *gomock.Controller
	recorder *MockWindowInterfaceMockRecorder
}

// MockWindowInterfaceMockRecorder is the mock recorder for MockWindowInterface.
type MockWindowInterfaceMockRecorder struct {
	mock *MockWindowInterface
}

// NewMockWindowInterface creates a new mock instance.
func NewMockWindowInterface(ctrl *gomock.Controller) *MockWindowInterface {
	mock := &MockWindowInterface{ctrl: ctrl}
	mock.recorder = &MockWindowInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockWindowInterface) EXPECT() *MockWindowInterfaceMockRecorder {
	return m.recorder
}

// SetChild mocks base method.
func (m *MockWindowInterface) SetChild(widget uintptr) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetChild", widget)
}

// SetChild indicates an expected call of SetChild.
func (mr *MockWindowInterfaceMockRecorder) SetChild(widget interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetChild", reflect.TypeOf((*MockWindowInterface)(nil).SetChild), widget)
}

// MockWindowShortcutHandlerInterface is a mock of WindowShortcutHandlerInterface interface.
type MockWindowShortcutHandlerInterface struct {
	ctrl     *gomock.Controller
	recorder *MockWindowShortcutHandlerInterfaceMockRecorder
}

// MockWindowShortcutHandlerInterfaceMockRecorder is the mock recorder for MockWindowShortcutHandlerInterface.
type MockWindowShortcutHandlerInterfaceMockRecorder struct {
	mock *MockWindowShortcutHandlerInterface
}

// NewMockWindowShortcutHandlerInterface creates a new mock instance.
func NewMockWindowShortcutHandlerInterface(ctrl *gomock.Controller) *MockWindowShortcutHandlerInterface {
	mock := &MockWindowShortcutHandlerInterface{ctrl: ctrl}
	mock.recorder = &MockWindowShortcutHandlerInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockWindowShortcutHandlerInterface) EXPECT() *MockWindowShortcutHandlerInterfaceMockRecorder {
	return m.recorder
}

// Cleanup mocks base method.
func (m *MockWindowShortcutHandlerInterface) Cleanup() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Cleanup")
}

// Cleanup indicates an expected call of Cleanup.
func (mr *MockWindowShortcutHandlerInterfaceMockRecorder) Cleanup() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cleanup", reflect.TypeOf((*MockWindowShortcutHandlerInterface)(nil).Cleanup))
}