mocks.go RawHistoryFolder

1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package mocks
6
7import (
8	"context"
9	"database/sql"
10	"encoding/json"
11	"io"
12	"time"
13
14	"github.com/bnema/dumber/internal/application/dto"
15	"github.com/bnema/dumber/internal/application/port"
16	"github.com/bnema/dumber/internal/domain/entity"
17	"github.com/rs/zerolog"
18	mock "github.com/stretchr/testify/mock"
19)
20
21// NewMockAccentPickerUI creates a new instance of MockAccentPickerUI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
22// The first argument is typically a *testing.T value.
23func NewMockAccentPickerUI(t interface {
24	mock.TestingT
25	Cleanup(func())
26}) *MockAccentPickerUI {
27	mock := &MockAccentPickerUI{}
28	mock.Mock.Test(t)
29
30	t.Cleanup(func() { mock.AssertExpectations(t) })
31
32	return mock
33}
34
35// MockAccentPickerUI is an autogenerated mock type for the AccentPickerUI type
36type MockAccentPickerUI struct {
37	mock.Mock
38}
39
40type MockAccentPickerUI_Expecter struct {
41	mock *mock.Mock
42}
43
44func (_m *MockAccentPickerUI) EXPECT() *MockAccentPickerUI_Expecter {
45	return &MockAccentPickerUI_Expecter{mock: &_m.Mock}
46}
47
48// Hide provides a mock function for the type MockAccentPickerUI
49func (_mock *MockAccentPickerUI) Hide() {
50	_mock.Called()
51	return
52}
53
54// MockAccentPickerUI_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
55type MockAccentPickerUI_Hide_Call struct {
56	*mock.Call
57}
58
59// Hide is a helper method to define mock.On call
60func (_e *MockAccentPickerUI_Expecter) Hide() *MockAccentPickerUI_Hide_Call {
61	return &MockAccentPickerUI_Hide_Call{Call: _e.mock.On("Hide")}
62}
63
64func (_c *MockAccentPickerUI_Hide_Call) Run(run func()) *MockAccentPickerUI_Hide_Call {
65	_c.Call.Run(func(args mock.Arguments) {
66		run()
67	})
68	return _c
69}
70
71func (_c *MockAccentPickerUI_Hide_Call) Return() *MockAccentPickerUI_Hide_Call {
72	_c.Call.Return()
73	return _c
74}
75
76func (_c *MockAccentPickerUI_Hide_Call) RunAndReturn(run func()) *MockAccentPickerUI_Hide_Call {
77	_c.Run(run)
78	return _c
79}
80
81// IsVisible provides a mock function for the type MockAccentPickerUI
82func (_mock *MockAccentPickerUI) IsVisible() bool {
83	ret := _mock.Called()
84
85	if len(ret) == 0 {
86		panic("no return value specified for IsVisible")
87	}
88
89	var r0 bool
90	if returnFunc, ok := ret.Get(0).(func() bool); ok {
91		r0 = returnFunc()
92	} else {
93		r0 = ret.Get(0).(bool)
94	}
95	return r0
96}
97
98// MockAccentPickerUI_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
99type MockAccentPickerUI_IsVisible_Call struct {
100	*mock.Call
101}
102
103// IsVisible is a helper method to define mock.On call
104func (_e *MockAccentPickerUI_Expecter) IsVisible() *MockAccentPickerUI_IsVisible_Call {
105	return &MockAccentPickerUI_IsVisible_Call{Call: _e.mock.On("IsVisible")}
106}
107
108func (_c *MockAccentPickerUI_IsVisible_Call) Run(run func()) *MockAccentPickerUI_IsVisible_Call {
109	_c.Call.Run(func(args mock.Arguments) {
110		run()
111	})
112	return _c
113}
114
115func (_c *MockAccentPickerUI_IsVisible_Call) Return(b bool) *MockAccentPickerUI_IsVisible_Call {
116	_c.Call.Return(b)
117	return _c
118}
119
120func (_c *MockAccentPickerUI_IsVisible_Call) RunAndReturn(run func() bool) *MockAccentPickerUI_IsVisible_Call {
121	_c.Call.Return(run)
122	return _c
123}
124
125// Show provides a mock function for the type MockAccentPickerUI
126func (_mock *MockAccentPickerUI) Show(accents []rune, selectedCallback func(accent rune), cancelCallback func()) {
127	_mock.Called(accents, selectedCallback, cancelCallback)
128	return
129}
130
131// MockAccentPickerUI_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
132type MockAccentPickerUI_Show_Call struct {
133	*mock.Call
134}
135
136// Show is a helper method to define mock.On call
137//   - accents []rune
138//   - selectedCallback func(accent rune)
139//   - cancelCallback func()
140func (_e *MockAccentPickerUI_Expecter) Show(accents interface{}, selectedCallback interface{}, cancelCallback interface{}) *MockAccentPickerUI_Show_Call {
141	return &MockAccentPickerUI_Show_Call{Call: _e.mock.On("Show", accents, selectedCallback, cancelCallback)}
142}
143
144func (_c *MockAccentPickerUI_Show_Call) Run(run func(accents []rune, selectedCallback func(accent rune), cancelCallback func())) *MockAccentPickerUI_Show_Call {
145	_c.Call.Run(func(args mock.Arguments) {
146		var arg0 []rune
147		if args[0] != nil {
148			arg0 = args[0].([]rune)
149		}
150		var arg1 func(accent rune)
151		if args[1] != nil {
152			arg1 = args[1].(func(accent rune))
153		}
154		var arg2 func()
155		if args[2] != nil {
156			arg2 = args[2].(func())
157		}
158		run(
159			arg0,
160			arg1,
161			arg2,
162		)
163	})
164	return _c
165}
166
167func (_c *MockAccentPickerUI_Show_Call) Return() *MockAccentPickerUI_Show_Call {
168	_c.Call.Return()
169	return _c
170}
171
172func (_c *MockAccentPickerUI_Show_Call) RunAndReturn(run func(accents []rune, selectedCallback func(accent rune), cancelCallback func())) *MockAccentPickerUI_Show_Call {
173	_c.Run(run)
174	return _c
175}
176
177// NewMockBrowserWindowOpener creates a new instance of MockBrowserWindowOpener. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
178// The first argument is typically a *testing.T value.
179func NewMockBrowserWindowOpener(t interface {
180	mock.TestingT
181	Cleanup(func())
182}) *MockBrowserWindowOpener {
183	mock := &MockBrowserWindowOpener{}
184	mock.Mock.Test(t)
185
186	t.Cleanup(func() { mock.AssertExpectations(t) })
187
188	return mock
189}
190
191// MockBrowserWindowOpener is an autogenerated mock type for the BrowserWindowOpener type
192type MockBrowserWindowOpener struct {
193	mock.Mock
194}
195
196type MockBrowserWindowOpener_Expecter struct {
197	mock *mock.Mock
198}
199
200func (_m *MockBrowserWindowOpener) EXPECT() *MockBrowserWindowOpener_Expecter {
201	return &MockBrowserWindowOpener_Expecter{mock: &_m.Mock}
202}
203
204// OpenFreshWindow provides a mock function for the type MockBrowserWindowOpener
205func (_mock *MockBrowserWindowOpener) OpenFreshWindow(ctx context.Context, url string) error {
206	ret := _mock.Called(ctx, url)
207
208	if len(ret) == 0 {
209		panic("no return value specified for OpenFreshWindow")
210	}
211
212	var r0 error
213	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
214		r0 = returnFunc(ctx, url)
215	} else {
216		r0 = ret.Error(0)
217	}
218	return r0
219}
220
221// MockBrowserWindowOpener_OpenFreshWindow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenFreshWindow'
222type MockBrowserWindowOpener_OpenFreshWindow_Call struct {
223	*mock.Call
224}
225
226// OpenFreshWindow is a helper method to define mock.On call
227//   - ctx context.Context
228//   - url string
229func (_e *MockBrowserWindowOpener_Expecter) OpenFreshWindow(ctx interface{}, url interface{}) *MockBrowserWindowOpener_OpenFreshWindow_Call {
230	return &MockBrowserWindowOpener_OpenFreshWindow_Call{Call: _e.mock.On("OpenFreshWindow", ctx, url)}
231}
232
233func (_c *MockBrowserWindowOpener_OpenFreshWindow_Call) Run(run func(ctx context.Context, url string)) *MockBrowserWindowOpener_OpenFreshWindow_Call {
234	_c.Call.Run(func(args mock.Arguments) {
235		var arg0 context.Context
236		if args[0] != nil {
237			arg0 = args[0].(context.Context)
238		}
239		var arg1 string
240		if args[1] != nil {
241			arg1 = args[1].(string)
242		}
243		run(
244			arg0,
245			arg1,
246		)
247	})
248	return _c
249}
250
251func (_c *MockBrowserWindowOpener_OpenFreshWindow_Call) Return(err error) *MockBrowserWindowOpener_OpenFreshWindow_Call {
252	_c.Call.Return(err)
253	return _c
254}
255
256func (_c *MockBrowserWindowOpener_OpenFreshWindow_Call) RunAndReturn(run func(ctx context.Context, url string) error) *MockBrowserWindowOpener_OpenFreshWindow_Call {
257	_c.Call.Return(run)
258	return _c
259}
260
261// NewMockBrowserLaunchRelay creates a new instance of MockBrowserLaunchRelay. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
262// The first argument is typically a *testing.T value.
263func NewMockBrowserLaunchRelay(t interface {
264	mock.TestingT
265	Cleanup(func())
266}) *MockBrowserLaunchRelay {
267	mock := &MockBrowserLaunchRelay{}
268	mock.Mock.Test(t)
269
270	t.Cleanup(func() { mock.AssertExpectations(t) })
271
272	return mock
273}
274
275// MockBrowserLaunchRelay is an autogenerated mock type for the BrowserLaunchRelay type
276type MockBrowserLaunchRelay struct {
277	mock.Mock
278}
279
280type MockBrowserLaunchRelay_Expecter struct {
281	mock *mock.Mock
282}
283
284func (_m *MockBrowserLaunchRelay) EXPECT() *MockBrowserLaunchRelay_Expecter {
285	return &MockBrowserLaunchRelay_Expecter{mock: &_m.Mock}
286}
287
288// DeliverOpenFreshWindow provides a mock function for the type MockBrowserLaunchRelay
289func (_mock *MockBrowserLaunchRelay) DeliverOpenFreshWindow(ctx context.Context, url string) (bool, error) {
290	ret := _mock.Called(ctx, url)
291
292	if len(ret) == 0 {
293		panic("no return value specified for DeliverOpenFreshWindow")
294	}
295
296	var r0 bool
297	var r1 error
298	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (bool, error)); ok {
299		return returnFunc(ctx, url)
300	}
301	if returnFunc, ok := ret.Get(0).(func(context.Context, string) bool); ok {
302		r0 = returnFunc(ctx, url)
303	} else {
304		r0 = ret.Get(0).(bool)
305	}
306	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
307		r1 = returnFunc(ctx, url)
308	} else {
309		r1 = ret.Error(1)
310	}
311	return r0, r1
312}
313
314// MockBrowserLaunchRelay_DeliverOpenFreshWindow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeliverOpenFreshWindow'
315type MockBrowserLaunchRelay_DeliverOpenFreshWindow_Call struct {
316	*mock.Call
317}
318
319// DeliverOpenFreshWindow is a helper method to define mock.On call
320//   - ctx context.Context
321//   - url string
322func (_e *MockBrowserLaunchRelay_Expecter) DeliverOpenFreshWindow(ctx interface{}, url interface{}) *MockBrowserLaunchRelay_DeliverOpenFreshWindow_Call {
323	return &MockBrowserLaunchRelay_DeliverOpenFreshWindow_Call{Call: _e.mock.On("DeliverOpenFreshWindow", ctx, url)}
324}
325
326func (_c *MockBrowserLaunchRelay_DeliverOpenFreshWindow_Call) Run(run func(ctx context.Context, url string)) *MockBrowserLaunchRelay_DeliverOpenFreshWindow_Call {
327	_c.Call.Run(func(args mock.Arguments) {
328		var arg0 context.Context
329		if args[0] != nil {
330			arg0 = args[0].(context.Context)
331		}
332		var arg1 string
333		if args[1] != nil {
334			arg1 = args[1].(string)
335		}
336		run(
337			arg0,
338			arg1,
339		)
340	})
341	return _c
342}
343
344func (_c *MockBrowserLaunchRelay_DeliverOpenFreshWindow_Call) Return(b bool, err error) *MockBrowserLaunchRelay_DeliverOpenFreshWindow_Call {
345	_c.Call.Return(b, err)
346	return _c
347}
348
349func (_c *MockBrowserLaunchRelay_DeliverOpenFreshWindow_Call) RunAndReturn(run func(ctx context.Context, url string) (bool, error)) *MockBrowserLaunchRelay_DeliverOpenFreshWindow_Call {
350	_c.Call.Return(run)
351	return _c
352}
353
354// Listen provides a mock function for the type MockBrowserLaunchRelay
355func (_mock *MockBrowserLaunchRelay) Listen(ctx context.Context, opener port.BrowserWindowOpener) (io.Closer, error) {
356	ret := _mock.Called(ctx, opener)
357
358	if len(ret) == 0 {
359		panic("no return value specified for Listen")
360	}
361
362	var r0 io.Closer
363	var r1 error
364	if returnFunc, ok := ret.Get(0).(func(context.Context, port.BrowserWindowOpener) (io.Closer, error)); ok {
365		return returnFunc(ctx, opener)
366	}
367	if returnFunc, ok := ret.Get(0).(func(context.Context, port.BrowserWindowOpener) io.Closer); ok {
368		r0 = returnFunc(ctx, opener)
369	} else {
370		if ret.Get(0) != nil {
371			r0 = ret.Get(0).(io.Closer)
372		}
373	}
374	if returnFunc, ok := ret.Get(1).(func(context.Context, port.BrowserWindowOpener) error); ok {
375		r1 = returnFunc(ctx, opener)
376	} else {
377		r1 = ret.Error(1)
378	}
379	return r0, r1
380}
381
382// MockBrowserLaunchRelay_Listen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Listen'
383type MockBrowserLaunchRelay_Listen_Call struct {
384	*mock.Call
385}
386
387// Listen is a helper method to define mock.On call
388//   - ctx context.Context
389//   - opener port.BrowserWindowOpener
390func (_e *MockBrowserLaunchRelay_Expecter) Listen(ctx interface{}, opener interface{}) *MockBrowserLaunchRelay_Listen_Call {
391	return &MockBrowserLaunchRelay_Listen_Call{Call: _e.mock.On("Listen", ctx, opener)}
392}
393
394func (_c *MockBrowserLaunchRelay_Listen_Call) Run(run func(ctx context.Context, opener port.BrowserWindowOpener)) *MockBrowserLaunchRelay_Listen_Call {
395	_c.Call.Run(func(args mock.Arguments) {
396		var arg0 context.Context
397		if args[0] != nil {
398			arg0 = args[0].(context.Context)
399		}
400		var arg1 port.BrowserWindowOpener
401		if args[1] != nil {
402			arg1 = args[1].(port.BrowserWindowOpener)
403		}
404		run(
405			arg0,
406			arg1,
407		)
408	})
409	return _c
410}
411
412func (_c *MockBrowserLaunchRelay_Listen_Call) Return(closer io.Closer, err error) *MockBrowserLaunchRelay_Listen_Call {
413	_c.Call.Return(closer, err)
414	return _c
415}
416
417func (_c *MockBrowserLaunchRelay_Listen_Call) RunAndReturn(run func(ctx context.Context, opener port.BrowserWindowOpener) (io.Closer, error)) *MockBrowserLaunchRelay_Listen_Call {
418	_c.Call.Return(run)
419	return _c
420}
421
422// NewMockClipboard creates a new instance of MockClipboard. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
423// The first argument is typically a *testing.T value.
424func NewMockClipboard(t interface {
425	mock.TestingT
426	Cleanup(func())
427}) *MockClipboard {
428	mock := &MockClipboard{}
429	mock.Mock.Test(t)
430
431	t.Cleanup(func() { mock.AssertExpectations(t) })
432
433	return mock
434}
435
436// MockClipboard is an autogenerated mock type for the Clipboard type
437type MockClipboard struct {
438	mock.Mock
439}
440
441type MockClipboard_Expecter struct {
442	mock *mock.Mock
443}
444
445func (_m *MockClipboard) EXPECT() *MockClipboard_Expecter {
446	return &MockClipboard_Expecter{mock: &_m.Mock}
447}
448
449// Clear provides a mock function for the type MockClipboard
450func (_mock *MockClipboard) Clear(ctx context.Context) error {
451	ret := _mock.Called(ctx)
452
453	if len(ret) == 0 {
454		panic("no return value specified for Clear")
455	}
456
457	var r0 error
458	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
459		r0 = returnFunc(ctx)
460	} else {
461		r0 = ret.Error(0)
462	}
463	return r0
464}
465
466// MockClipboard_Clear_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Clear'
467type MockClipboard_Clear_Call struct {
468	*mock.Call
469}
470
471// Clear is a helper method to define mock.On call
472//   - ctx context.Context
473func (_e *MockClipboard_Expecter) Clear(ctx interface{}) *MockClipboard_Clear_Call {
474	return &MockClipboard_Clear_Call{Call: _e.mock.On("Clear", ctx)}
475}
476
477func (_c *MockClipboard_Clear_Call) Run(run func(ctx context.Context)) *MockClipboard_Clear_Call {
478	_c.Call.Run(func(args mock.Arguments) {
479		var arg0 context.Context
480		if args[0] != nil {
481			arg0 = args[0].(context.Context)
482		}
483		run(
484			arg0,
485		)
486	})
487	return _c
488}
489
490func (_c *MockClipboard_Clear_Call) Return(err error) *MockClipboard_Clear_Call {
491	_c.Call.Return(err)
492	return _c
493}
494
495func (_c *MockClipboard_Clear_Call) RunAndReturn(run func(ctx context.Context) error) *MockClipboard_Clear_Call {
496	_c.Call.Return(run)
497	return _c
498}
499
500// HasText provides a mock function for the type MockClipboard
501func (_mock *MockClipboard) HasText(ctx context.Context) (bool, error) {
502	ret := _mock.Called(ctx)
503
504	if len(ret) == 0 {
505		panic("no return value specified for HasText")
506	}
507
508	var r0 bool
509	var r1 error
510	if returnFunc, ok := ret.Get(0).(func(context.Context) (bool, error)); ok {
511		return returnFunc(ctx)
512	}
513	if returnFunc, ok := ret.Get(0).(func(context.Context) bool); ok {
514		r0 = returnFunc(ctx)
515	} else {
516		r0 = ret.Get(0).(bool)
517	}
518	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
519		r1 = returnFunc(ctx)
520	} else {
521		r1 = ret.Error(1)
522	}
523	return r0, r1
524}
525
526// MockClipboard_HasText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasText'
527type MockClipboard_HasText_Call struct {
528	*mock.Call
529}
530
531// HasText is a helper method to define mock.On call
532//   - ctx context.Context
533func (_e *MockClipboard_Expecter) HasText(ctx interface{}) *MockClipboard_HasText_Call {
534	return &MockClipboard_HasText_Call{Call: _e.mock.On("HasText", ctx)}
535}
536
537func (_c *MockClipboard_HasText_Call) Run(run func(ctx context.Context)) *MockClipboard_HasText_Call {
538	_c.Call.Run(func(args mock.Arguments) {
539		var arg0 context.Context
540		if args[0] != nil {
541			arg0 = args[0].(context.Context)
542		}
543		run(
544			arg0,
545		)
546	})
547	return _c
548}
549
550func (_c *MockClipboard_HasText_Call) Return(b bool, err error) *MockClipboard_HasText_Call {
551	_c.Call.Return(b, err)
552	return _c
553}
554
555func (_c *MockClipboard_HasText_Call) RunAndReturn(run func(ctx context.Context) (bool, error)) *MockClipboard_HasText_Call {
556	_c.Call.Return(run)
557	return _c
558}
559
560// ReadText provides a mock function for the type MockClipboard
561func (_mock *MockClipboard) ReadText(ctx context.Context) (string, error) {
562	ret := _mock.Called(ctx)
563
564	if len(ret) == 0 {
565		panic("no return value specified for ReadText")
566	}
567
568	var r0 string
569	var r1 error
570	if returnFunc, ok := ret.Get(0).(func(context.Context) (string, error)); ok {
571		return returnFunc(ctx)
572	}
573	if returnFunc, ok := ret.Get(0).(func(context.Context) string); ok {
574		r0 = returnFunc(ctx)
575	} else {
576		r0 = ret.Get(0).(string)
577	}
578	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
579		r1 = returnFunc(ctx)
580	} else {
581		r1 = ret.Error(1)
582	}
583	return r0, r1
584}
585
586// MockClipboard_ReadText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadText'
587type MockClipboard_ReadText_Call struct {
588	*mock.Call
589}
590
591// ReadText is a helper method to define mock.On call
592//   - ctx context.Context
593func (_e *MockClipboard_Expecter) ReadText(ctx interface{}) *MockClipboard_ReadText_Call {
594	return &MockClipboard_ReadText_Call{Call: _e.mock.On("ReadText", ctx)}
595}
596
597func (_c *MockClipboard_ReadText_Call) Run(run func(ctx context.Context)) *MockClipboard_ReadText_Call {
598	_c.Call.Run(func(args mock.Arguments) {
599		var arg0 context.Context
600		if args[0] != nil {
601			arg0 = args[0].(context.Context)
602		}
603		run(
604			arg0,
605		)
606	})
607	return _c
608}
609
610func (_c *MockClipboard_ReadText_Call) Return(s string, err error) *MockClipboard_ReadText_Call {
611	_c.Call.Return(s, err)
612	return _c
613}
614
615func (_c *MockClipboard_ReadText_Call) RunAndReturn(run func(ctx context.Context) (string, error)) *MockClipboard_ReadText_Call {
616	_c.Call.Return(run)
617	return _c
618}
619
620// WriteImage provides a mock function for the type MockClipboard
621func (_mock *MockClipboard) WriteImage(ctx context.Context, image entity.ImageData) error {
622	ret := _mock.Called(ctx, image)
623
624	if len(ret) == 0 {
625		panic("no return value specified for WriteImage")
626	}
627
628	var r0 error
629	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.ImageData) error); ok {
630		r0 = returnFunc(ctx, image)
631	} else {
632		r0 = ret.Error(0)
633	}
634	return r0
635}
636
637// MockClipboard_WriteImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteImage'
638type MockClipboard_WriteImage_Call struct {
639	*mock.Call
640}
641
642// WriteImage is a helper method to define mock.On call
643//   - ctx context.Context
644//   - image entity.ImageData
645func (_e *MockClipboard_Expecter) WriteImage(ctx interface{}, image interface{}) *MockClipboard_WriteImage_Call {
646	return &MockClipboard_WriteImage_Call{Call: _e.mock.On("WriteImage", ctx, image)}
647}
648
649func (_c *MockClipboard_WriteImage_Call) Run(run func(ctx context.Context, image entity.ImageData)) *MockClipboard_WriteImage_Call {
650	_c.Call.Run(func(args mock.Arguments) {
651		var arg0 context.Context
652		if args[0] != nil {
653			arg0 = args[0].(context.Context)
654		}
655		var arg1 entity.ImageData
656		if args[1] != nil {
657			arg1 = args[1].(entity.ImageData)
658		}
659		run(
660			arg0,
661			arg1,
662		)
663	})
664	return _c
665}
666
667func (_c *MockClipboard_WriteImage_Call) Return(err error) *MockClipboard_WriteImage_Call {
668	_c.Call.Return(err)
669	return _c
670}
671
672func (_c *MockClipboard_WriteImage_Call) RunAndReturn(run func(ctx context.Context, image entity.ImageData) error) *MockClipboard_WriteImage_Call {
673	_c.Call.Return(run)
674	return _c
675}
676
677// WriteText provides a mock function for the type MockClipboard
678func (_mock *MockClipboard) WriteText(ctx context.Context, text string) error {
679	ret := _mock.Called(ctx, text)
680
681	if len(ret) == 0 {
682		panic("no return value specified for WriteText")
683	}
684
685	var r0 error
686	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
687		r0 = returnFunc(ctx, text)
688	} else {
689		r0 = ret.Error(0)
690	}
691	return r0
692}
693
694// MockClipboard_WriteText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteText'
695type MockClipboard_WriteText_Call struct {
696	*mock.Call
697}
698
699// WriteText is a helper method to define mock.On call
700//   - ctx context.Context
701//   - text string
702func (_e *MockClipboard_Expecter) WriteText(ctx interface{}, text interface{}) *MockClipboard_WriteText_Call {
703	return &MockClipboard_WriteText_Call{Call: _e.mock.On("WriteText", ctx, text)}
704}
705
706func (_c *MockClipboard_WriteText_Call) Run(run func(ctx context.Context, text string)) *MockClipboard_WriteText_Call {
707	_c.Call.Run(func(args mock.Arguments) {
708		var arg0 context.Context
709		if args[0] != nil {
710			arg0 = args[0].(context.Context)
711		}
712		var arg1 string
713		if args[1] != nil {
714			arg1 = args[1].(string)
715		}
716		run(
717			arg0,
718			arg1,
719		)
720	})
721	return _c
722}
723
724func (_c *MockClipboard_WriteText_Call) Return(err error) *MockClipboard_WriteText_Call {
725	_c.Call.Return(err)
726	return _c
727}
728
729func (_c *MockClipboard_WriteText_Call) RunAndReturn(run func(ctx context.Context, text string) error) *MockClipboard_WriteText_Call {
730	_c.Call.Return(run)
731	return _c
732}
733
734// NewMockClipboardTextOrchestrator creates a new instance of MockClipboardTextOrchestrator. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
735// The first argument is typically a *testing.T value.
736func NewMockClipboardTextOrchestrator(t interface {
737	mock.TestingT
738	Cleanup(func())
739}) *MockClipboardTextOrchestrator {
740	mock := &MockClipboardTextOrchestrator{}
741	mock.Mock.Test(t)
742
743	t.Cleanup(func() { mock.AssertExpectations(t) })
744
745	return mock
746}
747
748// MockClipboardTextOrchestrator is an autogenerated mock type for the ClipboardTextOrchestrator type
749type MockClipboardTextOrchestrator struct {
750	mock.Mock
751}
752
753type MockClipboardTextOrchestrator_Expecter struct {
754	mock *mock.Mock
755}
756
757func (_m *MockClipboardTextOrchestrator) EXPECT() *MockClipboardTextOrchestrator_Expecter {
758	return &MockClipboardTextOrchestrator_Expecter{mock: &_m.Mock}
759}
760
761// HandleExplicitCopy provides a mock function for the type MockClipboardTextOrchestrator
762func (_mock *MockClipboardTextOrchestrator) HandleExplicitCopy(ctx context.Context, input dto.ExplicitClipboardInput) error {
763	ret := _mock.Called(ctx, input)
764
765	if len(ret) == 0 {
766		panic("no return value specified for HandleExplicitCopy")
767	}
768
769	var r0 error
770	if returnFunc, ok := ret.Get(0).(func(context.Context, dto.ExplicitClipboardInput) error); ok {
771		r0 = returnFunc(ctx, input)
772	} else {
773		r0 = ret.Error(0)
774	}
775	return r0
776}
777
778// MockClipboardTextOrchestrator_HandleExplicitCopy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HandleExplicitCopy'
779type MockClipboardTextOrchestrator_HandleExplicitCopy_Call struct {
780	*mock.Call
781}
782
783// HandleExplicitCopy is a helper method to define mock.On call
784//   - ctx context.Context
785//   - input dto.ExplicitClipboardInput
786func (_e *MockClipboardTextOrchestrator_Expecter) HandleExplicitCopy(ctx interface{}, input interface{}) *MockClipboardTextOrchestrator_HandleExplicitCopy_Call {
787	return &MockClipboardTextOrchestrator_HandleExplicitCopy_Call{Call: _e.mock.On("HandleExplicitCopy", ctx, input)}
788}
789
790func (_c *MockClipboardTextOrchestrator_HandleExplicitCopy_Call) Run(run func(ctx context.Context, input dto.ExplicitClipboardInput)) *MockClipboardTextOrchestrator_HandleExplicitCopy_Call {
791	_c.Call.Run(func(args mock.Arguments) {
792		var arg0 context.Context
793		if args[0] != nil {
794			arg0 = args[0].(context.Context)
795		}
796		var arg1 dto.ExplicitClipboardInput
797		if args[1] != nil {
798			arg1 = args[1].(dto.ExplicitClipboardInput)
799		}
800		run(
801			arg0,
802			arg1,
803		)
804	})
805	return _c
806}
807
808func (_c *MockClipboardTextOrchestrator_HandleExplicitCopy_Call) Return(err error) *MockClipboardTextOrchestrator_HandleExplicitCopy_Call {
809	_c.Call.Return(err)
810	return _c
811}
812
813func (_c *MockClipboardTextOrchestrator_HandleExplicitCopy_Call) RunAndReturn(run func(ctx context.Context, input dto.ExplicitClipboardInput) error) *MockClipboardTextOrchestrator_HandleExplicitCopy_Call {
814	_c.Call.Return(run)
815	return _c
816}
817
818// HandleSelectionUpdate provides a mock function for the type MockClipboardTextOrchestrator
819func (_mock *MockClipboardTextOrchestrator) HandleSelectionUpdate(ctx context.Context, input dto.SelectionClipboardInput) error {
820	ret := _mock.Called(ctx, input)
821
822	if len(ret) == 0 {
823		panic("no return value specified for HandleSelectionUpdate")
824	}
825
826	var r0 error
827	if returnFunc, ok := ret.Get(0).(func(context.Context, dto.SelectionClipboardInput) error); ok {
828		r0 = returnFunc(ctx, input)
829	} else {
830		r0 = ret.Error(0)
831	}
832	return r0
833}
834
835// MockClipboardTextOrchestrator_HandleSelectionUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HandleSelectionUpdate'
836type MockClipboardTextOrchestrator_HandleSelectionUpdate_Call struct {
837	*mock.Call
838}
839
840// HandleSelectionUpdate is a helper method to define mock.On call
841//   - ctx context.Context
842//   - input dto.SelectionClipboardInput
843func (_e *MockClipboardTextOrchestrator_Expecter) HandleSelectionUpdate(ctx interface{}, input interface{}) *MockClipboardTextOrchestrator_HandleSelectionUpdate_Call {
844	return &MockClipboardTextOrchestrator_HandleSelectionUpdate_Call{Call: _e.mock.On("HandleSelectionUpdate", ctx, input)}
845}
846
847func (_c *MockClipboardTextOrchestrator_HandleSelectionUpdate_Call) Run(run func(ctx context.Context, input dto.SelectionClipboardInput)) *MockClipboardTextOrchestrator_HandleSelectionUpdate_Call {
848	_c.Call.Run(func(args mock.Arguments) {
849		var arg0 context.Context
850		if args[0] != nil {
851			arg0 = args[0].(context.Context)
852		}
853		var arg1 dto.SelectionClipboardInput
854		if args[1] != nil {
855			arg1 = args[1].(dto.SelectionClipboardInput)
856		}
857		run(
858			arg0,
859			arg1,
860		)
861	})
862	return _c
863}
864
865func (_c *MockClipboardTextOrchestrator_HandleSelectionUpdate_Call) Return(err error) *MockClipboardTextOrchestrator_HandleSelectionUpdate_Call {
866	_c.Call.Return(err)
867	return _c
868}
869
870func (_c *MockClipboardTextOrchestrator_HandleSelectionUpdate_Call) RunAndReturn(run func(ctx context.Context, input dto.SelectionClipboardInput) error) *MockClipboardTextOrchestrator_HandleSelectionUpdate_Call {
871	_c.Call.Return(run)
872	return _c
873}
874
875// NewMockColorSchemeDetector creates a new instance of MockColorSchemeDetector. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
876// The first argument is typically a *testing.T value.
877func NewMockColorSchemeDetector(t interface {
878	mock.TestingT
879	Cleanup(func())
880}) *MockColorSchemeDetector {
881	mock := &MockColorSchemeDetector{}
882	mock.Mock.Test(t)
883
884	t.Cleanup(func() { mock.AssertExpectations(t) })
885
886	return mock
887}
888
889// MockColorSchemeDetector is an autogenerated mock type for the ColorSchemeDetector type
890type MockColorSchemeDetector struct {
891	mock.Mock
892}
893
894type MockColorSchemeDetector_Expecter struct {
895	mock *mock.Mock
896}
897
898func (_m *MockColorSchemeDetector) EXPECT() *MockColorSchemeDetector_Expecter {
899	return &MockColorSchemeDetector_Expecter{mock: &_m.Mock}
900}
901
902// Available provides a mock function for the type MockColorSchemeDetector
903func (_mock *MockColorSchemeDetector) Available() bool {
904	ret := _mock.Called()
905
906	if len(ret) == 0 {
907		panic("no return value specified for Available")
908	}
909
910	var r0 bool
911	if returnFunc, ok := ret.Get(0).(func() bool); ok {
912		r0 = returnFunc()
913	} else {
914		r0 = ret.Get(0).(bool)
915	}
916	return r0
917}
918
919// MockColorSchemeDetector_Available_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Available'
920type MockColorSchemeDetector_Available_Call struct {
921	*mock.Call
922}
923
924// Available is a helper method to define mock.On call
925func (_e *MockColorSchemeDetector_Expecter) Available() *MockColorSchemeDetector_Available_Call {
926	return &MockColorSchemeDetector_Available_Call{Call: _e.mock.On("Available")}
927}
928
929func (_c *MockColorSchemeDetector_Available_Call) Run(run func()) *MockColorSchemeDetector_Available_Call {
930	_c.Call.Run(func(args mock.Arguments) {
931		run()
932	})
933	return _c
934}
935
936func (_c *MockColorSchemeDetector_Available_Call) Return(b bool) *MockColorSchemeDetector_Available_Call {
937	_c.Call.Return(b)
938	return _c
939}
940
941func (_c *MockColorSchemeDetector_Available_Call) RunAndReturn(run func() bool) *MockColorSchemeDetector_Available_Call {
942	_c.Call.Return(run)
943	return _c
944}
945
946// Detect provides a mock function for the type MockColorSchemeDetector
947func (_mock *MockColorSchemeDetector) Detect() (bool, bool) {
948	ret := _mock.Called()
949
950	if len(ret) == 0 {
951		panic("no return value specified for Detect")
952	}
953
954	var r0 bool
955	var r1 bool
956	if returnFunc, ok := ret.Get(0).(func() (bool, bool)); ok {
957		return returnFunc()
958	}
959	if returnFunc, ok := ret.Get(0).(func() bool); ok {
960		r0 = returnFunc()
961	} else {
962		r0 = ret.Get(0).(bool)
963	}
964	if returnFunc, ok := ret.Get(1).(func() bool); ok {
965		r1 = returnFunc()
966	} else {
967		r1 = ret.Get(1).(bool)
968	}
969	return r0, r1
970}
971
972// MockColorSchemeDetector_Detect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Detect'
973type MockColorSchemeDetector_Detect_Call struct {
974	*mock.Call
975}
976
977// Detect is a helper method to define mock.On call
978func (_e *MockColorSchemeDetector_Expecter) Detect() *MockColorSchemeDetector_Detect_Call {
979	return &MockColorSchemeDetector_Detect_Call{Call: _e.mock.On("Detect")}
980}
981
982func (_c *MockColorSchemeDetector_Detect_Call) Run(run func()) *MockColorSchemeDetector_Detect_Call {
983	_c.Call.Run(func(args mock.Arguments) {
984		run()
985	})
986	return _c
987}
988
989func (_c *MockColorSchemeDetector_Detect_Call) Return(prefersDark bool, ok bool) *MockColorSchemeDetector_Detect_Call {
990	_c.Call.Return(prefersDark, ok)
991	return _c
992}
993
994func (_c *MockColorSchemeDetector_Detect_Call) RunAndReturn(run func() (bool, bool)) *MockColorSchemeDetector_Detect_Call {
995	_c.Call.Return(run)
996	return _c
997}
998
999// Name provides a mock function for the type MockColorSchemeDetector
1000func (_mock *MockColorSchemeDetector) Name() string {
1001	ret := _mock.Called()
1002
1003	if len(ret) == 0 {
1004		panic("no return value specified for Name")
1005	}
1006
1007	var r0 string
1008	if returnFunc, ok := ret.Get(0).(func() string); ok {
1009		r0 = returnFunc()
1010	} else {
1011		r0 = ret.Get(0).(string)
1012	}
1013	return r0
1014}
1015
1016// MockColorSchemeDetector_Name_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Name'
1017type MockColorSchemeDetector_Name_Call struct {
1018	*mock.Call
1019}
1020
1021// Name is a helper method to define mock.On call
1022func (_e *MockColorSchemeDetector_Expecter) Name() *MockColorSchemeDetector_Name_Call {
1023	return &MockColorSchemeDetector_Name_Call{Call: _e.mock.On("Name")}
1024}
1025
1026func (_c *MockColorSchemeDetector_Name_Call) Run(run func()) *MockColorSchemeDetector_Name_Call {
1027	_c.Call.Run(func(args mock.Arguments) {
1028		run()
1029	})
1030	return _c
1031}
1032
1033func (_c *MockColorSchemeDetector_Name_Call) Return(s string) *MockColorSchemeDetector_Name_Call {
1034	_c.Call.Return(s)
1035	return _c
1036}
1037
1038func (_c *MockColorSchemeDetector_Name_Call) RunAndReturn(run func() string) *MockColorSchemeDetector_Name_Call {
1039	_c.Call.Return(run)
1040	return _c
1041}
1042
1043// Priority provides a mock function for the type MockColorSchemeDetector
1044func (_mock *MockColorSchemeDetector) Priority() int {
1045	ret := _mock.Called()
1046
1047	if len(ret) == 0 {
1048		panic("no return value specified for Priority")
1049	}
1050
1051	var r0 int
1052	if returnFunc, ok := ret.Get(0).(func() int); ok {
1053		r0 = returnFunc()
1054	} else {
1055		r0 = ret.Get(0).(int)
1056	}
1057	return r0
1058}
1059
1060// MockColorSchemeDetector_Priority_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Priority'
1061type MockColorSchemeDetector_Priority_Call struct {
1062	*mock.Call
1063}
1064
1065// Priority is a helper method to define mock.On call
1066func (_e *MockColorSchemeDetector_Expecter) Priority() *MockColorSchemeDetector_Priority_Call {
1067	return &MockColorSchemeDetector_Priority_Call{Call: _e.mock.On("Priority")}
1068}
1069
1070func (_c *MockColorSchemeDetector_Priority_Call) Run(run func()) *MockColorSchemeDetector_Priority_Call {
1071	_c.Call.Run(func(args mock.Arguments) {
1072		run()
1073	})
1074	return _c
1075}
1076
1077func (_c *MockColorSchemeDetector_Priority_Call) Return(n int) *MockColorSchemeDetector_Priority_Call {
1078	_c.Call.Return(n)
1079	return _c
1080}
1081
1082func (_c *MockColorSchemeDetector_Priority_Call) RunAndReturn(run func() int) *MockColorSchemeDetector_Priority_Call {
1083	_c.Call.Return(run)
1084	return _c
1085}
1086
1087// NewMockToolkitAvailabilityNotifier creates a new instance of MockToolkitAvailabilityNotifier. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
1088// The first argument is typically a *testing.T value.
1089func NewMockToolkitAvailabilityNotifier(t interface {
1090	mock.TestingT
1091	Cleanup(func())
1092}) *MockToolkitAvailabilityNotifier {
1093	mock := &MockToolkitAvailabilityNotifier{}
1094	mock.Mock.Test(t)
1095
1096	t.Cleanup(func() { mock.AssertExpectations(t) })
1097
1098	return mock
1099}
1100
1101// MockToolkitAvailabilityNotifier is an autogenerated mock type for the ToolkitAvailabilityNotifier type
1102type MockToolkitAvailabilityNotifier struct {
1103	mock.Mock
1104}
1105
1106type MockToolkitAvailabilityNotifier_Expecter struct {
1107	mock *mock.Mock
1108}
1109
1110func (_m *MockToolkitAvailabilityNotifier) EXPECT() *MockToolkitAvailabilityNotifier_Expecter {
1111	return &MockToolkitAvailabilityNotifier_Expecter{mock: &_m.Mock}
1112}
1113
1114// MarkAvailable provides a mock function for the type MockToolkitAvailabilityNotifier
1115func (_mock *MockToolkitAvailabilityNotifier) MarkAvailable() {
1116	_mock.Called()
1117	return
1118}
1119
1120// MockToolkitAvailabilityNotifier_MarkAvailable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarkAvailable'
1121type MockToolkitAvailabilityNotifier_MarkAvailable_Call struct {
1122	*mock.Call
1123}
1124
1125// MarkAvailable is a helper method to define mock.On call
1126func (_e *MockToolkitAvailabilityNotifier_Expecter) MarkAvailable() *MockToolkitAvailabilityNotifier_MarkAvailable_Call {
1127	return &MockToolkitAvailabilityNotifier_MarkAvailable_Call{Call: _e.mock.On("MarkAvailable")}
1128}
1129
1130func (_c *MockToolkitAvailabilityNotifier_MarkAvailable_Call) Run(run func()) *MockToolkitAvailabilityNotifier_MarkAvailable_Call {
1131	_c.Call.Run(func(args mock.Arguments) {
1132		run()
1133	})
1134	return _c
1135}
1136
1137func (_c *MockToolkitAvailabilityNotifier_MarkAvailable_Call) Return() *MockToolkitAvailabilityNotifier_MarkAvailable_Call {
1138	_c.Call.Return()
1139	return _c
1140}
1141
1142func (_c *MockToolkitAvailabilityNotifier_MarkAvailable_Call) RunAndReturn(run func()) *MockToolkitAvailabilityNotifier_MarkAvailable_Call {
1143	_c.Run(run)
1144	return _c
1145}
1146
1147// NewMockColorSchemeResolver creates a new instance of MockColorSchemeResolver. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
1148// The first argument is typically a *testing.T value.
1149func NewMockColorSchemeResolver(t interface {
1150	mock.TestingT
1151	Cleanup(func())
1152}) *MockColorSchemeResolver {
1153	mock := &MockColorSchemeResolver{}
1154	mock.Mock.Test(t)
1155
1156	t.Cleanup(func() { mock.AssertExpectations(t) })
1157
1158	return mock
1159}
1160
1161// MockColorSchemeResolver is an autogenerated mock type for the ColorSchemeResolver type
1162type MockColorSchemeResolver struct {
1163	mock.Mock
1164}
1165
1166type MockColorSchemeResolver_Expecter struct {
1167	mock *mock.Mock
1168}
1169
1170func (_m *MockColorSchemeResolver) EXPECT() *MockColorSchemeResolver_Expecter {
1171	return &MockColorSchemeResolver_Expecter{mock: &_m.Mock}
1172}
1173
1174// OnChange provides a mock function for the type MockColorSchemeResolver
1175func (_mock *MockColorSchemeResolver) OnChange(callback func(port.ColorSchemePreference)) func() {
1176	ret := _mock.Called(callback)
1177
1178	if len(ret) == 0 {
1179		panic("no return value specified for OnChange")
1180	}
1181
1182	var r0 func()
1183	if returnFunc, ok := ret.Get(0).(func(func(port.ColorSchemePreference)) func()); ok {
1184		r0 = returnFunc(callback)
1185	} else {
1186		if ret.Get(0) != nil {
1187			r0 = ret.Get(0).(func())
1188		}
1189	}
1190	return r0
1191}
1192
1193// MockColorSchemeResolver_OnChange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnChange'
1194type MockColorSchemeResolver_OnChange_Call struct {
1195	*mock.Call
1196}
1197
1198// OnChange is a helper method to define mock.On call
1199//   - callback func(port.ColorSchemePreference)
1200func (_e *MockColorSchemeResolver_Expecter) OnChange(callback interface{}) *MockColorSchemeResolver_OnChange_Call {
1201	return &MockColorSchemeResolver_OnChange_Call{Call: _e.mock.On("OnChange", callback)}
1202}
1203
1204func (_c *MockColorSchemeResolver_OnChange_Call) Run(run func(callback func(port.ColorSchemePreference))) *MockColorSchemeResolver_OnChange_Call {
1205	_c.Call.Run(func(args mock.Arguments) {
1206		var arg0 func(port.ColorSchemePreference)
1207		if args[0] != nil {
1208			arg0 = args[0].(func(port.ColorSchemePreference))
1209		}
1210		run(
1211			arg0,
1212		)
1213	})
1214	return _c
1215}
1216
1217func (_c *MockColorSchemeResolver_OnChange_Call) Return(fn func()) *MockColorSchemeResolver_OnChange_Call {
1218	_c.Call.Return(fn)
1219	return _c
1220}
1221
1222func (_c *MockColorSchemeResolver_OnChange_Call) RunAndReturn(run func(callback func(port.ColorSchemePreference)) func()) *MockColorSchemeResolver_OnChange_Call {
1223	_c.Call.Return(run)
1224	return _c
1225}
1226
1227// Refresh provides a mock function for the type MockColorSchemeResolver
1228func (_mock *MockColorSchemeResolver) Refresh() port.ColorSchemePreference {
1229	ret := _mock.Called()
1230
1231	if len(ret) == 0 {
1232		panic("no return value specified for Refresh")
1233	}
1234
1235	var r0 port.ColorSchemePreference
1236	if returnFunc, ok := ret.Get(0).(func() port.ColorSchemePreference); ok {
1237		r0 = returnFunc()
1238	} else {
1239		r0 = ret.Get(0).(port.ColorSchemePreference)
1240	}
1241	return r0
1242}
1243
1244// MockColorSchemeResolver_Refresh_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Refresh'
1245type MockColorSchemeResolver_Refresh_Call struct {
1246	*mock.Call
1247}
1248
1249// Refresh is a helper method to define mock.On call
1250func (_e *MockColorSchemeResolver_Expecter) Refresh() *MockColorSchemeResolver_Refresh_Call {
1251	return &MockColorSchemeResolver_Refresh_Call{Call: _e.mock.On("Refresh")}
1252}
1253
1254func (_c *MockColorSchemeResolver_Refresh_Call) Run(run func()) *MockColorSchemeResolver_Refresh_Call {
1255	_c.Call.Run(func(args mock.Arguments) {
1256		run()
1257	})
1258	return _c
1259}
1260
1261func (_c *MockColorSchemeResolver_Refresh_Call) Return(colorSchemePreference port.ColorSchemePreference) *MockColorSchemeResolver_Refresh_Call {
1262	_c.Call.Return(colorSchemePreference)
1263	return _c
1264}
1265
1266func (_c *MockColorSchemeResolver_Refresh_Call) RunAndReturn(run func() port.ColorSchemePreference) *MockColorSchemeResolver_Refresh_Call {
1267	_c.Call.Return(run)
1268	return _c
1269}
1270
1271// RegisterDetector provides a mock function for the type MockColorSchemeResolver
1272func (_mock *MockColorSchemeResolver) RegisterDetector(detector port.ColorSchemeDetector) {
1273	_mock.Called(detector)
1274	return
1275}
1276
1277// MockColorSchemeResolver_RegisterDetector_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterDetector'
1278type MockColorSchemeResolver_RegisterDetector_Call struct {
1279	*mock.Call
1280}
1281
1282// RegisterDetector is a helper method to define mock.On call
1283//   - detector port.ColorSchemeDetector
1284func (_e *MockColorSchemeResolver_Expecter) RegisterDetector(detector interface{}) *MockColorSchemeResolver_RegisterDetector_Call {
1285	return &MockColorSchemeResolver_RegisterDetector_Call{Call: _e.mock.On("RegisterDetector", detector)}
1286}
1287
1288func (_c *MockColorSchemeResolver_RegisterDetector_Call) Run(run func(detector port.ColorSchemeDetector)) *MockColorSchemeResolver_RegisterDetector_Call {
1289	_c.Call.Run(func(args mock.Arguments) {
1290		var arg0 port.ColorSchemeDetector
1291		if args[0] != nil {
1292			arg0 = args[0].(port.ColorSchemeDetector)
1293		}
1294		run(
1295			arg0,
1296		)
1297	})
1298	return _c
1299}
1300
1301func (_c *MockColorSchemeResolver_RegisterDetector_Call) Return() *MockColorSchemeResolver_RegisterDetector_Call {
1302	_c.Call.Return()
1303	return _c
1304}
1305
1306func (_c *MockColorSchemeResolver_RegisterDetector_Call) RunAndReturn(run func(detector port.ColorSchemeDetector)) *MockColorSchemeResolver_RegisterDetector_Call {
1307	_c.Run(run)
1308	return _c
1309}
1310
1311// Resolve provides a mock function for the type MockColorSchemeResolver
1312func (_mock *MockColorSchemeResolver) Resolve() port.ColorSchemePreference {
1313	ret := _mock.Called()
1314
1315	if len(ret) == 0 {
1316		panic("no return value specified for Resolve")
1317	}
1318
1319	var r0 port.ColorSchemePreference
1320	if returnFunc, ok := ret.Get(0).(func() port.ColorSchemePreference); ok {
1321		r0 = returnFunc()
1322	} else {
1323		r0 = ret.Get(0).(port.ColorSchemePreference)
1324	}
1325	return r0
1326}
1327
1328// MockColorSchemeResolver_Resolve_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Resolve'
1329type MockColorSchemeResolver_Resolve_Call struct {
1330	*mock.Call
1331}
1332
1333// Resolve is a helper method to define mock.On call
1334func (_e *MockColorSchemeResolver_Expecter) Resolve() *MockColorSchemeResolver_Resolve_Call {
1335	return &MockColorSchemeResolver_Resolve_Call{Call: _e.mock.On("Resolve")}
1336}
1337
1338func (_c *MockColorSchemeResolver_Resolve_Call) Run(run func()) *MockColorSchemeResolver_Resolve_Call {
1339	_c.Call.Run(func(args mock.Arguments) {
1340		run()
1341	})
1342	return _c
1343}
1344
1345func (_c *MockColorSchemeResolver_Resolve_Call) Return(colorSchemePreference port.ColorSchemePreference) *MockColorSchemeResolver_Resolve_Call {
1346	_c.Call.Return(colorSchemePreference)
1347	return _c
1348}
1349
1350func (_c *MockColorSchemeResolver_Resolve_Call) RunAndReturn(run func() port.ColorSchemePreference) *MockColorSchemeResolver_Resolve_Call {
1351	_c.Call.Return(run)
1352	return _c
1353}
1354
1355// NewMockConfigMigrator creates a new instance of MockConfigMigrator. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
1356// The first argument is typically a *testing.T value.
1357func NewMockConfigMigrator(t interface {
1358	mock.TestingT
1359	Cleanup(func())
1360}) *MockConfigMigrator {
1361	mock := &MockConfigMigrator{}
1362	mock.Mock.Test(t)
1363
1364	t.Cleanup(func() { mock.AssertExpectations(t) })
1365
1366	return mock
1367}
1368
1369// MockConfigMigrator is an autogenerated mock type for the ConfigMigrator type
1370type MockConfigMigrator struct {
1371	mock.Mock
1372}
1373
1374type MockConfigMigrator_Expecter struct {
1375	mock *mock.Mock
1376}
1377
1378func (_m *MockConfigMigrator) EXPECT() *MockConfigMigrator_Expecter {
1379	return &MockConfigMigrator_Expecter{mock: &_m.Mock}
1380}
1381
1382// CheckMigration provides a mock function for the type MockConfigMigrator
1383func (_mock *MockConfigMigrator) CheckMigration() (*port.MigrationResult, error) {
1384	ret := _mock.Called()
1385
1386	if len(ret) == 0 {
1387		panic("no return value specified for CheckMigration")
1388	}
1389
1390	var r0 *port.MigrationResult
1391	var r1 error
1392	if returnFunc, ok := ret.Get(0).(func() (*port.MigrationResult, error)); ok {
1393		return returnFunc()
1394	}
1395	if returnFunc, ok := ret.Get(0).(func() *port.MigrationResult); ok {
1396		r0 = returnFunc()
1397	} else {
1398		if ret.Get(0) != nil {
1399			r0 = ret.Get(0).(*port.MigrationResult)
1400		}
1401	}
1402	if returnFunc, ok := ret.Get(1).(func() error); ok {
1403		r1 = returnFunc()
1404	} else {
1405		r1 = ret.Error(1)
1406	}
1407	return r0, r1
1408}
1409
1410// MockConfigMigrator_CheckMigration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckMigration'
1411type MockConfigMigrator_CheckMigration_Call struct {
1412	*mock.Call
1413}
1414
1415// CheckMigration is a helper method to define mock.On call
1416func (_e *MockConfigMigrator_Expecter) CheckMigration() *MockConfigMigrator_CheckMigration_Call {
1417	return &MockConfigMigrator_CheckMigration_Call{Call: _e.mock.On("CheckMigration")}
1418}
1419
1420func (_c *MockConfigMigrator_CheckMigration_Call) Run(run func()) *MockConfigMigrator_CheckMigration_Call {
1421	_c.Call.Run(func(args mock.Arguments) {
1422		run()
1423	})
1424	return _c
1425}
1426
1427func (_c *MockConfigMigrator_CheckMigration_Call) Return(migrationResult *port.MigrationResult, err error) *MockConfigMigrator_CheckMigration_Call {
1428	_c.Call.Return(migrationResult, err)
1429	return _c
1430}
1431
1432func (_c *MockConfigMigrator_CheckMigration_Call) RunAndReturn(run func() (*port.MigrationResult, error)) *MockConfigMigrator_CheckMigration_Call {
1433	_c.Call.Return(run)
1434	return _c
1435}
1436
1437// DetectChanges provides a mock function for the type MockConfigMigrator
1438func (_mock *MockConfigMigrator) DetectChanges() ([]port.KeyChange, error) {
1439	ret := _mock.Called()
1440
1441	if len(ret) == 0 {
1442		panic("no return value specified for DetectChanges")
1443	}
1444
1445	var r0 []port.KeyChange
1446	var r1 error
1447	if returnFunc, ok := ret.Get(0).(func() ([]port.KeyChange, error)); ok {
1448		return returnFunc()
1449	}
1450	if returnFunc, ok := ret.Get(0).(func() []port.KeyChange); ok {
1451		r0 = returnFunc()
1452	} else {
1453		if ret.Get(0) != nil {
1454			r0 = ret.Get(0).([]port.KeyChange)
1455		}
1456	}
1457	if returnFunc, ok := ret.Get(1).(func() error); ok {
1458		r1 = returnFunc()
1459	} else {
1460		r1 = ret.Error(1)
1461	}
1462	return r0, r1
1463}
1464
1465// MockConfigMigrator_DetectChanges_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DetectChanges'
1466type MockConfigMigrator_DetectChanges_Call struct {
1467	*mock.Call
1468}
1469
1470// DetectChanges is a helper method to define mock.On call
1471func (_e *MockConfigMigrator_Expecter) DetectChanges() *MockConfigMigrator_DetectChanges_Call {
1472	return &MockConfigMigrator_DetectChanges_Call{Call: _e.mock.On("DetectChanges")}
1473}
1474
1475func (_c *MockConfigMigrator_DetectChanges_Call) Run(run func()) *MockConfigMigrator_DetectChanges_Call {
1476	_c.Call.Run(func(args mock.Arguments) {
1477		run()
1478	})
1479	return _c
1480}
1481
1482func (_c *MockConfigMigrator_DetectChanges_Call) Return(keyChanges []port.KeyChange, err error) *MockConfigMigrator_DetectChanges_Call {
1483	_c.Call.Return(keyChanges, err)
1484	return _c
1485}
1486
1487func (_c *MockConfigMigrator_DetectChanges_Call) RunAndReturn(run func() ([]port.KeyChange, error)) *MockConfigMigrator_DetectChanges_Call {
1488	_c.Call.Return(run)
1489	return _c
1490}
1491
1492// GetConfigFile provides a mock function for the type MockConfigMigrator
1493func (_mock *MockConfigMigrator) GetConfigFile() (string, error) {
1494	ret := _mock.Called()
1495
1496	if len(ret) == 0 {
1497		panic("no return value specified for GetConfigFile")
1498	}
1499
1500	var r0 string
1501	var r1 error
1502	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
1503		return returnFunc()
1504	}
1505	if returnFunc, ok := ret.Get(0).(func() string); ok {
1506		r0 = returnFunc()
1507	} else {
1508		r0 = ret.Get(0).(string)
1509	}
1510	if returnFunc, ok := ret.Get(1).(func() error); ok {
1511		r1 = returnFunc()
1512	} else {
1513		r1 = ret.Error(1)
1514	}
1515	return r0, r1
1516}
1517
1518// MockConfigMigrator_GetConfigFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConfigFile'
1519type MockConfigMigrator_GetConfigFile_Call struct {
1520	*mock.Call
1521}
1522
1523// GetConfigFile is a helper method to define mock.On call
1524func (_e *MockConfigMigrator_Expecter) GetConfigFile() *MockConfigMigrator_GetConfigFile_Call {
1525	return &MockConfigMigrator_GetConfigFile_Call{Call: _e.mock.On("GetConfigFile")}
1526}
1527
1528func (_c *MockConfigMigrator_GetConfigFile_Call) Run(run func()) *MockConfigMigrator_GetConfigFile_Call {
1529	_c.Call.Run(func(args mock.Arguments) {
1530		run()
1531	})
1532	return _c
1533}
1534
1535func (_c *MockConfigMigrator_GetConfigFile_Call) Return(s string, err error) *MockConfigMigrator_GetConfigFile_Call {
1536	_c.Call.Return(s, err)
1537	return _c
1538}
1539
1540func (_c *MockConfigMigrator_GetConfigFile_Call) RunAndReturn(run func() (string, error)) *MockConfigMigrator_GetConfigFile_Call {
1541	_c.Call.Return(run)
1542	return _c
1543}
1544
1545// GetKeyInfo provides a mock function for the type MockConfigMigrator
1546func (_mock *MockConfigMigrator) GetKeyInfo(key string) port.KeyInfo {
1547	ret := _mock.Called(key)
1548
1549	if len(ret) == 0 {
1550		panic("no return value specified for GetKeyInfo")
1551	}
1552
1553	var r0 port.KeyInfo
1554	if returnFunc, ok := ret.Get(0).(func(string) port.KeyInfo); ok {
1555		r0 = returnFunc(key)
1556	} else {
1557		r0 = ret.Get(0).(port.KeyInfo)
1558	}
1559	return r0
1560}
1561
1562// MockConfigMigrator_GetKeyInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetKeyInfo'
1563type MockConfigMigrator_GetKeyInfo_Call struct {
1564	*mock.Call
1565}
1566
1567// GetKeyInfo is a helper method to define mock.On call
1568//   - key string
1569func (_e *MockConfigMigrator_Expecter) GetKeyInfo(key interface{}) *MockConfigMigrator_GetKeyInfo_Call {
1570	return &MockConfigMigrator_GetKeyInfo_Call{Call: _e.mock.On("GetKeyInfo", key)}
1571}
1572
1573func (_c *MockConfigMigrator_GetKeyInfo_Call) Run(run func(key string)) *MockConfigMigrator_GetKeyInfo_Call {
1574	_c.Call.Run(func(args mock.Arguments) {
1575		var arg0 string
1576		if args[0] != nil {
1577			arg0 = args[0].(string)
1578		}
1579		run(
1580			arg0,
1581		)
1582	})
1583	return _c
1584}
1585
1586func (_c *MockConfigMigrator_GetKeyInfo_Call) Return(keyInfo port.KeyInfo) *MockConfigMigrator_GetKeyInfo_Call {
1587	_c.Call.Return(keyInfo)
1588	return _c
1589}
1590
1591func (_c *MockConfigMigrator_GetKeyInfo_Call) RunAndReturn(run func(key string) port.KeyInfo) *MockConfigMigrator_GetKeyInfo_Call {
1592	_c.Call.Return(run)
1593	return _c
1594}
1595
1596// Migrate provides a mock function for the type MockConfigMigrator
1597func (_mock *MockConfigMigrator) Migrate() ([]string, error) {
1598	ret := _mock.Called()
1599
1600	if len(ret) == 0 {
1601		panic("no return value specified for Migrate")
1602	}
1603
1604	var r0 []string
1605	var r1 error
1606	if returnFunc, ok := ret.Get(0).(func() ([]string, error)); ok {
1607		return returnFunc()
1608	}
1609	if returnFunc, ok := ret.Get(0).(func() []string); ok {
1610		r0 = returnFunc()
1611	} else {
1612		if ret.Get(0) != nil {
1613			r0 = ret.Get(0).([]string)
1614		}
1615	}
1616	if returnFunc, ok := ret.Get(1).(func() error); ok {
1617		r1 = returnFunc()
1618	} else {
1619		r1 = ret.Error(1)
1620	}
1621	return r0, r1
1622}
1623
1624// MockConfigMigrator_Migrate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Migrate'
1625type MockConfigMigrator_Migrate_Call struct {
1626	*mock.Call
1627}
1628
1629// Migrate is a helper method to define mock.On call
1630func (_e *MockConfigMigrator_Expecter) Migrate() *MockConfigMigrator_Migrate_Call {
1631	return &MockConfigMigrator_Migrate_Call{Call: _e.mock.On("Migrate")}
1632}
1633
1634func (_c *MockConfigMigrator_Migrate_Call) Run(run func()) *MockConfigMigrator_Migrate_Call {
1635	_c.Call.Run(func(args mock.Arguments) {
1636		run()
1637	})
1638	return _c
1639}
1640
1641func (_c *MockConfigMigrator_Migrate_Call) Return(strings []string, err error) *MockConfigMigrator_Migrate_Call {
1642	_c.Call.Return(strings, err)
1643	return _c
1644}
1645
1646func (_c *MockConfigMigrator_Migrate_Call) RunAndReturn(run func() ([]string, error)) *MockConfigMigrator_Migrate_Call {
1647	_c.Call.Return(run)
1648	return _c
1649}
1650
1651// NewMockDiffFormatter creates a new instance of MockDiffFormatter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
1652// The first argument is typically a *testing.T value.
1653func NewMockDiffFormatter(t interface {
1654	mock.TestingT
1655	Cleanup(func())
1656}) *MockDiffFormatter {
1657	mock := &MockDiffFormatter{}
1658	mock.Mock.Test(t)
1659
1660	t.Cleanup(func() { mock.AssertExpectations(t) })
1661
1662	return mock
1663}
1664
1665// MockDiffFormatter is an autogenerated mock type for the DiffFormatter type
1666type MockDiffFormatter struct {
1667	mock.Mock
1668}
1669
1670type MockDiffFormatter_Expecter struct {
1671	mock *mock.Mock
1672}
1673
1674func (_m *MockDiffFormatter) EXPECT() *MockDiffFormatter_Expecter {
1675	return &MockDiffFormatter_Expecter{mock: &_m.Mock}
1676}
1677
1678// FormatChangesAsDiff provides a mock function for the type MockDiffFormatter
1679func (_mock *MockDiffFormatter) FormatChangesAsDiff(changes []port.KeyChange) string {
1680	ret := _mock.Called(changes)
1681
1682	if len(ret) == 0 {
1683		panic("no return value specified for FormatChangesAsDiff")
1684	}
1685
1686	var r0 string
1687	if returnFunc, ok := ret.Get(0).(func([]port.KeyChange) string); ok {
1688		r0 = returnFunc(changes)
1689	} else {
1690		r0 = ret.Get(0).(string)
1691	}
1692	return r0
1693}
1694
1695// MockDiffFormatter_FormatChangesAsDiff_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FormatChangesAsDiff'
1696type MockDiffFormatter_FormatChangesAsDiff_Call struct {
1697	*mock.Call
1698}
1699
1700// FormatChangesAsDiff is a helper method to define mock.On call
1701//   - changes []port.KeyChange
1702func (_e *MockDiffFormatter_Expecter) FormatChangesAsDiff(changes interface{}) *MockDiffFormatter_FormatChangesAsDiff_Call {
1703	return &MockDiffFormatter_FormatChangesAsDiff_Call{Call: _e.mock.On("FormatChangesAsDiff", changes)}
1704}
1705
1706func (_c *MockDiffFormatter_FormatChangesAsDiff_Call) Run(run func(changes []port.KeyChange)) *MockDiffFormatter_FormatChangesAsDiff_Call {
1707	_c.Call.Run(func(args mock.Arguments) {
1708		var arg0 []port.KeyChange
1709		if args[0] != nil {
1710			arg0 = args[0].([]port.KeyChange)
1711		}
1712		run(
1713			arg0,
1714		)
1715	})
1716	return _c
1717}
1718
1719func (_c *MockDiffFormatter_FormatChangesAsDiff_Call) Return(s string) *MockDiffFormatter_FormatChangesAsDiff_Call {
1720	_c.Call.Return(s)
1721	return _c
1722}
1723
1724func (_c *MockDiffFormatter_FormatChangesAsDiff_Call) RunAndReturn(run func(changes []port.KeyChange) string) *MockDiffFormatter_FormatChangesAsDiff_Call {
1725	_c.Call.Return(run)
1726	return _c
1727}
1728
1729// NewMockConfigSchemaProvider creates a new instance of MockConfigSchemaProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
1730// The first argument is typically a *testing.T value.
1731func NewMockConfigSchemaProvider(t interface {
1732	mock.TestingT
1733	Cleanup(func())
1734}) *MockConfigSchemaProvider {
1735	mock := &MockConfigSchemaProvider{}
1736	mock.Mock.Test(t)
1737
1738	t.Cleanup(func() { mock.AssertExpectations(t) })
1739
1740	return mock
1741}
1742
1743// MockConfigSchemaProvider is an autogenerated mock type for the ConfigSchemaProvider type
1744type MockConfigSchemaProvider struct {
1745	mock.Mock
1746}
1747
1748type MockConfigSchemaProvider_Expecter struct {
1749	mock *mock.Mock
1750}
1751
1752func (_m *MockConfigSchemaProvider) EXPECT() *MockConfigSchemaProvider_Expecter {
1753	return &MockConfigSchemaProvider_Expecter{mock: &_m.Mock}
1754}
1755
1756// GetSchema provides a mock function for the type MockConfigSchemaProvider
1757func (_mock *MockConfigSchemaProvider) GetSchema() []entity.ConfigKeyInfo {
1758	ret := _mock.Called()
1759
1760	if len(ret) == 0 {
1761		panic("no return value specified for GetSchema")
1762	}
1763
1764	var r0 []entity.ConfigKeyInfo
1765	if returnFunc, ok := ret.Get(0).(func() []entity.ConfigKeyInfo); ok {
1766		r0 = returnFunc()
1767	} else {
1768		if ret.Get(0) != nil {
1769			r0 = ret.Get(0).([]entity.ConfigKeyInfo)
1770		}
1771	}
1772	return r0
1773}
1774
1775// MockConfigSchemaProvider_GetSchema_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSchema'
1776type MockConfigSchemaProvider_GetSchema_Call struct {
1777	*mock.Call
1778}
1779
1780// GetSchema is a helper method to define mock.On call
1781func (_e *MockConfigSchemaProvider_Expecter) GetSchema() *MockConfigSchemaProvider_GetSchema_Call {
1782	return &MockConfigSchemaProvider_GetSchema_Call{Call: _e.mock.On("GetSchema")}
1783}
1784
1785func (_c *MockConfigSchemaProvider_GetSchema_Call) Run(run func()) *MockConfigSchemaProvider_GetSchema_Call {
1786	_c.Call.Run(func(args mock.Arguments) {
1787		run()
1788	})
1789	return _c
1790}
1791
1792func (_c *MockConfigSchemaProvider_GetSchema_Call) Return(configKeyInfos []entity.ConfigKeyInfo) *MockConfigSchemaProvider_GetSchema_Call {
1793	_c.Call.Return(configKeyInfos)
1794	return _c
1795}
1796
1797func (_c *MockConfigSchemaProvider_GetSchema_Call) RunAndReturn(run func() []entity.ConfigKeyInfo) *MockConfigSchemaProvider_GetSchema_Call {
1798	_c.Call.Return(run)
1799	return _c
1800}
1801
1802// NewMockConfigTransformer creates a new instance of MockConfigTransformer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
1803// The first argument is typically a *testing.T value.
1804func NewMockConfigTransformer(t interface {
1805	mock.TestingT
1806	Cleanup(func())
1807}) *MockConfigTransformer {
1808	mock := &MockConfigTransformer{}
1809	mock.Mock.Test(t)
1810
1811	t.Cleanup(func() { mock.AssertExpectations(t) })
1812
1813	return mock
1814}
1815
1816// MockConfigTransformer is an autogenerated mock type for the ConfigTransformer type
1817type MockConfigTransformer struct {
1818	mock.Mock
1819}
1820
1821type MockConfigTransformer_Expecter struct {
1822	mock *mock.Mock
1823}
1824
1825func (_m *MockConfigTransformer) EXPECT() *MockConfigTransformer_Expecter {
1826	return &MockConfigTransformer_Expecter{mock: &_m.Mock}
1827}
1828
1829// TransformLegacyActions provides a mock function for the type MockConfigTransformer
1830func (_mock *MockConfigTransformer) TransformLegacyActions(rawConfig map[string]any) {
1831	_mock.Called(rawConfig)
1832	return
1833}
1834
1835// MockConfigTransformer_TransformLegacyActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformLegacyActions'
1836type MockConfigTransformer_TransformLegacyActions_Call struct {
1837	*mock.Call
1838}
1839
1840// TransformLegacyActions is a helper method to define mock.On call
1841//   - rawConfig map[string]any
1842func (_e *MockConfigTransformer_Expecter) TransformLegacyActions(rawConfig interface{}) *MockConfigTransformer_TransformLegacyActions_Call {
1843	return &MockConfigTransformer_TransformLegacyActions_Call{Call: _e.mock.On("TransformLegacyActions", rawConfig)}
1844}
1845
1846func (_c *MockConfigTransformer_TransformLegacyActions_Call) Run(run func(rawConfig map[string]any)) *MockConfigTransformer_TransformLegacyActions_Call {
1847	_c.Call.Run(func(args mock.Arguments) {
1848		var arg0 map[string]any
1849		if args[0] != nil {
1850			arg0 = args[0].(map[string]any)
1851		}
1852		run(
1853			arg0,
1854		)
1855	})
1856	return _c
1857}
1858
1859func (_c *MockConfigTransformer_TransformLegacyActions_Call) Return() *MockConfigTransformer_TransformLegacyActions_Call {
1860	_c.Call.Return()
1861	return _c
1862}
1863
1864func (_c *MockConfigTransformer_TransformLegacyActions_Call) RunAndReturn(run func(rawConfig map[string]any)) *MockConfigTransformer_TransformLegacyActions_Call {
1865	_c.Run(run)
1866	return _c
1867}
1868
1869// TransformLegacyEngineConfig provides a mock function for the type MockConfigTransformer
1870func (_mock *MockConfigTransformer) TransformLegacyEngineConfig(rawConfig map[string]any) {
1871	_mock.Called(rawConfig)
1872	return
1873}
1874
1875// MockConfigTransformer_TransformLegacyEngineConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformLegacyEngineConfig'
1876type MockConfigTransformer_TransformLegacyEngineConfig_Call struct {
1877	*mock.Call
1878}
1879
1880// TransformLegacyEngineConfig is a helper method to define mock.On call
1881//   - rawConfig map[string]any
1882func (_e *MockConfigTransformer_Expecter) TransformLegacyEngineConfig(rawConfig interface{}) *MockConfigTransformer_TransformLegacyEngineConfig_Call {
1883	return &MockConfigTransformer_TransformLegacyEngineConfig_Call{Call: _e.mock.On("TransformLegacyEngineConfig", rawConfig)}
1884}
1885
1886func (_c *MockConfigTransformer_TransformLegacyEngineConfig_Call) Run(run func(rawConfig map[string]any)) *MockConfigTransformer_TransformLegacyEngineConfig_Call {
1887	_c.Call.Run(func(args mock.Arguments) {
1888		var arg0 map[string]any
1889		if args[0] != nil {
1890			arg0 = args[0].(map[string]any)
1891		}
1892		run(
1893			arg0,
1894		)
1895	})
1896	return _c
1897}
1898
1899func (_c *MockConfigTransformer_TransformLegacyEngineConfig_Call) Return() *MockConfigTransformer_TransformLegacyEngineConfig_Call {
1900	_c.Call.Return()
1901	return _c
1902}
1903
1904func (_c *MockConfigTransformer_TransformLegacyEngineConfig_Call) RunAndReturn(run func(rawConfig map[string]any)) *MockConfigTransformer_TransformLegacyEngineConfig_Call {
1905	_c.Run(run)
1906	return _c
1907}
1908
1909// NewMockContentInjector creates a new instance of MockContentInjector. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
1910// The first argument is typically a *testing.T value.
1911func NewMockContentInjector(t interface {
1912	mock.TestingT
1913	Cleanup(func())
1914}) *MockContentInjector {
1915	mock := &MockContentInjector{}
1916	mock.Mock.Test(t)
1917
1918	t.Cleanup(func() { mock.AssertExpectations(t) })
1919
1920	return mock
1921}
1922
1923// MockContentInjector is an autogenerated mock type for the ContentInjector type
1924type MockContentInjector struct {
1925	mock.Mock
1926}
1927
1928type MockContentInjector_Expecter struct {
1929	mock *mock.Mock
1930}
1931
1932func (_m *MockContentInjector) EXPECT() *MockContentInjector_Expecter {
1933	return &MockContentInjector_Expecter{mock: &_m.Mock}
1934}
1935
1936// InjectFindHighlightCSS provides a mock function for the type MockContentInjector
1937func (_mock *MockContentInjector) InjectFindHighlightCSS(ctx context.Context, css string) error {
1938	ret := _mock.Called(ctx, css)
1939
1940	if len(ret) == 0 {
1941		panic("no return value specified for InjectFindHighlightCSS")
1942	}
1943
1944	var r0 error
1945	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1946		r0 = returnFunc(ctx, css)
1947	} else {
1948		r0 = ret.Error(0)
1949	}
1950	return r0
1951}
1952
1953// MockContentInjector_InjectFindHighlightCSS_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InjectFindHighlightCSS'
1954type MockContentInjector_InjectFindHighlightCSS_Call struct {
1955	*mock.Call
1956}
1957
1958// InjectFindHighlightCSS is a helper method to define mock.On call
1959//   - ctx context.Context
1960//   - css string
1961func (_e *MockContentInjector_Expecter) InjectFindHighlightCSS(ctx interface{}, css interface{}) *MockContentInjector_InjectFindHighlightCSS_Call {
1962	return &MockContentInjector_InjectFindHighlightCSS_Call{Call: _e.mock.On("InjectFindHighlightCSS", ctx, css)}
1963}
1964
1965func (_c *MockContentInjector_InjectFindHighlightCSS_Call) Run(run func(ctx context.Context, css string)) *MockContentInjector_InjectFindHighlightCSS_Call {
1966	_c.Call.Run(func(args mock.Arguments) {
1967		var arg0 context.Context
1968		if args[0] != nil {
1969			arg0 = args[0].(context.Context)
1970		}
1971		var arg1 string
1972		if args[1] != nil {
1973			arg1 = args[1].(string)
1974		}
1975		run(
1976			arg0,
1977			arg1,
1978		)
1979	})
1980	return _c
1981}
1982
1983func (_c *MockContentInjector_InjectFindHighlightCSS_Call) Return(err error) *MockContentInjector_InjectFindHighlightCSS_Call {
1984	_c.Call.Return(err)
1985	return _c
1986}
1987
1988func (_c *MockContentInjector_InjectFindHighlightCSS_Call) RunAndReturn(run func(ctx context.Context, css string) error) *MockContentInjector_InjectFindHighlightCSS_Call {
1989	_c.Call.Return(run)
1990	return _c
1991}
1992
1993// InjectThemeCSS provides a mock function for the type MockContentInjector
1994func (_mock *MockContentInjector) InjectThemeCSS(ctx context.Context, css string) error {
1995	ret := _mock.Called(ctx, css)
1996
1997	if len(ret) == 0 {
1998		panic("no return value specified for InjectThemeCSS")
1999	}
2000
2001	var r0 error
2002	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
2003		r0 = returnFunc(ctx, css)
2004	} else {
2005		r0 = ret.Error(0)
2006	}
2007	return r0
2008}
2009
2010// MockContentInjector_InjectThemeCSS_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InjectThemeCSS'
2011type MockContentInjector_InjectThemeCSS_Call struct {
2012	*mock.Call
2013}
2014
2015// InjectThemeCSS is a helper method to define mock.On call
2016//   - ctx context.Context
2017//   - css string
2018func (_e *MockContentInjector_Expecter) InjectThemeCSS(ctx interface{}, css interface{}) *MockContentInjector_InjectThemeCSS_Call {
2019	return &MockContentInjector_InjectThemeCSS_Call{Call: _e.mock.On("InjectThemeCSS", ctx, css)}
2020}
2021
2022func (_c *MockContentInjector_InjectThemeCSS_Call) Run(run func(ctx context.Context, css string)) *MockContentInjector_InjectThemeCSS_Call {
2023	_c.Call.Run(func(args mock.Arguments) {
2024		var arg0 context.Context
2025		if args[0] != nil {
2026			arg0 = args[0].(context.Context)
2027		}
2028		var arg1 string
2029		if args[1] != nil {
2030			arg1 = args[1].(string)
2031		}
2032		run(
2033			arg0,
2034			arg1,
2035		)
2036	})
2037	return _c
2038}
2039
2040func (_c *MockContentInjector_InjectThemeCSS_Call) Return(err error) *MockContentInjector_InjectThemeCSS_Call {
2041	_c.Call.Return(err)
2042	return _c
2043}
2044
2045func (_c *MockContentInjector_InjectThemeCSS_Call) RunAndReturn(run func(ctx context.Context, css string) error) *MockContentInjector_InjectThemeCSS_Call {
2046	_c.Call.Return(run)
2047	return _c
2048}
2049
2050// RefreshScripts provides a mock function for the type MockContentInjector
2051func (_mock *MockContentInjector) RefreshScripts(ctx context.Context, wv port.WebView) error {
2052	ret := _mock.Called(ctx, wv)
2053
2054	if len(ret) == 0 {
2055		panic("no return value specified for RefreshScripts")
2056	}
2057
2058	var r0 error
2059	if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebView) error); ok {
2060		r0 = returnFunc(ctx, wv)
2061	} else {
2062		r0 = ret.Error(0)
2063	}
2064	return r0
2065}
2066
2067// MockContentInjector_RefreshScripts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RefreshScripts'
2068type MockContentInjector_RefreshScripts_Call struct {
2069	*mock.Call
2070}
2071
2072// RefreshScripts is a helper method to define mock.On call
2073//   - ctx context.Context
2074//   - wv port.WebView
2075func (_e *MockContentInjector_Expecter) RefreshScripts(ctx interface{}, wv interface{}) *MockContentInjector_RefreshScripts_Call {
2076	return &MockContentInjector_RefreshScripts_Call{Call: _e.mock.On("RefreshScripts", ctx, wv)}
2077}
2078
2079func (_c *MockContentInjector_RefreshScripts_Call) Run(run func(ctx context.Context, wv port.WebView)) *MockContentInjector_RefreshScripts_Call {
2080	_c.Call.Run(func(args mock.Arguments) {
2081		var arg0 context.Context
2082		if args[0] != nil {
2083			arg0 = args[0].(context.Context)
2084		}
2085		var arg1 port.WebView
2086		if args[1] != nil {
2087			arg1 = args[1].(port.WebView)
2088		}
2089		run(
2090			arg0,
2091			arg1,
2092		)
2093	})
2094	return _c
2095}
2096
2097func (_c *MockContentInjector_RefreshScripts_Call) Return(err error) *MockContentInjector_RefreshScripts_Call {
2098	_c.Call.Return(err)
2099	return _c
2100}
2101
2102func (_c *MockContentInjector_RefreshScripts_Call) RunAndReturn(run func(ctx context.Context, wv port.WebView) error) *MockContentInjector_RefreshScripts_Call {
2103	_c.Call.Return(run)
2104	return _c
2105}
2106
2107// NewMockContextMenuBuilder creates a new instance of MockContextMenuBuilder. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
2108// The first argument is typically a *testing.T value.
2109func NewMockContextMenuBuilder(t interface {
2110	mock.TestingT
2111	Cleanup(func())
2112}) *MockContextMenuBuilder {
2113	mock := &MockContextMenuBuilder{}
2114	mock.Mock.Test(t)
2115
2116	t.Cleanup(func() { mock.AssertExpectations(t) })
2117
2118	return mock
2119}
2120
2121// MockContextMenuBuilder is an autogenerated mock type for the ContextMenuBuilder type
2122type MockContextMenuBuilder struct {
2123	mock.Mock
2124}
2125
2126type MockContextMenuBuilder_Expecter struct {
2127	mock *mock.Mock
2128}
2129
2130func (_m *MockContextMenuBuilder) EXPECT() *MockContextMenuBuilder_Expecter {
2131	return &MockContextMenuBuilder_Expecter{mock: &_m.Mock}
2132}
2133
2134// Build provides a mock function for the type MockContextMenuBuilder
2135func (_mock *MockContextMenuBuilder) Build(ctx context.Context, menuContext port.MenuContext) []port.MenuItem {
2136	ret := _mock.Called(ctx, menuContext)
2137
2138	if len(ret) == 0 {
2139		panic("no return value specified for Build")
2140	}
2141
2142	var r0 []port.MenuItem
2143	if returnFunc, ok := ret.Get(0).(func(context.Context, port.MenuContext) []port.MenuItem); ok {
2144		r0 = returnFunc(ctx, menuContext)
2145	} else {
2146		if ret.Get(0) != nil {
2147			r0 = ret.Get(0).([]port.MenuItem)
2148		}
2149	}
2150	return r0
2151}
2152
2153// MockContextMenuBuilder_Build_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Build'
2154type MockContextMenuBuilder_Build_Call struct {
2155	*mock.Call
2156}
2157
2158// Build is a helper method to define mock.On call
2159//   - ctx context.Context
2160//   - menuContext port.MenuContext
2161func (_e *MockContextMenuBuilder_Expecter) Build(ctx interface{}, menuContext interface{}) *MockContextMenuBuilder_Build_Call {
2162	return &MockContextMenuBuilder_Build_Call{Call: _e.mock.On("Build", ctx, menuContext)}
2163}
2164
2165func (_c *MockContextMenuBuilder_Build_Call) Run(run func(ctx context.Context, menuContext port.MenuContext)) *MockContextMenuBuilder_Build_Call {
2166	_c.Call.Run(func(args mock.Arguments) {
2167		var arg0 context.Context
2168		if args[0] != nil {
2169			arg0 = args[0].(context.Context)
2170		}
2171		var arg1 port.MenuContext
2172		if args[1] != nil {
2173			arg1 = args[1].(port.MenuContext)
2174		}
2175		run(
2176			arg0,
2177			arg1,
2178		)
2179	})
2180	return _c
2181}
2182
2183func (_c *MockContextMenuBuilder_Build_Call) Return(menuItems []port.MenuItem) *MockContextMenuBuilder_Build_Call {
2184	_c.Call.Return(menuItems)
2185	return _c
2186}
2187
2188func (_c *MockContextMenuBuilder_Build_Call) RunAndReturn(run func(ctx context.Context, menuContext port.MenuContext) []port.MenuItem) *MockContextMenuBuilder_Build_Call {
2189	_c.Call.Return(run)
2190	return _c
2191}
2192
2193// NewMockContextMenuActionExecutor creates a new instance of MockContextMenuActionExecutor. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
2194// The first argument is typically a *testing.T value.
2195func NewMockContextMenuActionExecutor(t interface {
2196	mock.TestingT
2197	Cleanup(func())
2198}) *MockContextMenuActionExecutor {
2199	mock := &MockContextMenuActionExecutor{}
2200	mock.Mock.Test(t)
2201
2202	t.Cleanup(func() { mock.AssertExpectations(t) })
2203
2204	return mock
2205}
2206
2207// MockContextMenuActionExecutor is an autogenerated mock type for the ContextMenuActionExecutor type
2208type MockContextMenuActionExecutor struct {
2209	mock.Mock
2210}
2211
2212type MockContextMenuActionExecutor_Expecter struct {
2213	mock *mock.Mock
2214}
2215
2216func (_m *MockContextMenuActionExecutor) EXPECT() *MockContextMenuActionExecutor_Expecter {
2217	return &MockContextMenuActionExecutor_Expecter{mock: &_m.Mock}
2218}
2219
2220// ExecuteMenuAction provides a mock function for the type MockContextMenuActionExecutor
2221func (_mock *MockContextMenuActionExecutor) ExecuteMenuAction(ctx context.Context, action port.MenuAction, menuContext port.MenuContext) error {
2222	ret := _mock.Called(ctx, action, menuContext)
2223
2224	if len(ret) == 0 {
2225		panic("no return value specified for ExecuteMenuAction")
2226	}
2227
2228	var r0 error
2229	if returnFunc, ok := ret.Get(0).(func(context.Context, port.MenuAction, port.MenuContext) error); ok {
2230		r0 = returnFunc(ctx, action, menuContext)
2231	} else {
2232		r0 = ret.Error(0)
2233	}
2234	return r0
2235}
2236
2237// MockContextMenuActionExecutor_ExecuteMenuAction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExecuteMenuAction'
2238type MockContextMenuActionExecutor_ExecuteMenuAction_Call struct {
2239	*mock.Call
2240}
2241
2242// ExecuteMenuAction is a helper method to define mock.On call
2243//   - ctx context.Context
2244//   - action port.MenuAction
2245//   - menuContext port.MenuContext
2246func (_e *MockContextMenuActionExecutor_Expecter) ExecuteMenuAction(ctx interface{}, action interface{}, menuContext interface{}) *MockContextMenuActionExecutor_ExecuteMenuAction_Call {
2247	return &MockContextMenuActionExecutor_ExecuteMenuAction_Call{Call: _e.mock.On("ExecuteMenuAction", ctx, action, menuContext)}
2248}
2249
2250func (_c *MockContextMenuActionExecutor_ExecuteMenuAction_Call) Run(run func(ctx context.Context, action port.MenuAction, menuContext port.MenuContext)) *MockContextMenuActionExecutor_ExecuteMenuAction_Call {
2251	_c.Call.Run(func(args mock.Arguments) {
2252		var arg0 context.Context
2253		if args[0] != nil {
2254			arg0 = args[0].(context.Context)
2255		}
2256		var arg1 port.MenuAction
2257		if args[1] != nil {
2258			arg1 = args[1].(port.MenuAction)
2259		}
2260		var arg2 port.MenuContext
2261		if args[2] != nil {
2262			arg2 = args[2].(port.MenuContext)
2263		}
2264		run(
2265			arg0,
2266			arg1,
2267			arg2,
2268		)
2269	})
2270	return _c
2271}
2272
2273func (_c *MockContextMenuActionExecutor_ExecuteMenuAction_Call) Return(err error) *MockContextMenuActionExecutor_ExecuteMenuAction_Call {
2274	_c.Call.Return(err)
2275	return _c
2276}
2277
2278func (_c *MockContextMenuActionExecutor_ExecuteMenuAction_Call) RunAndReturn(run func(ctx context.Context, action port.MenuAction, menuContext port.MenuContext) error) *MockContextMenuActionExecutor_ExecuteMenuAction_Call {
2279	_c.Call.Return(run)
2280	return _c
2281}
2282
2283// NewMockContextMenuActionExecutorFactory creates a new instance of MockContextMenuActionExecutorFactory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
2284// The first argument is typically a *testing.T value.
2285func NewMockContextMenuActionExecutorFactory(t interface {
2286	mock.TestingT
2287	Cleanup(func())
2288}) *MockContextMenuActionExecutorFactory {
2289	mock := &MockContextMenuActionExecutorFactory{}
2290	mock.Mock.Test(t)
2291
2292	t.Cleanup(func() { mock.AssertExpectations(t) })
2293
2294	return mock
2295}
2296
2297// MockContextMenuActionExecutorFactory is an autogenerated mock type for the ContextMenuActionExecutorFactory type
2298type MockContextMenuActionExecutorFactory struct {
2299	mock.Mock
2300}
2301
2302type MockContextMenuActionExecutorFactory_Expecter struct {
2303	mock *mock.Mock
2304}
2305
2306func (_m *MockContextMenuActionExecutorFactory) EXPECT() *MockContextMenuActionExecutorFactory_Expecter {
2307	return &MockContextMenuActionExecutorFactory_Expecter{mock: &_m.Mock}
2308}
2309
2310// NewContextMenuActionExecutor provides a mock function for the type MockContextMenuActionExecutorFactory
2311func (_mock *MockContextMenuActionExecutorFactory) NewContextMenuActionExecutor(clipboard port.Clipboard, resolver port.ImageDataResolver, saver port.ResolvedImageSaver, delegator port.MenuActionDelegator) port.ContextMenuActionExecutor {
2312	ret := _mock.Called(clipboard, resolver, saver, delegator)
2313
2314	if len(ret) == 0 {
2315		panic("no return value specified for NewContextMenuActionExecutor")
2316	}
2317
2318	var r0 port.ContextMenuActionExecutor
2319	if returnFunc, ok := ret.Get(0).(func(port.Clipboard, port.ImageDataResolver, port.ResolvedImageSaver, port.MenuActionDelegator) port.ContextMenuActionExecutor); ok {
2320		r0 = returnFunc(clipboard, resolver, saver, delegator)
2321	} else {
2322		if ret.Get(0) != nil {
2323			r0 = ret.Get(0).(port.ContextMenuActionExecutor)
2324		}
2325	}
2326	return r0
2327}
2328
2329// MockContextMenuActionExecutorFactory_NewContextMenuActionExecutor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewContextMenuActionExecutor'
2330type MockContextMenuActionExecutorFactory_NewContextMenuActionExecutor_Call struct {
2331	*mock.Call
2332}
2333
2334// NewContextMenuActionExecutor is a helper method to define mock.On call
2335//   - clipboard port.Clipboard
2336//   - resolver port.ImageDataResolver
2337//   - saver port.ResolvedImageSaver
2338//   - delegator port.MenuActionDelegator
2339func (_e *MockContextMenuActionExecutorFactory_Expecter) NewContextMenuActionExecutor(clipboard interface{}, resolver interface{}, saver interface{}, delegator interface{}) *MockContextMenuActionExecutorFactory_NewContextMenuActionExecutor_Call {
2340	return &MockContextMenuActionExecutorFactory_NewContextMenuActionExecutor_Call{Call: _e.mock.On("NewContextMenuActionExecutor", clipboard, resolver, saver, delegator)}
2341}
2342
2343func (_c *MockContextMenuActionExecutorFactory_NewContextMenuActionExecutor_Call) Run(run func(clipboard port.Clipboard, resolver port.ImageDataResolver, saver port.ResolvedImageSaver, delegator port.MenuActionDelegator)) *MockContextMenuActionExecutorFactory_NewContextMenuActionExecutor_Call {
2344	_c.Call.Run(func(args mock.Arguments) {
2345		var arg0 port.Clipboard
2346		if args[0] != nil {
2347			arg0 = args[0].(port.Clipboard)
2348		}
2349		var arg1 port.ImageDataResolver
2350		if args[1] != nil {
2351			arg1 = args[1].(port.ImageDataResolver)
2352		}
2353		var arg2 port.ResolvedImageSaver
2354		if args[2] != nil {
2355			arg2 = args[2].(port.ResolvedImageSaver)
2356		}
2357		var arg3 port.MenuActionDelegator
2358		if args[3] != nil {
2359			arg3 = args[3].(port.MenuActionDelegator)
2360		}
2361		run(
2362			arg0,
2363			arg1,
2364			arg2,
2365			arg3,
2366		)
2367	})
2368	return _c
2369}
2370
2371func (_c *MockContextMenuActionExecutorFactory_NewContextMenuActionExecutor_Call) Return(contextMenuActionExecutor port.ContextMenuActionExecutor) *MockContextMenuActionExecutorFactory_NewContextMenuActionExecutor_Call {
2372	_c.Call.Return(contextMenuActionExecutor)
2373	return _c
2374}
2375
2376func (_c *MockContextMenuActionExecutorFactory_NewContextMenuActionExecutor_Call) RunAndReturn(run func(clipboard port.Clipboard, resolver port.ImageDataResolver, saver port.ResolvedImageSaver, delegator port.MenuActionDelegator) port.ContextMenuActionExecutor) *MockContextMenuActionExecutorFactory_NewContextMenuActionExecutor_Call {
2377	_c.Call.Return(run)
2378	return _c
2379}
2380
2381// NewMockMenuActionDelegator creates a new instance of MockMenuActionDelegator. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
2382// The first argument is typically a *testing.T value.
2383func NewMockMenuActionDelegator(t interface {
2384	mock.TestingT
2385	Cleanup(func())
2386}) *MockMenuActionDelegator {
2387	mock := &MockMenuActionDelegator{}
2388	mock.Mock.Test(t)
2389
2390	t.Cleanup(func() { mock.AssertExpectations(t) })
2391
2392	return mock
2393}
2394
2395// MockMenuActionDelegator is an autogenerated mock type for the MenuActionDelegator type
2396type MockMenuActionDelegator struct {
2397	mock.Mock
2398}
2399
2400type MockMenuActionDelegator_Expecter struct {
2401	mock *mock.Mock
2402}
2403
2404func (_m *MockMenuActionDelegator) EXPECT() *MockMenuActionDelegator_Expecter {
2405	return &MockMenuActionDelegator_Expecter{mock: &_m.Mock}
2406}
2407
2408// DelegateMenuAction provides a mock function for the type MockMenuActionDelegator
2409func (_mock *MockMenuActionDelegator) DelegateMenuAction(ctx context.Context, action port.MenuAction, menuContext port.MenuContext) error {
2410	ret := _mock.Called(ctx, action, menuContext)
2411
2412	if len(ret) == 0 {
2413		panic("no return value specified for DelegateMenuAction")
2414	}
2415
2416	var r0 error
2417	if returnFunc, ok := ret.Get(0).(func(context.Context, port.MenuAction, port.MenuContext) error); ok {
2418		r0 = returnFunc(ctx, action, menuContext)
2419	} else {
2420		r0 = ret.Error(0)
2421	}
2422	return r0
2423}
2424
2425// MockMenuActionDelegator_DelegateMenuAction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DelegateMenuAction'
2426type MockMenuActionDelegator_DelegateMenuAction_Call struct {
2427	*mock.Call
2428}
2429
2430// DelegateMenuAction is a helper method to define mock.On call
2431//   - ctx context.Context
2432//   - action port.MenuAction
2433//   - menuContext port.MenuContext
2434func (_e *MockMenuActionDelegator_Expecter) DelegateMenuAction(ctx interface{}, action interface{}, menuContext interface{}) *MockMenuActionDelegator_DelegateMenuAction_Call {
2435	return &MockMenuActionDelegator_DelegateMenuAction_Call{Call: _e.mock.On("DelegateMenuAction", ctx, action, menuContext)}
2436}
2437
2438func (_c *MockMenuActionDelegator_DelegateMenuAction_Call) Run(run func(ctx context.Context, action port.MenuAction, menuContext port.MenuContext)) *MockMenuActionDelegator_DelegateMenuAction_Call {
2439	_c.Call.Run(func(args mock.Arguments) {
2440		var arg0 context.Context
2441		if args[0] != nil {
2442			arg0 = args[0].(context.Context)
2443		}
2444		var arg1 port.MenuAction
2445		if args[1] != nil {
2446			arg1 = args[1].(port.MenuAction)
2447		}
2448		var arg2 port.MenuContext
2449		if args[2] != nil {
2450			arg2 = args[2].(port.MenuContext)
2451		}
2452		run(
2453			arg0,
2454			arg1,
2455			arg2,
2456		)
2457	})
2458	return _c
2459}
2460
2461func (_c *MockMenuActionDelegator_DelegateMenuAction_Call) Return(err error) *MockMenuActionDelegator_DelegateMenuAction_Call {
2462	_c.Call.Return(err)
2463	return _c
2464}
2465
2466func (_c *MockMenuActionDelegator_DelegateMenuAction_Call) RunAndReturn(run func(ctx context.Context, action port.MenuAction, menuContext port.MenuContext) error) *MockMenuActionDelegator_DelegateMenuAction_Call {
2467	_c.Call.Return(run)
2468	return _c
2469}
2470
2471// NewMockDatabaseProvider creates a new instance of MockDatabaseProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
2472// The first argument is typically a *testing.T value.
2473func NewMockDatabaseProvider(t interface {
2474	mock.TestingT
2475	Cleanup(func())
2476}) *MockDatabaseProvider {
2477	mock := &MockDatabaseProvider{}
2478	mock.Mock.Test(t)
2479
2480	t.Cleanup(func() { mock.AssertExpectations(t) })
2481
2482	return mock
2483}
2484
2485// MockDatabaseProvider is an autogenerated mock type for the DatabaseProvider type
2486type MockDatabaseProvider struct {
2487	mock.Mock
2488}
2489
2490type MockDatabaseProvider_Expecter struct {
2491	mock *mock.Mock
2492}
2493
2494func (_m *MockDatabaseProvider) EXPECT() *MockDatabaseProvider_Expecter {
2495	return &MockDatabaseProvider_Expecter{mock: &_m.Mock}
2496}
2497
2498// Close provides a mock function for the type MockDatabaseProvider
2499func (_mock *MockDatabaseProvider) Close() error {
2500	ret := _mock.Called()
2501
2502	if len(ret) == 0 {
2503		panic("no return value specified for Close")
2504	}
2505
2506	var r0 error
2507	if returnFunc, ok := ret.Get(0).(func() error); ok {
2508		r0 = returnFunc()
2509	} else {
2510		r0 = ret.Error(0)
2511	}
2512	return r0
2513}
2514
2515// MockDatabaseProvider_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
2516type MockDatabaseProvider_Close_Call struct {
2517	*mock.Call
2518}
2519
2520// Close is a helper method to define mock.On call
2521func (_e *MockDatabaseProvider_Expecter) Close() *MockDatabaseProvider_Close_Call {
2522	return &MockDatabaseProvider_Close_Call{Call: _e.mock.On("Close")}
2523}
2524
2525func (_c *MockDatabaseProvider_Close_Call) Run(run func()) *MockDatabaseProvider_Close_Call {
2526	_c.Call.Run(func(args mock.Arguments) {
2527		run()
2528	})
2529	return _c
2530}
2531
2532func (_c *MockDatabaseProvider_Close_Call) Return(err error) *MockDatabaseProvider_Close_Call {
2533	_c.Call.Return(err)
2534	return _c
2535}
2536
2537func (_c *MockDatabaseProvider_Close_Call) RunAndReturn(run func() error) *MockDatabaseProvider_Close_Call {
2538	_c.Call.Return(run)
2539	return _c
2540}
2541
2542// DB provides a mock function for the type MockDatabaseProvider
2543func (_mock *MockDatabaseProvider) DB(ctx context.Context) (*sql.DB, error) {
2544	ret := _mock.Called(ctx)
2545
2546	if len(ret) == 0 {
2547		panic("no return value specified for DB")
2548	}
2549
2550	var r0 *sql.DB
2551	var r1 error
2552	if returnFunc, ok := ret.Get(0).(func(context.Context) (*sql.DB, error)); ok {
2553		return returnFunc(ctx)
2554	}
2555	if returnFunc, ok := ret.Get(0).(func(context.Context) *sql.DB); ok {
2556		r0 = returnFunc(ctx)
2557	} else {
2558		if ret.Get(0) != nil {
2559			r0 = ret.Get(0).(*sql.DB)
2560		}
2561	}
2562	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2563		r1 = returnFunc(ctx)
2564	} else {
2565		r1 = ret.Error(1)
2566	}
2567	return r0, r1
2568}
2569
2570// MockDatabaseProvider_DB_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DB'
2571type MockDatabaseProvider_DB_Call struct {
2572	*mock.Call
2573}
2574
2575// DB is a helper method to define mock.On call
2576//   - ctx context.Context
2577func (_e *MockDatabaseProvider_Expecter) DB(ctx interface{}) *MockDatabaseProvider_DB_Call {
2578	return &MockDatabaseProvider_DB_Call{Call: _e.mock.On("DB", ctx)}
2579}
2580
2581func (_c *MockDatabaseProvider_DB_Call) Run(run func(ctx context.Context)) *MockDatabaseProvider_DB_Call {
2582	_c.Call.Run(func(args mock.Arguments) {
2583		var arg0 context.Context
2584		if args[0] != nil {
2585			arg0 = args[0].(context.Context)
2586		}
2587		run(
2588			arg0,
2589		)
2590	})
2591	return _c
2592}
2593
2594func (_c *MockDatabaseProvider_DB_Call) Return(dB *sql.DB, err error) *MockDatabaseProvider_DB_Call {
2595	_c.Call.Return(dB, err)
2596	return _c
2597}
2598
2599func (_c *MockDatabaseProvider_DB_Call) RunAndReturn(run func(ctx context.Context) (*sql.DB, error)) *MockDatabaseProvider_DB_Call {
2600	_c.Call.Return(run)
2601	return _c
2602}
2603
2604// IsInitialized provides a mock function for the type MockDatabaseProvider
2605func (_mock *MockDatabaseProvider) IsInitialized() bool {
2606	ret := _mock.Called()
2607
2608	if len(ret) == 0 {
2609		panic("no return value specified for IsInitialized")
2610	}
2611
2612	var r0 bool
2613	if returnFunc, ok := ret.Get(0).(func() bool); ok {
2614		r0 = returnFunc()
2615	} else {
2616		r0 = ret.Get(0).(bool)
2617	}
2618	return r0
2619}
2620
2621// MockDatabaseProvider_IsInitialized_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsInitialized'
2622type MockDatabaseProvider_IsInitialized_Call struct {
2623	*mock.Call
2624}
2625
2626// IsInitialized is a helper method to define mock.On call
2627func (_e *MockDatabaseProvider_Expecter) IsInitialized() *MockDatabaseProvider_IsInitialized_Call {
2628	return &MockDatabaseProvider_IsInitialized_Call{Call: _e.mock.On("IsInitialized")}
2629}
2630
2631func (_c *MockDatabaseProvider_IsInitialized_Call) Run(run func()) *MockDatabaseProvider_IsInitialized_Call {
2632	_c.Call.Run(func(args mock.Arguments) {
2633		run()
2634	})
2635	return _c
2636}
2637
2638func (_c *MockDatabaseProvider_IsInitialized_Call) Return(b bool) *MockDatabaseProvider_IsInitialized_Call {
2639	_c.Call.Return(b)
2640	return _c
2641}
2642
2643func (_c *MockDatabaseProvider_IsInitialized_Call) RunAndReturn(run func() bool) *MockDatabaseProvider_IsInitialized_Call {
2644	_c.Call.Return(run)
2645	return _c
2646}
2647
2648// NewMockDesktopIntegration creates a new instance of MockDesktopIntegration. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
2649// The first argument is typically a *testing.T value.
2650func NewMockDesktopIntegration(t interface {
2651	mock.TestingT
2652	Cleanup(func())
2653}) *MockDesktopIntegration {
2654	mock := &MockDesktopIntegration{}
2655	mock.Mock.Test(t)
2656
2657	t.Cleanup(func() { mock.AssertExpectations(t) })
2658
2659	return mock
2660}
2661
2662// MockDesktopIntegration is an autogenerated mock type for the DesktopIntegration type
2663type MockDesktopIntegration struct {
2664	mock.Mock
2665}
2666
2667type MockDesktopIntegration_Expecter struct {
2668	mock *mock.Mock
2669}
2670
2671func (_m *MockDesktopIntegration) EXPECT() *MockDesktopIntegration_Expecter {
2672	return &MockDesktopIntegration_Expecter{mock: &_m.Mock}
2673}
2674
2675// GetStatus provides a mock function for the type MockDesktopIntegration
2676func (_mock *MockDesktopIntegration) GetStatus(ctx context.Context) (*port.DesktopIntegrationStatus, error) {
2677	ret := _mock.Called(ctx)
2678
2679	if len(ret) == 0 {
2680		panic("no return value specified for GetStatus")
2681	}
2682
2683	var r0 *port.DesktopIntegrationStatus
2684	var r1 error
2685	if returnFunc, ok := ret.Get(0).(func(context.Context) (*port.DesktopIntegrationStatus, error)); ok {
2686		return returnFunc(ctx)
2687	}
2688	if returnFunc, ok := ret.Get(0).(func(context.Context) *port.DesktopIntegrationStatus); ok {
2689		r0 = returnFunc(ctx)
2690	} else {
2691		if ret.Get(0) != nil {
2692			r0 = ret.Get(0).(*port.DesktopIntegrationStatus)
2693		}
2694	}
2695	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2696		r1 = returnFunc(ctx)
2697	} else {
2698		r1 = ret.Error(1)
2699	}
2700	return r0, r1
2701}
2702
2703// MockDesktopIntegration_GetStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStatus'
2704type MockDesktopIntegration_GetStatus_Call struct {
2705	*mock.Call
2706}
2707
2708// GetStatus is a helper method to define mock.On call
2709//   - ctx context.Context
2710func (_e *MockDesktopIntegration_Expecter) GetStatus(ctx interface{}) *MockDesktopIntegration_GetStatus_Call {
2711	return &MockDesktopIntegration_GetStatus_Call{Call: _e.mock.On("GetStatus", ctx)}
2712}
2713
2714func (_c *MockDesktopIntegration_GetStatus_Call) Run(run func(ctx context.Context)) *MockDesktopIntegration_GetStatus_Call {
2715	_c.Call.Run(func(args mock.Arguments) {
2716		var arg0 context.Context
2717		if args[0] != nil {
2718			arg0 = args[0].(context.Context)
2719		}
2720		run(
2721			arg0,
2722		)
2723	})
2724	return _c
2725}
2726
2727func (_c *MockDesktopIntegration_GetStatus_Call) Return(desktopIntegrationStatus *port.DesktopIntegrationStatus, err error) *MockDesktopIntegration_GetStatus_Call {
2728	_c.Call.Return(desktopIntegrationStatus, err)
2729	return _c
2730}
2731
2732func (_c *MockDesktopIntegration_GetStatus_Call) RunAndReturn(run func(ctx context.Context) (*port.DesktopIntegrationStatus, error)) *MockDesktopIntegration_GetStatus_Call {
2733	_c.Call.Return(run)
2734	return _c
2735}
2736
2737// InstallDesktopFile provides a mock function for the type MockDesktopIntegration
2738func (_mock *MockDesktopIntegration) InstallDesktopFile(ctx context.Context) (string, error) {
2739	ret := _mock.Called(ctx)
2740
2741	if len(ret) == 0 {
2742		panic("no return value specified for InstallDesktopFile")
2743	}
2744
2745	var r0 string
2746	var r1 error
2747	if returnFunc, ok := ret.Get(0).(func(context.Context) (string, error)); ok {
2748		return returnFunc(ctx)
2749	}
2750	if returnFunc, ok := ret.Get(0).(func(context.Context) string); ok {
2751		r0 = returnFunc(ctx)
2752	} else {
2753		r0 = ret.Get(0).(string)
2754	}
2755	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2756		r1 = returnFunc(ctx)
2757	} else {
2758		r1 = ret.Error(1)
2759	}
2760	return r0, r1
2761}
2762
2763// MockDesktopIntegration_InstallDesktopFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InstallDesktopFile'
2764type MockDesktopIntegration_InstallDesktopFile_Call struct {
2765	*mock.Call
2766}
2767
2768// InstallDesktopFile is a helper method to define mock.On call
2769//   - ctx context.Context
2770func (_e *MockDesktopIntegration_Expecter) InstallDesktopFile(ctx interface{}) *MockDesktopIntegration_InstallDesktopFile_Call {
2771	return &MockDesktopIntegration_InstallDesktopFile_Call{Call: _e.mock.On("InstallDesktopFile", ctx)}
2772}
2773
2774func (_c *MockDesktopIntegration_InstallDesktopFile_Call) Run(run func(ctx context.Context)) *MockDesktopIntegration_InstallDesktopFile_Call {
2775	_c.Call.Run(func(args mock.Arguments) {
2776		var arg0 context.Context
2777		if args[0] != nil {
2778			arg0 = args[0].(context.Context)
2779		}
2780		run(
2781			arg0,
2782		)
2783	})
2784	return _c
2785}
2786
2787func (_c *MockDesktopIntegration_InstallDesktopFile_Call) Return(s string, err error) *MockDesktopIntegration_InstallDesktopFile_Call {
2788	_c.Call.Return(s, err)
2789	return _c
2790}
2791
2792func (_c *MockDesktopIntegration_InstallDesktopFile_Call) RunAndReturn(run func(ctx context.Context) (string, error)) *MockDesktopIntegration_InstallDesktopFile_Call {
2793	_c.Call.Return(run)
2794	return _c
2795}
2796
2797// InstallIcon provides a mock function for the type MockDesktopIntegration
2798func (_mock *MockDesktopIntegration) InstallIcon(ctx context.Context, svgData []byte) (string, error) {
2799	ret := _mock.Called(ctx, svgData)
2800
2801	if len(ret) == 0 {
2802		panic("no return value specified for InstallIcon")
2803	}
2804
2805	var r0 string
2806	var r1 error
2807	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte) (string, error)); ok {
2808		return returnFunc(ctx, svgData)
2809	}
2810	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte) string); ok {
2811		r0 = returnFunc(ctx, svgData)
2812	} else {
2813		r0 = ret.Get(0).(string)
2814	}
2815	if returnFunc, ok := ret.Get(1).(func(context.Context, []byte) error); ok {
2816		r1 = returnFunc(ctx, svgData)
2817	} else {
2818		r1 = ret.Error(1)
2819	}
2820	return r0, r1
2821}
2822
2823// MockDesktopIntegration_InstallIcon_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InstallIcon'
2824type MockDesktopIntegration_InstallIcon_Call struct {
2825	*mock.Call
2826}
2827
2828// InstallIcon is a helper method to define mock.On call
2829//   - ctx context.Context
2830//   - svgData []byte
2831func (_e *MockDesktopIntegration_Expecter) InstallIcon(ctx interface{}, svgData interface{}) *MockDesktopIntegration_InstallIcon_Call {
2832	return &MockDesktopIntegration_InstallIcon_Call{Call: _e.mock.On("InstallIcon", ctx, svgData)}
2833}
2834
2835func (_c *MockDesktopIntegration_InstallIcon_Call) Run(run func(ctx context.Context, svgData []byte)) *MockDesktopIntegration_InstallIcon_Call {
2836	_c.Call.Run(func(args mock.Arguments) {
2837		var arg0 context.Context
2838		if args[0] != nil {
2839			arg0 = args[0].(context.Context)
2840		}
2841		var arg1 []byte
2842		if args[1] != nil {
2843			arg1 = args[1].([]byte)
2844		}
2845		run(
2846			arg0,
2847			arg1,
2848		)
2849	})
2850	return _c
2851}
2852
2853func (_c *MockDesktopIntegration_InstallIcon_Call) Return(s string, err error) *MockDesktopIntegration_InstallIcon_Call {
2854	_c.Call.Return(s, err)
2855	return _c
2856}
2857
2858func (_c *MockDesktopIntegration_InstallIcon_Call) RunAndReturn(run func(ctx context.Context, svgData []byte) (string, error)) *MockDesktopIntegration_InstallIcon_Call {
2859	_c.Call.Return(run)
2860	return _c
2861}
2862
2863// RemoveDesktopFile provides a mock function for the type MockDesktopIntegration
2864func (_mock *MockDesktopIntegration) RemoveDesktopFile(ctx context.Context) error {
2865	ret := _mock.Called(ctx)
2866
2867	if len(ret) == 0 {
2868		panic("no return value specified for RemoveDesktopFile")
2869	}
2870
2871	var r0 error
2872	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
2873		r0 = returnFunc(ctx)
2874	} else {
2875		r0 = ret.Error(0)
2876	}
2877	return r0
2878}
2879
2880// MockDesktopIntegration_RemoveDesktopFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveDesktopFile'
2881type MockDesktopIntegration_RemoveDesktopFile_Call struct {
2882	*mock.Call
2883}
2884
2885// RemoveDesktopFile is a helper method to define mock.On call
2886//   - ctx context.Context
2887func (_e *MockDesktopIntegration_Expecter) RemoveDesktopFile(ctx interface{}) *MockDesktopIntegration_RemoveDesktopFile_Call {
2888	return &MockDesktopIntegration_RemoveDesktopFile_Call{Call: _e.mock.On("RemoveDesktopFile", ctx)}
2889}
2890
2891func (_c *MockDesktopIntegration_RemoveDesktopFile_Call) Run(run func(ctx context.Context)) *MockDesktopIntegration_RemoveDesktopFile_Call {
2892	_c.Call.Run(func(args mock.Arguments) {
2893		var arg0 context.Context
2894		if args[0] != nil {
2895			arg0 = args[0].(context.Context)
2896		}
2897		run(
2898			arg0,
2899		)
2900	})
2901	return _c
2902}
2903
2904func (_c *MockDesktopIntegration_RemoveDesktopFile_Call) Return(err error) *MockDesktopIntegration_RemoveDesktopFile_Call {
2905	_c.Call.Return(err)
2906	return _c
2907}
2908
2909func (_c *MockDesktopIntegration_RemoveDesktopFile_Call) RunAndReturn(run func(ctx context.Context) error) *MockDesktopIntegration_RemoveDesktopFile_Call {
2910	_c.Call.Return(run)
2911	return _c
2912}
2913
2914// RemoveIcon provides a mock function for the type MockDesktopIntegration
2915func (_mock *MockDesktopIntegration) RemoveIcon(ctx context.Context) error {
2916	ret := _mock.Called(ctx)
2917
2918	if len(ret) == 0 {
2919		panic("no return value specified for RemoveIcon")
2920	}
2921
2922	var r0 error
2923	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
2924		r0 = returnFunc(ctx)
2925	} else {
2926		r0 = ret.Error(0)
2927	}
2928	return r0
2929}
2930
2931// MockDesktopIntegration_RemoveIcon_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveIcon'
2932type MockDesktopIntegration_RemoveIcon_Call struct {
2933	*mock.Call
2934}
2935
2936// RemoveIcon is a helper method to define mock.On call
2937//   - ctx context.Context
2938func (_e *MockDesktopIntegration_Expecter) RemoveIcon(ctx interface{}) *MockDesktopIntegration_RemoveIcon_Call {
2939	return &MockDesktopIntegration_RemoveIcon_Call{Call: _e.mock.On("RemoveIcon", ctx)}
2940}
2941
2942func (_c *MockDesktopIntegration_RemoveIcon_Call) Run(run func(ctx context.Context)) *MockDesktopIntegration_RemoveIcon_Call {
2943	_c.Call.Run(func(args mock.Arguments) {
2944		var arg0 context.Context
2945		if args[0] != nil {
2946			arg0 = args[0].(context.Context)
2947		}
2948		run(
2949			arg0,
2950		)
2951	})
2952	return _c
2953}
2954
2955func (_c *MockDesktopIntegration_RemoveIcon_Call) Return(err error) *MockDesktopIntegration_RemoveIcon_Call {
2956	_c.Call.Return(err)
2957	return _c
2958}
2959
2960func (_c *MockDesktopIntegration_RemoveIcon_Call) RunAndReturn(run func(ctx context.Context) error) *MockDesktopIntegration_RemoveIcon_Call {
2961	_c.Call.Return(run)
2962	return _c
2963}
2964
2965// SetAsDefaultBrowser provides a mock function for the type MockDesktopIntegration
2966func (_mock *MockDesktopIntegration) SetAsDefaultBrowser(ctx context.Context) error {
2967	ret := _mock.Called(ctx)
2968
2969	if len(ret) == 0 {
2970		panic("no return value specified for SetAsDefaultBrowser")
2971	}
2972
2973	var r0 error
2974	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
2975		r0 = returnFunc(ctx)
2976	} else {
2977		r0 = ret.Error(0)
2978	}
2979	return r0
2980}
2981
2982// MockDesktopIntegration_SetAsDefaultBrowser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAsDefaultBrowser'
2983type MockDesktopIntegration_SetAsDefaultBrowser_Call struct {
2984	*mock.Call
2985}
2986
2987// SetAsDefaultBrowser is a helper method to define mock.On call
2988//   - ctx context.Context
2989func (_e *MockDesktopIntegration_Expecter) SetAsDefaultBrowser(ctx interface{}) *MockDesktopIntegration_SetAsDefaultBrowser_Call {
2990	return &MockDesktopIntegration_SetAsDefaultBrowser_Call{Call: _e.mock.On("SetAsDefaultBrowser", ctx)}
2991}
2992
2993func (_c *MockDesktopIntegration_SetAsDefaultBrowser_Call) Run(run func(ctx context.Context)) *MockDesktopIntegration_SetAsDefaultBrowser_Call {
2994	_c.Call.Run(func(args mock.Arguments) {
2995		var arg0 context.Context
2996		if args[0] != nil {
2997			arg0 = args[0].(context.Context)
2998		}
2999		run(
3000			arg0,
3001		)
3002	})
3003	return _c
3004}
3005
3006func (_c *MockDesktopIntegration_SetAsDefaultBrowser_Call) Return(err error) *MockDesktopIntegration_SetAsDefaultBrowser_Call {
3007	_c.Call.Return(err)
3008	return _c
3009}
3010
3011func (_c *MockDesktopIntegration_SetAsDefaultBrowser_Call) RunAndReturn(run func(ctx context.Context) error) *MockDesktopIntegration_SetAsDefaultBrowser_Call {
3012	_c.Call.Return(run)
3013	return _c
3014}
3015
3016// UnsetAsDefaultBrowser provides a mock function for the type MockDesktopIntegration
3017func (_mock *MockDesktopIntegration) UnsetAsDefaultBrowser(ctx context.Context) error {
3018	ret := _mock.Called(ctx)
3019
3020	if len(ret) == 0 {
3021		panic("no return value specified for UnsetAsDefaultBrowser")
3022	}
3023
3024	var r0 error
3025	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
3026		r0 = returnFunc(ctx)
3027	} else {
3028		r0 = ret.Error(0)
3029	}
3030	return r0
3031}
3032
3033// MockDesktopIntegration_UnsetAsDefaultBrowser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnsetAsDefaultBrowser'
3034type MockDesktopIntegration_UnsetAsDefaultBrowser_Call struct {
3035	*mock.Call
3036}
3037
3038// UnsetAsDefaultBrowser is a helper method to define mock.On call
3039//   - ctx context.Context
3040func (_e *MockDesktopIntegration_Expecter) UnsetAsDefaultBrowser(ctx interface{}) *MockDesktopIntegration_UnsetAsDefaultBrowser_Call {
3041	return &MockDesktopIntegration_UnsetAsDefaultBrowser_Call{Call: _e.mock.On("UnsetAsDefaultBrowser", ctx)}
3042}
3043
3044func (_c *MockDesktopIntegration_UnsetAsDefaultBrowser_Call) Run(run func(ctx context.Context)) *MockDesktopIntegration_UnsetAsDefaultBrowser_Call {
3045	_c.Call.Run(func(args mock.Arguments) {
3046		var arg0 context.Context
3047		if args[0] != nil {
3048			arg0 = args[0].(context.Context)
3049		}
3050		run(
3051			arg0,
3052		)
3053	})
3054	return _c
3055}
3056
3057func (_c *MockDesktopIntegration_UnsetAsDefaultBrowser_Call) Return(err error) *MockDesktopIntegration_UnsetAsDefaultBrowser_Call {
3058	_c.Call.Return(err)
3059	return _c
3060}
3061
3062func (_c *MockDesktopIntegration_UnsetAsDefaultBrowser_Call) RunAndReturn(run func(ctx context.Context) error) *MockDesktopIntegration_UnsetAsDefaultBrowser_Call {
3063	_c.Call.Return(run)
3064	return _c
3065}
3066
3067// NewMockDownloadEventHandler creates a new instance of MockDownloadEventHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3068// The first argument is typically a *testing.T value.
3069func NewMockDownloadEventHandler(t interface {
3070	mock.TestingT
3071	Cleanup(func())
3072}) *MockDownloadEventHandler {
3073	mock := &MockDownloadEventHandler{}
3074	mock.Mock.Test(t)
3075
3076	t.Cleanup(func() { mock.AssertExpectations(t) })
3077
3078	return mock
3079}
3080
3081// MockDownloadEventHandler is an autogenerated mock type for the DownloadEventHandler type
3082type MockDownloadEventHandler struct {
3083	mock.Mock
3084}
3085
3086type MockDownloadEventHandler_Expecter struct {
3087	mock *mock.Mock
3088}
3089
3090func (_m *MockDownloadEventHandler) EXPECT() *MockDownloadEventHandler_Expecter {
3091	return &MockDownloadEventHandler_Expecter{mock: &_m.Mock}
3092}
3093
3094// OnDownloadEvent provides a mock function for the type MockDownloadEventHandler
3095func (_mock *MockDownloadEventHandler) OnDownloadEvent(ctx context.Context, event port.DownloadEvent) {
3096	_mock.Called(ctx, event)
3097	return
3098}
3099
3100// MockDownloadEventHandler_OnDownloadEvent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnDownloadEvent'
3101type MockDownloadEventHandler_OnDownloadEvent_Call struct {
3102	*mock.Call
3103}
3104
3105// OnDownloadEvent is a helper method to define mock.On call
3106//   - ctx context.Context
3107//   - event port.DownloadEvent
3108func (_e *MockDownloadEventHandler_Expecter) OnDownloadEvent(ctx interface{}, event interface{}) *MockDownloadEventHandler_OnDownloadEvent_Call {
3109	return &MockDownloadEventHandler_OnDownloadEvent_Call{Call: _e.mock.On("OnDownloadEvent", ctx, event)}
3110}
3111
3112func (_c *MockDownloadEventHandler_OnDownloadEvent_Call) Run(run func(ctx context.Context, event port.DownloadEvent)) *MockDownloadEventHandler_OnDownloadEvent_Call {
3113	_c.Call.Run(func(args mock.Arguments) {
3114		var arg0 context.Context
3115		if args[0] != nil {
3116			arg0 = args[0].(context.Context)
3117		}
3118		var arg1 port.DownloadEvent
3119		if args[1] != nil {
3120			arg1 = args[1].(port.DownloadEvent)
3121		}
3122		run(
3123			arg0,
3124			arg1,
3125		)
3126	})
3127	return _c
3128}
3129
3130func (_c *MockDownloadEventHandler_OnDownloadEvent_Call) Return() *MockDownloadEventHandler_OnDownloadEvent_Call {
3131	_c.Call.Return()
3132	return _c
3133}
3134
3135func (_c *MockDownloadEventHandler_OnDownloadEvent_Call) RunAndReturn(run func(ctx context.Context, event port.DownloadEvent)) *MockDownloadEventHandler_OnDownloadEvent_Call {
3136	_c.Run(run)
3137	return _c
3138}
3139
3140// NewMockDownloadResponse creates a new instance of MockDownloadResponse. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3141// The first argument is typically a *testing.T value.
3142func NewMockDownloadResponse(t interface {
3143	mock.TestingT
3144	Cleanup(func())
3145}) *MockDownloadResponse {
3146	mock := &MockDownloadResponse{}
3147	mock.Mock.Test(t)
3148
3149	t.Cleanup(func() { mock.AssertExpectations(t) })
3150
3151	return mock
3152}
3153
3154// MockDownloadResponse is an autogenerated mock type for the DownloadResponse type
3155type MockDownloadResponse struct {
3156	mock.Mock
3157}
3158
3159type MockDownloadResponse_Expecter struct {
3160	mock *mock.Mock
3161}
3162
3163func (_m *MockDownloadResponse) EXPECT() *MockDownloadResponse_Expecter {
3164	return &MockDownloadResponse_Expecter{mock: &_m.Mock}
3165}
3166
3167// GetMimeType provides a mock function for the type MockDownloadResponse
3168func (_mock *MockDownloadResponse) GetMimeType() string {
3169	ret := _mock.Called()
3170
3171	if len(ret) == 0 {
3172		panic("no return value specified for GetMimeType")
3173	}
3174
3175	var r0 string
3176	if returnFunc, ok := ret.Get(0).(func() string); ok {
3177		r0 = returnFunc()
3178	} else {
3179		r0 = ret.Get(0).(string)
3180	}
3181	return r0
3182}
3183
3184// MockDownloadResponse_GetMimeType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMimeType'
3185type MockDownloadResponse_GetMimeType_Call struct {
3186	*mock.Call
3187}
3188
3189// GetMimeType is a helper method to define mock.On call
3190func (_e *MockDownloadResponse_Expecter) GetMimeType() *MockDownloadResponse_GetMimeType_Call {
3191	return &MockDownloadResponse_GetMimeType_Call{Call: _e.mock.On("GetMimeType")}
3192}
3193
3194func (_c *MockDownloadResponse_GetMimeType_Call) Run(run func()) *MockDownloadResponse_GetMimeType_Call {
3195	_c.Call.Run(func(args mock.Arguments) {
3196		run()
3197	})
3198	return _c
3199}
3200
3201func (_c *MockDownloadResponse_GetMimeType_Call) Return(s string) *MockDownloadResponse_GetMimeType_Call {
3202	_c.Call.Return(s)
3203	return _c
3204}
3205
3206func (_c *MockDownloadResponse_GetMimeType_Call) RunAndReturn(run func() string) *MockDownloadResponse_GetMimeType_Call {
3207	_c.Call.Return(run)
3208	return _c
3209}
3210
3211// GetSuggestedFilename provides a mock function for the type MockDownloadResponse
3212func (_mock *MockDownloadResponse) GetSuggestedFilename() string {
3213	ret := _mock.Called()
3214
3215	if len(ret) == 0 {
3216		panic("no return value specified for GetSuggestedFilename")
3217	}
3218
3219	var r0 string
3220	if returnFunc, ok := ret.Get(0).(func() string); ok {
3221		r0 = returnFunc()
3222	} else {
3223		r0 = ret.Get(0).(string)
3224	}
3225	return r0
3226}
3227
3228// MockDownloadResponse_GetSuggestedFilename_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSuggestedFilename'
3229type MockDownloadResponse_GetSuggestedFilename_Call struct {
3230	*mock.Call
3231}
3232
3233// GetSuggestedFilename is a helper method to define mock.On call
3234func (_e *MockDownloadResponse_Expecter) GetSuggestedFilename() *MockDownloadResponse_GetSuggestedFilename_Call {
3235	return &MockDownloadResponse_GetSuggestedFilename_Call{Call: _e.mock.On("GetSuggestedFilename")}
3236}
3237
3238func (_c *MockDownloadResponse_GetSuggestedFilename_Call) Run(run func()) *MockDownloadResponse_GetSuggestedFilename_Call {
3239	_c.Call.Run(func(args mock.Arguments) {
3240		run()
3241	})
3242	return _c
3243}
3244
3245func (_c *MockDownloadResponse_GetSuggestedFilename_Call) Return(s string) *MockDownloadResponse_GetSuggestedFilename_Call {
3246	_c.Call.Return(s)
3247	return _c
3248}
3249
3250func (_c *MockDownloadResponse_GetSuggestedFilename_Call) RunAndReturn(run func() string) *MockDownloadResponse_GetSuggestedFilename_Call {
3251	_c.Call.Return(run)
3252	return _c
3253}
3254
3255// GetUri provides a mock function for the type MockDownloadResponse
3256func (_mock *MockDownloadResponse) GetUri() string {
3257	ret := _mock.Called()
3258
3259	if len(ret) == 0 {
3260		panic("no return value specified for GetUri")
3261	}
3262
3263	var r0 string
3264	if returnFunc, ok := ret.Get(0).(func() string); ok {
3265		r0 = returnFunc()
3266	} else {
3267		r0 = ret.Get(0).(string)
3268	}
3269	return r0
3270}
3271
3272// MockDownloadResponse_GetUri_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUri'
3273type MockDownloadResponse_GetUri_Call struct {
3274	*mock.Call
3275}
3276
3277// GetUri is a helper method to define mock.On call
3278func (_e *MockDownloadResponse_Expecter) GetUri() *MockDownloadResponse_GetUri_Call {
3279	return &MockDownloadResponse_GetUri_Call{Call: _e.mock.On("GetUri")}
3280}
3281
3282func (_c *MockDownloadResponse_GetUri_Call) Run(run func()) *MockDownloadResponse_GetUri_Call {
3283	_c.Call.Run(func(args mock.Arguments) {
3284		run()
3285	})
3286	return _c
3287}
3288
3289func (_c *MockDownloadResponse_GetUri_Call) Return(s string) *MockDownloadResponse_GetUri_Call {
3290	_c.Call.Return(s)
3291	return _c
3292}
3293
3294func (_c *MockDownloadResponse_GetUri_Call) RunAndReturn(run func() string) *MockDownloadResponse_GetUri_Call {
3295	_c.Call.Return(run)
3296	return _c
3297}
3298
3299// NewMockMemoryPressureApplier creates a new instance of MockMemoryPressureApplier. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3300// The first argument is typically a *testing.T value.
3301func NewMockMemoryPressureApplier(t interface {
3302	mock.TestingT
3303	Cleanup(func())
3304}) *MockMemoryPressureApplier {
3305	mock := &MockMemoryPressureApplier{}
3306	mock.Mock.Test(t)
3307
3308	t.Cleanup(func() { mock.AssertExpectations(t) })
3309
3310	return mock
3311}
3312
3313// MockMemoryPressureApplier is an autogenerated mock type for the MemoryPressureApplier type
3314type MockMemoryPressureApplier struct {
3315	mock.Mock
3316}
3317
3318type MockMemoryPressureApplier_Expecter struct {
3319	mock *mock.Mock
3320}
3321
3322func (_m *MockMemoryPressureApplier) EXPECT() *MockMemoryPressureApplier_Expecter {
3323	return &MockMemoryPressureApplier_Expecter{mock: &_m.Mock}
3324}
3325
3326// ApplyNetworkProcessSettings provides a mock function for the type MockMemoryPressureApplier
3327func (_mock *MockMemoryPressureApplier) ApplyNetworkProcessSettings(ctx context.Context, cfg *port.MemoryPressureConfig) error {
3328	ret := _mock.Called(ctx, cfg)
3329
3330	if len(ret) == 0 {
3331		panic("no return value specified for ApplyNetworkProcessSettings")
3332	}
3333
3334	var r0 error
3335	if returnFunc, ok := ret.Get(0).(func(context.Context, *port.MemoryPressureConfig) error); ok {
3336		r0 = returnFunc(ctx, cfg)
3337	} else {
3338		r0 = ret.Error(0)
3339	}
3340	return r0
3341}
3342
3343// MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApplyNetworkProcessSettings'
3344type MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call struct {
3345	*mock.Call
3346}
3347
3348// ApplyNetworkProcessSettings is a helper method to define mock.On call
3349//   - ctx context.Context
3350//   - cfg *port.MemoryPressureConfig
3351func (_e *MockMemoryPressureApplier_Expecter) ApplyNetworkProcessSettings(ctx interface{}, cfg interface{}) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
3352	return &MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call{Call: _e.mock.On("ApplyNetworkProcessSettings", ctx, cfg)}
3353}
3354
3355func (_c *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call) Run(run func(ctx context.Context, cfg *port.MemoryPressureConfig)) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
3356	_c.Call.Run(func(args mock.Arguments) {
3357		var arg0 context.Context
3358		if args[0] != nil {
3359			arg0 = args[0].(context.Context)
3360		}
3361		var arg1 *port.MemoryPressureConfig
3362		if args[1] != nil {
3363			arg1 = args[1].(*port.MemoryPressureConfig)
3364		}
3365		run(
3366			arg0,
3367			arg1,
3368		)
3369	})
3370	return _c
3371}
3372
3373func (_c *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call) Return(err error) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
3374	_c.Call.Return(err)
3375	return _c
3376}
3377
3378func (_c *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call) RunAndReturn(run func(ctx context.Context, cfg *port.MemoryPressureConfig) error) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
3379	_c.Call.Return(run)
3380	return _c
3381}
3382
3383// ApplyWebProcessSettings provides a mock function for the type MockMemoryPressureApplier
3384func (_mock *MockMemoryPressureApplier) ApplyWebProcessSettings(ctx context.Context, cfg *port.MemoryPressureConfig) (any, error) {
3385	ret := _mock.Called(ctx, cfg)
3386
3387	if len(ret) == 0 {
3388		panic("no return value specified for ApplyWebProcessSettings")
3389	}
3390
3391	var r0 any
3392	var r1 error
3393	if returnFunc, ok := ret.Get(0).(func(context.Context, *port.MemoryPressureConfig) (any, error)); ok {
3394		return returnFunc(ctx, cfg)
3395	}
3396	if returnFunc, ok := ret.Get(0).(func(context.Context, *port.MemoryPressureConfig) any); ok {
3397		r0 = returnFunc(ctx, cfg)
3398	} else {
3399		if ret.Get(0) != nil {
3400			r0 = ret.Get(0).(any)
3401		}
3402	}
3403	if returnFunc, ok := ret.Get(1).(func(context.Context, *port.MemoryPressureConfig) error); ok {
3404		r1 = returnFunc(ctx, cfg)
3405	} else {
3406		r1 = ret.Error(1)
3407	}
3408	return r0, r1
3409}
3410
3411// MockMemoryPressureApplier_ApplyWebProcessSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApplyWebProcessSettings'
3412type MockMemoryPressureApplier_ApplyWebProcessSettings_Call struct {
3413	*mock.Call
3414}
3415
3416// ApplyWebProcessSettings is a helper method to define mock.On call
3417//   - ctx context.Context
3418//   - cfg *port.MemoryPressureConfig
3419func (_e *MockMemoryPressureApplier_Expecter) ApplyWebProcessSettings(ctx interface{}, cfg interface{}) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
3420	return &MockMemoryPressureApplier_ApplyWebProcessSettings_Call{Call: _e.mock.On("ApplyWebProcessSettings", ctx, cfg)}
3421}
3422
3423func (_c *MockMemoryPressureApplier_ApplyWebProcessSettings_Call) Run(run func(ctx context.Context, cfg *port.MemoryPressureConfig)) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
3424	_c.Call.Run(func(args mock.Arguments) {
3425		var arg0 context.Context
3426		if args[0] != nil {
3427			arg0 = args[0].(context.Context)
3428		}
3429		var arg1 *port.MemoryPressureConfig
3430		if args[1] != nil {
3431			arg1 = args[1].(*port.MemoryPressureConfig)
3432		}
3433		run(
3434			arg0,
3435			arg1,
3436		)
3437	})
3438	return _c
3439}
3440
3441func (_c *MockMemoryPressureApplier_ApplyWebProcessSettings_Call) Return(v any, err error) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
3442	_c.Call.Return(v, err)
3443	return _c
3444}
3445
3446func (_c *MockMemoryPressureApplier_ApplyWebProcessSettings_Call) RunAndReturn(run func(ctx context.Context, cfg *port.MemoryPressureConfig) (any, error)) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
3447	_c.Call.Return(run)
3448	return _c
3449}
3450
3451// NewMockEngine creates a new instance of MockEngine. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3452// The first argument is typically a *testing.T value.
3453func NewMockEngine(t interface {
3454	mock.TestingT
3455	Cleanup(func())
3456}) *MockEngine {
3457	mock := &MockEngine{}
3458	mock.Mock.Test(t)
3459
3460	t.Cleanup(func() { mock.AssertExpectations(t) })
3461
3462	return mock
3463}
3464
3465// MockEngine is an autogenerated mock type for the Engine type
3466type MockEngine struct {
3467	mock.Mock
3468}
3469
3470type MockEngine_Expecter struct {
3471	mock *mock.Mock
3472}
3473
3474func (_m *MockEngine) EXPECT() *MockEngine_Expecter {
3475	return &MockEngine_Expecter{mock: &_m.Mock}
3476}
3477
3478// Close provides a mock function for the type MockEngine
3479func (_mock *MockEngine) Close() error {
3480	ret := _mock.Called()
3481
3482	if len(ret) == 0 {
3483		panic("no return value specified for Close")
3484	}
3485
3486	var r0 error
3487	if returnFunc, ok := ret.Get(0).(func() error); ok {
3488		r0 = returnFunc()
3489	} else {
3490		r0 = ret.Error(0)
3491	}
3492	return r0
3493}
3494
3495// MockEngine_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
3496type MockEngine_Close_Call struct {
3497	*mock.Call
3498}
3499
3500// Close is a helper method to define mock.On call
3501func (_e *MockEngine_Expecter) Close() *MockEngine_Close_Call {
3502	return &MockEngine_Close_Call{Call: _e.mock.On("Close")}
3503}
3504
3505func (_c *MockEngine_Close_Call) Run(run func()) *MockEngine_Close_Call {
3506	_c.Call.Run(func(args mock.Arguments) {
3507		run()
3508	})
3509	return _c
3510}
3511
3512func (_c *MockEngine_Close_Call) Return(err error) *MockEngine_Close_Call {
3513	_c.Call.Return(err)
3514	return _c
3515}
3516
3517func (_c *MockEngine_Close_Call) RunAndReturn(run func() error) *MockEngine_Close_Call {
3518	_c.Call.Return(run)
3519	return _c
3520}
3521
3522// ConfigureDownloads provides a mock function for the type MockEngine
3523func (_mock *MockEngine) ConfigureDownloads(ctx context.Context, downloadPath string, eventHandler port.DownloadEventHandler, preparer port.DownloadPreparer) error {
3524	ret := _mock.Called(ctx, downloadPath, eventHandler, preparer)
3525
3526	if len(ret) == 0 {
3527		panic("no return value specified for ConfigureDownloads")
3528	}
3529
3530	var r0 error
3531	if returnFunc, ok := ret.Get(0).(func(context.Context, string, port.DownloadEventHandler, port.DownloadPreparer) error); ok {
3532		r0 = returnFunc(ctx, downloadPath, eventHandler, preparer)
3533	} else {
3534		r0 = ret.Error(0)
3535	}
3536	return r0
3537}
3538
3539// MockEngine_ConfigureDownloads_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigureDownloads'
3540type MockEngine_ConfigureDownloads_Call struct {
3541	*mock.Call
3542}
3543
3544// ConfigureDownloads is a helper method to define mock.On call
3545//   - ctx context.Context
3546//   - downloadPath string
3547//   - eventHandler port.DownloadEventHandler
3548//   - preparer port.DownloadPreparer
3549func (_e *MockEngine_Expecter) ConfigureDownloads(ctx interface{}, downloadPath interface{}, eventHandler interface{}, preparer interface{}) *MockEngine_ConfigureDownloads_Call {
3550	return &MockEngine_ConfigureDownloads_Call{Call: _e.mock.On("ConfigureDownloads", ctx, downloadPath, eventHandler, preparer)}
3551}
3552
3553func (_c *MockEngine_ConfigureDownloads_Call) Run(run func(ctx context.Context, downloadPath string, eventHandler port.DownloadEventHandler, preparer port.DownloadPreparer)) *MockEngine_ConfigureDownloads_Call {
3554	_c.Call.Run(func(args mock.Arguments) {
3555		var arg0 context.Context
3556		if args[0] != nil {
3557			arg0 = args[0].(context.Context)
3558		}
3559		var arg1 string
3560		if args[1] != nil {
3561			arg1 = args[1].(string)
3562		}
3563		var arg2 port.DownloadEventHandler
3564		if args[2] != nil {
3565			arg2 = args[2].(port.DownloadEventHandler)
3566		}
3567		var arg3 port.DownloadPreparer
3568		if args[3] != nil {
3569			arg3 = args[3].(port.DownloadPreparer)
3570		}
3571		run(
3572			arg0,
3573			arg1,
3574			arg2,
3575			arg3,
3576		)
3577	})
3578	return _c
3579}
3580
3581func (_c *MockEngine_ConfigureDownloads_Call) Return(err error) *MockEngine_ConfigureDownloads_Call {
3582	_c.Call.Return(err)
3583	return _c
3584}
3585
3586func (_c *MockEngine_ConfigureDownloads_Call) RunAndReturn(run func(ctx context.Context, downloadPath string, eventHandler port.DownloadEventHandler, preparer port.DownloadPreparer) error) *MockEngine_ConfigureDownloads_Call {
3587	_c.Call.Return(run)
3588	return _c
3589}
3590
3591// ContentInjector provides a mock function for the type MockEngine
3592func (_mock *MockEngine) ContentInjector() port.ContentInjector {
3593	ret := _mock.Called()
3594
3595	if len(ret) == 0 {
3596		panic("no return value specified for ContentInjector")
3597	}
3598
3599	var r0 port.ContentInjector
3600	if returnFunc, ok := ret.Get(0).(func() port.ContentInjector); ok {
3601		r0 = returnFunc()
3602	} else {
3603		if ret.Get(0) != nil {
3604			r0 = ret.Get(0).(port.ContentInjector)
3605		}
3606	}
3607	return r0
3608}
3609
3610// MockEngine_ContentInjector_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContentInjector'
3611type MockEngine_ContentInjector_Call struct {
3612	*mock.Call
3613}
3614
3615// ContentInjector is a helper method to define mock.On call
3616func (_e *MockEngine_Expecter) ContentInjector() *MockEngine_ContentInjector_Call {
3617	return &MockEngine_ContentInjector_Call{Call: _e.mock.On("ContentInjector")}
3618}
3619
3620func (_c *MockEngine_ContentInjector_Call) Run(run func()) *MockEngine_ContentInjector_Call {
3621	_c.Call.Run(func(args mock.Arguments) {
3622		run()
3623	})
3624	return _c
3625}
3626
3627func (_c *MockEngine_ContentInjector_Call) Return(contentInjector port.ContentInjector) *MockEngine_ContentInjector_Call {
3628	_c.Call.Return(contentInjector)
3629	return _c
3630}
3631
3632func (_c *MockEngine_ContentInjector_Call) RunAndReturn(run func() port.ContentInjector) *MockEngine_ContentInjector_Call {
3633	_c.Call.Return(run)
3634	return _c
3635}
3636
3637// Factory provides a mock function for the type MockEngine
3638func (_mock *MockEngine) Factory() port.WebViewFactory {
3639	ret := _mock.Called()
3640
3641	if len(ret) == 0 {
3642		panic("no return value specified for Factory")
3643	}
3644
3645	var r0 port.WebViewFactory
3646	if returnFunc, ok := ret.Get(0).(func() port.WebViewFactory); ok {
3647		r0 = returnFunc()
3648	} else {
3649		if ret.Get(0) != nil {
3650			r0 = ret.Get(0).(port.WebViewFactory)
3651		}
3652	}
3653	return r0
3654}
3655
3656// MockEngine_Factory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Factory'
3657type MockEngine_Factory_Call struct {
3658	*mock.Call
3659}
3660
3661// Factory is a helper method to define mock.On call
3662func (_e *MockEngine_Expecter) Factory() *MockEngine_Factory_Call {
3663	return &MockEngine_Factory_Call{Call: _e.mock.On("Factory")}
3664}
3665
3666func (_c *MockEngine_Factory_Call) Run(run func()) *MockEngine_Factory_Call {
3667	_c.Call.Run(func(args mock.Arguments) {
3668		run()
3669	})
3670	return _c
3671}
3672
3673func (_c *MockEngine_Factory_Call) Return(webViewFactory port.WebViewFactory) *MockEngine_Factory_Call {
3674	_c.Call.Return(webViewFactory)
3675	return _c
3676}
3677
3678func (_c *MockEngine_Factory_Call) RunAndReturn(run func() port.WebViewFactory) *MockEngine_Factory_Call {
3679	_c.Call.Return(run)
3680	return _c
3681}
3682
3683// FaviconDatabase provides a mock function for the type MockEngine
3684func (_mock *MockEngine) FaviconDatabase() port.FaviconDatabase {
3685	ret := _mock.Called()
3686
3687	if len(ret) == 0 {
3688		panic("no return value specified for FaviconDatabase")
3689	}
3690
3691	var r0 port.FaviconDatabase
3692	if returnFunc, ok := ret.Get(0).(func() port.FaviconDatabase); ok {
3693		r0 = returnFunc()
3694	} else {
3695		if ret.Get(0) != nil {
3696			r0 = ret.Get(0).(port.FaviconDatabase)
3697		}
3698	}
3699	return r0
3700}
3701
3702// MockEngine_FaviconDatabase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FaviconDatabase'
3703type MockEngine_FaviconDatabase_Call struct {
3704	*mock.Call
3705}
3706
3707// FaviconDatabase is a helper method to define mock.On call
3708func (_e *MockEngine_Expecter) FaviconDatabase() *MockEngine_FaviconDatabase_Call {
3709	return &MockEngine_FaviconDatabase_Call{Call: _e.mock.On("FaviconDatabase")}
3710}
3711
3712func (_c *MockEngine_FaviconDatabase_Call) Run(run func()) *MockEngine_FaviconDatabase_Call {
3713	_c.Call.Run(func(args mock.Arguments) {
3714		run()
3715	})
3716	return _c
3717}
3718
3719func (_c *MockEngine_FaviconDatabase_Call) Return(faviconDatabase port.FaviconDatabase) *MockEngine_FaviconDatabase_Call {
3720	_c.Call.Return(faviconDatabase)
3721	return _c
3722}
3723
3724func (_c *MockEngine_FaviconDatabase_Call) RunAndReturn(run func() port.FaviconDatabase) *MockEngine_FaviconDatabase_Call {
3725	_c.Call.Return(run)
3726	return _c
3727}
3728
3729// FilterApplier provides a mock function for the type MockEngine
3730func (_mock *MockEngine) FilterApplier() port.FilterApplier {
3731	ret := _mock.Called()
3732
3733	if len(ret) == 0 {
3734		panic("no return value specified for FilterApplier")
3735	}
3736
3737	var r0 port.FilterApplier
3738	if returnFunc, ok := ret.Get(0).(func() port.FilterApplier); ok {
3739		r0 = returnFunc()
3740	} else {
3741		if ret.Get(0) != nil {
3742			r0 = ret.Get(0).(port.FilterApplier)
3743		}
3744	}
3745	return r0
3746}
3747
3748// MockEngine_FilterApplier_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FilterApplier'
3749type MockEngine_FilterApplier_Call struct {
3750	*mock.Call
3751}
3752
3753// FilterApplier is a helper method to define mock.On call
3754func (_e *MockEngine_Expecter) FilterApplier() *MockEngine_FilterApplier_Call {
3755	return &MockEngine_FilterApplier_Call{Call: _e.mock.On("FilterApplier")}
3756}
3757
3758func (_c *MockEngine_FilterApplier_Call) Run(run func()) *MockEngine_FilterApplier_Call {
3759	_c.Call.Run(func(args mock.Arguments) {
3760		run()
3761	})
3762	return _c
3763}
3764
3765func (_c *MockEngine_FilterApplier_Call) Return(filterApplier port.FilterApplier) *MockEngine_FilterApplier_Call {
3766	_c.Call.Return(filterApplier)
3767	return _c
3768}
3769
3770func (_c *MockEngine_FilterApplier_Call) RunAndReturn(run func() port.FilterApplier) *MockEngine_FilterApplier_Call {
3771	_c.Call.Return(run)
3772	return _c
3773}
3774
3775// InternalSchemePath provides a mock function for the type MockEngine
3776func (_mock *MockEngine) InternalSchemePath() string {
3777	ret := _mock.Called()
3778
3779	if len(ret) == 0 {
3780		panic("no return value specified for InternalSchemePath")
3781	}
3782
3783	var r0 string
3784	if returnFunc, ok := ret.Get(0).(func() string); ok {
3785		r0 = returnFunc()
3786	} else {
3787		r0 = ret.Get(0).(string)
3788	}
3789	return r0
3790}
3791
3792// MockEngine_InternalSchemePath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InternalSchemePath'
3793type MockEngine_InternalSchemePath_Call struct {
3794	*mock.Call
3795}
3796
3797// InternalSchemePath is a helper method to define mock.On call
3798func (_e *MockEngine_Expecter) InternalSchemePath() *MockEngine_InternalSchemePath_Call {
3799	return &MockEngine_InternalSchemePath_Call{Call: _e.mock.On("InternalSchemePath")}
3800}
3801
3802func (_c *MockEngine_InternalSchemePath_Call) Run(run func()) *MockEngine_InternalSchemePath_Call {
3803	_c.Call.Run(func(args mock.Arguments) {
3804		run()
3805	})
3806	return _c
3807}
3808
3809func (_c *MockEngine_InternalSchemePath_Call) Return(s string) *MockEngine_InternalSchemePath_Call {
3810	_c.Call.Return(s)
3811	return _c
3812}
3813
3814func (_c *MockEngine_InternalSchemePath_Call) RunAndReturn(run func() string) *MockEngine_InternalSchemePath_Call {
3815	_c.Call.Return(run)
3816	return _c
3817}
3818
3819// OnToolkitReady provides a mock function for the type MockEngine
3820func (_mock *MockEngine) OnToolkitReady(ctx context.Context) error {
3821	ret := _mock.Called(ctx)
3822
3823	if len(ret) == 0 {
3824		panic("no return value specified for OnToolkitReady")
3825	}
3826
3827	var r0 error
3828	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
3829		r0 = returnFunc(ctx)
3830	} else {
3831		r0 = ret.Error(0)
3832	}
3833	return r0
3834}
3835
3836// MockEngine_OnToolkitReady_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnToolkitReady'
3837type MockEngine_OnToolkitReady_Call struct {
3838	*mock.Call
3839}
3840
3841// OnToolkitReady is a helper method to define mock.On call
3842//   - ctx context.Context
3843func (_e *MockEngine_Expecter) OnToolkitReady(ctx interface{}) *MockEngine_OnToolkitReady_Call {
3844	return &MockEngine_OnToolkitReady_Call{Call: _e.mock.On("OnToolkitReady", ctx)}
3845}
3846
3847func (_c *MockEngine_OnToolkitReady_Call) Run(run func(ctx context.Context)) *MockEngine_OnToolkitReady_Call {
3848	_c.Call.Run(func(args mock.Arguments) {
3849		var arg0 context.Context
3850		if args[0] != nil {
3851			arg0 = args[0].(context.Context)
3852		}
3853		run(
3854			arg0,
3855		)
3856	})
3857	return _c
3858}
3859
3860func (_c *MockEngine_OnToolkitReady_Call) Return(err error) *MockEngine_OnToolkitReady_Call {
3861	_c.Call.Return(err)
3862	return _c
3863}
3864
3865func (_c *MockEngine_OnToolkitReady_Call) RunAndReturn(run func(ctx context.Context) error) *MockEngine_OnToolkitReady_Call {
3866	_c.Call.Return(run)
3867	return _c
3868}
3869
3870// Pool provides a mock function for the type MockEngine
3871func (_mock *MockEngine) Pool() port.WebViewPool {
3872	ret := _mock.Called()
3873
3874	if len(ret) == 0 {
3875		panic("no return value specified for Pool")
3876	}
3877
3878	var r0 port.WebViewPool
3879	if returnFunc, ok := ret.Get(0).(func() port.WebViewPool); ok {
3880		r0 = returnFunc()
3881	} else {
3882		if ret.Get(0) != nil {
3883			r0 = ret.Get(0).(port.WebViewPool)
3884		}
3885	}
3886	return r0
3887}
3888
3889// MockEngine_Pool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Pool'
3890type MockEngine_Pool_Call struct {
3891	*mock.Call
3892}
3893
3894// Pool is a helper method to define mock.On call
3895func (_e *MockEngine_Expecter) Pool() *MockEngine_Pool_Call {
3896	return &MockEngine_Pool_Call{Call: _e.mock.On("Pool")}
3897}
3898
3899func (_c *MockEngine_Pool_Call) Run(run func()) *MockEngine_Pool_Call {
3900	_c.Call.Run(func(args mock.Arguments) {
3901		run()
3902	})
3903	return _c
3904}
3905
3906func (_c *MockEngine_Pool_Call) Return(webViewPool port.WebViewPool) *MockEngine_Pool_Call {
3907	_c.Call.Return(webViewPool)
3908	return _c
3909}
3910
3911func (_c *MockEngine_Pool_Call) RunAndReturn(run func() port.WebViewPool) *MockEngine_Pool_Call {
3912	_c.Call.Return(run)
3913	return _c
3914}
3915
3916// RegisterAccentHandlers provides a mock function for the type MockEngine
3917func (_mock *MockEngine) RegisterAccentHandlers(ctx context.Context, handler port.AccentKeyHandler) error {
3918	ret := _mock.Called(ctx, handler)
3919
3920	if len(ret) == 0 {
3921		panic("no return value specified for RegisterAccentHandlers")
3922	}
3923
3924	var r0 error
3925	if returnFunc, ok := ret.Get(0).(func(context.Context, port.AccentKeyHandler) error); ok {
3926		r0 = returnFunc(ctx, handler)
3927	} else {
3928		r0 = ret.Error(0)
3929	}
3930	return r0
3931}
3932
3933// MockEngine_RegisterAccentHandlers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAccentHandlers'
3934type MockEngine_RegisterAccentHandlers_Call struct {
3935	*mock.Call
3936}
3937
3938// RegisterAccentHandlers is a helper method to define mock.On call
3939//   - ctx context.Context
3940//   - handler port.AccentKeyHandler
3941func (_e *MockEngine_Expecter) RegisterAccentHandlers(ctx interface{}, handler interface{}) *MockEngine_RegisterAccentHandlers_Call {
3942	return &MockEngine_RegisterAccentHandlers_Call{Call: _e.mock.On("RegisterAccentHandlers", ctx, handler)}
3943}
3944
3945func (_c *MockEngine_RegisterAccentHandlers_Call) Run(run func(ctx context.Context, handler port.AccentKeyHandler)) *MockEngine_RegisterAccentHandlers_Call {
3946	_c.Call.Run(func(args mock.Arguments) {
3947		var arg0 context.Context
3948		if args[0] != nil {
3949			arg0 = args[0].(context.Context)
3950		}
3951		var arg1 port.AccentKeyHandler
3952		if args[1] != nil {
3953			arg1 = args[1].(port.AccentKeyHandler)
3954		}
3955		run(
3956			arg0,
3957			arg1,
3958		)
3959	})
3960	return _c
3961}
3962
3963func (_c *MockEngine_RegisterAccentHandlers_Call) Return(err error) *MockEngine_RegisterAccentHandlers_Call {
3964	_c.Call.Return(err)
3965	return _c
3966}
3967
3968func (_c *MockEngine_RegisterAccentHandlers_Call) RunAndReturn(run func(ctx context.Context, handler port.AccentKeyHandler) error) *MockEngine_RegisterAccentHandlers_Call {
3969	_c.Call.Return(run)
3970	return _c
3971}
3972
3973// RegisterHandlers provides a mock function for the type MockEngine
3974func (_mock *MockEngine) RegisterHandlers(ctx context.Context, deps port.HandlerDependencies) error {
3975	ret := _mock.Called(ctx, deps)
3976
3977	if len(ret) == 0 {
3978		panic("no return value specified for RegisterHandlers")
3979	}
3980
3981	var r0 error
3982	if returnFunc, ok := ret.Get(0).(func(context.Context, port.HandlerDependencies) error); ok {
3983		r0 = returnFunc(ctx, deps)
3984	} else {
3985		r0 = ret.Error(0)
3986	}
3987	return r0
3988}
3989
3990// MockEngine_RegisterHandlers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterHandlers'
3991type MockEngine_RegisterHandlers_Call struct {
3992	*mock.Call
3993}
3994
3995// RegisterHandlers is a helper method to define mock.On call
3996//   - ctx context.Context
3997//   - deps port.HandlerDependencies
3998func (_e *MockEngine_Expecter) RegisterHandlers(ctx interface{}, deps interface{}) *MockEngine_RegisterHandlers_Call {
3999	return &MockEngine_RegisterHandlers_Call{Call: _e.mock.On("RegisterHandlers", ctx, deps)}
4000}
4001
4002func (_c *MockEngine_RegisterHandlers_Call) Run(run func(ctx context.Context, deps port.HandlerDependencies)) *MockEngine_RegisterHandlers_Call {
4003	_c.Call.Run(func(args mock.Arguments) {
4004		var arg0 context.Context
4005		if args[0] != nil {
4006			arg0 = args[0].(context.Context)
4007		}
4008		var arg1 port.HandlerDependencies
4009		if args[1] != nil {
4010			arg1 = args[1].(port.HandlerDependencies)
4011		}
4012		run(
4013			arg0,
4014			arg1,
4015		)
4016	})
4017	return _c
4018}
4019
4020func (_c *MockEngine_RegisterHandlers_Call) Return(err error) *MockEngine_RegisterHandlers_Call {
4021	_c.Call.Return(err)
4022	return _c
4023}
4024
4025func (_c *MockEngine_RegisterHandlers_Call) RunAndReturn(run func(ctx context.Context, deps port.HandlerDependencies) error) *MockEngine_RegisterHandlers_Call {
4026	_c.Call.Return(run)
4027	return _c
4028}
4029
4030// SetHandlerContext provides a mock function for the type MockEngine
4031func (_mock *MockEngine) SetHandlerContext(ctx context.Context) {
4032	_mock.Called(ctx)
4033	return
4034}
4035
4036// MockEngine_SetHandlerContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHandlerContext'
4037type MockEngine_SetHandlerContext_Call struct {
4038	*mock.Call
4039}
4040
4041// SetHandlerContext is a helper method to define mock.On call
4042//   - ctx context.Context
4043func (_e *MockEngine_Expecter) SetHandlerContext(ctx interface{}) *MockEngine_SetHandlerContext_Call {
4044	return &MockEngine_SetHandlerContext_Call{Call: _e.mock.On("SetHandlerContext", ctx)}
4045}
4046
4047func (_c *MockEngine_SetHandlerContext_Call) Run(run func(ctx context.Context)) *MockEngine_SetHandlerContext_Call {
4048	_c.Call.Run(func(args mock.Arguments) {
4049		var arg0 context.Context
4050		if args[0] != nil {
4051			arg0 = args[0].(context.Context)
4052		}
4053		run(
4054			arg0,
4055		)
4056	})
4057	return _c
4058}
4059
4060func (_c *MockEngine_SetHandlerContext_Call) Return() *MockEngine_SetHandlerContext_Call {
4061	_c.Call.Return()
4062	return _c
4063}
4064
4065func (_c *MockEngine_SetHandlerContext_Call) RunAndReturn(run func(ctx context.Context)) *MockEngine_SetHandlerContext_Call {
4066	_c.Run(run)
4067	return _c
4068}
4069
4070// SettingsApplier provides a mock function for the type MockEngine
4071func (_mock *MockEngine) SettingsApplier() port.SettingsApplier {
4072	ret := _mock.Called()
4073
4074	if len(ret) == 0 {
4075		panic("no return value specified for SettingsApplier")
4076	}
4077
4078	var r0 port.SettingsApplier
4079	if returnFunc, ok := ret.Get(0).(func() port.SettingsApplier); ok {
4080		r0 = returnFunc()
4081	} else {
4082		if ret.Get(0) != nil {
4083			r0 = ret.Get(0).(port.SettingsApplier)
4084		}
4085	}
4086	return r0
4087}
4088
4089// MockEngine_SettingsApplier_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SettingsApplier'
4090type MockEngine_SettingsApplier_Call struct {
4091	*mock.Call
4092}
4093
4094// SettingsApplier is a helper method to define mock.On call
4095func (_e *MockEngine_Expecter) SettingsApplier() *MockEngine_SettingsApplier_Call {
4096	return &MockEngine_SettingsApplier_Call{Call: _e.mock.On("SettingsApplier")}
4097}
4098
4099func (_c *MockEngine_SettingsApplier_Call) Run(run func()) *MockEngine_SettingsApplier_Call {
4100	_c.Call.Run(func(args mock.Arguments) {
4101		run()
4102	})
4103	return _c
4104}
4105
4106func (_c *MockEngine_SettingsApplier_Call) Return(settingsApplier port.SettingsApplier) *MockEngine_SettingsApplier_Call {
4107	_c.Call.Return(settingsApplier)
4108	return _c
4109}
4110
4111func (_c *MockEngine_SettingsApplier_Call) RunAndReturn(run func() port.SettingsApplier) *MockEngine_SettingsApplier_Call {
4112	_c.Call.Return(run)
4113	return _c
4114}
4115
4116// UpdateAppearance provides a mock function for the type MockEngine
4117func (_mock *MockEngine) UpdateAppearance(ctx context.Context, r float64, g float64, b float64, alpha float64) error {
4118	ret := _mock.Called(ctx, r, g, b, alpha)
4119
4120	if len(ret) == 0 {
4121		panic("no return value specified for UpdateAppearance")
4122	}
4123
4124	var r0 error
4125	if returnFunc, ok := ret.Get(0).(func(context.Context, float64, float64, float64, float64) error); ok {
4126		r0 = returnFunc(ctx, r, g, b, alpha)
4127	} else {
4128		r0 = ret.Error(0)
4129	}
4130	return r0
4131}
4132
4133// MockEngine_UpdateAppearance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAppearance'
4134type MockEngine_UpdateAppearance_Call struct {
4135	*mock.Call
4136}
4137
4138// UpdateAppearance is a helper method to define mock.On call
4139//   - ctx context.Context
4140//   - r float64
4141//   - g float64
4142//   - b float64
4143//   - alpha float64
4144func (_e *MockEngine_Expecter) UpdateAppearance(ctx interface{}, r interface{}, g interface{}, b interface{}, alpha interface{}) *MockEngine_UpdateAppearance_Call {
4145	return &MockEngine_UpdateAppearance_Call{Call: _e.mock.On("UpdateAppearance", ctx, r, g, b, alpha)}
4146}
4147
4148func (_c *MockEngine_UpdateAppearance_Call) Run(run func(ctx context.Context, r float64, g float64, b float64, alpha float64)) *MockEngine_UpdateAppearance_Call {
4149	_c.Call.Run(func(args mock.Arguments) {
4150		var arg0 context.Context
4151		if args[0] != nil {
4152			arg0 = args[0].(context.Context)
4153		}
4154		var arg1 float64
4155		if args[1] != nil {
4156			arg1 = args[1].(float64)
4157		}
4158		var arg2 float64
4159		if args[2] != nil {
4160			arg2 = args[2].(float64)
4161		}
4162		var arg3 float64
4163		if args[3] != nil {
4164			arg3 = args[3].(float64)
4165		}
4166		var arg4 float64
4167		if args[4] != nil {
4168			arg4 = args[4].(float64)
4169		}
4170		run(
4171			arg0,
4172			arg1,
4173			arg2,
4174			arg3,
4175			arg4,
4176		)
4177	})
4178	return _c
4179}
4180
4181func (_c *MockEngine_UpdateAppearance_Call) Return(err error) *MockEngine_UpdateAppearance_Call {
4182	_c.Call.Return(err)
4183	return _c
4184}
4185
4186func (_c *MockEngine_UpdateAppearance_Call) RunAndReturn(run func(ctx context.Context, r float64, g float64, b float64, alpha float64) error) *MockEngine_UpdateAppearance_Call {
4187	_c.Call.Return(run)
4188	return _c
4189}
4190
4191// UpdateSettings provides a mock function for the type MockEngine
4192func (_mock *MockEngine) UpdateSettings(ctx context.Context, update port.EngineSettingsUpdate) error {
4193	ret := _mock.Called(ctx, update)
4194
4195	if len(ret) == 0 {
4196		panic("no return value specified for UpdateSettings")
4197	}
4198
4199	var r0 error
4200	if returnFunc, ok := ret.Get(0).(func(context.Context, port.EngineSettingsUpdate) error); ok {
4201		r0 = returnFunc(ctx, update)
4202	} else {
4203		r0 = ret.Error(0)
4204	}
4205	return r0
4206}
4207
4208// MockEngine_UpdateSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSettings'
4209type MockEngine_UpdateSettings_Call struct {
4210	*mock.Call
4211}
4212
4213// UpdateSettings is a helper method to define mock.On call
4214//   - ctx context.Context
4215//   - update port.EngineSettingsUpdate
4216func (_e *MockEngine_Expecter) UpdateSettings(ctx interface{}, update interface{}) *MockEngine_UpdateSettings_Call {
4217	return &MockEngine_UpdateSettings_Call{Call: _e.mock.On("UpdateSettings", ctx, update)}
4218}
4219
4220func (_c *MockEngine_UpdateSettings_Call) Run(run func(ctx context.Context, update port.EngineSettingsUpdate)) *MockEngine_UpdateSettings_Call {
4221	_c.Call.Run(func(args mock.Arguments) {
4222		var arg0 context.Context
4223		if args[0] != nil {
4224			arg0 = args[0].(context.Context)
4225		}
4226		var arg1 port.EngineSettingsUpdate
4227		if args[1] != nil {
4228			arg1 = args[1].(port.EngineSettingsUpdate)
4229		}
4230		run(
4231			arg0,
4232			arg1,
4233		)
4234	})
4235	return _c
4236}
4237
4238func (_c *MockEngine_UpdateSettings_Call) Return(err error) *MockEngine_UpdateSettings_Call {
4239	_c.Call.Return(err)
4240	return _c
4241}
4242
4243func (_c *MockEngine_UpdateSettings_Call) RunAndReturn(run func(ctx context.Context, update port.EngineSettingsUpdate) error) *MockEngine_UpdateSettings_Call {
4244	_c.Call.Return(run)
4245	return _c
4246}
4247
4248// NewMockWebUIMessageHandler creates a new instance of MockWebUIMessageHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
4249// The first argument is typically a *testing.T value.
4250func NewMockWebUIMessageHandler(t interface {
4251	mock.TestingT
4252	Cleanup(func())
4253}) *MockWebUIMessageHandler {
4254	mock := &MockWebUIMessageHandler{}
4255	mock.Mock.Test(t)
4256
4257	t.Cleanup(func() { mock.AssertExpectations(t) })
4258
4259	return mock
4260}
4261
4262// MockWebUIMessageHandler is an autogenerated mock type for the WebUIMessageHandler type
4263type MockWebUIMessageHandler struct {
4264	mock.Mock
4265}
4266
4267type MockWebUIMessageHandler_Expecter struct {
4268	mock *mock.Mock
4269}
4270
4271func (_m *MockWebUIMessageHandler) EXPECT() *MockWebUIMessageHandler_Expecter {
4272	return &MockWebUIMessageHandler_Expecter{mock: &_m.Mock}
4273}
4274
4275// Handle provides a mock function for the type MockWebUIMessageHandler
4276func (_mock *MockWebUIMessageHandler) Handle(ctx context.Context, webviewID port.WebViewID, payload json.RawMessage) (any, error) {
4277	ret := _mock.Called(ctx, webviewID, payload)
4278
4279	if len(ret) == 0 {
4280		panic("no return value specified for Handle")
4281	}
4282
4283	var r0 any
4284	var r1 error
4285	if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID, json.RawMessage) (any, error)); ok {
4286		return returnFunc(ctx, webviewID, payload)
4287	}
4288	if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID, json.RawMessage) any); ok {
4289		r0 = returnFunc(ctx, webviewID, payload)
4290	} else {
4291		if ret.Get(0) != nil {
4292			r0 = ret.Get(0).(any)
4293		}
4294	}
4295	if returnFunc, ok := ret.Get(1).(func(context.Context, port.WebViewID, json.RawMessage) error); ok {
4296		r1 = returnFunc(ctx, webviewID, payload)
4297	} else {
4298		r1 = ret.Error(1)
4299	}
4300	return r0, r1
4301}
4302
4303// MockWebUIMessageHandler_Handle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Handle'
4304type MockWebUIMessageHandler_Handle_Call struct {
4305	*mock.Call
4306}
4307
4308// Handle is a helper method to define mock.On call
4309//   - ctx context.Context
4310//   - webviewID port.WebViewID
4311//   - payload json.RawMessage
4312func (_e *MockWebUIMessageHandler_Expecter) Handle(ctx interface{}, webviewID interface{}, payload interface{}) *MockWebUIMessageHandler_Handle_Call {
4313	return &MockWebUIMessageHandler_Handle_Call{Call: _e.mock.On("Handle", ctx, webviewID, payload)}
4314}
4315
4316func (_c *MockWebUIMessageHandler_Handle_Call) Run(run func(ctx context.Context, webviewID port.WebViewID, payload json.RawMessage)) *MockWebUIMessageHandler_Handle_Call {
4317	_c.Call.Run(func(args mock.Arguments) {
4318		var arg0 context.Context
4319		if args[0] != nil {
4320			arg0 = args[0].(context.Context)
4321		}
4322		var arg1 port.WebViewID
4323		if args[1] != nil {
4324			arg1 = args[1].(port.WebViewID)
4325		}
4326		var arg2 json.RawMessage
4327		if args[2] != nil {
4328			arg2 = args[2].(json.RawMessage)
4329		}
4330		run(
4331			arg0,
4332			arg1,
4333			arg2,
4334		)
4335	})
4336	return _c
4337}
4338
4339func (_c *MockWebUIMessageHandler_Handle_Call) Return(v any, err error) *MockWebUIMessageHandler_Handle_Call {
4340	_c.Call.Return(v, err)
4341	return _c
4342}
4343
4344func (_c *MockWebUIMessageHandler_Handle_Call) RunAndReturn(run func(ctx context.Context, webviewID port.WebViewID, payload json.RawMessage) (any, error)) *MockWebUIMessageHandler_Handle_Call {
4345	_c.Call.Return(run)
4346	return _c
4347}
4348
4349// NewMockWebUIHandlerRouter creates a new instance of MockWebUIHandlerRouter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
4350// The first argument is typically a *testing.T value.
4351func NewMockWebUIHandlerRouter(t interface {
4352	mock.TestingT
4353	Cleanup(func())
4354}) *MockWebUIHandlerRouter {
4355	mock := &MockWebUIHandlerRouter{}
4356	mock.Mock.Test(t)
4357
4358	t.Cleanup(func() { mock.AssertExpectations(t) })
4359
4360	return mock
4361}
4362
4363// MockWebUIHandlerRouter is an autogenerated mock type for the WebUIHandlerRouter type
4364type MockWebUIHandlerRouter struct {
4365	mock.Mock
4366}
4367
4368type MockWebUIHandlerRouter_Expecter struct {
4369	mock *mock.Mock
4370}
4371
4372func (_m *MockWebUIHandlerRouter) EXPECT() *MockWebUIHandlerRouter_Expecter {
4373	return &MockWebUIHandlerRouter_Expecter{mock: &_m.Mock}
4374}
4375
4376// RegisterHandler provides a mock function for the type MockWebUIHandlerRouter
4377func (_mock *MockWebUIHandlerRouter) RegisterHandler(msgType string, handler port.WebUIMessageHandler) error {
4378	ret := _mock.Called(msgType, handler)
4379
4380	if len(ret) == 0 {
4381		panic("no return value specified for RegisterHandler")
4382	}
4383
4384	var r0 error
4385	if returnFunc, ok := ret.Get(0).(func(string, port.WebUIMessageHandler) error); ok {
4386		r0 = returnFunc(msgType, handler)
4387	} else {
4388		r0 = ret.Error(0)
4389	}
4390	return r0
4391}
4392
4393// MockWebUIHandlerRouter_RegisterHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterHandler'
4394type MockWebUIHandlerRouter_RegisterHandler_Call struct {
4395	*mock.Call
4396}
4397
4398// RegisterHandler is a helper method to define mock.On call
4399//   - msgType string
4400//   - handler port.WebUIMessageHandler
4401func (_e *MockWebUIHandlerRouter_Expecter) RegisterHandler(msgType interface{}, handler interface{}) *MockWebUIHandlerRouter_RegisterHandler_Call {
4402	return &MockWebUIHandlerRouter_RegisterHandler_Call{Call: _e.mock.On("RegisterHandler", msgType, handler)}
4403}
4404
4405func (_c *MockWebUIHandlerRouter_RegisterHandler_Call) Run(run func(msgType string, handler port.WebUIMessageHandler)) *MockWebUIHandlerRouter_RegisterHandler_Call {
4406	_c.Call.Run(func(args mock.Arguments) {
4407		var arg0 string
4408		if args[0] != nil {
4409			arg0 = args[0].(string)
4410		}
4411		var arg1 port.WebUIMessageHandler
4412		if args[1] != nil {
4413			arg1 = args[1].(port.WebUIMessageHandler)
4414		}
4415		run(
4416			arg0,
4417			arg1,
4418		)
4419	})
4420	return _c
4421}
4422
4423func (_c *MockWebUIHandlerRouter_RegisterHandler_Call) Return(err error) *MockWebUIHandlerRouter_RegisterHandler_Call {
4424	_c.Call.Return(err)
4425	return _c
4426}
4427
4428func (_c *MockWebUIHandlerRouter_RegisterHandler_Call) RunAndReturn(run func(msgType string, handler port.WebUIMessageHandler) error) *MockWebUIHandlerRouter_RegisterHandler_Call {
4429	_c.Call.Return(run)
4430	return _c
4431}
4432
4433// RegisterHandlerWithCallbacks provides a mock function for the type MockWebUIHandlerRouter
4434func (_mock *MockWebUIHandlerRouter) RegisterHandlerWithCallbacks(msgType string, callback string, errorCallback string, worldName string, handler port.WebUIMessageHandler) error {
4435	ret := _mock.Called(msgType, callback, errorCallback, worldName, handler)
4436
4437	if len(ret) == 0 {
4438		panic("no return value specified for RegisterHandlerWithCallbacks")
4439	}
4440
4441	var r0 error
4442	if returnFunc, ok := ret.Get(0).(func(string, string, string, string, port.WebUIMessageHandler) error); ok {
4443		r0 = returnFunc(msgType, callback, errorCallback, worldName, handler)
4444	} else {
4445		r0 = ret.Error(0)
4446	}
4447	return r0
4448}
4449
4450// MockWebUIHandlerRouter_RegisterHandlerWithCallbacks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterHandlerWithCallbacks'
4451type MockWebUIHandlerRouter_RegisterHandlerWithCallbacks_Call struct {
4452	*mock.Call
4453}
4454
4455// RegisterHandlerWithCallbacks is a helper method to define mock.On call
4456//   - msgType string
4457//   - callback string
4458//   - errorCallback string
4459//   - worldName string
4460//   - handler port.WebUIMessageHandler
4461func (_e *MockWebUIHandlerRouter_Expecter) RegisterHandlerWithCallbacks(msgType interface{}, callback interface{}, errorCallback interface{}, worldName interface{}, handler interface{}) *MockWebUIHandlerRouter_RegisterHandlerWithCallbacks_Call {
4462	return &MockWebUIHandlerRouter_RegisterHandlerWithCallbacks_Call{Call: _e.mock.On("RegisterHandlerWithCallbacks", msgType, callback, errorCallback, worldName, handler)}
4463}
4464
4465func (_c *MockWebUIHandlerRouter_RegisterHandlerWithCallbacks_Call) Run(run func(msgType string, callback string, errorCallback string, worldName string, handler port.WebUIMessageHandler)) *MockWebUIHandlerRouter_RegisterHandlerWithCallbacks_Call {
4466	_c.Call.Run(func(args mock.Arguments) {
4467		var arg0 string
4468		if args[0] != nil {
4469			arg0 = args[0].(string)
4470		}
4471		var arg1 string
4472		if args[1] != nil {
4473			arg1 = args[1].(string)
4474		}
4475		var arg2 string
4476		if args[2] != nil {
4477			arg2 = args[2].(string)
4478		}
4479		var arg3 string
4480		if args[3] != nil {
4481			arg3 = args[3].(string)
4482		}
4483		var arg4 port.WebUIMessageHandler
4484		if args[4] != nil {
4485			arg4 = args[4].(port.WebUIMessageHandler)
4486		}
4487		run(
4488			arg0,
4489			arg1,
4490			arg2,
4491			arg3,
4492			arg4,
4493		)
4494	})
4495	return _c
4496}
4497
4498func (_c *MockWebUIHandlerRouter_RegisterHandlerWithCallbacks_Call) Return(err error) *MockWebUIHandlerRouter_RegisterHandlerWithCallbacks_Call {
4499	_c.Call.Return(err)
4500	return _c
4501}
4502
4503func (_c *MockWebUIHandlerRouter_RegisterHandlerWithCallbacks_Call) RunAndReturn(run func(msgType string, callback string, errorCallback string, worldName string, handler port.WebUIMessageHandler) error) *MockWebUIHandlerRouter_RegisterHandlerWithCallbacks_Call {
4504	_c.Call.Return(run)
4505	return _c
4506}
4507
4508// NewMockSchemeHandler creates a new instance of MockSchemeHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
4509// The first argument is typically a *testing.T value.
4510func NewMockSchemeHandler(t interface {
4511	mock.TestingT
4512	Cleanup(func())
4513}) *MockSchemeHandler {
4514	mock := &MockSchemeHandler{}
4515	mock.Mock.Test(t)
4516
4517	t.Cleanup(func() { mock.AssertExpectations(t) })
4518
4519	return mock
4520}
4521
4522// MockSchemeHandler is an autogenerated mock type for the SchemeHandler type
4523type MockSchemeHandler struct {
4524	mock.Mock
4525}
4526
4527type MockSchemeHandler_Expecter struct {
4528	mock *mock.Mock
4529}
4530
4531func (_m *MockSchemeHandler) EXPECT() *MockSchemeHandler_Expecter {
4532	return &MockSchemeHandler_Expecter{mock: &_m.Mock}
4533}
4534
4535// RegisterScheme provides a mock function for the type MockSchemeHandler
4536func (_mock *MockSchemeHandler) RegisterScheme(scheme string, handler func(uri string) ([]byte, string, error)) {
4537	_mock.Called(scheme, handler)
4538	return
4539}
4540
4541// MockSchemeHandler_RegisterScheme_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterScheme'
4542type MockSchemeHandler_RegisterScheme_Call struct {
4543	*mock.Call
4544}
4545
4546// RegisterScheme is a helper method to define mock.On call
4547//   - scheme string
4548//   - handler func(uri string) ([]byte, string, error)
4549func (_e *MockSchemeHandler_Expecter) RegisterScheme(scheme interface{}, handler interface{}) *MockSchemeHandler_RegisterScheme_Call {
4550	return &MockSchemeHandler_RegisterScheme_Call{Call: _e.mock.On("RegisterScheme", scheme, handler)}
4551}
4552
4553func (_c *MockSchemeHandler_RegisterScheme_Call) Run(run func(scheme string, handler func(uri string) ([]byte, string, error))) *MockSchemeHandler_RegisterScheme_Call {
4554	_c.Call.Run(func(args mock.Arguments) {
4555		var arg0 string
4556		if args[0] != nil {
4557			arg0 = args[0].(string)
4558		}
4559		var arg1 func(uri string) ([]byte, string, error)
4560		if args[1] != nil {
4561			arg1 = args[1].(func(uri string) ([]byte, string, error))
4562		}
4563		run(
4564			arg0,
4565			arg1,
4566		)
4567	})
4568	return _c
4569}
4570
4571func (_c *MockSchemeHandler_RegisterScheme_Call) Return() *MockSchemeHandler_RegisterScheme_Call {
4572	_c.Call.Return()
4573	return _c
4574}
4575
4576func (_c *MockSchemeHandler_RegisterScheme_Call) RunAndReturn(run func(scheme string, handler func(uri string) ([]byte, string, error))) *MockSchemeHandler_RegisterScheme_Call {
4577	_c.Run(run)
4578	return _c
4579}
4580
4581// NewMockSettingsApplier creates a new instance of MockSettingsApplier. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
4582// The first argument is typically a *testing.T value.
4583func NewMockSettingsApplier(t interface {
4584	mock.TestingT
4585	Cleanup(func())
4586}) *MockSettingsApplier {
4587	mock := &MockSettingsApplier{}
4588	mock.Mock.Test(t)
4589
4590	t.Cleanup(func() { mock.AssertExpectations(t) })
4591
4592	return mock
4593}
4594
4595// MockSettingsApplier is an autogenerated mock type for the SettingsApplier type
4596type MockSettingsApplier struct {
4597	mock.Mock
4598}
4599
4600type MockSettingsApplier_Expecter struct {
4601	mock *mock.Mock
4602}
4603
4604func (_m *MockSettingsApplier) EXPECT() *MockSettingsApplier_Expecter {
4605	return &MockSettingsApplier_Expecter{mock: &_m.Mock}
4606}
4607
4608// ApplyToAll provides a mock function for the type MockSettingsApplier
4609func (_mock *MockSettingsApplier) ApplyToAll(ctx context.Context, webviews []port.WebView) {
4610	_mock.Called(ctx, webviews)
4611	return
4612}
4613
4614// MockSettingsApplier_ApplyToAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApplyToAll'
4615type MockSettingsApplier_ApplyToAll_Call struct {
4616	*mock.Call
4617}
4618
4619// ApplyToAll is a helper method to define mock.On call
4620//   - ctx context.Context
4621//   - webviews []port.WebView
4622func (_e *MockSettingsApplier_Expecter) ApplyToAll(ctx interface{}, webviews interface{}) *MockSettingsApplier_ApplyToAll_Call {
4623	return &MockSettingsApplier_ApplyToAll_Call{Call: _e.mock.On("ApplyToAll", ctx, webviews)}
4624}
4625
4626func (_c *MockSettingsApplier_ApplyToAll_Call) Run(run func(ctx context.Context, webviews []port.WebView)) *MockSettingsApplier_ApplyToAll_Call {
4627	_c.Call.Run(func(args mock.Arguments) {
4628		var arg0 context.Context
4629		if args[0] != nil {
4630			arg0 = args[0].(context.Context)
4631		}
4632		var arg1 []port.WebView
4633		if args[1] != nil {
4634			arg1 = args[1].([]port.WebView)
4635		}
4636		run(
4637			arg0,
4638			arg1,
4639		)
4640	})
4641	return _c
4642}
4643
4644func (_c *MockSettingsApplier_ApplyToAll_Call) Return() *MockSettingsApplier_ApplyToAll_Call {
4645	_c.Call.Return()
4646	return _c
4647}
4648
4649func (_c *MockSettingsApplier_ApplyToAll_Call) RunAndReturn(run func(ctx context.Context, webviews []port.WebView)) *MockSettingsApplier_ApplyToAll_Call {
4650	_c.Run(run)
4651	return _c
4652}
4653
4654// NewMockFilterApplier creates a new instance of MockFilterApplier. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
4655// The first argument is typically a *testing.T value.
4656func NewMockFilterApplier(t interface {
4657	mock.TestingT
4658	Cleanup(func())
4659}) *MockFilterApplier {
4660	mock := &MockFilterApplier{}
4661	mock.Mock.Test(t)
4662
4663	t.Cleanup(func() { mock.AssertExpectations(t) })
4664
4665	return mock
4666}
4667
4668// MockFilterApplier is an autogenerated mock type for the FilterApplier type
4669type MockFilterApplier struct {
4670	mock.Mock
4671}
4672
4673type MockFilterApplier_Expecter struct {
4674	mock *mock.Mock
4675}
4676
4677func (_m *MockFilterApplier) EXPECT() *MockFilterApplier_Expecter {
4678	return &MockFilterApplier_Expecter{mock: &_m.Mock}
4679}
4680
4681// ApplyToAll provides a mock function for the type MockFilterApplier
4682func (_mock *MockFilterApplier) ApplyToAll(ctx context.Context, webviews []port.WebView) {
4683	_mock.Called(ctx, webviews)
4684	return
4685}
4686
4687// MockFilterApplier_ApplyToAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApplyToAll'
4688type MockFilterApplier_ApplyToAll_Call struct {
4689	*mock.Call
4690}
4691
4692// ApplyToAll is a helper method to define mock.On call
4693//   - ctx context.Context
4694//   - webviews []port.WebView
4695func (_e *MockFilterApplier_Expecter) ApplyToAll(ctx interface{}, webviews interface{}) *MockFilterApplier_ApplyToAll_Call {
4696	return &MockFilterApplier_ApplyToAll_Call{Call: _e.mock.On("ApplyToAll", ctx, webviews)}
4697}
4698
4699func (_c *MockFilterApplier_ApplyToAll_Call) Run(run func(ctx context.Context, webviews []port.WebView)) *MockFilterApplier_ApplyToAll_Call {
4700	_c.Call.Run(func(args mock.Arguments) {
4701		var arg0 context.Context
4702		if args[0] != nil {
4703			arg0 = args[0].(context.Context)
4704		}
4705		var arg1 []port.WebView
4706		if args[1] != nil {
4707			arg1 = args[1].([]port.WebView)
4708		}
4709		run(
4710			arg0,
4711			arg1,
4712		)
4713	})
4714	return _c
4715}
4716
4717func (_c *MockFilterApplier_ApplyToAll_Call) Return() *MockFilterApplier_ApplyToAll_Call {
4718	_c.Call.Return()
4719	return _c
4720}
4721
4722func (_c *MockFilterApplier_ApplyToAll_Call) RunAndReturn(run func(ctx context.Context, webviews []port.WebView)) *MockFilterApplier_ApplyToAll_Call {
4723	_c.Run(run)
4724	return _c
4725}
4726
4727// NewMockFaviconDatabase creates a new instance of MockFaviconDatabase. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
4728// The first argument is typically a *testing.T value.
4729func NewMockFaviconDatabase(t interface {
4730	mock.TestingT
4731	Cleanup(func())
4732}) *MockFaviconDatabase {
4733	mock := &MockFaviconDatabase{}
4734	mock.Mock.Test(t)
4735
4736	t.Cleanup(func() { mock.AssertExpectations(t) })
4737
4738	return mock
4739}
4740
4741// MockFaviconDatabase is an autogenerated mock type for the FaviconDatabase type
4742type MockFaviconDatabase struct {
4743	mock.Mock
4744}
4745
4746type MockFaviconDatabase_Expecter struct {
4747	mock *mock.Mock
4748}
4749
4750func (_m *MockFaviconDatabase) EXPECT() *MockFaviconDatabase_Expecter {
4751	return &MockFaviconDatabase_Expecter{mock: &_m.Mock}
4752}
4753
4754// GetFaviconAsync provides a mock function for the type MockFaviconDatabase
4755func (_mock *MockFaviconDatabase) GetFaviconAsync(pageURL string, callback func(port.Texture)) {
4756	_mock.Called(pageURL, callback)
4757	return
4758}
4759
4760// MockFaviconDatabase_GetFaviconAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFaviconAsync'
4761type MockFaviconDatabase_GetFaviconAsync_Call struct {
4762	*mock.Call
4763}
4764
4765// GetFaviconAsync is a helper method to define mock.On call
4766//   - pageURL string
4767//   - callback func(port.Texture)
4768func (_e *MockFaviconDatabase_Expecter) GetFaviconAsync(pageURL interface{}, callback interface{}) *MockFaviconDatabase_GetFaviconAsync_Call {
4769	return &MockFaviconDatabase_GetFaviconAsync_Call{Call: _e.mock.On("GetFaviconAsync", pageURL, callback)}
4770}
4771
4772func (_c *MockFaviconDatabase_GetFaviconAsync_Call) Run(run func(pageURL string, callback func(port.Texture))) *MockFaviconDatabase_GetFaviconAsync_Call {
4773	_c.Call.Run(func(args mock.Arguments) {
4774		var arg0 string
4775		if args[0] != nil {
4776			arg0 = args[0].(string)
4777		}
4778		var arg1 func(port.Texture)
4779		if args[1] != nil {
4780			arg1 = args[1].(func(port.Texture))
4781		}
4782		run(
4783			arg0,
4784			arg1,
4785		)
4786	})
4787	return _c
4788}
4789
4790func (_c *MockFaviconDatabase_GetFaviconAsync_Call) Return() *MockFaviconDatabase_GetFaviconAsync_Call {
4791	_c.Call.Return()
4792	return _c
4793}
4794
4795func (_c *MockFaviconDatabase_GetFaviconAsync_Call) RunAndReturn(run func(pageURL string, callback func(port.Texture))) *MockFaviconDatabase_GetFaviconAsync_Call {
4796	_c.Run(run)
4797	return _c
4798}
4799
4800// NewMockScriptRefresher creates a new instance of MockScriptRefresher. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
4801// The first argument is typically a *testing.T value.
4802func NewMockScriptRefresher(t interface {
4803	mock.TestingT
4804	Cleanup(func())
4805}) *MockScriptRefresher {
4806	mock := &MockScriptRefresher{}
4807	mock.Mock.Test(t)
4808
4809	t.Cleanup(func() { mock.AssertExpectations(t) })
4810
4811	return mock
4812}
4813
4814// MockScriptRefresher is an autogenerated mock type for the ScriptRefresher type
4815type MockScriptRefresher struct {
4816	mock.Mock
4817}
4818
4819type MockScriptRefresher_Expecter struct {
4820	mock *mock.Mock
4821}
4822
4823func (_m *MockScriptRefresher) EXPECT() *MockScriptRefresher_Expecter {
4824	return &MockScriptRefresher_Expecter{mock: &_m.Mock}
4825}
4826
4827// RefreshAll provides a mock function for the type MockScriptRefresher
4828func (_mock *MockScriptRefresher) RefreshAll(ctx context.Context, webviews []port.WebView) {
4829	_mock.Called(ctx, webviews)
4830	return
4831}
4832
4833// MockScriptRefresher_RefreshAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RefreshAll'
4834type MockScriptRefresher_RefreshAll_Call struct {
4835	*mock.Call
4836}
4837
4838// RefreshAll is a helper method to define mock.On call
4839//   - ctx context.Context
4840//   - webviews []port.WebView
4841func (_e *MockScriptRefresher_Expecter) RefreshAll(ctx interface{}, webviews interface{}) *MockScriptRefresher_RefreshAll_Call {
4842	return &MockScriptRefresher_RefreshAll_Call{Call: _e.mock.On("RefreshAll", ctx, webviews)}
4843}
4844
4845func (_c *MockScriptRefresher_RefreshAll_Call) Run(run func(ctx context.Context, webviews []port.WebView)) *MockScriptRefresher_RefreshAll_Call {
4846	_c.Call.Run(func(args mock.Arguments) {
4847		var arg0 context.Context
4848		if args[0] != nil {
4849			arg0 = args[0].(context.Context)
4850		}
4851		var arg1 []port.WebView
4852		if args[1] != nil {
4853			arg1 = args[1].([]port.WebView)
4854		}
4855		run(
4856			arg0,
4857			arg1,
4858		)
4859	})
4860	return _c
4861}
4862
4863func (_c *MockScriptRefresher_RefreshAll_Call) Return() *MockScriptRefresher_RefreshAll_Call {
4864	_c.Call.Return()
4865	return _c
4866}
4867
4868func (_c *MockScriptRefresher_RefreshAll_Call) RunAndReturn(run func(ctx context.Context, webviews []port.WebView)) *MockScriptRefresher_RefreshAll_Call {
4869	_c.Run(run)
4870	return _c
4871}
4872
4873// NewMockNativeWidgetProvider creates a new instance of MockNativeWidgetProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
4874// The first argument is typically a *testing.T value.
4875func NewMockNativeWidgetProvider(t interface {
4876	mock.TestingT
4877	Cleanup(func())
4878}) *MockNativeWidgetProvider {
4879	mock := &MockNativeWidgetProvider{}
4880	mock.Mock.Test(t)
4881
4882	t.Cleanup(func() { mock.AssertExpectations(t) })
4883
4884	return mock
4885}
4886
4887// MockNativeWidgetProvider is an autogenerated mock type for the NativeWidgetProvider type
4888type MockNativeWidgetProvider struct {
4889	mock.Mock
4890}
4891
4892type MockNativeWidgetProvider_Expecter struct {
4893	mock *mock.Mock
4894}
4895
4896func (_m *MockNativeWidgetProvider) EXPECT() *MockNativeWidgetProvider_Expecter {
4897	return &MockNativeWidgetProvider_Expecter{mock: &_m.Mock}
4898}
4899
4900// NativeWidget provides a mock function for the type MockNativeWidgetProvider
4901func (_mock *MockNativeWidgetProvider) NativeWidget() uintptr {
4902	ret := _mock.Called()
4903
4904	if len(ret) == 0 {
4905		panic("no return value specified for NativeWidget")
4906	}
4907
4908	var r0 uintptr
4909	if returnFunc, ok := ret.Get(0).(func() uintptr); ok {
4910		r0 = returnFunc()
4911	} else {
4912		r0 = ret.Get(0).(uintptr)
4913	}
4914	return r0
4915}
4916
4917// MockNativeWidgetProvider_NativeWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NativeWidget'
4918type MockNativeWidgetProvider_NativeWidget_Call struct {
4919	*mock.Call
4920}
4921
4922// NativeWidget is a helper method to define mock.On call
4923func (_e *MockNativeWidgetProvider_Expecter) NativeWidget() *MockNativeWidgetProvider_NativeWidget_Call {
4924	return &MockNativeWidgetProvider_NativeWidget_Call{Call: _e.mock.On("NativeWidget")}
4925}
4926
4927func (_c *MockNativeWidgetProvider_NativeWidget_Call) Run(run func()) *MockNativeWidgetProvider_NativeWidget_Call {
4928	_c.Call.Run(func(args mock.Arguments) {
4929		run()
4930	})
4931	return _c
4932}
4933
4934func (_c *MockNativeWidgetProvider_NativeWidget_Call) Return(v uintptr) *MockNativeWidgetProvider_NativeWidget_Call {
4935	_c.Call.Return(v)
4936	return _c
4937}
4938
4939func (_c *MockNativeWidgetProvider_NativeWidget_Call) RunAndReturn(run func() uintptr) *MockNativeWidgetProvider_NativeWidget_Call {
4940	_c.Call.Return(run)
4941	return _c
4942}
4943
4944// NewMockFaviconService creates a new instance of MockFaviconService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
4945// The first argument is typically a *testing.T value.
4946func NewMockFaviconService(t interface {
4947	mock.TestingT
4948	Cleanup(func())
4949}) *MockFaviconService {
4950	mock := &MockFaviconService{}
4951	mock.Mock.Test(t)
4952
4953	t.Cleanup(func() { mock.AssertExpectations(t) })
4954
4955	return mock
4956}
4957
4958// MockFaviconService is an autogenerated mock type for the FaviconService type
4959type MockFaviconService struct {
4960	mock.Mock
4961}
4962
4963type MockFaviconService_Expecter struct {
4964	mock *mock.Mock
4965}
4966
4967func (_m *MockFaviconService) EXPECT() *MockFaviconService_Expecter {
4968	return &MockFaviconService_Expecter{mock: &_m.Mock}
4969}
4970
4971// Close provides a mock function for the type MockFaviconService
4972func (_mock *MockFaviconService) Close() {
4973	_mock.Called()
4974	return
4975}
4976
4977// MockFaviconService_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
4978type MockFaviconService_Close_Call struct {
4979	*mock.Call
4980}
4981
4982// Close is a helper method to define mock.On call
4983func (_e *MockFaviconService_Expecter) Close() *MockFaviconService_Close_Call {
4984	return &MockFaviconService_Close_Call{Call: _e.mock.On("Close")}
4985}
4986
4987func (_c *MockFaviconService_Close_Call) Run(run func()) *MockFaviconService_Close_Call {
4988	_c.Call.Run(func(args mock.Arguments) {
4989		run()
4990	})
4991	return _c
4992}
4993
4994func (_c *MockFaviconService_Close_Call) Return() *MockFaviconService_Close_Call {
4995	_c.Call.Return()
4996	return _c
4997}
4998
4999func (_c *MockFaviconService_Close_Call) RunAndReturn(run func()) *MockFaviconService_Close_Call {
5000	_c.Run(run)
5001	return _c
5002}
5003
5004// DiskPathPNG provides a mock function for the type MockFaviconService
5005func (_mock *MockFaviconService) DiskPathPNG(domain string) string {
5006	ret := _mock.Called(domain)
5007
5008	if len(ret) == 0 {
5009		panic("no return value specified for DiskPathPNG")
5010	}
5011
5012	var r0 string
5013	if returnFunc, ok := ret.Get(0).(func(string) string); ok {
5014		r0 = returnFunc(domain)
5015	} else {
5016		r0 = ret.Get(0).(string)
5017	}
5018	return r0
5019}
5020
5021// MockFaviconService_DiskPathPNG_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DiskPathPNG'
5022type MockFaviconService_DiskPathPNG_Call struct {
5023	*mock.Call
5024}
5025
5026// DiskPathPNG is a helper method to define mock.On call
5027//   - domain string
5028func (_e *MockFaviconService_Expecter) DiskPathPNG(domain interface{}) *MockFaviconService_DiskPathPNG_Call {
5029	return &MockFaviconService_DiskPathPNG_Call{Call: _e.mock.On("DiskPathPNG", domain)}
5030}
5031
5032func (_c *MockFaviconService_DiskPathPNG_Call) Run(run func(domain string)) *MockFaviconService_DiskPathPNG_Call {
5033	_c.Call.Run(func(args mock.Arguments) {
5034		var arg0 string
5035		if args[0] != nil {
5036			arg0 = args[0].(string)
5037		}
5038		run(
5039			arg0,
5040		)
5041	})
5042	return _c
5043}
5044
5045func (_c *MockFaviconService_DiskPathPNG_Call) Return(s string) *MockFaviconService_DiskPathPNG_Call {
5046	_c.Call.Return(s)
5047	return _c
5048}
5049
5050func (_c *MockFaviconService_DiskPathPNG_Call) RunAndReturn(run func(domain string) string) *MockFaviconService_DiskPathPNG_Call {
5051	_c.Call.Return(run)
5052	return _c
5053}
5054
5055// DiskPathPNGSized provides a mock function for the type MockFaviconService
5056func (_mock *MockFaviconService) DiskPathPNGSized(domain string, size int) string {
5057	ret := _mock.Called(domain, size)
5058
5059	if len(ret) == 0 {
5060		panic("no return value specified for DiskPathPNGSized")
5061	}
5062
5063	var r0 string
5064	if returnFunc, ok := ret.Get(0).(func(string, int) string); ok {
5065		r0 = returnFunc(domain, size)
5066	} else {
5067		r0 = ret.Get(0).(string)
5068	}
5069	return r0
5070}
5071
5072// MockFaviconService_DiskPathPNGSized_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DiskPathPNGSized'
5073type MockFaviconService_DiskPathPNGSized_Call struct {
5074	*mock.Call
5075}
5076
5077// DiskPathPNGSized is a helper method to define mock.On call
5078//   - domain string
5079//   - size int
5080func (_e *MockFaviconService_Expecter) DiskPathPNGSized(domain interface{}, size interface{}) *MockFaviconService_DiskPathPNGSized_Call {
5081	return &MockFaviconService_DiskPathPNGSized_Call{Call: _e.mock.On("DiskPathPNGSized", domain, size)}
5082}
5083
5084func (_c *MockFaviconService_DiskPathPNGSized_Call) Run(run func(domain string, size int)) *MockFaviconService_DiskPathPNGSized_Call {
5085	_c.Call.Run(func(args mock.Arguments) {
5086		var arg0 string
5087		if args[0] != nil {
5088			arg0 = args[0].(string)
5089		}
5090		var arg1 int
5091		if args[1] != nil {
5092			arg1 = args[1].(int)
5093		}
5094		run(
5095			arg0,
5096			arg1,
5097		)
5098	})
5099	return _c
5100}
5101
5102func (_c *MockFaviconService_DiskPathPNGSized_Call) Return(s string) *MockFaviconService_DiskPathPNGSized_Call {
5103	_c.Call.Return(s)
5104	return _c
5105}
5106
5107func (_c *MockFaviconService_DiskPathPNGSized_Call) RunAndReturn(run func(domain string, size int) string) *MockFaviconService_DiskPathPNGSized_Call {
5108	_c.Call.Return(run)
5109	return _c
5110}
5111
5112// EnsureCacheDir provides a mock function for the type MockFaviconService
5113func (_mock *MockFaviconService) EnsureCacheDir() error {
5114	ret := _mock.Called()
5115
5116	if len(ret) == 0 {
5117		panic("no return value specified for EnsureCacheDir")
5118	}
5119
5120	var r0 error
5121	if returnFunc, ok := ret.Get(0).(func() error); ok {
5122		r0 = returnFunc()
5123	} else {
5124		r0 = ret.Error(0)
5125	}
5126	return r0
5127}
5128
5129// MockFaviconService_EnsureCacheDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnsureCacheDir'
5130type MockFaviconService_EnsureCacheDir_Call struct {
5131	*mock.Call
5132}
5133
5134// EnsureCacheDir is a helper method to define mock.On call
5135func (_e *MockFaviconService_Expecter) EnsureCacheDir() *MockFaviconService_EnsureCacheDir_Call {
5136	return &MockFaviconService_EnsureCacheDir_Call{Call: _e.mock.On("EnsureCacheDir")}
5137}
5138
5139func (_c *MockFaviconService_EnsureCacheDir_Call) Run(run func()) *MockFaviconService_EnsureCacheDir_Call {
5140	_c.Call.Run(func(args mock.Arguments) {
5141		run()
5142	})
5143	return _c
5144}
5145
5146func (_c *MockFaviconService_EnsureCacheDir_Call) Return(err error) *MockFaviconService_EnsureCacheDir_Call {
5147	_c.Call.Return(err)
5148	return _c
5149}
5150
5151func (_c *MockFaviconService_EnsureCacheDir_Call) RunAndReturn(run func() error) *MockFaviconService_EnsureCacheDir_Call {
5152	_c.Call.Return(run)
5153	return _c
5154}
5155
5156// EnsureDiskCache provides a mock function for the type MockFaviconService
5157func (_mock *MockFaviconService) EnsureDiskCache(ctx context.Context, domain string) {
5158	_mock.Called(ctx, domain)
5159	return
5160}
5161
5162// MockFaviconService_EnsureDiskCache_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnsureDiskCache'
5163type MockFaviconService_EnsureDiskCache_Call struct {
5164	*mock.Call
5165}
5166
5167// EnsureDiskCache is a helper method to define mock.On call
5168//   - ctx context.Context
5169//   - domain string
5170func (_e *MockFaviconService_Expecter) EnsureDiskCache(ctx interface{}, domain interface{}) *MockFaviconService_EnsureDiskCache_Call {
5171	return &MockFaviconService_EnsureDiskCache_Call{Call: _e.mock.On("EnsureDiskCache", ctx, domain)}
5172}
5173
5174func (_c *MockFaviconService_EnsureDiskCache_Call) Run(run func(ctx context.Context, domain string)) *MockFaviconService_EnsureDiskCache_Call {
5175	_c.Call.Run(func(args mock.Arguments) {
5176		var arg0 context.Context
5177		if args[0] != nil {
5178			arg0 = args[0].(context.Context)
5179		}
5180		var arg1 string
5181		if args[1] != nil {
5182			arg1 = args[1].(string)
5183		}
5184		run(
5185			arg0,
5186			arg1,
5187		)
5188	})
5189	return _c
5190}
5191
5192func (_c *MockFaviconService_EnsureDiskCache_Call) Return() *MockFaviconService_EnsureDiskCache_Call {
5193	_c.Call.Return()
5194	return _c
5195}
5196
5197func (_c *MockFaviconService_EnsureDiskCache_Call) RunAndReturn(run func(ctx context.Context, domain string)) *MockFaviconService_EnsureDiskCache_Call {
5198	_c.Run(run)
5199	return _c
5200}
5201
5202// EnsureSizedPNG provides a mock function for the type MockFaviconService
5203func (_mock *MockFaviconService) EnsureSizedPNG(ctx context.Context, domain string, size int) error {
5204	ret := _mock.Called(ctx, domain, size)
5205
5206	if len(ret) == 0 {
5207		panic("no return value specified for EnsureSizedPNG")
5208	}
5209
5210	var r0 error
5211	if returnFunc, ok := ret.Get(0).(func(context.Context, string, int) error); ok {
5212		r0 = returnFunc(ctx, domain, size)
5213	} else {
5214		r0 = ret.Error(0)
5215	}
5216	return r0
5217}
5218
5219// MockFaviconService_EnsureSizedPNG_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnsureSizedPNG'
5220type MockFaviconService_EnsureSizedPNG_Call struct {
5221	*mock.Call
5222}
5223
5224// EnsureSizedPNG is a helper method to define mock.On call
5225//   - ctx context.Context
5226//   - domain string
5227//   - size int
5228func (_e *MockFaviconService_Expecter) EnsureSizedPNG(ctx interface{}, domain interface{}, size interface{}) *MockFaviconService_EnsureSizedPNG_Call {
5229	return &MockFaviconService_EnsureSizedPNG_Call{Call: _e.mock.On("EnsureSizedPNG", ctx, domain, size)}
5230}
5231
5232func (_c *MockFaviconService_EnsureSizedPNG_Call) Run(run func(ctx context.Context, domain string, size int)) *MockFaviconService_EnsureSizedPNG_Call {
5233	_c.Call.Run(func(args mock.Arguments) {
5234		var arg0 context.Context
5235		if args[0] != nil {
5236			arg0 = args[0].(context.Context)
5237		}
5238		var arg1 string
5239		if args[1] != nil {
5240			arg1 = args[1].(string)
5241		}
5242		var arg2 int
5243		if args[2] != nil {
5244			arg2 = args[2].(int)
5245		}
5246		run(
5247			arg0,
5248			arg1,
5249			arg2,
5250		)
5251	})
5252	return _c
5253}
5254
5255func (_c *MockFaviconService_EnsureSizedPNG_Call) Return(err error) *MockFaviconService_EnsureSizedPNG_Call {
5256	_c.Call.Return(err)
5257	return _c
5258}
5259
5260func (_c *MockFaviconService_EnsureSizedPNG_Call) RunAndReturn(run func(ctx context.Context, domain string, size int) error) *MockFaviconService_EnsureSizedPNG_Call {
5261	_c.Call.Return(run)
5262	return _c
5263}
5264
5265// Get provides a mock function for the type MockFaviconService
5266func (_mock *MockFaviconService) Get(ctx context.Context, domain string) ([]byte, error) {
5267	ret := _mock.Called(ctx, domain)
5268
5269	if len(ret) == 0 {
5270		panic("no return value specified for Get")
5271	}
5272
5273	var r0 []byte
5274	var r1 error
5275	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]byte, error)); ok {
5276		return returnFunc(ctx, domain)
5277	}
5278	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []byte); ok {
5279		r0 = returnFunc(ctx, domain)
5280	} else {
5281		if ret.Get(0) != nil {
5282			r0 = ret.Get(0).([]byte)
5283		}
5284	}
5285	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
5286		r1 = returnFunc(ctx, domain)
5287	} else {
5288		r1 = ret.Error(1)
5289	}
5290	return r0, r1
5291}
5292
5293// MockFaviconService_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
5294type MockFaviconService_Get_Call struct {
5295	*mock.Call
5296}
5297
5298// Get is a helper method to define mock.On call
5299//   - ctx context.Context
5300//   - domain string
5301func (_e *MockFaviconService_Expecter) Get(ctx interface{}, domain interface{}) *MockFaviconService_Get_Call {
5302	return &MockFaviconService_Get_Call{Call: _e.mock.On("Get", ctx, domain)}
5303}
5304
5305func (_c *MockFaviconService_Get_Call) Run(run func(ctx context.Context, domain string)) *MockFaviconService_Get_Call {
5306	_c.Call.Run(func(args mock.Arguments) {
5307		var arg0 context.Context
5308		if args[0] != nil {
5309			arg0 = args[0].(context.Context)
5310		}
5311		var arg1 string
5312		if args[1] != nil {
5313			arg1 = args[1].(string)
5314		}
5315		run(
5316			arg0,
5317			arg1,
5318		)
5319	})
5320	return _c
5321}
5322
5323func (_c *MockFaviconService_Get_Call) Return(bytes []byte, err error) *MockFaviconService_Get_Call {
5324	_c.Call.Return(bytes, err)
5325	return _c
5326}
5327
5328func (_c *MockFaviconService_Get_Call) RunAndReturn(run func(ctx context.Context, domain string) ([]byte, error)) *MockFaviconService_Get_Call {
5329	_c.Call.Return(run)
5330	return _c
5331}
5332
5333// GetCached provides a mock function for the type MockFaviconService
5334func (_mock *MockFaviconService) GetCached(ctx context.Context, domain string) ([]byte, bool) {
5335	ret := _mock.Called(ctx, domain)
5336
5337	if len(ret) == 0 {
5338		panic("no return value specified for GetCached")
5339	}
5340
5341	var r0 []byte
5342	var r1 bool
5343	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]byte, bool)); ok {
5344		return returnFunc(ctx, domain)
5345	}
5346	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []byte); ok {
5347		r0 = returnFunc(ctx, domain)
5348	} else {
5349		if ret.Get(0) != nil {
5350			r0 = ret.Get(0).([]byte)
5351		}
5352	}
5353	if returnFunc, ok := ret.Get(1).(func(context.Context, string) bool); ok {
5354		r1 = returnFunc(ctx, domain)
5355	} else {
5356		r1 = ret.Get(1).(bool)
5357	}
5358	return r0, r1
5359}
5360
5361// MockFaviconService_GetCached_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCached'
5362type MockFaviconService_GetCached_Call struct {
5363	*mock.Call
5364}
5365
5366// GetCached is a helper method to define mock.On call
5367//   - ctx context.Context
5368//   - domain string
5369func (_e *MockFaviconService_Expecter) GetCached(ctx interface{}, domain interface{}) *MockFaviconService_GetCached_Call {
5370	return &MockFaviconService_GetCached_Call{Call: _e.mock.On("GetCached", ctx, domain)}
5371}
5372
5373func (_c *MockFaviconService_GetCached_Call) Run(run func(ctx context.Context, domain string)) *MockFaviconService_GetCached_Call {
5374	_c.Call.Run(func(args mock.Arguments) {
5375		var arg0 context.Context
5376		if args[0] != nil {
5377			arg0 = args[0].(context.Context)
5378		}
5379		var arg1 string
5380		if args[1] != nil {
5381			arg1 = args[1].(string)
5382		}
5383		run(
5384			arg0,
5385			arg1,
5386		)
5387	})
5388	return _c
5389}
5390
5391func (_c *MockFaviconService_GetCached_Call) Return(bytes []byte, b bool) *MockFaviconService_GetCached_Call {
5392	_c.Call.Return(bytes, b)
5393	return _c
5394}
5395
5396func (_c *MockFaviconService_GetCached_Call) RunAndReturn(run func(ctx context.Context, domain string) ([]byte, bool)) *MockFaviconService_GetCached_Call {
5397	_c.Call.Return(run)
5398	return _c
5399}
5400
5401// HasPNGOnDisk provides a mock function for the type MockFaviconService
5402func (_mock *MockFaviconService) HasPNGOnDisk(domain string) bool {
5403	ret := _mock.Called(domain)
5404
5405	if len(ret) == 0 {
5406		panic("no return value specified for HasPNGOnDisk")
5407	}
5408
5409	var r0 bool
5410	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
5411		r0 = returnFunc(domain)
5412	} else {
5413		r0 = ret.Get(0).(bool)
5414	}
5415	return r0
5416}
5417
5418// MockFaviconService_HasPNGOnDisk_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasPNGOnDisk'
5419type MockFaviconService_HasPNGOnDisk_Call struct {
5420	*mock.Call
5421}
5422
5423// HasPNGOnDisk is a helper method to define mock.On call
5424//   - domain string
5425func (_e *MockFaviconService_Expecter) HasPNGOnDisk(domain interface{}) *MockFaviconService_HasPNGOnDisk_Call {
5426	return &MockFaviconService_HasPNGOnDisk_Call{Call: _e.mock.On("HasPNGOnDisk", domain)}
5427}
5428
5429func (_c *MockFaviconService_HasPNGOnDisk_Call) Run(run func(domain string)) *MockFaviconService_HasPNGOnDisk_Call {
5430	_c.Call.Run(func(args mock.Arguments) {
5431		var arg0 string
5432		if args[0] != nil {
5433			arg0 = args[0].(string)
5434		}
5435		run(
5436			arg0,
5437		)
5438	})
5439	return _c
5440}
5441
5442func (_c *MockFaviconService_HasPNGOnDisk_Call) Return(b bool) *MockFaviconService_HasPNGOnDisk_Call {
5443	_c.Call.Return(b)
5444	return _c
5445}
5446
5447func (_c *MockFaviconService_HasPNGOnDisk_Call) RunAndReturn(run func(domain string) bool) *MockFaviconService_HasPNGOnDisk_Call {
5448	_c.Call.Return(run)
5449	return _c
5450}
5451
5452// HasPNGSizedOnDisk provides a mock function for the type MockFaviconService
5453func (_mock *MockFaviconService) HasPNGSizedOnDisk(domain string, size int) bool {
5454	ret := _mock.Called(domain, size)
5455
5456	if len(ret) == 0 {
5457		panic("no return value specified for HasPNGSizedOnDisk")
5458	}
5459
5460	var r0 bool
5461	if returnFunc, ok := ret.Get(0).(func(string, int) bool); ok {
5462		r0 = returnFunc(domain, size)
5463	} else {
5464		r0 = ret.Get(0).(bool)
5465	}
5466	return r0
5467}
5468
5469// MockFaviconService_HasPNGSizedOnDisk_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasPNGSizedOnDisk'
5470type MockFaviconService_HasPNGSizedOnDisk_Call struct {
5471	*mock.Call
5472}
5473
5474// HasPNGSizedOnDisk is a helper method to define mock.On call
5475//   - domain string
5476//   - size int
5477func (_e *MockFaviconService_Expecter) HasPNGSizedOnDisk(domain interface{}, size interface{}) *MockFaviconService_HasPNGSizedOnDisk_Call {
5478	return &MockFaviconService_HasPNGSizedOnDisk_Call{Call: _e.mock.On("HasPNGSizedOnDisk", domain, size)}
5479}
5480
5481func (_c *MockFaviconService_HasPNGSizedOnDisk_Call) Run(run func(domain string, size int)) *MockFaviconService_HasPNGSizedOnDisk_Call {
5482	_c.Call.Run(func(args mock.Arguments) {
5483		var arg0 string
5484		if args[0] != nil {
5485			arg0 = args[0].(string)
5486		}
5487		var arg1 int
5488		if args[1] != nil {
5489			arg1 = args[1].(int)
5490		}
5491		run(
5492			arg0,
5493			arg1,
5494		)
5495	})
5496	return _c
5497}
5498
5499func (_c *MockFaviconService_HasPNGSizedOnDisk_Call) Return(b bool) *MockFaviconService_HasPNGSizedOnDisk_Call {
5500	_c.Call.Return(b)
5501	return _c
5502}
5503
5504func (_c *MockFaviconService_HasPNGSizedOnDisk_Call) RunAndReturn(run func(domain string, size int) bool) *MockFaviconService_HasPNGSizedOnDisk_Call {
5505	_c.Call.Return(run)
5506	return _c
5507}
5508
5509// NewMockFileSystem creates a new instance of MockFileSystem. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
5510// The first argument is typically a *testing.T value.
5511func NewMockFileSystem(t interface {
5512	mock.TestingT
5513	Cleanup(func())
5514}) *MockFileSystem {
5515	mock := &MockFileSystem{}
5516	mock.Mock.Test(t)
5517
5518	t.Cleanup(func() { mock.AssertExpectations(t) })
5519
5520	return mock
5521}
5522
5523// MockFileSystem is an autogenerated mock type for the FileSystem type
5524type MockFileSystem struct {
5525	mock.Mock
5526}
5527
5528type MockFileSystem_Expecter struct {
5529	mock *mock.Mock
5530}
5531
5532func (_m *MockFileSystem) EXPECT() *MockFileSystem_Expecter {
5533	return &MockFileSystem_Expecter{mock: &_m.Mock}
5534}
5535
5536// Exists provides a mock function for the type MockFileSystem
5537func (_mock *MockFileSystem) Exists(ctx context.Context, path string) (bool, error) {
5538	ret := _mock.Called(ctx, path)
5539
5540	if len(ret) == 0 {
5541		panic("no return value specified for Exists")
5542	}
5543
5544	var r0 bool
5545	var r1 error
5546	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (bool, error)); ok {
5547		return returnFunc(ctx, path)
5548	}
5549	if returnFunc, ok := ret.Get(0).(func(context.Context, string) bool); ok {
5550		r0 = returnFunc(ctx, path)
5551	} else {
5552		r0 = ret.Get(0).(bool)
5553	}
5554	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
5555		r1 = returnFunc(ctx, path)
5556	} else {
5557		r1 = ret.Error(1)
5558	}
5559	return r0, r1
5560}
5561
5562// MockFileSystem_Exists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Exists'
5563type MockFileSystem_Exists_Call struct {
5564	*mock.Call
5565}
5566
5567// Exists is a helper method to define mock.On call
5568//   - ctx context.Context
5569//   - path string
5570func (_e *MockFileSystem_Expecter) Exists(ctx interface{}, path interface{}) *MockFileSystem_Exists_Call {
5571	return &MockFileSystem_Exists_Call{Call: _e.mock.On("Exists", ctx, path)}
5572}
5573
5574func (_c *MockFileSystem_Exists_Call) Run(run func(ctx context.Context, path string)) *MockFileSystem_Exists_Call {
5575	_c.Call.Run(func(args mock.Arguments) {
5576		var arg0 context.Context
5577		if args[0] != nil {
5578			arg0 = args[0].(context.Context)
5579		}
5580		var arg1 string
5581		if args[1] != nil {
5582			arg1 = args[1].(string)
5583		}
5584		run(
5585			arg0,
5586			arg1,
5587		)
5588	})
5589	return _c
5590}
5591
5592func (_c *MockFileSystem_Exists_Call) Return(b bool, err error) *MockFileSystem_Exists_Call {
5593	_c.Call.Return(b, err)
5594	return _c
5595}
5596
5597func (_c *MockFileSystem_Exists_Call) RunAndReturn(run func(ctx context.Context, path string) (bool, error)) *MockFileSystem_Exists_Call {
5598	_c.Call.Return(run)
5599	return _c
5600}
5601
5602// GetSize provides a mock function for the type MockFileSystem
5603func (_mock *MockFileSystem) GetSize(ctx context.Context, path string) (int64, error) {
5604	ret := _mock.Called(ctx, path)
5605
5606	if len(ret) == 0 {
5607		panic("no return value specified for GetSize")
5608	}
5609
5610	var r0 int64
5611	var r1 error
5612	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (int64, error)); ok {
5613		return returnFunc(ctx, path)
5614	}
5615	if returnFunc, ok := ret.Get(0).(func(context.Context, string) int64); ok {
5616		r0 = returnFunc(ctx, path)
5617	} else {
5618		r0 = ret.Get(0).(int64)
5619	}
5620	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
5621		r1 = returnFunc(ctx, path)
5622	} else {
5623		r1 = ret.Error(1)
5624	}
5625	return r0, r1
5626}
5627
5628// MockFileSystem_GetSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSize'
5629type MockFileSystem_GetSize_Call struct {
5630	*mock.Call
5631}
5632
5633// GetSize is a helper method to define mock.On call
5634//   - ctx context.Context
5635//   - path string
5636func (_e *MockFileSystem_Expecter) GetSize(ctx interface{}, path interface{}) *MockFileSystem_GetSize_Call {
5637	return &MockFileSystem_GetSize_Call{Call: _e.mock.On("GetSize", ctx, path)}
5638}
5639
5640func (_c *MockFileSystem_GetSize_Call) Run(run func(ctx context.Context, path string)) *MockFileSystem_GetSize_Call {
5641	_c.Call.Run(func(args mock.Arguments) {
5642		var arg0 context.Context
5643		if args[0] != nil {
5644			arg0 = args[0].(context.Context)
5645		}
5646		var arg1 string
5647		if args[1] != nil {
5648			arg1 = args[1].(string)
5649		}
5650		run(
5651			arg0,
5652			arg1,
5653		)
5654	})
5655	return _c
5656}
5657
5658func (_c *MockFileSystem_GetSize_Call) Return(n int64, err error) *MockFileSystem_GetSize_Call {
5659	_c.Call.Return(n, err)
5660	return _c
5661}
5662
5663func (_c *MockFileSystem_GetSize_Call) RunAndReturn(run func(ctx context.Context, path string) (int64, error)) *MockFileSystem_GetSize_Call {
5664	_c.Call.Return(run)
5665	return _c
5666}
5667
5668// IsDirectory provides a mock function for the type MockFileSystem
5669func (_mock *MockFileSystem) IsDirectory(ctx context.Context, path string) (bool, error) {
5670	ret := _mock.Called(ctx, path)
5671
5672	if len(ret) == 0 {
5673		panic("no return value specified for IsDirectory")
5674	}
5675
5676	var r0 bool
5677	var r1 error
5678	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (bool, error)); ok {
5679		return returnFunc(ctx, path)
5680	}
5681	if returnFunc, ok := ret.Get(0).(func(context.Context, string) bool); ok {
5682		r0 = returnFunc(ctx, path)
5683	} else {
5684		r0 = ret.Get(0).(bool)
5685	}
5686	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
5687		r1 = returnFunc(ctx, path)
5688	} else {
5689		r1 = ret.Error(1)
5690	}
5691	return r0, r1
5692}
5693
5694// MockFileSystem_IsDirectory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsDirectory'
5695type MockFileSystem_IsDirectory_Call struct {
5696	*mock.Call
5697}
5698
5699// IsDirectory is a helper method to define mock.On call
5700//   - ctx context.Context
5701//   - path string
5702func (_e *MockFileSystem_Expecter) IsDirectory(ctx interface{}, path interface{}) *MockFileSystem_IsDirectory_Call {
5703	return &MockFileSystem_IsDirectory_Call{Call: _e.mock.On("IsDirectory", ctx, path)}
5704}
5705
5706func (_c *MockFileSystem_IsDirectory_Call) Run(run func(ctx context.Context, path string)) *MockFileSystem_IsDirectory_Call {
5707	_c.Call.Run(func(args mock.Arguments) {
5708		var arg0 context.Context
5709		if args[0] != nil {
5710			arg0 = args[0].(context.Context)
5711		}
5712		var arg1 string
5713		if args[1] != nil {
5714			arg1 = args[1].(string)
5715		}
5716		run(
5717			arg0,
5718			arg1,
5719		)
5720	})
5721	return _c
5722}
5723
5724func (_c *MockFileSystem_IsDirectory_Call) Return(b bool, err error) *MockFileSystem_IsDirectory_Call {
5725	_c.Call.Return(b, err)
5726	return _c
5727}
5728
5729func (_c *MockFileSystem_IsDirectory_Call) RunAndReturn(run func(ctx context.Context, path string) (bool, error)) *MockFileSystem_IsDirectory_Call {
5730	_c.Call.Return(run)
5731	return _c
5732}
5733
5734// RemoveAll provides a mock function for the type MockFileSystem
5735func (_mock *MockFileSystem) RemoveAll(ctx context.Context, path string) error {
5736	ret := _mock.Called(ctx, path)
5737
5738	if len(ret) == 0 {
5739		panic("no return value specified for RemoveAll")
5740	}
5741
5742	var r0 error
5743	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
5744		r0 = returnFunc(ctx, path)
5745	} else {
5746		r0 = ret.Error(0)
5747	}
5748	return r0
5749}
5750
5751// MockFileSystem_RemoveAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAll'
5752type MockFileSystem_RemoveAll_Call struct {
5753	*mock.Call
5754}
5755
5756// RemoveAll is a helper method to define mock.On call
5757//   - ctx context.Context
5758//   - path string
5759func (_e *MockFileSystem_Expecter) RemoveAll(ctx interface{}, path interface{}) *MockFileSystem_RemoveAll_Call {
5760	return &MockFileSystem_RemoveAll_Call{Call: _e.mock.On("RemoveAll", ctx, path)}
5761}
5762
5763func (_c *MockFileSystem_RemoveAll_Call) Run(run func(ctx context.Context, path string)) *MockFileSystem_RemoveAll_Call {
5764	_c.Call.Run(func(args mock.Arguments) {
5765		var arg0 context.Context
5766		if args[0] != nil {
5767			arg0 = args[0].(context.Context)
5768		}
5769		var arg1 string
5770		if args[1] != nil {
5771			arg1 = args[1].(string)
5772		}
5773		run(
5774			arg0,
5775			arg1,
5776		)
5777	})
5778	return _c
5779}
5780
5781func (_c *MockFileSystem_RemoveAll_Call) Return(err error) *MockFileSystem_RemoveAll_Call {
5782	_c.Call.Return(err)
5783	return _c
5784}
5785
5786func (_c *MockFileSystem_RemoveAll_Call) RunAndReturn(run func(ctx context.Context, path string) error) *MockFileSystem_RemoveAll_Call {
5787	_c.Call.Return(run)
5788	return _c
5789}
5790
5791// NewMockFilterManager creates a new instance of MockFilterManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
5792// The first argument is typically a *testing.T value.
5793func NewMockFilterManager(t interface {
5794	mock.TestingT
5795	Cleanup(func())
5796}) *MockFilterManager {
5797	mock := &MockFilterManager{}
5798	mock.Mock.Test(t)
5799
5800	t.Cleanup(func() { mock.AssertExpectations(t) })
5801
5802	return mock
5803}
5804
5805// MockFilterManager is an autogenerated mock type for the FilterManager type
5806type MockFilterManager struct {
5807	mock.Mock
5808}
5809
5810type MockFilterManager_Expecter struct {
5811	mock *mock.Mock
5812}
5813
5814func (_m *MockFilterManager) EXPECT() *MockFilterManager_Expecter {
5815	return &MockFilterManager_Expecter{mock: &_m.Mock}
5816}
5817
5818// LoadAsync provides a mock function for the type MockFilterManager
5819func (_mock *MockFilterManager) LoadAsync(ctx context.Context) {
5820	_mock.Called(ctx)
5821	return
5822}
5823
5824// MockFilterManager_LoadAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadAsync'
5825type MockFilterManager_LoadAsync_Call struct {
5826	*mock.Call
5827}
5828
5829// LoadAsync is a helper method to define mock.On call
5830//   - ctx context.Context
5831func (_e *MockFilterManager_Expecter) LoadAsync(ctx interface{}) *MockFilterManager_LoadAsync_Call {
5832	return &MockFilterManager_LoadAsync_Call{Call: _e.mock.On("LoadAsync", ctx)}
5833}
5834
5835func (_c *MockFilterManager_LoadAsync_Call) Run(run func(ctx context.Context)) *MockFilterManager_LoadAsync_Call {
5836	_c.Call.Run(func(args mock.Arguments) {
5837		var arg0 context.Context
5838		if args[0] != nil {
5839			arg0 = args[0].(context.Context)
5840		}
5841		run(
5842			arg0,
5843		)
5844	})
5845	return _c
5846}
5847
5848func (_c *MockFilterManager_LoadAsync_Call) Return() *MockFilterManager_LoadAsync_Call {
5849	_c.Call.Return()
5850	return _c
5851}
5852
5853func (_c *MockFilterManager_LoadAsync_Call) RunAndReturn(run func(ctx context.Context)) *MockFilterManager_LoadAsync_Call {
5854	_c.Run(run)
5855	return _c
5856}
5857
5858// SetStatusCallback provides a mock function for the type MockFilterManager
5859func (_mock *MockFilterManager) SetStatusCallback(fn func(port.FilterStatus)) {
5860	_mock.Called(fn)
5861	return
5862}
5863
5864// MockFilterManager_SetStatusCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetStatusCallback'
5865type MockFilterManager_SetStatusCallback_Call struct {
5866	*mock.Call
5867}
5868
5869// SetStatusCallback is a helper method to define mock.On call
5870//   - fn func(port.FilterStatus)
5871func (_e *MockFilterManager_Expecter) SetStatusCallback(fn interface{}) *MockFilterManager_SetStatusCallback_Call {
5872	return &MockFilterManager_SetStatusCallback_Call{Call: _e.mock.On("SetStatusCallback", fn)}
5873}
5874
5875func (_c *MockFilterManager_SetStatusCallback_Call) Run(run func(fn func(port.FilterStatus))) *MockFilterManager_SetStatusCallback_Call {
5876	_c.Call.Run(func(args mock.Arguments) {
5877		var arg0 func(port.FilterStatus)
5878		if args[0] != nil {
5879			arg0 = args[0].(func(port.FilterStatus))
5880		}
5881		run(
5882			arg0,
5883		)
5884	})
5885	return _c
5886}
5887
5888func (_c *MockFilterManager_SetStatusCallback_Call) Return() *MockFilterManager_SetStatusCallback_Call {
5889	_c.Call.Return()
5890	return _c
5891}
5892
5893func (_c *MockFilterManager_SetStatusCallback_Call) RunAndReturn(run func(fn func(port.FilterStatus))) *MockFilterManager_SetStatusCallback_Call {
5894	_c.Run(run)
5895	return _c
5896}
5897
5898// NewMockFontDetector creates a new instance of MockFontDetector. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
5899// The first argument is typically a *testing.T value.
5900func NewMockFontDetector(t interface {
5901	mock.TestingT
5902	Cleanup(func())
5903}) *MockFontDetector {
5904	mock := &MockFontDetector{}
5905	mock.Mock.Test(t)
5906
5907	t.Cleanup(func() { mock.AssertExpectations(t) })
5908
5909	return mock
5910}
5911
5912// MockFontDetector is an autogenerated mock type for the FontDetector type
5913type MockFontDetector struct {
5914	mock.Mock
5915}
5916
5917type MockFontDetector_Expecter struct {
5918	mock *mock.Mock
5919}
5920
5921func (_m *MockFontDetector) EXPECT() *MockFontDetector_Expecter {
5922	return &MockFontDetector_Expecter{mock: &_m.Mock}
5923}
5924
5925// GetAvailableFonts provides a mock function for the type MockFontDetector
5926func (_mock *MockFontDetector) GetAvailableFonts(ctx context.Context) ([]string, error) {
5927	ret := _mock.Called(ctx)
5928
5929	if len(ret) == 0 {
5930		panic("no return value specified for GetAvailableFonts")
5931	}
5932
5933	var r0 []string
5934	var r1 error
5935	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
5936		return returnFunc(ctx)
5937	}
5938	if returnFunc, ok := ret.Get(0).(func(context.Context) []string); ok {
5939		r0 = returnFunc(ctx)
5940	} else {
5941		if ret.Get(0) != nil {
5942			r0 = ret.Get(0).([]string)
5943		}
5944	}
5945	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
5946		r1 = returnFunc(ctx)
5947	} else {
5948		r1 = ret.Error(1)
5949	}
5950	return r0, r1
5951}
5952
5953// MockFontDetector_GetAvailableFonts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAvailableFonts'
5954type MockFontDetector_GetAvailableFonts_Call struct {
5955	*mock.Call
5956}
5957
5958// GetAvailableFonts is a helper method to define mock.On call
5959//   - ctx context.Context
5960func (_e *MockFontDetector_Expecter) GetAvailableFonts(ctx interface{}) *MockFontDetector_GetAvailableFonts_Call {
5961	return &MockFontDetector_GetAvailableFonts_Call{Call: _e.mock.On("GetAvailableFonts", ctx)}
5962}
5963
5964func (_c *MockFontDetector_GetAvailableFonts_Call) Run(run func(ctx context.Context)) *MockFontDetector_GetAvailableFonts_Call {
5965	_c.Call.Run(func(args mock.Arguments) {
5966		var arg0 context.Context
5967		if args[0] != nil {
5968			arg0 = args[0].(context.Context)
5969		}
5970		run(
5971			arg0,
5972		)
5973	})
5974	return _c
5975}
5976
5977func (_c *MockFontDetector_GetAvailableFonts_Call) Return(strings []string, err error) *MockFontDetector_GetAvailableFonts_Call {
5978	_c.Call.Return(strings, err)
5979	return _c
5980}
5981
5982func (_c *MockFontDetector_GetAvailableFonts_Call) RunAndReturn(run func(ctx context.Context) ([]string, error)) *MockFontDetector_GetAvailableFonts_Call {
5983	_c.Call.Return(run)
5984	return _c
5985}
5986
5987// IsAvailable provides a mock function for the type MockFontDetector
5988func (_mock *MockFontDetector) IsAvailable(ctx context.Context) bool {
5989	ret := _mock.Called(ctx)
5990
5991	if len(ret) == 0 {
5992		panic("no return value specified for IsAvailable")
5993	}
5994
5995	var r0 bool
5996	if returnFunc, ok := ret.Get(0).(func(context.Context) bool); ok {
5997		r0 = returnFunc(ctx)
5998	} else {
5999		r0 = ret.Get(0).(bool)
6000	}
6001	return r0
6002}
6003
6004// MockFontDetector_IsAvailable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsAvailable'
6005type MockFontDetector_IsAvailable_Call struct {
6006	*mock.Call
6007}
6008
6009// IsAvailable is a helper method to define mock.On call
6010//   - ctx context.Context
6011func (_e *MockFontDetector_Expecter) IsAvailable(ctx interface{}) *MockFontDetector_IsAvailable_Call {
6012	return &MockFontDetector_IsAvailable_Call{Call: _e.mock.On("IsAvailable", ctx)}
6013}
6014
6015func (_c *MockFontDetector_IsAvailable_Call) Run(run func(ctx context.Context)) *MockFontDetector_IsAvailable_Call {
6016	_c.Call.Run(func(args mock.Arguments) {
6017		var arg0 context.Context
6018		if args[0] != nil {
6019			arg0 = args[0].(context.Context)
6020		}
6021		run(
6022			arg0,
6023		)
6024	})
6025	return _c
6026}
6027
6028func (_c *MockFontDetector_IsAvailable_Call) Return(b bool) *MockFontDetector_IsAvailable_Call {
6029	_c.Call.Return(b)
6030	return _c
6031}
6032
6033func (_c *MockFontDetector_IsAvailable_Call) RunAndReturn(run func(ctx context.Context) bool) *MockFontDetector_IsAvailable_Call {
6034	_c.Call.Return(run)
6035	return _c
6036}
6037
6038// SelectBestFont provides a mock function for the type MockFontDetector
6039func (_mock *MockFontDetector) SelectBestFont(ctx context.Context, category port.FontCategory, fallbackChain []string) string {
6040	ret := _mock.Called(ctx, category, fallbackChain)
6041
6042	if len(ret) == 0 {
6043		panic("no return value specified for SelectBestFont")
6044	}
6045
6046	var r0 string
6047	if returnFunc, ok := ret.Get(0).(func(context.Context, port.FontCategory, []string) string); ok {
6048		r0 = returnFunc(ctx, category, fallbackChain)
6049	} else {
6050		r0 = ret.Get(0).(string)
6051	}
6052	return r0
6053}
6054
6055// MockFontDetector_SelectBestFont_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectBestFont'
6056type MockFontDetector_SelectBestFont_Call struct {
6057	*mock.Call
6058}
6059
6060// SelectBestFont is a helper method to define mock.On call
6061//   - ctx context.Context
6062//   - category port.FontCategory
6063//   - fallbackChain []string
6064func (_e *MockFontDetector_Expecter) SelectBestFont(ctx interface{}, category interface{}, fallbackChain interface{}) *MockFontDetector_SelectBestFont_Call {
6065	return &MockFontDetector_SelectBestFont_Call{Call: _e.mock.On("SelectBestFont", ctx, category, fallbackChain)}
6066}
6067
6068func (_c *MockFontDetector_SelectBestFont_Call) Run(run func(ctx context.Context, category port.FontCategory, fallbackChain []string)) *MockFontDetector_SelectBestFont_Call {
6069	_c.Call.Run(func(args mock.Arguments) {
6070		var arg0 context.Context
6071		if args[0] != nil {
6072			arg0 = args[0].(context.Context)
6073		}
6074		var arg1 port.FontCategory
6075		if args[1] != nil {
6076			arg1 = args[1].(port.FontCategory)
6077		}
6078		var arg2 []string
6079		if args[2] != nil {
6080			arg2 = args[2].([]string)
6081		}
6082		run(
6083			arg0,
6084			arg1,
6085			arg2,
6086		)
6087	})
6088	return _c
6089}
6090
6091func (_c *MockFontDetector_SelectBestFont_Call) Return(s string) *MockFontDetector_SelectBestFont_Call {
6092	_c.Call.Return(s)
6093	return _c
6094}
6095
6096func (_c *MockFontDetector_SelectBestFont_Call) RunAndReturn(run func(ctx context.Context, category port.FontCategory, fallbackChain []string) string) *MockFontDetector_SelectBestFont_Call {
6097	_c.Call.Return(run)
6098	return _c
6099}
6100
6101// NewMockAccentKeyHandler creates a new instance of MockAccentKeyHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
6102// The first argument is typically a *testing.T value.
6103func NewMockAccentKeyHandler(t interface {
6104	mock.TestingT
6105	Cleanup(func())
6106}) *MockAccentKeyHandler {
6107	mock := &MockAccentKeyHandler{}
6108	mock.Mock.Test(t)
6109
6110	t.Cleanup(func() { mock.AssertExpectations(t) })
6111
6112	return mock
6113}
6114
6115// MockAccentKeyHandler is an autogenerated mock type for the AccentKeyHandler type
6116type MockAccentKeyHandler struct {
6117	mock.Mock
6118}
6119
6120type MockAccentKeyHandler_Expecter struct {
6121	mock *mock.Mock
6122}
6123
6124func (_m *MockAccentKeyHandler) EXPECT() *MockAccentKeyHandler_Expecter {
6125	return &MockAccentKeyHandler_Expecter{mock: &_m.Mock}
6126}
6127
6128// OnKeyPressed provides a mock function for the type MockAccentKeyHandler
6129func (_mock *MockAccentKeyHandler) OnKeyPressed(ctx context.Context, char rune, shiftHeld bool) bool {
6130	ret := _mock.Called(ctx, char, shiftHeld)
6131
6132	if len(ret) == 0 {
6133		panic("no return value specified for OnKeyPressed")
6134	}
6135
6136	var r0 bool
6137	if returnFunc, ok := ret.Get(0).(func(context.Context, rune, bool) bool); ok {
6138		r0 = returnFunc(ctx, char, shiftHeld)
6139	} else {
6140		r0 = ret.Get(0).(bool)
6141	}
6142	return r0
6143}
6144
6145// MockAccentKeyHandler_OnKeyPressed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnKeyPressed'
6146type MockAccentKeyHandler_OnKeyPressed_Call struct {
6147	*mock.Call
6148}
6149
6150// OnKeyPressed is a helper method to define mock.On call
6151//   - ctx context.Context
6152//   - char rune
6153//   - shiftHeld bool
6154func (_e *MockAccentKeyHandler_Expecter) OnKeyPressed(ctx interface{}, char interface{}, shiftHeld interface{}) *MockAccentKeyHandler_OnKeyPressed_Call {
6155	return &MockAccentKeyHandler_OnKeyPressed_Call{Call: _e.mock.On("OnKeyPressed", ctx, char, shiftHeld)}
6156}
6157
6158func (_c *MockAccentKeyHandler_OnKeyPressed_Call) Run(run func(ctx context.Context, char rune, shiftHeld bool)) *MockAccentKeyHandler_OnKeyPressed_Call {
6159	_c.Call.Run(func(args mock.Arguments) {
6160		var arg0 context.Context
6161		if args[0] != nil {
6162			arg0 = args[0].(context.Context)
6163		}
6164		var arg1 rune
6165		if args[1] != nil {
6166			arg1 = args[1].(rune)
6167		}
6168		var arg2 bool
6169		if args[2] != nil {
6170			arg2 = args[2].(bool)
6171		}
6172		run(
6173			arg0,
6174			arg1,
6175			arg2,
6176		)
6177	})
6178	return _c
6179}
6180
6181func (_c *MockAccentKeyHandler_OnKeyPressed_Call) Return(b bool) *MockAccentKeyHandler_OnKeyPressed_Call {
6182	_c.Call.Return(b)
6183	return _c
6184}
6185
6186func (_c *MockAccentKeyHandler_OnKeyPressed_Call) RunAndReturn(run func(ctx context.Context, char rune, shiftHeld bool) bool) *MockAccentKeyHandler_OnKeyPressed_Call {
6187	_c.Call.Return(run)
6188	return _c
6189}
6190
6191// OnKeyReleased provides a mock function for the type MockAccentKeyHandler
6192func (_mock *MockAccentKeyHandler) OnKeyReleased(ctx context.Context, char rune) {
6193	_mock.Called(ctx, char)
6194	return
6195}
6196
6197// MockAccentKeyHandler_OnKeyReleased_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnKeyReleased'
6198type MockAccentKeyHandler_OnKeyReleased_Call struct {
6199	*mock.Call
6200}
6201
6202// OnKeyReleased is a helper method to define mock.On call
6203//   - ctx context.Context
6204//   - char rune
6205func (_e *MockAccentKeyHandler_Expecter) OnKeyReleased(ctx interface{}, char interface{}) *MockAccentKeyHandler_OnKeyReleased_Call {
6206	return &MockAccentKeyHandler_OnKeyReleased_Call{Call: _e.mock.On("OnKeyReleased", ctx, char)}
6207}
6208
6209func (_c *MockAccentKeyHandler_OnKeyReleased_Call) Run(run func(ctx context.Context, char rune)) *MockAccentKeyHandler_OnKeyReleased_Call {
6210	_c.Call.Run(func(args mock.Arguments) {
6211		var arg0 context.Context
6212		if args[0] != nil {
6213			arg0 = args[0].(context.Context)
6214		}
6215		var arg1 rune
6216		if args[1] != nil {
6217			arg1 = args[1].(rune)
6218		}
6219		run(
6220			arg0,
6221			arg1,
6222		)
6223	})
6224	return _c
6225}
6226
6227func (_c *MockAccentKeyHandler_OnKeyReleased_Call) Return() *MockAccentKeyHandler_OnKeyReleased_Call {
6228	_c.Call.Return()
6229	return _c
6230}
6231
6232func (_c *MockAccentKeyHandler_OnKeyReleased_Call) RunAndReturn(run func(ctx context.Context, char rune)) *MockAccentKeyHandler_OnKeyReleased_Call {
6233	_c.Run(run)
6234	return _c
6235}
6236
6237// NewMockDownloadPreparer creates a new instance of MockDownloadPreparer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
6238// The first argument is typically a *testing.T value.
6239func NewMockDownloadPreparer(t interface {
6240	mock.TestingT
6241	Cleanup(func())
6242}) *MockDownloadPreparer {
6243	mock := &MockDownloadPreparer{}
6244	mock.Mock.Test(t)
6245
6246	t.Cleanup(func() { mock.AssertExpectations(t) })
6247
6248	return mock
6249}
6250
6251// MockDownloadPreparer is an autogenerated mock type for the DownloadPreparer type
6252type MockDownloadPreparer struct {
6253	mock.Mock
6254}
6255
6256type MockDownloadPreparer_Expecter struct {
6257	mock *mock.Mock
6258}
6259
6260func (_m *MockDownloadPreparer) EXPECT() *MockDownloadPreparer_Expecter {
6261	return &MockDownloadPreparer_Expecter{mock: &_m.Mock}
6262}
6263
6264// Execute provides a mock function for the type MockDownloadPreparer
6265func (_mock *MockDownloadPreparer) Execute(ctx context.Context, input port.DownloadPrepareInput) *port.DownloadPrepareOutput {
6266	ret := _mock.Called(ctx, input)
6267
6268	if len(ret) == 0 {
6269		panic("no return value specified for Execute")
6270	}
6271
6272	var r0 *port.DownloadPrepareOutput
6273	if returnFunc, ok := ret.Get(0).(func(context.Context, port.DownloadPrepareInput) *port.DownloadPrepareOutput); ok {
6274		r0 = returnFunc(ctx, input)
6275	} else {
6276		if ret.Get(0) != nil {
6277			r0 = ret.Get(0).(*port.DownloadPrepareOutput)
6278		}
6279	}
6280	return r0
6281}
6282
6283// MockDownloadPreparer_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'
6284type MockDownloadPreparer_Execute_Call struct {
6285	*mock.Call
6286}
6287
6288// Execute is a helper method to define mock.On call
6289//   - ctx context.Context
6290//   - input port.DownloadPrepareInput
6291func (_e *MockDownloadPreparer_Expecter) Execute(ctx interface{}, input interface{}) *MockDownloadPreparer_Execute_Call {
6292	return &MockDownloadPreparer_Execute_Call{Call: _e.mock.On("Execute", ctx, input)}
6293}
6294
6295func (_c *MockDownloadPreparer_Execute_Call) Run(run func(ctx context.Context, input port.DownloadPrepareInput)) *MockDownloadPreparer_Execute_Call {
6296	_c.Call.Run(func(args mock.Arguments) {
6297		var arg0 context.Context
6298		if args[0] != nil {
6299			arg0 = args[0].(context.Context)
6300		}
6301		var arg1 port.DownloadPrepareInput
6302		if args[1] != nil {
6303			arg1 = args[1].(port.DownloadPrepareInput)
6304		}
6305		run(
6306			arg0,
6307			arg1,
6308		)
6309	})
6310	return _c
6311}
6312
6313func (_c *MockDownloadPreparer_Execute_Call) Return(downloadPrepareOutput *port.DownloadPrepareOutput) *MockDownloadPreparer_Execute_Call {
6314	_c.Call.Return(downloadPrepareOutput)
6315	return _c
6316}
6317
6318func (_c *MockDownloadPreparer_Execute_Call) RunAndReturn(run func(ctx context.Context, input port.DownloadPrepareInput) *port.DownloadPrepareOutput) *MockDownloadPreparer_Execute_Call {
6319	_c.Call.Return(run)
6320	return _c
6321}
6322
6323// NewMockAutoCopyConfig creates a new instance of MockAutoCopyConfig. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
6324// The first argument is typically a *testing.T value.
6325func NewMockAutoCopyConfig(t interface {
6326	mock.TestingT
6327	Cleanup(func())
6328}) *MockAutoCopyConfig {
6329	mock := &MockAutoCopyConfig{}
6330	mock.Mock.Test(t)
6331
6332	t.Cleanup(func() { mock.AssertExpectations(t) })
6333
6334	return mock
6335}
6336
6337// MockAutoCopyConfig is an autogenerated mock type for the AutoCopyConfig type
6338type MockAutoCopyConfig struct {
6339	mock.Mock
6340}
6341
6342type MockAutoCopyConfig_Expecter struct {
6343	mock *mock.Mock
6344}
6345
6346func (_m *MockAutoCopyConfig) EXPECT() *MockAutoCopyConfig_Expecter {
6347	return &MockAutoCopyConfig_Expecter{mock: &_m.Mock}
6348}
6349
6350// IsAutoCopyEnabled provides a mock function for the type MockAutoCopyConfig
6351func (_mock *MockAutoCopyConfig) IsAutoCopyEnabled() bool {
6352	ret := _mock.Called()
6353
6354	if len(ret) == 0 {
6355		panic("no return value specified for IsAutoCopyEnabled")
6356	}
6357
6358	var r0 bool
6359	if returnFunc, ok := ret.Get(0).(func() bool); ok {
6360		r0 = returnFunc()
6361	} else {
6362		r0 = ret.Get(0).(bool)
6363	}
6364	return r0
6365}
6366
6367// MockAutoCopyConfig_IsAutoCopyEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsAutoCopyEnabled'
6368type MockAutoCopyConfig_IsAutoCopyEnabled_Call struct {
6369	*mock.Call
6370}
6371
6372// IsAutoCopyEnabled is a helper method to define mock.On call
6373func (_e *MockAutoCopyConfig_Expecter) IsAutoCopyEnabled() *MockAutoCopyConfig_IsAutoCopyEnabled_Call {
6374	return &MockAutoCopyConfig_IsAutoCopyEnabled_Call{Call: _e.mock.On("IsAutoCopyEnabled")}
6375}
6376
6377func (_c *MockAutoCopyConfig_IsAutoCopyEnabled_Call) Run(run func()) *MockAutoCopyConfig_IsAutoCopyEnabled_Call {
6378	_c.Call.Run(func(args mock.Arguments) {
6379		run()
6380	})
6381	return _c
6382}
6383
6384func (_c *MockAutoCopyConfig_IsAutoCopyEnabled_Call) Return(b bool) *MockAutoCopyConfig_IsAutoCopyEnabled_Call {
6385	_c.Call.Return(b)
6386	return _c
6387}
6388
6389func (_c *MockAutoCopyConfig_IsAutoCopyEnabled_Call) RunAndReturn(run func() bool) *MockAutoCopyConfig_IsAutoCopyEnabled_Call {
6390	_c.Call.Return(run)
6391	return _c
6392}
6393
6394// NewMockHardwareSurveyor creates a new instance of MockHardwareSurveyor. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
6395// The first argument is typically a *testing.T value.
6396func NewMockHardwareSurveyor(t interface {
6397	mock.TestingT
6398	Cleanup(func())
6399}) *MockHardwareSurveyor {
6400	mock := &MockHardwareSurveyor{}
6401	mock.Mock.Test(t)
6402
6403	t.Cleanup(func() { mock.AssertExpectations(t) })
6404
6405	return mock
6406}
6407
6408// MockHardwareSurveyor is an autogenerated mock type for the HardwareSurveyor type
6409type MockHardwareSurveyor struct {
6410	mock.Mock
6411}
6412
6413type MockHardwareSurveyor_Expecter struct {
6414	mock *mock.Mock
6415}
6416
6417func (_m *MockHardwareSurveyor) EXPECT() *MockHardwareSurveyor_Expecter {
6418	return &MockHardwareSurveyor_Expecter{mock: &_m.Mock}
6419}
6420
6421// Survey provides a mock function for the type MockHardwareSurveyor
6422func (_mock *MockHardwareSurveyor) Survey(ctx context.Context) port.HardwareInfo {
6423	ret := _mock.Called(ctx)
6424
6425	if len(ret) == 0 {
6426		panic("no return value specified for Survey")
6427	}
6428
6429	var r0 port.HardwareInfo
6430	if returnFunc, ok := ret.Get(0).(func(context.Context) port.HardwareInfo); ok {
6431		r0 = returnFunc(ctx)
6432	} else {
6433		r0 = ret.Get(0).(port.HardwareInfo)
6434	}
6435	return r0
6436}
6437
6438// MockHardwareSurveyor_Survey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Survey'
6439type MockHardwareSurveyor_Survey_Call struct {
6440	*mock.Call
6441}
6442
6443// Survey is a helper method to define mock.On call
6444//   - ctx context.Context
6445func (_e *MockHardwareSurveyor_Expecter) Survey(ctx interface{}) *MockHardwareSurveyor_Survey_Call {
6446	return &MockHardwareSurveyor_Survey_Call{Call: _e.mock.On("Survey", ctx)}
6447}
6448
6449func (_c *MockHardwareSurveyor_Survey_Call) Run(run func(ctx context.Context)) *MockHardwareSurveyor_Survey_Call {
6450	_c.Call.Run(func(args mock.Arguments) {
6451		var arg0 context.Context
6452		if args[0] != nil {
6453			arg0 = args[0].(context.Context)
6454		}
6455		run(
6456			arg0,
6457		)
6458	})
6459	return _c
6460}
6461
6462func (_c *MockHardwareSurveyor_Survey_Call) Return(hardwareInfo port.HardwareInfo) *MockHardwareSurveyor_Survey_Call {
6463	_c.Call.Return(hardwareInfo)
6464	return _c
6465}
6466
6467func (_c *MockHardwareSurveyor_Survey_Call) RunAndReturn(run func(ctx context.Context) port.HardwareInfo) *MockHardwareSurveyor_Survey_Call {
6468	_c.Call.Return(run)
6469	return _c
6470}
6471
6472// NewMockHomepageHistory creates a new instance of MockHomepageHistory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
6473// The first argument is typically a *testing.T value.
6474func NewMockHomepageHistory(t interface {
6475	mock.TestingT
6476	Cleanup(func())
6477}) *MockHomepageHistory {
6478	mock := &MockHomepageHistory{}
6479	mock.Mock.Test(t)
6480
6481	t.Cleanup(func() { mock.AssertExpectations(t) })
6482
6483	return mock
6484}
6485
6486// MockHomepageHistory is an autogenerated mock type for the HomepageHistory type
6487type MockHomepageHistory struct {
6488	mock.Mock
6489}
6490
6491type MockHomepageHistory_Expecter struct {
6492	mock *mock.Mock
6493}
6494
6495func (_m *MockHomepageHistory) EXPECT() *MockHomepageHistory_Expecter {
6496	return &MockHomepageHistory_Expecter{mock: &_m.Mock}
6497}
6498
6499// ClearAll provides a mock function for the type MockHomepageHistory
6500func (_mock *MockHomepageHistory) ClearAll(ctx context.Context) error {
6501	ret := _mock.Called(ctx)
6502
6503	if len(ret) == 0 {
6504		panic("no return value specified for ClearAll")
6505	}
6506
6507	var r0 error
6508	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
6509		r0 = returnFunc(ctx)
6510	} else {
6511		r0 = ret.Error(0)
6512	}
6513	return r0
6514}
6515
6516// MockHomepageHistory_ClearAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearAll'
6517type MockHomepageHistory_ClearAll_Call struct {
6518	*mock.Call
6519}
6520
6521// ClearAll is a helper method to define mock.On call
6522//   - ctx context.Context
6523func (_e *MockHomepageHistory_Expecter) ClearAll(ctx interface{}) *MockHomepageHistory_ClearAll_Call {
6524	return &MockHomepageHistory_ClearAll_Call{Call: _e.mock.On("ClearAll", ctx)}
6525}
6526
6527func (_c *MockHomepageHistory_ClearAll_Call) Run(run func(ctx context.Context)) *MockHomepageHistory_ClearAll_Call {
6528	_c.Call.Run(func(args mock.Arguments) {
6529		var arg0 context.Context
6530		if args[0] != nil {
6531			arg0 = args[0].(context.Context)
6532		}
6533		run(
6534			arg0,
6535		)
6536	})
6537	return _c
6538}
6539
6540func (_c *MockHomepageHistory_ClearAll_Call) Return(err error) *MockHomepageHistory_ClearAll_Call {
6541	_c.Call.Return(err)
6542	return _c
6543}
6544
6545func (_c *MockHomepageHistory_ClearAll_Call) RunAndReturn(run func(ctx context.Context) error) *MockHomepageHistory_ClearAll_Call {
6546	_c.Call.Return(run)
6547	return _c
6548}
6549
6550// ClearOlderThan provides a mock function for the type MockHomepageHistory
6551func (_mock *MockHomepageHistory) ClearOlderThan(ctx context.Context, before time.Time) error {
6552	ret := _mock.Called(ctx, before)
6553
6554	if len(ret) == 0 {
6555		panic("no return value specified for ClearOlderThan")
6556	}
6557
6558	var r0 error
6559	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time) error); ok {
6560		r0 = returnFunc(ctx, before)
6561	} else {
6562		r0 = ret.Error(0)
6563	}
6564	return r0
6565}
6566
6567// MockHomepageHistory_ClearOlderThan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearOlderThan'
6568type MockHomepageHistory_ClearOlderThan_Call struct {
6569	*mock.Call
6570}
6571
6572// ClearOlderThan is a helper method to define mock.On call
6573//   - ctx context.Context
6574//   - before time.Time
6575func (_e *MockHomepageHistory_Expecter) ClearOlderThan(ctx interface{}, before interface{}) *MockHomepageHistory_ClearOlderThan_Call {
6576	return &MockHomepageHistory_ClearOlderThan_Call{Call: _e.mock.On("ClearOlderThan", ctx, before)}
6577}
6578
6579func (_c *MockHomepageHistory_ClearOlderThan_Call) Run(run func(ctx context.Context, before time.Time)) *MockHomepageHistory_ClearOlderThan_Call {
6580	_c.Call.Run(func(args mock.Arguments) {
6581		var arg0 context.Context
6582		if args[0] != nil {
6583			arg0 = args[0].(context.Context)
6584		}
6585		var arg1 time.Time
6586		if args[1] != nil {
6587			arg1 = args[1].(time.Time)
6588		}
6589		run(
6590			arg0,
6591			arg1,
6592		)
6593	})
6594	return _c
6595}
6596
6597func (_c *MockHomepageHistory_ClearOlderThan_Call) Return(err error) *MockHomepageHistory_ClearOlderThan_Call {
6598	_c.Call.Return(err)
6599	return _c
6600}
6601
6602func (_c *MockHomepageHistory_ClearOlderThan_Call) RunAndReturn(run func(ctx context.Context, before time.Time) error) *MockHomepageHistory_ClearOlderThan_Call {
6603	_c.Call.Return(run)
6604	return _c
6605}
6606
6607// ClearRange provides a mock function for the type MockHomepageHistory
6608func (_mock *MockHomepageHistory) ClearRange(ctx context.Context, rangeID string) error {
6609	ret := _mock.Called(ctx, rangeID)
6610
6611	if len(ret) == 0 {
6612		panic("no return value specified for ClearRange")
6613	}
6614
6615	var r0 error
6616	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
6617		r0 = returnFunc(ctx, rangeID)
6618	} else {
6619		r0 = ret.Error(0)
6620	}
6621	return r0
6622}
6623
6624// MockHomepageHistory_ClearRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearRange'
6625type MockHomepageHistory_ClearRange_Call struct {
6626	*mock.Call
6627}
6628
6629// ClearRange is a helper method to define mock.On call
6630//   - ctx context.Context
6631//   - rangeID string
6632func (_e *MockHomepageHistory_Expecter) ClearRange(ctx interface{}, rangeID interface{}) *MockHomepageHistory_ClearRange_Call {
6633	return &MockHomepageHistory_ClearRange_Call{Call: _e.mock.On("ClearRange", ctx, rangeID)}
6634}
6635
6636func (_c *MockHomepageHistory_ClearRange_Call) Run(run func(ctx context.Context, rangeID string)) *MockHomepageHistory_ClearRange_Call {
6637	_c.Call.Run(func(args mock.Arguments) {
6638		var arg0 context.Context
6639		if args[0] != nil {
6640			arg0 = args[0].(context.Context)
6641		}
6642		var arg1 string
6643		if args[1] != nil {
6644			arg1 = args[1].(string)
6645		}
6646		run(
6647			arg0,
6648			arg1,
6649		)
6650	})
6651	return _c
6652}
6653
6654func (_c *MockHomepageHistory_ClearRange_Call) Return(err error) *MockHomepageHistory_ClearRange_Call {
6655	_c.Call.Return(err)
6656	return _c
6657}
6658
6659func (_c *MockHomepageHistory_ClearRange_Call) RunAndReturn(run func(ctx context.Context, rangeID string) error) *MockHomepageHistory_ClearRange_Call {
6660	_c.Call.Return(run)
6661	return _c
6662}
6663
6664// Delete provides a mock function for the type MockHomepageHistory
6665func (_mock *MockHomepageHistory) Delete(ctx context.Context, id int64) error {
6666	ret := _mock.Called(ctx, id)
6667
6668	if len(ret) == 0 {
6669		panic("no return value specified for Delete")
6670	}
6671
6672	var r0 error
6673	if returnFunc, ok := ret.Get(0).(func(context.Context, int64) error); ok {
6674		r0 = returnFunc(ctx, id)
6675	} else {
6676		r0 = ret.Error(0)
6677	}
6678	return r0
6679}
6680
6681// MockHomepageHistory_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
6682type MockHomepageHistory_Delete_Call struct {
6683	*mock.Call
6684}
6685
6686// Delete is a helper method to define mock.On call
6687//   - ctx context.Context
6688//   - id int64
6689func (_e *MockHomepageHistory_Expecter) Delete(ctx interface{}, id interface{}) *MockHomepageHistory_Delete_Call {
6690	return &MockHomepageHistory_Delete_Call{Call: _e.mock.On("Delete", ctx, id)}
6691}
6692
6693func (_c *MockHomepageHistory_Delete_Call) Run(run func(ctx context.Context, id int64)) *MockHomepageHistory_Delete_Call {
6694	_c.Call.Run(func(args mock.Arguments) {
6695		var arg0 context.Context
6696		if args[0] != nil {
6697			arg0 = args[0].(context.Context)
6698		}
6699		var arg1 int64
6700		if args[1] != nil {
6701			arg1 = args[1].(int64)
6702		}
6703		run(
6704			arg0,
6705			arg1,
6706		)
6707	})
6708	return _c
6709}
6710
6711func (_c *MockHomepageHistory_Delete_Call) Return(err error) *MockHomepageHistory_Delete_Call {
6712	_c.Call.Return(err)
6713	return _c
6714}
6715
6716func (_c *MockHomepageHistory_Delete_Call) RunAndReturn(run func(ctx context.Context, id int64) error) *MockHomepageHistory_Delete_Call {
6717	_c.Call.Return(run)
6718	return _c
6719}
6720
6721// DeleteByDomain provides a mock function for the type MockHomepageHistory
6722func (_mock *MockHomepageHistory) DeleteByDomain(ctx context.Context, domain string) error {
6723	ret := _mock.Called(ctx, domain)
6724
6725	if len(ret) == 0 {
6726		panic("no return value specified for DeleteByDomain")
6727	}
6728
6729	var r0 error
6730	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
6731		r0 = returnFunc(ctx, domain)
6732	} else {
6733		r0 = ret.Error(0)
6734	}
6735	return r0
6736}
6737
6738// MockHomepageHistory_DeleteByDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteByDomain'
6739type MockHomepageHistory_DeleteByDomain_Call struct {
6740	*mock.Call
6741}
6742
6743// DeleteByDomain is a helper method to define mock.On call
6744//   - ctx context.Context
6745//   - domain string
6746func (_e *MockHomepageHistory_Expecter) DeleteByDomain(ctx interface{}, domain interface{}) *MockHomepageHistory_DeleteByDomain_Call {
6747	return &MockHomepageHistory_DeleteByDomain_Call{Call: _e.mock.On("DeleteByDomain", ctx, domain)}
6748}
6749
6750func (_c *MockHomepageHistory_DeleteByDomain_Call) Run(run func(ctx context.Context, domain string)) *MockHomepageHistory_DeleteByDomain_Call {
6751	_c.Call.Run(func(args mock.Arguments) {
6752		var arg0 context.Context
6753		if args[0] != nil {
6754			arg0 = args[0].(context.Context)
6755		}
6756		var arg1 string
6757		if args[1] != nil {
6758			arg1 = args[1].(string)
6759		}
6760		run(
6761			arg0,
6762			arg1,
6763		)
6764	})
6765	return _c
6766}
6767
6768func (_c *MockHomepageHistory_DeleteByDomain_Call) Return(err error) *MockHomepageHistory_DeleteByDomain_Call {
6769	_c.Call.Return(err)
6770	return _c
6771}
6772
6773func (_c *MockHomepageHistory_DeleteByDomain_Call) RunAndReturn(run func(ctx context.Context, domain string) error) *MockHomepageHistory_DeleteByDomain_Call {
6774	_c.Call.Return(run)
6775	return _c
6776}
6777
6778// GetAnalytics provides a mock function for the type MockHomepageHistory
6779func (_mock *MockHomepageHistory) GetAnalytics(ctx context.Context) (*entity.HistoryAnalytics, error) {
6780	ret := _mock.Called(ctx)
6781
6782	if len(ret) == 0 {
6783		panic("no return value specified for GetAnalytics")
6784	}
6785
6786	var r0 *entity.HistoryAnalytics
6787	var r1 error
6788	if returnFunc, ok := ret.Get(0).(func(context.Context) (*entity.HistoryAnalytics, error)); ok {
6789		return returnFunc(ctx)
6790	}
6791	if returnFunc, ok := ret.Get(0).(func(context.Context) *entity.HistoryAnalytics); ok {
6792		r0 = returnFunc(ctx)
6793	} else {
6794		if ret.Get(0) != nil {
6795			r0 = ret.Get(0).(*entity.HistoryAnalytics)
6796		}
6797	}
6798	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
6799		r1 = returnFunc(ctx)
6800	} else {
6801		r1 = ret.Error(1)
6802	}
6803	return r0, r1
6804}
6805
6806// MockHomepageHistory_GetAnalytics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAnalytics'
6807type MockHomepageHistory_GetAnalytics_Call struct {
6808	*mock.Call
6809}
6810
6811// GetAnalytics is a helper method to define mock.On call
6812//   - ctx context.Context
6813func (_e *MockHomepageHistory_Expecter) GetAnalytics(ctx interface{}) *MockHomepageHistory_GetAnalytics_Call {
6814	return &MockHomepageHistory_GetAnalytics_Call{Call: _e.mock.On("GetAnalytics", ctx)}
6815}
6816
6817func (_c *MockHomepageHistory_GetAnalytics_Call) Run(run func(ctx context.Context)) *MockHomepageHistory_GetAnalytics_Call {
6818	_c.Call.Run(func(args mock.Arguments) {
6819		var arg0 context.Context
6820		if args[0] != nil {
6821			arg0 = args[0].(context.Context)
6822		}
6823		run(
6824			arg0,
6825		)
6826	})
6827	return _c
6828}
6829
6830func (_c *MockHomepageHistory_GetAnalytics_Call) Return(historyAnalytics *entity.HistoryAnalytics, err error) *MockHomepageHistory_GetAnalytics_Call {
6831	_c.Call.Return(historyAnalytics, err)
6832	return _c
6833}
6834
6835func (_c *MockHomepageHistory_GetAnalytics_Call) RunAndReturn(run func(ctx context.Context) (*entity.HistoryAnalytics, error)) *MockHomepageHistory_GetAnalytics_Call {
6836	_c.Call.Return(run)
6837	return _c
6838}
6839
6840// GetDomainStats provides a mock function for the type MockHomepageHistory
6841func (_mock *MockHomepageHistory) GetDomainStats(ctx context.Context, limit int) ([]*entity.DomainStat, error) {
6842	ret := _mock.Called(ctx, limit)
6843
6844	if len(ret) == 0 {
6845		panic("no return value specified for GetDomainStats")
6846	}
6847
6848	var r0 []*entity.DomainStat
6849	var r1 error
6850	if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]*entity.DomainStat, error)); ok {
6851		return returnFunc(ctx, limit)
6852	}
6853	if returnFunc, ok := ret.Get(0).(func(context.Context, int) []*entity.DomainStat); ok {
6854		r0 = returnFunc(ctx, limit)
6855	} else {
6856		if ret.Get(0) != nil {
6857			r0 = ret.Get(0).([]*entity.DomainStat)
6858		}
6859	}
6860	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
6861		r1 = returnFunc(ctx, limit)
6862	} else {
6863		r1 = ret.Error(1)
6864	}
6865	return r0, r1
6866}
6867
6868// MockHomepageHistory_GetDomainStats_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDomainStats'
6869type MockHomepageHistory_GetDomainStats_Call struct {
6870	*mock.Call
6871}
6872
6873// GetDomainStats is a helper method to define mock.On call
6874//   - ctx context.Context
6875//   - limit int
6876func (_e *MockHomepageHistory_Expecter) GetDomainStats(ctx interface{}, limit interface{}) *MockHomepageHistory_GetDomainStats_Call {
6877	return &MockHomepageHistory_GetDomainStats_Call{Call: _e.mock.On("GetDomainStats", ctx, limit)}
6878}
6879
6880func (_c *MockHomepageHistory_GetDomainStats_Call) Run(run func(ctx context.Context, limit int)) *MockHomepageHistory_GetDomainStats_Call {
6881	_c.Call.Run(func(args mock.Arguments) {
6882		var arg0 context.Context
6883		if args[0] != nil {
6884			arg0 = args[0].(context.Context)
6885		}
6886		var arg1 int
6887		if args[1] != nil {
6888			arg1 = args[1].(int)
6889		}
6890		run(
6891			arg0,
6892			arg1,
6893		)
6894	})
6895	return _c
6896}
6897
6898func (_c *MockHomepageHistory_GetDomainStats_Call) Return(domainStats []*entity.DomainStat, err error) *MockHomepageHistory_GetDomainStats_Call {
6899	_c.Call.Return(domainStats, err)
6900	return _c
6901}
6902
6903func (_c *MockHomepageHistory_GetDomainStats_Call) RunAndReturn(run func(ctx context.Context, limit int) ([]*entity.DomainStat, error)) *MockHomepageHistory_GetDomainStats_Call {
6904	_c.Call.Return(run)
6905	return _c
6906}
6907
6908// GetRecent provides a mock function for the type MockHomepageHistory
6909func (_mock *MockHomepageHistory) GetRecent(ctx context.Context, limit int, offset int) ([]*entity.HistoryEntry, error) {
6910	ret := _mock.Called(ctx, limit, offset)
6911
6912	if len(ret) == 0 {
6913		panic("no return value specified for GetRecent")
6914	}
6915
6916	var r0 []*entity.HistoryEntry
6917	var r1 error
6918	if returnFunc, ok := ret.Get(0).(func(context.Context, int, int) ([]*entity.HistoryEntry, error)); ok {
6919		return returnFunc(ctx, limit, offset)
6920	}
6921	if returnFunc, ok := ret.Get(0).(func(context.Context, int, int) []*entity.HistoryEntry); ok {
6922		r0 = returnFunc(ctx, limit, offset)
6923	} else {
6924		if ret.Get(0) != nil {
6925			r0 = ret.Get(0).([]*entity.HistoryEntry)
6926		}
6927	}
6928	if returnFunc, ok := ret.Get(1).(func(context.Context, int, int) error); ok {
6929		r1 = returnFunc(ctx, limit, offset)
6930	} else {
6931		r1 = ret.Error(1)
6932	}
6933	return r0, r1
6934}
6935
6936// MockHomepageHistory_GetRecent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecent'
6937type MockHomepageHistory_GetRecent_Call struct {
6938	*mock.Call
6939}
6940
6941// GetRecent is a helper method to define mock.On call
6942//   - ctx context.Context
6943//   - limit int
6944//   - offset int
6945func (_e *MockHomepageHistory_Expecter) GetRecent(ctx interface{}, limit interface{}, offset interface{}) *MockHomepageHistory_GetRecent_Call {
6946	return &MockHomepageHistory_GetRecent_Call{Call: _e.mock.On("GetRecent", ctx, limit, offset)}
6947}
6948
6949func (_c *MockHomepageHistory_GetRecent_Call) Run(run func(ctx context.Context, limit int, offset int)) *MockHomepageHistory_GetRecent_Call {
6950	_c.Call.Run(func(args mock.Arguments) {
6951		var arg0 context.Context
6952		if args[0] != nil {
6953			arg0 = args[0].(context.Context)
6954		}
6955		var arg1 int
6956		if args[1] != nil {
6957			arg1 = args[1].(int)
6958		}
6959		var arg2 int
6960		if args[2] != nil {
6961			arg2 = args[2].(int)
6962		}
6963		run(
6964			arg0,
6965			arg1,
6966			arg2,
6967		)
6968	})
6969	return _c
6970}
6971
6972func (_c *MockHomepageHistory_GetRecent_Call) Return(historyEntrys []*entity.HistoryEntry, err error) *MockHomepageHistory_GetRecent_Call {
6973	_c.Call.Return(historyEntrys, err)
6974	return _c
6975}
6976
6977func (_c *MockHomepageHistory_GetRecent_Call) RunAndReturn(run func(ctx context.Context, limit int, offset int) ([]*entity.HistoryEntry, error)) *MockHomepageHistory_GetRecent_Call {
6978	_c.Call.Return(run)
6979	return _c
6980}
6981
6982// GetRecentByDomain provides a mock function for the type MockHomepageHistory
6983func (_mock *MockHomepageHistory) GetRecentByDomain(ctx context.Context, domain string, limit int, offset int) ([]*entity.HistoryEntry, error) {
6984	ret := _mock.Called(ctx, domain, limit, offset)
6985
6986	if len(ret) == 0 {
6987		panic("no return value specified for GetRecentByDomain")
6988	}
6989
6990	var r0 []*entity.HistoryEntry
6991	var r1 error
6992	if returnFunc, ok := ret.Get(0).(func(context.Context, string, int, int) ([]*entity.HistoryEntry, error)); ok {
6993		return returnFunc(ctx, domain, limit, offset)
6994	}
6995	if returnFunc, ok := ret.Get(0).(func(context.Context, string, int, int) []*entity.HistoryEntry); ok {
6996		r0 = returnFunc(ctx, domain, limit, offset)
6997	} else {
6998		if ret.Get(0) != nil {
6999			r0 = ret.Get(0).([]*entity.HistoryEntry)
7000		}
7001	}
7002	if returnFunc, ok := ret.Get(1).(func(context.Context, string, int, int) error); ok {
7003		r1 = returnFunc(ctx, domain, limit, offset)
7004	} else {
7005		r1 = ret.Error(1)
7006	}
7007	return r0, r1
7008}
7009
7010// MockHomepageHistory_GetRecentByDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecentByDomain'
7011type MockHomepageHistory_GetRecentByDomain_Call struct {
7012	*mock.Call
7013}
7014
7015// GetRecentByDomain is a helper method to define mock.On call
7016//   - ctx context.Context
7017//   - domain string
7018//   - limit int
7019//   - offset int
7020func (_e *MockHomepageHistory_Expecter) GetRecentByDomain(ctx interface{}, domain interface{}, limit interface{}, offset interface{}) *MockHomepageHistory_GetRecentByDomain_Call {
7021	return &MockHomepageHistory_GetRecentByDomain_Call{Call: _e.mock.On("GetRecentByDomain", ctx, domain, limit, offset)}
7022}
7023
7024func (_c *MockHomepageHistory_GetRecentByDomain_Call) Run(run func(ctx context.Context, domain string, limit int, offset int)) *MockHomepageHistory_GetRecentByDomain_Call {
7025	_c.Call.Run(func(args mock.Arguments) {
7026		var arg0 context.Context
7027		if args[0] != nil {
7028			arg0 = args[0].(context.Context)
7029		}
7030		var arg1 string
7031		if args[1] != nil {
7032			arg1 = args[1].(string)
7033		}
7034		var arg2 int
7035		if args[2] != nil {
7036			arg2 = args[2].(int)
7037		}
7038		var arg3 int
7039		if args[3] != nil {
7040			arg3 = args[3].(int)
7041		}
7042		run(
7043			arg0,
7044			arg1,
7045			arg2,
7046			arg3,
7047		)
7048	})
7049	return _c
7050}
7051
7052func (_c *MockHomepageHistory_GetRecentByDomain_Call) Return(historyEntrys []*entity.HistoryEntry, err error) *MockHomepageHistory_GetRecentByDomain_Call {
7053	_c.Call.Return(historyEntrys, err)
7054	return _c
7055}
7056
7057func (_c *MockHomepageHistory_GetRecentByDomain_Call) RunAndReturn(run func(ctx context.Context, domain string, limit int, offset int) ([]*entity.HistoryEntry, error)) *MockHomepageHistory_GetRecentByDomain_Call {
7058	_c.Call.Return(run)
7059	return _c
7060}
7061
7062// GetRecentWindow provides a mock function for the type MockHomepageHistory
7063func (_mock *MockHomepageHistory) GetRecentWindow(ctx context.Context, before time.Time, domain string) (*entity.HistoryWindow, error) {
7064	ret := _mock.Called(ctx, before, domain)
7065
7066	if len(ret) == 0 {
7067		panic("no return value specified for GetRecentWindow")
7068	}
7069
7070	var r0 *entity.HistoryWindow
7071	var r1 error
7072	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time, string) (*entity.HistoryWindow, error)); ok {
7073		return returnFunc(ctx, before, domain)
7074	}
7075	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time, string) *entity.HistoryWindow); ok {
7076		r0 = returnFunc(ctx, before, domain)
7077	} else {
7078		if ret.Get(0) != nil {
7079			r0 = ret.Get(0).(*entity.HistoryWindow)
7080		}
7081	}
7082	if returnFunc, ok := ret.Get(1).(func(context.Context, time.Time, string) error); ok {
7083		r1 = returnFunc(ctx, before, domain)
7084	} else {
7085		r1 = ret.Error(1)
7086	}
7087	return r0, r1
7088}
7089
7090// MockHomepageHistory_GetRecentWindow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecentWindow'
7091type MockHomepageHistory_GetRecentWindow_Call struct {
7092	*mock.Call
7093}
7094
7095// GetRecentWindow is a helper method to define mock.On call
7096//   - ctx context.Context
7097//   - before time.Time
7098//   - domain string
7099func (_e *MockHomepageHistory_Expecter) GetRecentWindow(ctx interface{}, before interface{}, domain interface{}) *MockHomepageHistory_GetRecentWindow_Call {
7100	return &MockHomepageHistory_GetRecentWindow_Call{Call: _e.mock.On("GetRecentWindow", ctx, before, domain)}
7101}
7102
7103func (_c *MockHomepageHistory_GetRecentWindow_Call) Run(run func(ctx context.Context, before time.Time, domain string)) *MockHomepageHistory_GetRecentWindow_Call {
7104	_c.Call.Run(func(args mock.Arguments) {
7105		var arg0 context.Context
7106		if args[0] != nil {
7107			arg0 = args[0].(context.Context)
7108		}
7109		var arg1 time.Time
7110		if args[1] != nil {
7111			arg1 = args[1].(time.Time)
7112		}
7113		var arg2 string
7114		if args[2] != nil {
7115			arg2 = args[2].(string)
7116		}
7117		run(
7118			arg0,
7119			arg1,
7120			arg2,
7121		)
7122	})
7123	return _c
7124}
7125
7126func (_c *MockHomepageHistory_GetRecentWindow_Call) Return(historyWindow *entity.HistoryWindow, err error) *MockHomepageHistory_GetRecentWindow_Call {
7127	_c.Call.Return(historyWindow, err)
7128	return _c
7129}
7130
7131func (_c *MockHomepageHistory_GetRecentWindow_Call) RunAndReturn(run func(ctx context.Context, before time.Time, domain string) (*entity.HistoryWindow, error)) *MockHomepageHistory_GetRecentWindow_Call {
7132	_c.Call.Return(run)
7133	return _c
7134}
7135
7136// GetStats provides a mock function for the type MockHomepageHistory
7137func (_mock *MockHomepageHistory) GetStats(ctx context.Context) (*entity.HistoryStats, error) {
7138	ret := _mock.Called(ctx)
7139
7140	if len(ret) == 0 {
7141		panic("no return value specified for GetStats")
7142	}
7143
7144	var r0 *entity.HistoryStats
7145	var r1 error
7146	if returnFunc, ok := ret.Get(0).(func(context.Context) (*entity.HistoryStats, error)); ok {
7147		return returnFunc(ctx)
7148	}
7149	if returnFunc, ok := ret.Get(0).(func(context.Context) *entity.HistoryStats); ok {
7150		r0 = returnFunc(ctx)
7151	} else {
7152		if ret.Get(0) != nil {
7153			r0 = ret.Get(0).(*entity.HistoryStats)
7154		}
7155	}
7156	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
7157		r1 = returnFunc(ctx)
7158	} else {
7159		r1 = ret.Error(1)
7160	}
7161	return r0, r1
7162}
7163
7164// MockHomepageHistory_GetStats_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStats'
7165type MockHomepageHistory_GetStats_Call struct {
7166	*mock.Call
7167}
7168
7169// GetStats is a helper method to define mock.On call
7170//   - ctx context.Context
7171func (_e *MockHomepageHistory_Expecter) GetStats(ctx interface{}) *MockHomepageHistory_GetStats_Call {
7172	return &MockHomepageHistory_GetStats_Call{Call: _e.mock.On("GetStats", ctx)}
7173}
7174
7175func (_c *MockHomepageHistory_GetStats_Call) Run(run func(ctx context.Context)) *MockHomepageHistory_GetStats_Call {
7176	_c.Call.Run(func(args mock.Arguments) {
7177		var arg0 context.Context
7178		if args[0] != nil {
7179			arg0 = args[0].(context.Context)
7180		}
7181		run(
7182			arg0,
7183		)
7184	})
7185	return _c
7186}
7187
7188func (_c *MockHomepageHistory_GetStats_Call) Return(historyStats *entity.HistoryStats, err error) *MockHomepageHistory_GetStats_Call {
7189	_c.Call.Return(historyStats, err)
7190	return _c
7191}
7192
7193func (_c *MockHomepageHistory_GetStats_Call) RunAndReturn(run func(ctx context.Context) (*entity.HistoryStats, error)) *MockHomepageHistory_GetStats_Call {
7194	_c.Call.Return(run)
7195	return _c
7196}
7197
7198// Search provides a mock function for the type MockHomepageHistory
7199func (_mock *MockHomepageHistory) Search(ctx context.Context, input dto.HistorySearchInput) (*dto.HistorySearchOutput, error) {
7200	ret := _mock.Called(ctx, input)
7201
7202	if len(ret) == 0 {
7203		panic("no return value specified for Search")
7204	}
7205
7206	var r0 *dto.HistorySearchOutput
7207	var r1 error
7208	if returnFunc, ok := ret.Get(0).(func(context.Context, dto.HistorySearchInput) (*dto.HistorySearchOutput, error)); ok {
7209		return returnFunc(ctx, input)
7210	}
7211	if returnFunc, ok := ret.Get(0).(func(context.Context, dto.HistorySearchInput) *dto.HistorySearchOutput); ok {
7212		r0 = returnFunc(ctx, input)
7213	} else {
7214		if ret.Get(0) != nil {
7215			r0 = ret.Get(0).(*dto.HistorySearchOutput)
7216		}
7217	}
7218	if returnFunc, ok := ret.Get(1).(func(context.Context, dto.HistorySearchInput) error); ok {
7219		r1 = returnFunc(ctx, input)
7220	} else {
7221		r1 = ret.Error(1)
7222	}
7223	return r0, r1
7224}
7225
7226// MockHomepageHistory_Search_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Search'
7227type MockHomepageHistory_Search_Call struct {
7228	*mock.Call
7229}
7230
7231// Search is a helper method to define mock.On call
7232//   - ctx context.Context
7233//   - input dto.HistorySearchInput
7234func (_e *MockHomepageHistory_Expecter) Search(ctx interface{}, input interface{}) *MockHomepageHistory_Search_Call {
7235	return &MockHomepageHistory_Search_Call{Call: _e.mock.On("Search", ctx, input)}
7236}
7237
7238func (_c *MockHomepageHistory_Search_Call) Run(run func(ctx context.Context, input dto.HistorySearchInput)) *MockHomepageHistory_Search_Call {
7239	_c.Call.Run(func(args mock.Arguments) {
7240		var arg0 context.Context
7241		if args[0] != nil {
7242			arg0 = args[0].(context.Context)
7243		}
7244		var arg1 dto.HistorySearchInput
7245		if args[1] != nil {
7246			arg1 = args[1].(dto.HistorySearchInput)
7247		}
7248		run(
7249			arg0,
7250			arg1,
7251		)
7252	})
7253	return _c
7254}
7255
7256func (_c *MockHomepageHistory_Search_Call) Return(historySearchOutput *dto.HistorySearchOutput, err error) *MockHomepageHistory_Search_Call {
7257	_c.Call.Return(historySearchOutput, err)
7258	return _c
7259}
7260
7261func (_c *MockHomepageHistory_Search_Call) RunAndReturn(run func(ctx context.Context, input dto.HistorySearchInput) (*dto.HistorySearchOutput, error)) *MockHomepageHistory_Search_Call {
7262	_c.Call.Return(run)
7263	return _c
7264}
7265
7266// NewMockHomepageFavorites creates a new instance of MockHomepageFavorites. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
7267// The first argument is typically a *testing.T value.
7268func NewMockHomepageFavorites(t interface {
7269	mock.TestingT
7270	Cleanup(func())
7271}) *MockHomepageFavorites {
7272	mock := &MockHomepageFavorites{}
7273	mock.Mock.Test(t)
7274
7275	t.Cleanup(func() { mock.AssertExpectations(t) })
7276
7277	return mock
7278}
7279
7280// MockHomepageFavorites is an autogenerated mock type for the HomepageFavorites type
7281type MockHomepageFavorites struct {
7282	mock.Mock
7283}
7284
7285type MockHomepageFavorites_Expecter struct {
7286	mock *mock.Mock
7287}
7288
7289func (_m *MockHomepageFavorites) EXPECT() *MockHomepageFavorites_Expecter {
7290	return &MockHomepageFavorites_Expecter{mock: &_m.Mock}
7291}
7292
7293// AddFavorite provides a mock function for the type MockHomepageFavorites
7294func (_mock *MockHomepageFavorites) AddFavorite(ctx context.Context, input dto.FavoriteCreateInput) (*entity.Favorite, error) {
7295	ret := _mock.Called(ctx, input)
7296
7297	if len(ret) == 0 {
7298		panic("no return value specified for AddFavorite")
7299	}
7300
7301	var r0 *entity.Favorite
7302	var r1 error
7303	if returnFunc, ok := ret.Get(0).(func(context.Context, dto.FavoriteCreateInput) (*entity.Favorite, error)); ok {
7304		return returnFunc(ctx, input)
7305	}
7306	if returnFunc, ok := ret.Get(0).(func(context.Context, dto.FavoriteCreateInput) *entity.Favorite); ok {
7307		r0 = returnFunc(ctx, input)
7308	} else {
7309		if ret.Get(0) != nil {
7310			r0 = ret.Get(0).(*entity.Favorite)
7311		}
7312	}
7313	if returnFunc, ok := ret.Get(1).(func(context.Context, dto.FavoriteCreateInput) error); ok {
7314		r1 = returnFunc(ctx, input)
7315	} else {
7316		r1 = ret.Error(1)
7317	}
7318	return r0, r1
7319}
7320
7321// MockHomepageFavorites_AddFavorite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFavorite'
7322type MockHomepageFavorites_AddFavorite_Call struct {
7323	*mock.Call
7324}
7325
7326// AddFavorite is a helper method to define mock.On call
7327//   - ctx context.Context
7328//   - input dto.FavoriteCreateInput
7329func (_e *MockHomepageFavorites_Expecter) AddFavorite(ctx interface{}, input interface{}) *MockHomepageFavorites_AddFavorite_Call {
7330	return &MockHomepageFavorites_AddFavorite_Call{Call: _e.mock.On("AddFavorite", ctx, input)}
7331}
7332
7333func (_c *MockHomepageFavorites_AddFavorite_Call) Run(run func(ctx context.Context, input dto.FavoriteCreateInput)) *MockHomepageFavorites_AddFavorite_Call {
7334	_c.Call.Run(func(args mock.Arguments) {
7335		var arg0 context.Context
7336		if args[0] != nil {
7337			arg0 = args[0].(context.Context)
7338		}
7339		var arg1 dto.FavoriteCreateInput
7340		if args[1] != nil {
7341			arg1 = args[1].(dto.FavoriteCreateInput)
7342		}
7343		run(
7344			arg0,
7345			arg1,
7346		)
7347	})
7348	return _c
7349}
7350
7351func (_c *MockHomepageFavorites_AddFavorite_Call) Return(favorite *entity.Favorite, err error) *MockHomepageFavorites_AddFavorite_Call {
7352	_c.Call.Return(favorite, err)
7353	return _c
7354}
7355
7356func (_c *MockHomepageFavorites_AddFavorite_Call) RunAndReturn(run func(ctx context.Context, input dto.FavoriteCreateInput) (*entity.Favorite, error)) *MockHomepageFavorites_AddFavorite_Call {
7357	_c.Call.Return(run)
7358	return _c
7359}
7360
7361// AddTag provides a mock function for the type MockHomepageFavorites
7362func (_mock *MockHomepageFavorites) AddTag(ctx context.Context, name string, color string) (*entity.Tag, error) {
7363	ret := _mock.Called(ctx, name, color)
7364
7365	if len(ret) == 0 {
7366		panic("no return value specified for AddTag")
7367	}
7368
7369	var r0 *entity.Tag
7370	var r1 error
7371	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*entity.Tag, error)); ok {
7372		return returnFunc(ctx, name, color)
7373	}
7374	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *entity.Tag); ok {
7375		r0 = returnFunc(ctx, name, color)
7376	} else {
7377		if ret.Get(0) != nil {
7378			r0 = ret.Get(0).(*entity.Tag)
7379		}
7380	}
7381	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
7382		r1 = returnFunc(ctx, name, color)
7383	} else {
7384		r1 = ret.Error(1)
7385	}
7386	return r0, r1
7387}
7388
7389// MockHomepageFavorites_AddTag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddTag'
7390type MockHomepageFavorites_AddTag_Call struct {
7391	*mock.Call
7392}
7393
7394// AddTag is a helper method to define mock.On call
7395//   - ctx context.Context
7396//   - name string
7397//   - color string
7398func (_e *MockHomepageFavorites_Expecter) AddTag(ctx interface{}, name interface{}, color interface{}) *MockHomepageFavorites_AddTag_Call {
7399	return &MockHomepageFavorites_AddTag_Call{Call: _e.mock.On("AddTag", ctx, name, color)}
7400}
7401
7402func (_c *MockHomepageFavorites_AddTag_Call) Run(run func(ctx context.Context, name string, color string)) *MockHomepageFavorites_AddTag_Call {
7403	_c.Call.Run(func(args mock.Arguments) {
7404		var arg0 context.Context
7405		if args[0] != nil {
7406			arg0 = args[0].(context.Context)
7407		}
7408		var arg1 string
7409		if args[1] != nil {
7410			arg1 = args[1].(string)
7411		}
7412		var arg2 string
7413		if args[2] != nil {
7414			arg2 = args[2].(string)
7415		}
7416		run(
7417			arg0,
7418			arg1,
7419			arg2,
7420		)
7421	})
7422	return _c
7423}
7424
7425func (_c *MockHomepageFavorites_AddTag_Call) Return(tag *entity.Tag, err error) *MockHomepageFavorites_AddTag_Call {
7426	_c.Call.Return(tag, err)
7427	return _c
7428}
7429
7430func (_c *MockHomepageFavorites_AddTag_Call) RunAndReturn(run func(ctx context.Context, name string, color string) (*entity.Tag, error)) *MockHomepageFavorites_AddTag_Call {
7431	_c.Call.Return(run)
7432	return _c
7433}
7434
7435// CreateFolder provides a mock function for the type MockHomepageFavorites
7436func (_mock *MockHomepageFavorites) CreateFolder(ctx context.Context, name string, icon string, parentID *entity.FolderID) (*entity.Folder, error) {
7437	ret := _mock.Called(ctx, name, icon, parentID)
7438
7439	if len(ret) == 0 {
7440		panic("no return value specified for CreateFolder")
7441	}
7442
7443	var r0 *entity.Folder
7444	var r1 error
7445	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *entity.FolderID) (*entity.Folder, error)); ok {
7446		return returnFunc(ctx, name, icon, parentID)
7447	}
7448	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *entity.FolderID) *entity.Folder); ok {
7449		r0 = returnFunc(ctx, name, icon, parentID)
7450	} else {
7451		if ret.Get(0) != nil {
7452			r0 = ret.Get(0).(*entity.Folder)
7453		}
7454	}
7455	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *entity.FolderID) error); ok {
7456		r1 = returnFunc(ctx, name, icon, parentID)
7457	} else {
7458		r1 = ret.Error(1)
7459	}
7460	return r0, r1
7461}
7462
7463// MockHomepageFavorites_CreateFolder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateFolder'
7464type MockHomepageFavorites_CreateFolder_Call struct {
7465	*mock.Call
7466}
7467
7468// CreateFolder is a helper method to define mock.On call
7469//   - ctx context.Context
7470//   - name string
7471//   - icon string
7472//   - parentID *entity.FolderID
7473func (_e *MockHomepageFavorites_Expecter) CreateFolder(ctx interface{}, name interface{}, icon interface{}, parentID interface{}) *MockHomepageFavorites_CreateFolder_Call {
7474	return &MockHomepageFavorites_CreateFolder_Call{Call: _e.mock.On("CreateFolder", ctx, name, icon, parentID)}
7475}
7476
7477func (_c *MockHomepageFavorites_CreateFolder_Call) Run(run func(ctx context.Context, name string, icon string, parentID *entity.FolderID)) *MockHomepageFavorites_CreateFolder_Call {
7478	_c.Call.Run(func(args mock.Arguments) {
7479		var arg0 context.Context
7480		if args[0] != nil {
7481			arg0 = args[0].(context.Context)
7482		}
7483		var arg1 string
7484		if args[1] != nil {
7485			arg1 = args[1].(string)
7486		}
7487		var arg2 string
7488		if args[2] != nil {
7489			arg2 = args[2].(string)
7490		}
7491		var arg3 *entity.FolderID
7492		if args[3] != nil {
7493			arg3 = args[3].(*entity.FolderID)
7494		}
7495		run(
7496			arg0,
7497			arg1,
7498			arg2,
7499			arg3,
7500		)
7501	})
7502	return _c
7503}
7504
7505func (_c *MockHomepageFavorites_CreateFolder_Call) Return(folder *entity.Folder, err error) *MockHomepageFavorites_CreateFolder_Call {
7506	_c.Call.Return(folder, err)
7507	return _c
7508}
7509
7510func (_c *MockHomepageFavorites_CreateFolder_Call) RunAndReturn(run func(ctx context.Context, name string, icon string, parentID *entity.FolderID) (*entity.Folder, error)) *MockHomepageFavorites_CreateFolder_Call {
7511	_c.Call.Return(run)
7512	return _c
7513}
7514
7515// DeleteFavorite provides a mock function for the type MockHomepageFavorites
7516func (_mock *MockHomepageFavorites) DeleteFavorite(ctx context.Context, id entity.FavoriteID) error {
7517	ret := _mock.Called(ctx, id)
7518
7519	if len(ret) == 0 {
7520		panic("no return value specified for DeleteFavorite")
7521	}
7522
7523	var r0 error
7524	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID) error); ok {
7525		r0 = returnFunc(ctx, id)
7526	} else {
7527		r0 = ret.Error(0)
7528	}
7529	return r0
7530}
7531
7532// MockHomepageFavorites_DeleteFavorite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFavorite'
7533type MockHomepageFavorites_DeleteFavorite_Call struct {
7534	*mock.Call
7535}
7536
7537// DeleteFavorite is a helper method to define mock.On call
7538//   - ctx context.Context
7539//   - id entity.FavoriteID
7540func (_e *MockHomepageFavorites_Expecter) DeleteFavorite(ctx interface{}, id interface{}) *MockHomepageFavorites_DeleteFavorite_Call {
7541	return &MockHomepageFavorites_DeleteFavorite_Call{Call: _e.mock.On("DeleteFavorite", ctx, id)}
7542}
7543
7544func (_c *MockHomepageFavorites_DeleteFavorite_Call) Run(run func(ctx context.Context, id entity.FavoriteID)) *MockHomepageFavorites_DeleteFavorite_Call {
7545	_c.Call.Run(func(args mock.Arguments) {
7546		var arg0 context.Context
7547		if args[0] != nil {
7548			arg0 = args[0].(context.Context)
7549		}
7550		var arg1 entity.FavoriteID
7551		if args[1] != nil {
7552			arg1 = args[1].(entity.FavoriteID)
7553		}
7554		run(
7555			arg0,
7556			arg1,
7557		)
7558	})
7559	return _c
7560}
7561
7562func (_c *MockHomepageFavorites_DeleteFavorite_Call) Return(err error) *MockHomepageFavorites_DeleteFavorite_Call {
7563	_c.Call.Return(err)
7564	return _c
7565}
7566
7567func (_c *MockHomepageFavorites_DeleteFavorite_Call) RunAndReturn(run func(ctx context.Context, id entity.FavoriteID) error) *MockHomepageFavorites_DeleteFavorite_Call {
7568	_c.Call.Return(run)
7569	return _c
7570}
7571
7572// DeleteFolder provides a mock function for the type MockHomepageFavorites
7573func (_mock *MockHomepageFavorites) DeleteFolder(ctx context.Context, id entity.FolderID) error {
7574	ret := _mock.Called(ctx, id)
7575
7576	if len(ret) == 0 {
7577		panic("no return value specified for DeleteFolder")
7578	}
7579
7580	var r0 error
7581	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FolderID) error); ok {
7582		r0 = returnFunc(ctx, id)
7583	} else {
7584		r0 = ret.Error(0)
7585	}
7586	return r0
7587}
7588
7589// MockHomepageFavorites_DeleteFolder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFolder'
7590type MockHomepageFavorites_DeleteFolder_Call struct {
7591	*mock.Call
7592}
7593
7594// DeleteFolder is a helper method to define mock.On call
7595//   - ctx context.Context
7596//   - id entity.FolderID
7597func (_e *MockHomepageFavorites_Expecter) DeleteFolder(ctx interface{}, id interface{}) *MockHomepageFavorites_DeleteFolder_Call {
7598	return &MockHomepageFavorites_DeleteFolder_Call{Call: _e.mock.On("DeleteFolder", ctx, id)}
7599}
7600
7601func (_c *MockHomepageFavorites_DeleteFolder_Call) Run(run func(ctx context.Context, id entity.FolderID)) *MockHomepageFavorites_DeleteFolder_Call {
7602	_c.Call.Run(func(args mock.Arguments) {
7603		var arg0 context.Context
7604		if args[0] != nil {
7605			arg0 = args[0].(context.Context)
7606		}
7607		var arg1 entity.FolderID
7608		if args[1] != nil {
7609			arg1 = args[1].(entity.FolderID)
7610		}
7611		run(
7612			arg0,
7613			arg1,
7614		)
7615	})
7616	return _c
7617}
7618
7619func (_c *MockHomepageFavorites_DeleteFolder_Call) Return(err error) *MockHomepageFavorites_DeleteFolder_Call {
7620	_c.Call.Return(err)
7621	return _c
7622}
7623
7624func (_c *MockHomepageFavorites_DeleteFolder_Call) RunAndReturn(run func(ctx context.Context, id entity.FolderID) error) *MockHomepageFavorites_DeleteFolder_Call {
7625	_c.Call.Return(run)
7626	return _c
7627}
7628
7629// DeleteTag provides a mock function for the type MockHomepageFavorites
7630func (_mock *MockHomepageFavorites) DeleteTag(ctx context.Context, id entity.TagID) error {
7631	ret := _mock.Called(ctx, id)
7632
7633	if len(ret) == 0 {
7634		panic("no return value specified for DeleteTag")
7635	}
7636
7637	var r0 error
7638	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.TagID) error); ok {
7639		r0 = returnFunc(ctx, id)
7640	} else {
7641		r0 = ret.Error(0)
7642	}
7643	return r0
7644}
7645
7646// MockHomepageFavorites_DeleteTag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTag'
7647type MockHomepageFavorites_DeleteTag_Call struct {
7648	*mock.Call
7649}
7650
7651// DeleteTag is a helper method to define mock.On call
7652//   - ctx context.Context
7653//   - id entity.TagID
7654func (_e *MockHomepageFavorites_Expecter) DeleteTag(ctx interface{}, id interface{}) *MockHomepageFavorites_DeleteTag_Call {
7655	return &MockHomepageFavorites_DeleteTag_Call{Call: _e.mock.On("DeleteTag", ctx, id)}
7656}
7657
7658func (_c *MockHomepageFavorites_DeleteTag_Call) Run(run func(ctx context.Context, id entity.TagID)) *MockHomepageFavorites_DeleteTag_Call {
7659	_c.Call.Run(func(args mock.Arguments) {
7660		var arg0 context.Context
7661		if args[0] != nil {
7662			arg0 = args[0].(context.Context)
7663		}
7664		var arg1 entity.TagID
7665		if args[1] != nil {
7666			arg1 = args[1].(entity.TagID)
7667		}
7668		run(
7669			arg0,
7670			arg1,
7671		)
7672	})
7673	return _c
7674}
7675
7676func (_c *MockHomepageFavorites_DeleteTag_Call) Return(err error) *MockHomepageFavorites_DeleteTag_Call {
7677	_c.Call.Return(err)
7678	return _c
7679}
7680
7681func (_c *MockHomepageFavorites_DeleteTag_Call) RunAndReturn(run func(ctx context.Context, id entity.TagID) error) *MockHomepageFavorites_DeleteTag_Call {
7682	_c.Call.Return(run)
7683	return _c
7684}
7685
7686// GetAll provides a mock function for the type MockHomepageFavorites
7687func (_mock *MockHomepageFavorites) GetAll(ctx context.Context) ([]*entity.Favorite, error) {
7688	ret := _mock.Called(ctx)
7689
7690	if len(ret) == 0 {
7691		panic("no return value specified for GetAll")
7692	}
7693
7694	var r0 []*entity.Favorite
7695	var r1 error
7696	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.Favorite, error)); ok {
7697		return returnFunc(ctx)
7698	}
7699	if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.Favorite); ok {
7700		r0 = returnFunc(ctx)
7701	} else {
7702		if ret.Get(0) != nil {
7703			r0 = ret.Get(0).([]*entity.Favorite)
7704		}
7705	}
7706	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
7707		r1 = returnFunc(ctx)
7708	} else {
7709		r1 = ret.Error(1)
7710	}
7711	return r0, r1
7712}
7713
7714// MockHomepageFavorites_GetAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAll'
7715type MockHomepageFavorites_GetAll_Call struct {
7716	*mock.Call
7717}
7718
7719// GetAll is a helper method to define mock.On call
7720//   - ctx context.Context
7721func (_e *MockHomepageFavorites_Expecter) GetAll(ctx interface{}) *MockHomepageFavorites_GetAll_Call {
7722	return &MockHomepageFavorites_GetAll_Call{Call: _e.mock.On("GetAll", ctx)}
7723}
7724
7725func (_c *MockHomepageFavorites_GetAll_Call) Run(run func(ctx context.Context)) *MockHomepageFavorites_GetAll_Call {
7726	_c.Call.Run(func(args mock.Arguments) {
7727		var arg0 context.Context
7728		if args[0] != nil {
7729			arg0 = args[0].(context.Context)
7730		}
7731		run(
7732			arg0,
7733		)
7734	})
7735	return _c
7736}
7737
7738func (_c *MockHomepageFavorites_GetAll_Call) Return(favorites []*entity.Favorite, err error) *MockHomepageFavorites_GetAll_Call {
7739	_c.Call.Return(favorites, err)
7740	return _c
7741}
7742
7743func (_c *MockHomepageFavorites_GetAll_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.Favorite, error)) *MockHomepageFavorites_GetAll_Call {
7744	_c.Call.Return(run)
7745	return _c
7746}
7747
7748// GetAllFolders provides a mock function for the type MockHomepageFavorites
7749func (_mock *MockHomepageFavorites) GetAllFolders(ctx context.Context) ([]*entity.Folder, error) {
7750	ret := _mock.Called(ctx)
7751
7752	if len(ret) == 0 {
7753		panic("no return value specified for GetAllFolders")
7754	}
7755
7756	var r0 []*entity.Folder
7757	var r1 error
7758	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.Folder, error)); ok {
7759		return returnFunc(ctx)
7760	}
7761	if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.Folder); ok {
7762		r0 = returnFunc(ctx)
7763	} else {
7764		if ret.Get(0) != nil {
7765			r0 = ret.Get(0).([]*entity.Folder)
7766		}
7767	}
7768	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
7769		r1 = returnFunc(ctx)
7770	} else {
7771		r1 = ret.Error(1)
7772	}
7773	return r0, r1
7774}
7775
7776// MockHomepageFavorites_GetAllFolders_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllFolders'
7777type MockHomepageFavorites_GetAllFolders_Call struct {
7778	*mock.Call
7779}
7780
7781// GetAllFolders is a helper method to define mock.On call
7782//   - ctx context.Context
7783func (_e *MockHomepageFavorites_Expecter) GetAllFolders(ctx interface{}) *MockHomepageFavorites_GetAllFolders_Call {
7784	return &MockHomepageFavorites_GetAllFolders_Call{Call: _e.mock.On("GetAllFolders", ctx)}
7785}
7786
7787func (_c *MockHomepageFavorites_GetAllFolders_Call) Run(run func(ctx context.Context)) *MockHomepageFavorites_GetAllFolders_Call {
7788	_c.Call.Run(func(args mock.Arguments) {
7789		var arg0 context.Context
7790		if args[0] != nil {
7791			arg0 = args[0].(context.Context)
7792		}
7793		run(
7794			arg0,
7795		)
7796	})
7797	return _c
7798}
7799
7800func (_c *MockHomepageFavorites_GetAllFolders_Call) Return(folders []*entity.Folder, err error) *MockHomepageFavorites_GetAllFolders_Call {
7801	_c.Call.Return(folders, err)
7802	return _c
7803}
7804
7805func (_c *MockHomepageFavorites_GetAllFolders_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.Folder, error)) *MockHomepageFavorites_GetAllFolders_Call {
7806	_c.Call.Return(run)
7807	return _c
7808}
7809
7810// GetAllTags provides a mock function for the type MockHomepageFavorites
7811func (_mock *MockHomepageFavorites) GetAllTags(ctx context.Context) ([]*entity.Tag, error) {
7812	ret := _mock.Called(ctx)
7813
7814	if len(ret) == 0 {
7815		panic("no return value specified for GetAllTags")
7816	}
7817
7818	var r0 []*entity.Tag
7819	var r1 error
7820	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.Tag, error)); ok {
7821		return returnFunc(ctx)
7822	}
7823	if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.Tag); ok {
7824		r0 = returnFunc(ctx)
7825	} else {
7826		if ret.Get(0) != nil {
7827			r0 = ret.Get(0).([]*entity.Tag)
7828		}
7829	}
7830	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
7831		r1 = returnFunc(ctx)
7832	} else {
7833		r1 = ret.Error(1)
7834	}
7835	return r0, r1
7836}
7837
7838// MockHomepageFavorites_GetAllTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllTags'
7839type MockHomepageFavorites_GetAllTags_Call struct {
7840	*mock.Call
7841}
7842
7843// GetAllTags is a helper method to define mock.On call
7844//   - ctx context.Context
7845func (_e *MockHomepageFavorites_Expecter) GetAllTags(ctx interface{}) *MockHomepageFavorites_GetAllTags_Call {
7846	return &MockHomepageFavorites_GetAllTags_Call{Call: _e.mock.On("GetAllTags", ctx)}
7847}
7848
7849func (_c *MockHomepageFavorites_GetAllTags_Call) Run(run func(ctx context.Context)) *MockHomepageFavorites_GetAllTags_Call {
7850	_c.Call.Run(func(args mock.Arguments) {
7851		var arg0 context.Context
7852		if args[0] != nil {
7853			arg0 = args[0].(context.Context)
7854		}
7855		run(
7856			arg0,
7857		)
7858	})
7859	return _c
7860}
7861
7862func (_c *MockHomepageFavorites_GetAllTags_Call) Return(tags []*entity.Tag, err error) *MockHomepageFavorites_GetAllTags_Call {
7863	_c.Call.Return(tags, err)
7864	return _c
7865}
7866
7867func (_c *MockHomepageFavorites_GetAllTags_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.Tag, error)) *MockHomepageFavorites_GetAllTags_Call {
7868	_c.Call.Return(run)
7869	return _c
7870}
7871
7872// GetByShortcut provides a mock function for the type MockHomepageFavorites
7873func (_mock *MockHomepageFavorites) GetByShortcut(ctx context.Context, key int) (*entity.Favorite, error) {
7874	ret := _mock.Called(ctx, key)
7875
7876	if len(ret) == 0 {
7877		panic("no return value specified for GetByShortcut")
7878	}
7879
7880	var r0 *entity.Favorite
7881	var r1 error
7882	if returnFunc, ok := ret.Get(0).(func(context.Context, int) (*entity.Favorite, error)); ok {
7883		return returnFunc(ctx, key)
7884	}
7885	if returnFunc, ok := ret.Get(0).(func(context.Context, int) *entity.Favorite); ok {
7886		r0 = returnFunc(ctx, key)
7887	} else {
7888		if ret.Get(0) != nil {
7889			r0 = ret.Get(0).(*entity.Favorite)
7890		}
7891	}
7892	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
7893		r1 = returnFunc(ctx, key)
7894	} else {
7895		r1 = ret.Error(1)
7896	}
7897	return r0, r1
7898}
7899
7900// MockHomepageFavorites_GetByShortcut_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetByShortcut'
7901type MockHomepageFavorites_GetByShortcut_Call struct {
7902	*mock.Call
7903}
7904
7905// GetByShortcut is a helper method to define mock.On call
7906//   - ctx context.Context
7907//   - key int
7908func (_e *MockHomepageFavorites_Expecter) GetByShortcut(ctx interface{}, key interface{}) *MockHomepageFavorites_GetByShortcut_Call {
7909	return &MockHomepageFavorites_GetByShortcut_Call{Call: _e.mock.On("GetByShortcut", ctx, key)}
7910}
7911
7912func (_c *MockHomepageFavorites_GetByShortcut_Call) Run(run func(ctx context.Context, key int)) *MockHomepageFavorites_GetByShortcut_Call {
7913	_c.Call.Run(func(args mock.Arguments) {
7914		var arg0 context.Context
7915		if args[0] != nil {
7916			arg0 = args[0].(context.Context)
7917		}
7918		var arg1 int
7919		if args[1] != nil {
7920			arg1 = args[1].(int)
7921		}
7922		run(
7923			arg0,
7924			arg1,
7925		)
7926	})
7927	return _c
7928}
7929
7930func (_c *MockHomepageFavorites_GetByShortcut_Call) Return(favorite *entity.Favorite, err error) *MockHomepageFavorites_GetByShortcut_Call {
7931	_c.Call.Return(favorite, err)
7932	return _c
7933}
7934
7935func (_c *MockHomepageFavorites_GetByShortcut_Call) RunAndReturn(run func(ctx context.Context, key int) (*entity.Favorite, error)) *MockHomepageFavorites_GetByShortcut_Call {
7936	_c.Call.Return(run)
7937	return _c
7938}
7939
7940// Move provides a mock function for the type MockHomepageFavorites
7941func (_mock *MockHomepageFavorites) Move(ctx context.Context, id entity.FavoriteID, folderID *entity.FolderID) error {
7942	ret := _mock.Called(ctx, id, folderID)
7943
7944	if len(ret) == 0 {
7945		panic("no return value specified for Move")
7946	}
7947
7948	var r0 error
7949	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID, *entity.FolderID) error); ok {
7950		r0 = returnFunc(ctx, id, folderID)
7951	} else {
7952		r0 = ret.Error(0)
7953	}
7954	return r0
7955}
7956
7957// MockHomepageFavorites_Move_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Move'
7958type MockHomepageFavorites_Move_Call struct {
7959	*mock.Call
7960}
7961
7962// Move is a helper method to define mock.On call
7963//   - ctx context.Context
7964//   - id entity.FavoriteID
7965//   - folderID *entity.FolderID
7966func (_e *MockHomepageFavorites_Expecter) Move(ctx interface{}, id interface{}, folderID interface{}) *MockHomepageFavorites_Move_Call {
7967	return &MockHomepageFavorites_Move_Call{Call: _e.mock.On("Move", ctx, id, folderID)}
7968}
7969
7970func (_c *MockHomepageFavorites_Move_Call) Run(run func(ctx context.Context, id entity.FavoriteID, folderID *entity.FolderID)) *MockHomepageFavorites_Move_Call {
7971	_c.Call.Run(func(args mock.Arguments) {
7972		var arg0 context.Context
7973		if args[0] != nil {
7974			arg0 = args[0].(context.Context)
7975		}
7976		var arg1 entity.FavoriteID
7977		if args[1] != nil {
7978			arg1 = args[1].(entity.FavoriteID)
7979		}
7980		var arg2 *entity.FolderID
7981		if args[2] != nil {
7982			arg2 = args[2].(*entity.FolderID)
7983		}
7984		run(
7985			arg0,
7986			arg1,
7987			arg2,
7988		)
7989	})
7990	return _c
7991}
7992
7993func (_c *MockHomepageFavorites_Move_Call) Return(err error) *MockHomepageFavorites_Move_Call {
7994	_c.Call.Return(err)
7995	return _c
7996}
7997
7998func (_c *MockHomepageFavorites_Move_Call) RunAndReturn(run func(ctx context.Context, id entity.FavoriteID, folderID *entity.FolderID) error) *MockHomepageFavorites_Move_Call {
7999	_c.Call.Return(run)
8000	return _c
8001}
8002
8003// SetShortcut provides a mock function for the type MockHomepageFavorites
8004func (_mock *MockHomepageFavorites) SetShortcut(ctx context.Context, id entity.FavoriteID, key *int) error {
8005	ret := _mock.Called(ctx, id, key)
8006
8007	if len(ret) == 0 {
8008		panic("no return value specified for SetShortcut")
8009	}
8010
8011	var r0 error
8012	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID, *int) error); ok {
8013		r0 = returnFunc(ctx, id, key)
8014	} else {
8015		r0 = ret.Error(0)
8016	}
8017	return r0
8018}
8019
8020// MockHomepageFavorites_SetShortcut_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetShortcut'
8021type MockHomepageFavorites_SetShortcut_Call struct {
8022	*mock.Call
8023}
8024
8025// SetShortcut is a helper method to define mock.On call
8026//   - ctx context.Context
8027//   - id entity.FavoriteID
8028//   - key *int
8029func (_e *MockHomepageFavorites_Expecter) SetShortcut(ctx interface{}, id interface{}, key interface{}) *MockHomepageFavorites_SetShortcut_Call {
8030	return &MockHomepageFavorites_SetShortcut_Call{Call: _e.mock.On("SetShortcut", ctx, id, key)}
8031}
8032
8033func (_c *MockHomepageFavorites_SetShortcut_Call) Run(run func(ctx context.Context, id entity.FavoriteID, key *int)) *MockHomepageFavorites_SetShortcut_Call {
8034	_c.Call.Run(func(args mock.Arguments) {
8035		var arg0 context.Context
8036		if args[0] != nil {
8037			arg0 = args[0].(context.Context)
8038		}
8039		var arg1 entity.FavoriteID
8040		if args[1] != nil {
8041			arg1 = args[1].(entity.FavoriteID)
8042		}
8043		var arg2 *int
8044		if args[2] != nil {
8045			arg2 = args[2].(*int)
8046		}
8047		run(
8048			arg0,
8049			arg1,
8050			arg2,
8051		)
8052	})
8053	return _c
8054}
8055
8056func (_c *MockHomepageFavorites_SetShortcut_Call) Return(err error) *MockHomepageFavorites_SetShortcut_Call {
8057	_c.Call.Return(err)
8058	return _c
8059}
8060
8061func (_c *MockHomepageFavorites_SetShortcut_Call) RunAndReturn(run func(ctx context.Context, id entity.FavoriteID, key *int) error) *MockHomepageFavorites_SetShortcut_Call {
8062	_c.Call.Return(run)
8063	return _c
8064}
8065
8066// TagFavorite provides a mock function for the type MockHomepageFavorites
8067func (_mock *MockHomepageFavorites) TagFavorite(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID) error {
8068	ret := _mock.Called(ctx, favID, tagID)
8069
8070	if len(ret) == 0 {
8071		panic("no return value specified for TagFavorite")
8072	}
8073
8074	var r0 error
8075	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID, entity.TagID) error); ok {
8076		r0 = returnFunc(ctx, favID, tagID)
8077	} else {
8078		r0 = ret.Error(0)
8079	}
8080	return r0
8081}
8082
8083// MockHomepageFavorites_TagFavorite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TagFavorite'
8084type MockHomepageFavorites_TagFavorite_Call struct {
8085	*mock.Call
8086}
8087
8088// TagFavorite is a helper method to define mock.On call
8089//   - ctx context.Context
8090//   - favID entity.FavoriteID
8091//   - tagID entity.TagID
8092func (_e *MockHomepageFavorites_Expecter) TagFavorite(ctx interface{}, favID interface{}, tagID interface{}) *MockHomepageFavorites_TagFavorite_Call {
8093	return &MockHomepageFavorites_TagFavorite_Call{Call: _e.mock.On("TagFavorite", ctx, favID, tagID)}
8094}
8095
8096func (_c *MockHomepageFavorites_TagFavorite_Call) Run(run func(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID)) *MockHomepageFavorites_TagFavorite_Call {
8097	_c.Call.Run(func(args mock.Arguments) {
8098		var arg0 context.Context
8099		if args[0] != nil {
8100			arg0 = args[0].(context.Context)
8101		}
8102		var arg1 entity.FavoriteID
8103		if args[1] != nil {
8104			arg1 = args[1].(entity.FavoriteID)
8105		}
8106		var arg2 entity.TagID
8107		if args[2] != nil {
8108			arg2 = args[2].(entity.TagID)
8109		}
8110		run(
8111			arg0,
8112			arg1,
8113			arg2,
8114		)
8115	})
8116	return _c
8117}
8118
8119func (_c *MockHomepageFavorites_TagFavorite_Call) Return(err error) *MockHomepageFavorites_TagFavorite_Call {
8120	_c.Call.Return(err)
8121	return _c
8122}
8123
8124func (_c *MockHomepageFavorites_TagFavorite_Call) RunAndReturn(run func(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID) error) *MockHomepageFavorites_TagFavorite_Call {
8125	_c.Call.Return(run)
8126	return _c
8127}
8128
8129// UntagFavorite provides a mock function for the type MockHomepageFavorites
8130func (_mock *MockHomepageFavorites) UntagFavorite(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID) error {
8131	ret := _mock.Called(ctx, favID, tagID)
8132
8133	if len(ret) == 0 {
8134		panic("no return value specified for UntagFavorite")
8135	}
8136
8137	var r0 error
8138	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID, entity.TagID) error); ok {
8139		r0 = returnFunc(ctx, favID, tagID)
8140	} else {
8141		r0 = ret.Error(0)
8142	}
8143	return r0
8144}
8145
8146// MockHomepageFavorites_UntagFavorite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UntagFavorite'
8147type MockHomepageFavorites_UntagFavorite_Call struct {
8148	*mock.Call
8149}
8150
8151// UntagFavorite is a helper method to define mock.On call
8152//   - ctx context.Context
8153//   - favID entity.FavoriteID
8154//   - tagID entity.TagID
8155func (_e *MockHomepageFavorites_Expecter) UntagFavorite(ctx interface{}, favID interface{}, tagID interface{}) *MockHomepageFavorites_UntagFavorite_Call {
8156	return &MockHomepageFavorites_UntagFavorite_Call{Call: _e.mock.On("UntagFavorite", ctx, favID, tagID)}
8157}
8158
8159func (_c *MockHomepageFavorites_UntagFavorite_Call) Run(run func(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID)) *MockHomepageFavorites_UntagFavorite_Call {
8160	_c.Call.Run(func(args mock.Arguments) {
8161		var arg0 context.Context
8162		if args[0] != nil {
8163			arg0 = args[0].(context.Context)
8164		}
8165		var arg1 entity.FavoriteID
8166		if args[1] != nil {
8167			arg1 = args[1].(entity.FavoriteID)
8168		}
8169		var arg2 entity.TagID
8170		if args[2] != nil {
8171			arg2 = args[2].(entity.TagID)
8172		}
8173		run(
8174			arg0,
8175			arg1,
8176			arg2,
8177		)
8178	})
8179	return _c
8180}
8181
8182func (_c *MockHomepageFavorites_UntagFavorite_Call) Return(err error) *MockHomepageFavorites_UntagFavorite_Call {
8183	_c.Call.Return(err)
8184	return _c
8185}
8186
8187func (_c *MockHomepageFavorites_UntagFavorite_Call) RunAndReturn(run func(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID) error) *MockHomepageFavorites_UntagFavorite_Call {
8188	_c.Call.Return(run)
8189	return _c
8190}
8191
8192// UpdateFavorite provides a mock function for the type MockHomepageFavorites
8193func (_mock *MockHomepageFavorites) UpdateFavorite(ctx context.Context, input dto.FavoriteUpdateInput) (*entity.Favorite, error) {
8194	ret := _mock.Called(ctx, input)
8195
8196	if len(ret) == 0 {
8197		panic("no return value specified for UpdateFavorite")
8198	}
8199
8200	var r0 *entity.Favorite
8201	var r1 error
8202	if returnFunc, ok := ret.Get(0).(func(context.Context, dto.FavoriteUpdateInput) (*entity.Favorite, error)); ok {
8203		return returnFunc(ctx, input)
8204	}
8205	if returnFunc, ok := ret.Get(0).(func(context.Context, dto.FavoriteUpdateInput) *entity.Favorite); ok {
8206		r0 = returnFunc(ctx, input)
8207	} else {
8208		if ret.Get(0) != nil {
8209			r0 = ret.Get(0).(*entity.Favorite)
8210		}
8211	}
8212	if returnFunc, ok := ret.Get(1).(func(context.Context, dto.FavoriteUpdateInput) error); ok {
8213		r1 = returnFunc(ctx, input)
8214	} else {
8215		r1 = ret.Error(1)
8216	}
8217	return r0, r1
8218}
8219
8220// MockHomepageFavorites_UpdateFavorite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFavorite'
8221type MockHomepageFavorites_UpdateFavorite_Call struct {
8222	*mock.Call
8223}
8224
8225// UpdateFavorite is a helper method to define mock.On call
8226//   - ctx context.Context
8227//   - input dto.FavoriteUpdateInput
8228func (_e *MockHomepageFavorites_Expecter) UpdateFavorite(ctx interface{}, input interface{}) *MockHomepageFavorites_UpdateFavorite_Call {
8229	return &MockHomepageFavorites_UpdateFavorite_Call{Call: _e.mock.On("UpdateFavorite", ctx, input)}
8230}
8231
8232func (_c *MockHomepageFavorites_UpdateFavorite_Call) Run(run func(ctx context.Context, input dto.FavoriteUpdateInput)) *MockHomepageFavorites_UpdateFavorite_Call {
8233	_c.Call.Run(func(args mock.Arguments) {
8234		var arg0 context.Context
8235		if args[0] != nil {
8236			arg0 = args[0].(context.Context)
8237		}
8238		var arg1 dto.FavoriteUpdateInput
8239		if args[1] != nil {
8240			arg1 = args[1].(dto.FavoriteUpdateInput)
8241		}
8242		run(
8243			arg0,
8244			arg1,
8245		)
8246	})
8247	return _c
8248}
8249
8250func (_c *MockHomepageFavorites_UpdateFavorite_Call) Return(favorite *entity.Favorite, err error) *MockHomepageFavorites_UpdateFavorite_Call {
8251	_c.Call.Return(favorite, err)
8252	return _c
8253}
8254
8255func (_c *MockHomepageFavorites_UpdateFavorite_Call) RunAndReturn(run func(ctx context.Context, input dto.FavoriteUpdateInput) (*entity.Favorite, error)) *MockHomepageFavorites_UpdateFavorite_Call {
8256	_c.Call.Return(run)
8257	return _c
8258}
8259
8260// UpdateFolder provides a mock function for the type MockHomepageFavorites
8261func (_mock *MockHomepageFavorites) UpdateFolder(ctx context.Context, id entity.FolderID, name string, icon string) error {
8262	ret := _mock.Called(ctx, id, name, icon)
8263
8264	if len(ret) == 0 {
8265		panic("no return value specified for UpdateFolder")
8266	}
8267
8268	var r0 error
8269	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FolderID, string, string) error); ok {
8270		r0 = returnFunc(ctx, id, name, icon)
8271	} else {
8272		r0 = ret.Error(0)
8273	}
8274	return r0
8275}
8276
8277// MockHomepageFavorites_UpdateFolder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFolder'
8278type MockHomepageFavorites_UpdateFolder_Call struct {
8279	*mock.Call
8280}
8281
8282// UpdateFolder is a helper method to define mock.On call
8283//   - ctx context.Context
8284//   - id entity.FolderID
8285//   - name string
8286//   - icon string
8287func (_e *MockHomepageFavorites_Expecter) UpdateFolder(ctx interface{}, id interface{}, name interface{}, icon interface{}) *MockHomepageFavorites_UpdateFolder_Call {
8288	return &MockHomepageFavorites_UpdateFolder_Call{Call: _e.mock.On("UpdateFolder", ctx, id, name, icon)}
8289}
8290
8291func (_c *MockHomepageFavorites_UpdateFolder_Call) Run(run func(ctx context.Context, id entity.FolderID, name string, icon string)) *MockHomepageFavorites_UpdateFolder_Call {
8292	_c.Call.Run(func(args mock.Arguments) {
8293		var arg0 context.Context
8294		if args[0] != nil {
8295			arg0 = args[0].(context.Context)
8296		}
8297		var arg1 entity.FolderID
8298		if args[1] != nil {
8299			arg1 = args[1].(entity.FolderID)
8300		}
8301		var arg2 string
8302		if args[2] != nil {
8303			arg2 = args[2].(string)
8304		}
8305		var arg3 string
8306		if args[3] != nil {
8307			arg3 = args[3].(string)
8308		}
8309		run(
8310			arg0,
8311			arg1,
8312			arg2,
8313			arg3,
8314		)
8315	})
8316	return _c
8317}
8318
8319func (_c *MockHomepageFavorites_UpdateFolder_Call) Return(err error) *MockHomepageFavorites_UpdateFolder_Call {
8320	_c.Call.Return(err)
8321	return _c
8322}
8323
8324func (_c *MockHomepageFavorites_UpdateFolder_Call) RunAndReturn(run func(ctx context.Context, id entity.FolderID, name string, icon string) error) *MockHomepageFavorites_UpdateFolder_Call {
8325	_c.Call.Return(run)
8326	return _c
8327}
8328
8329// UpdateTag provides a mock function for the type MockHomepageFavorites
8330func (_mock *MockHomepageFavorites) UpdateTag(ctx context.Context, id entity.TagID, name string, color string) error {
8331	ret := _mock.Called(ctx, id, name, color)
8332
8333	if len(ret) == 0 {
8334		panic("no return value specified for UpdateTag")
8335	}
8336
8337	var r0 error
8338	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.TagID, string, string) error); ok {
8339		r0 = returnFunc(ctx, id, name, color)
8340	} else {
8341		r0 = ret.Error(0)
8342	}
8343	return r0
8344}
8345
8346// MockHomepageFavorites_UpdateTag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTag'
8347type MockHomepageFavorites_UpdateTag_Call struct {
8348	*mock.Call
8349}
8350
8351// UpdateTag is a helper method to define mock.On call
8352//   - ctx context.Context
8353//   - id entity.TagID
8354//   - name string
8355//   - color string
8356func (_e *MockHomepageFavorites_Expecter) UpdateTag(ctx interface{}, id interface{}, name interface{}, color interface{}) *MockHomepageFavorites_UpdateTag_Call {
8357	return &MockHomepageFavorites_UpdateTag_Call{Call: _e.mock.On("UpdateTag", ctx, id, name, color)}
8358}
8359
8360func (_c *MockHomepageFavorites_UpdateTag_Call) Run(run func(ctx context.Context, id entity.TagID, name string, color string)) *MockHomepageFavorites_UpdateTag_Call {
8361	_c.Call.Run(func(args mock.Arguments) {
8362		var arg0 context.Context
8363		if args[0] != nil {
8364			arg0 = args[0].(context.Context)
8365		}
8366		var arg1 entity.TagID
8367		if args[1] != nil {
8368			arg1 = args[1].(entity.TagID)
8369		}
8370		var arg2 string
8371		if args[2] != nil {
8372			arg2 = args[2].(string)
8373		}
8374		var arg3 string
8375		if args[3] != nil {
8376			arg3 = args[3].(string)
8377		}
8378		run(
8379			arg0,
8380			arg1,
8381			arg2,
8382			arg3,
8383		)
8384	})
8385	return _c
8386}
8387
8388func (_c *MockHomepageFavorites_UpdateTag_Call) Return(err error) *MockHomepageFavorites_UpdateTag_Call {
8389	_c.Call.Return(err)
8390	return _c
8391}
8392
8393func (_c *MockHomepageFavorites_UpdateTag_Call) RunAndReturn(run func(ctx context.Context, id entity.TagID, name string, color string) error) *MockHomepageFavorites_UpdateTag_Call {
8394	_c.Call.Return(run)
8395	return _c
8396}
8397
8398// NewMockIdleInhibitor creates a new instance of MockIdleInhibitor. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
8399// The first argument is typically a *testing.T value.
8400func NewMockIdleInhibitor(t interface {
8401	mock.TestingT
8402	Cleanup(func())
8403}) *MockIdleInhibitor {
8404	mock := &MockIdleInhibitor{}
8405	mock.Mock.Test(t)
8406
8407	t.Cleanup(func() { mock.AssertExpectations(t) })
8408
8409	return mock
8410}
8411
8412// MockIdleInhibitor is an autogenerated mock type for the IdleInhibitor type
8413type MockIdleInhibitor struct {
8414	mock.Mock
8415}
8416
8417type MockIdleInhibitor_Expecter struct {
8418	mock *mock.Mock
8419}
8420
8421func (_m *MockIdleInhibitor) EXPECT() *MockIdleInhibitor_Expecter {
8422	return &MockIdleInhibitor_Expecter{mock: &_m.Mock}
8423}
8424
8425// Close provides a mock function for the type MockIdleInhibitor
8426func (_mock *MockIdleInhibitor) Close() error {
8427	ret := _mock.Called()
8428
8429	if len(ret) == 0 {
8430		panic("no return value specified for Close")
8431	}
8432
8433	var r0 error
8434	if returnFunc, ok := ret.Get(0).(func() error); ok {
8435		r0 = returnFunc()
8436	} else {
8437		r0 = ret.Error(0)
8438	}
8439	return r0
8440}
8441
8442// MockIdleInhibitor_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
8443type MockIdleInhibitor_Close_Call struct {
8444	*mock.Call
8445}
8446
8447// Close is a helper method to define mock.On call
8448func (_e *MockIdleInhibitor_Expecter) Close() *MockIdleInhibitor_Close_Call {
8449	return &MockIdleInhibitor_Close_Call{Call: _e.mock.On("Close")}
8450}
8451
8452func (_c *MockIdleInhibitor_Close_Call) Run(run func()) *MockIdleInhibitor_Close_Call {
8453	_c.Call.Run(func(args mock.Arguments) {
8454		run()
8455	})
8456	return _c
8457}
8458
8459func (_c *MockIdleInhibitor_Close_Call) Return(err error) *MockIdleInhibitor_Close_Call {
8460	_c.Call.Return(err)
8461	return _c
8462}
8463
8464func (_c *MockIdleInhibitor_Close_Call) RunAndReturn(run func() error) *MockIdleInhibitor_Close_Call {
8465	_c.Call.Return(run)
8466	return _c
8467}
8468
8469// Inhibit provides a mock function for the type MockIdleInhibitor
8470func (_mock *MockIdleInhibitor) Inhibit(ctx context.Context, reason string) error {
8471	ret := _mock.Called(ctx, reason)
8472
8473	if len(ret) == 0 {
8474		panic("no return value specified for Inhibit")
8475	}
8476
8477	var r0 error
8478	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
8479		r0 = returnFunc(ctx, reason)
8480	} else {
8481		r0 = ret.Error(0)
8482	}
8483	return r0
8484}
8485
8486// MockIdleInhibitor_Inhibit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Inhibit'
8487type MockIdleInhibitor_Inhibit_Call struct {
8488	*mock.Call
8489}
8490
8491// Inhibit is a helper method to define mock.On call
8492//   - ctx context.Context
8493//   - reason string
8494func (_e *MockIdleInhibitor_Expecter) Inhibit(ctx interface{}, reason interface{}) *MockIdleInhibitor_Inhibit_Call {
8495	return &MockIdleInhibitor_Inhibit_Call{Call: _e.mock.On("Inhibit", ctx, reason)}
8496}
8497
8498func (_c *MockIdleInhibitor_Inhibit_Call) Run(run func(ctx context.Context, reason string)) *MockIdleInhibitor_Inhibit_Call {
8499	_c.Call.Run(func(args mock.Arguments) {
8500		var arg0 context.Context
8501		if args[0] != nil {
8502			arg0 = args[0].(context.Context)
8503		}
8504		var arg1 string
8505		if args[1] != nil {
8506			arg1 = args[1].(string)
8507		}
8508		run(
8509			arg0,
8510			arg1,
8511		)
8512	})
8513	return _c
8514}
8515
8516func (_c *MockIdleInhibitor_Inhibit_Call) Return(err error) *MockIdleInhibitor_Inhibit_Call {
8517	_c.Call.Return(err)
8518	return _c
8519}
8520
8521func (_c *MockIdleInhibitor_Inhibit_Call) RunAndReturn(run func(ctx context.Context, reason string) error) *MockIdleInhibitor_Inhibit_Call {
8522	_c.Call.Return(run)
8523	return _c
8524}
8525
8526// IsInhibited provides a mock function for the type MockIdleInhibitor
8527func (_mock *MockIdleInhibitor) IsInhibited() bool {
8528	ret := _mock.Called()
8529
8530	if len(ret) == 0 {
8531		panic("no return value specified for IsInhibited")
8532	}
8533
8534	var r0 bool
8535	if returnFunc, ok := ret.Get(0).(func() bool); ok {
8536		r0 = returnFunc()
8537	} else {
8538		r0 = ret.Get(0).(bool)
8539	}
8540	return r0
8541}
8542
8543// MockIdleInhibitor_IsInhibited_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsInhibited'
8544type MockIdleInhibitor_IsInhibited_Call struct {
8545	*mock.Call
8546}
8547
8548// IsInhibited is a helper method to define mock.On call
8549func (_e *MockIdleInhibitor_Expecter) IsInhibited() *MockIdleInhibitor_IsInhibited_Call {
8550	return &MockIdleInhibitor_IsInhibited_Call{Call: _e.mock.On("IsInhibited")}
8551}
8552
8553func (_c *MockIdleInhibitor_IsInhibited_Call) Run(run func()) *MockIdleInhibitor_IsInhibited_Call {
8554	_c.Call.Run(func(args mock.Arguments) {
8555		run()
8556	})
8557	return _c
8558}
8559
8560func (_c *MockIdleInhibitor_IsInhibited_Call) Return(b bool) *MockIdleInhibitor_IsInhibited_Call {
8561	_c.Call.Return(b)
8562	return _c
8563}
8564
8565func (_c *MockIdleInhibitor_IsInhibited_Call) RunAndReturn(run func() bool) *MockIdleInhibitor_IsInhibited_Call {
8566	_c.Call.Return(run)
8567	return _c
8568}
8569
8570// Uninhibit provides a mock function for the type MockIdleInhibitor
8571func (_mock *MockIdleInhibitor) Uninhibit(ctx context.Context) error {
8572	ret := _mock.Called(ctx)
8573
8574	if len(ret) == 0 {
8575		panic("no return value specified for Uninhibit")
8576	}
8577
8578	var r0 error
8579	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
8580		r0 = returnFunc(ctx)
8581	} else {
8582		r0 = ret.Error(0)
8583	}
8584	return r0
8585}
8586
8587// MockIdleInhibitor_Uninhibit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Uninhibit'
8588type MockIdleInhibitor_Uninhibit_Call struct {
8589	*mock.Call
8590}
8591
8592// Uninhibit is a helper method to define mock.On call
8593//   - ctx context.Context
8594func (_e *MockIdleInhibitor_Expecter) Uninhibit(ctx interface{}) *MockIdleInhibitor_Uninhibit_Call {
8595	return &MockIdleInhibitor_Uninhibit_Call{Call: _e.mock.On("Uninhibit", ctx)}
8596}
8597
8598func (_c *MockIdleInhibitor_Uninhibit_Call) Run(run func(ctx context.Context)) *MockIdleInhibitor_Uninhibit_Call {
8599	_c.Call.Run(func(args mock.Arguments) {
8600		var arg0 context.Context
8601		if args[0] != nil {
8602			arg0 = args[0].(context.Context)
8603		}
8604		run(
8605			arg0,
8606		)
8607	})
8608	return _c
8609}
8610
8611func (_c *MockIdleInhibitor_Uninhibit_Call) Return(err error) *MockIdleInhibitor_Uninhibit_Call {
8612	_c.Call.Return(err)
8613	return _c
8614}
8615
8616func (_c *MockIdleInhibitor_Uninhibit_Call) RunAndReturn(run func(ctx context.Context) error) *MockIdleInhibitor_Uninhibit_Call {
8617	_c.Call.Return(run)
8618	return _c
8619}
8620
8621// NewMockImageDataResolver creates a new instance of MockImageDataResolver. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
8622// The first argument is typically a *testing.T value.
8623func NewMockImageDataResolver(t interface {
8624	mock.TestingT
8625	Cleanup(func())
8626}) *MockImageDataResolver {
8627	mock := &MockImageDataResolver{}
8628	mock.Mock.Test(t)
8629
8630	t.Cleanup(func() { mock.AssertExpectations(t) })
8631
8632	return mock
8633}
8634
8635// MockImageDataResolver is an autogenerated mock type for the ImageDataResolver type
8636type MockImageDataResolver struct {
8637	mock.Mock
8638}
8639
8640type MockImageDataResolver_Expecter struct {
8641	mock *mock.Mock
8642}
8643
8644func (_m *MockImageDataResolver) EXPECT() *MockImageDataResolver_Expecter {
8645	return &MockImageDataResolver_Expecter{mock: &_m.Mock}
8646}
8647
8648// ResolveImageData provides a mock function for the type MockImageDataResolver
8649func (_mock *MockImageDataResolver) ResolveImageData(ctx context.Context, uri string) (entity.ImageData, error) {
8650	ret := _mock.Called(ctx, uri)
8651
8652	if len(ret) == 0 {
8653		panic("no return value specified for ResolveImageData")
8654	}
8655
8656	var r0 entity.ImageData
8657	var r1 error
8658	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (entity.ImageData, error)); ok {
8659		return returnFunc(ctx, uri)
8660	}
8661	if returnFunc, ok := ret.Get(0).(func(context.Context, string) entity.ImageData); ok {
8662		r0 = returnFunc(ctx, uri)
8663	} else {
8664		r0 = ret.Get(0).(entity.ImageData)
8665	}
8666	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
8667		r1 = returnFunc(ctx, uri)
8668	} else {
8669		r1 = ret.Error(1)
8670	}
8671	return r0, r1
8672}
8673
8674// MockImageDataResolver_ResolveImageData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResolveImageData'
8675type MockImageDataResolver_ResolveImageData_Call struct {
8676	*mock.Call
8677}
8678
8679// ResolveImageData is a helper method to define mock.On call
8680//   - ctx context.Context
8681//   - uri string
8682func (_e *MockImageDataResolver_Expecter) ResolveImageData(ctx interface{}, uri interface{}) *MockImageDataResolver_ResolveImageData_Call {
8683	return &MockImageDataResolver_ResolveImageData_Call{Call: _e.mock.On("ResolveImageData", ctx, uri)}
8684}
8685
8686func (_c *MockImageDataResolver_ResolveImageData_Call) Run(run func(ctx context.Context, uri string)) *MockImageDataResolver_ResolveImageData_Call {
8687	_c.Call.Run(func(args mock.Arguments) {
8688		var arg0 context.Context
8689		if args[0] != nil {
8690			arg0 = args[0].(context.Context)
8691		}
8692		var arg1 string
8693		if args[1] != nil {
8694			arg1 = args[1].(string)
8695		}
8696		run(
8697			arg0,
8698			arg1,
8699		)
8700	})
8701	return _c
8702}
8703
8704func (_c *MockImageDataResolver_ResolveImageData_Call) Return(imageData entity.ImageData, err error) *MockImageDataResolver_ResolveImageData_Call {
8705	_c.Call.Return(imageData, err)
8706	return _c
8707}
8708
8709func (_c *MockImageDataResolver_ResolveImageData_Call) RunAndReturn(run func(ctx context.Context, uri string) (entity.ImageData, error)) *MockImageDataResolver_ResolveImageData_Call {
8710	_c.Call.Return(run)
8711	return _c
8712}
8713
8714// NewMockResolvedImageSaver creates a new instance of MockResolvedImageSaver. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
8715// The first argument is typically a *testing.T value.
8716func NewMockResolvedImageSaver(t interface {
8717	mock.TestingT
8718	Cleanup(func())
8719}) *MockResolvedImageSaver {
8720	mock := &MockResolvedImageSaver{}
8721	mock.Mock.Test(t)
8722
8723	t.Cleanup(func() { mock.AssertExpectations(t) })
8724
8725	return mock
8726}
8727
8728// MockResolvedImageSaver is an autogenerated mock type for the ResolvedImageSaver type
8729type MockResolvedImageSaver struct {
8730	mock.Mock
8731}
8732
8733type MockResolvedImageSaver_Expecter struct {
8734	mock *mock.Mock
8735}
8736
8737func (_m *MockResolvedImageSaver) EXPECT() *MockResolvedImageSaver_Expecter {
8738	return &MockResolvedImageSaver_Expecter{mock: &_m.Mock}
8739}
8740
8741// SaveResolvedImage provides a mock function for the type MockResolvedImageSaver
8742func (_mock *MockResolvedImageSaver) SaveResolvedImage(ctx context.Context, image entity.ImageData, menuContext port.MenuContext) error {
8743	ret := _mock.Called(ctx, image, menuContext)
8744
8745	if len(ret) == 0 {
8746		panic("no return value specified for SaveResolvedImage")
8747	}
8748
8749	var r0 error
8750	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.ImageData, port.MenuContext) error); ok {
8751		r0 = returnFunc(ctx, image, menuContext)
8752	} else {
8753		r0 = ret.Error(0)
8754	}
8755	return r0
8756}
8757
8758// MockResolvedImageSaver_SaveResolvedImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveResolvedImage'
8759type MockResolvedImageSaver_SaveResolvedImage_Call struct {
8760	*mock.Call
8761}
8762
8763// SaveResolvedImage is a helper method to define mock.On call
8764//   - ctx context.Context
8765//   - image entity.ImageData
8766//   - menuContext port.MenuContext
8767func (_e *MockResolvedImageSaver_Expecter) SaveResolvedImage(ctx interface{}, image interface{}, menuContext interface{}) *MockResolvedImageSaver_SaveResolvedImage_Call {
8768	return &MockResolvedImageSaver_SaveResolvedImage_Call{Call: _e.mock.On("SaveResolvedImage", ctx, image, menuContext)}
8769}
8770
8771func (_c *MockResolvedImageSaver_SaveResolvedImage_Call) Run(run func(ctx context.Context, image entity.ImageData, menuContext port.MenuContext)) *MockResolvedImageSaver_SaveResolvedImage_Call {
8772	_c.Call.Run(func(args mock.Arguments) {
8773		var arg0 context.Context
8774		if args[0] != nil {
8775			arg0 = args[0].(context.Context)
8776		}
8777		var arg1 entity.ImageData
8778		if args[1] != nil {
8779			arg1 = args[1].(entity.ImageData)
8780		}
8781		var arg2 port.MenuContext
8782		if args[2] != nil {
8783			arg2 = args[2].(port.MenuContext)
8784		}
8785		run(
8786			arg0,
8787			arg1,
8788			arg2,
8789		)
8790	})
8791	return _c
8792}
8793
8794func (_c *MockResolvedImageSaver_SaveResolvedImage_Call) Return(err error) *MockResolvedImageSaver_SaveResolvedImage_Call {
8795	_c.Call.Return(err)
8796	return _c
8797}
8798
8799func (_c *MockResolvedImageSaver_SaveResolvedImage_Call) RunAndReturn(run func(ctx context.Context, image entity.ImageData, menuContext port.MenuContext) error) *MockResolvedImageSaver_SaveResolvedImage_Call {
8800	_c.Call.Return(run)
8801	return _c
8802}
8803
8804// NewMockKeybindingsProvider creates a new instance of MockKeybindingsProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
8805// The first argument is typically a *testing.T value.
8806func NewMockKeybindingsProvider(t interface {
8807	mock.TestingT
8808	Cleanup(func())
8809}) *MockKeybindingsProvider {
8810	mock := &MockKeybindingsProvider{}
8811	mock.Mock.Test(t)
8812
8813	t.Cleanup(func() { mock.AssertExpectations(t) })
8814
8815	return mock
8816}
8817
8818// MockKeybindingsProvider is an autogenerated mock type for the KeybindingsProvider type
8819type MockKeybindingsProvider struct {
8820	mock.Mock
8821}
8822
8823type MockKeybindingsProvider_Expecter struct {
8824	mock *mock.Mock
8825}
8826
8827func (_m *MockKeybindingsProvider) EXPECT() *MockKeybindingsProvider_Expecter {
8828	return &MockKeybindingsProvider_Expecter{mock: &_m.Mock}
8829}
8830
8831// CheckConflicts provides a mock function for the type MockKeybindingsProvider
8832func (_mock *MockKeybindingsProvider) CheckConflicts(ctx context.Context, mode string, action string, keys []string) ([]port.KeybindingConflict, error) {
8833	ret := _mock.Called(ctx, mode, action, keys)
8834
8835	if len(ret) == 0 {
8836		panic("no return value specified for CheckConflicts")
8837	}
8838
8839	var r0 []port.KeybindingConflict
8840	var r1 error
8841	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string) ([]port.KeybindingConflict, error)); ok {
8842		return returnFunc(ctx, mode, action, keys)
8843	}
8844	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string) []port.KeybindingConflict); ok {
8845		r0 = returnFunc(ctx, mode, action, keys)
8846	} else {
8847		if ret.Get(0) != nil {
8848			r0 = ret.Get(0).([]port.KeybindingConflict)
8849		}
8850	}
8851	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, []string) error); ok {
8852		r1 = returnFunc(ctx, mode, action, keys)
8853	} else {
8854		r1 = ret.Error(1)
8855	}
8856	return r0, r1
8857}
8858
8859// MockKeybindingsProvider_CheckConflicts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckConflicts'
8860type MockKeybindingsProvider_CheckConflicts_Call struct {
8861	*mock.Call
8862}
8863
8864// CheckConflicts is a helper method to define mock.On call
8865//   - ctx context.Context
8866//   - mode string
8867//   - action string
8868//   - keys []string
8869func (_e *MockKeybindingsProvider_Expecter) CheckConflicts(ctx interface{}, mode interface{}, action interface{}, keys interface{}) *MockKeybindingsProvider_CheckConflicts_Call {
8870	return &MockKeybindingsProvider_CheckConflicts_Call{Call: _e.mock.On("CheckConflicts", ctx, mode, action, keys)}
8871}
8872
8873func (_c *MockKeybindingsProvider_CheckConflicts_Call) Run(run func(ctx context.Context, mode string, action string, keys []string)) *MockKeybindingsProvider_CheckConflicts_Call {
8874	_c.Call.Run(func(args mock.Arguments) {
8875		var arg0 context.Context
8876		if args[0] != nil {
8877			arg0 = args[0].(context.Context)
8878		}
8879		var arg1 string
8880		if args[1] != nil {
8881			arg1 = args[1].(string)
8882		}
8883		var arg2 string
8884		if args[2] != nil {
8885			arg2 = args[2].(string)
8886		}
8887		var arg3 []string
8888		if args[3] != nil {
8889			arg3 = args[3].([]string)
8890		}
8891		run(
8892			arg0,
8893			arg1,
8894			arg2,
8895			arg3,
8896		)
8897	})
8898	return _c
8899}
8900
8901func (_c *MockKeybindingsProvider_CheckConflicts_Call) Return(keybindingConflicts []port.KeybindingConflict, err error) *MockKeybindingsProvider_CheckConflicts_Call {
8902	_c.Call.Return(keybindingConflicts, err)
8903	return _c
8904}
8905
8906func (_c *MockKeybindingsProvider_CheckConflicts_Call) RunAndReturn(run func(ctx context.Context, mode string, action string, keys []string) ([]port.KeybindingConflict, error)) *MockKeybindingsProvider_CheckConflicts_Call {
8907	_c.Call.Return(run)
8908	return _c
8909}
8910
8911// GetDefaultKeybindings provides a mock function for the type MockKeybindingsProvider
8912func (_mock *MockKeybindingsProvider) GetDefaultKeybindings(ctx context.Context) (port.KeybindingsConfig, error) {
8913	ret := _mock.Called(ctx)
8914
8915	if len(ret) == 0 {
8916		panic("no return value specified for GetDefaultKeybindings")
8917	}
8918
8919	var r0 port.KeybindingsConfig
8920	var r1 error
8921	if returnFunc, ok := ret.Get(0).(func(context.Context) (port.KeybindingsConfig, error)); ok {
8922		return returnFunc(ctx)
8923	}
8924	if returnFunc, ok := ret.Get(0).(func(context.Context) port.KeybindingsConfig); ok {
8925		r0 = returnFunc(ctx)
8926	} else {
8927		r0 = ret.Get(0).(port.KeybindingsConfig)
8928	}
8929	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
8930		r1 = returnFunc(ctx)
8931	} else {
8932		r1 = ret.Error(1)
8933	}
8934	return r0, r1
8935}
8936
8937// MockKeybindingsProvider_GetDefaultKeybindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDefaultKeybindings'
8938type MockKeybindingsProvider_GetDefaultKeybindings_Call struct {
8939	*mock.Call
8940}
8941
8942// GetDefaultKeybindings is a helper method to define mock.On call
8943//   - ctx context.Context
8944func (_e *MockKeybindingsProvider_Expecter) GetDefaultKeybindings(ctx interface{}) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
8945	return &MockKeybindingsProvider_GetDefaultKeybindings_Call{Call: _e.mock.On("GetDefaultKeybindings", ctx)}
8946}
8947
8948func (_c *MockKeybindingsProvider_GetDefaultKeybindings_Call) Run(run func(ctx context.Context)) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
8949	_c.Call.Run(func(args mock.Arguments) {
8950		var arg0 context.Context
8951		if args[0] != nil {
8952			arg0 = args[0].(context.Context)
8953		}
8954		run(
8955			arg0,
8956		)
8957	})
8958	return _c
8959}
8960
8961func (_c *MockKeybindingsProvider_GetDefaultKeybindings_Call) Return(keybindingsConfig port.KeybindingsConfig, err error) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
8962	_c.Call.Return(keybindingsConfig, err)
8963	return _c
8964}
8965
8966func (_c *MockKeybindingsProvider_GetDefaultKeybindings_Call) RunAndReturn(run func(ctx context.Context) (port.KeybindingsConfig, error)) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
8967	_c.Call.Return(run)
8968	return _c
8969}
8970
8971// GetKeybindings provides a mock function for the type MockKeybindingsProvider
8972func (_mock *MockKeybindingsProvider) GetKeybindings(ctx context.Context) (port.KeybindingsConfig, error) {
8973	ret := _mock.Called(ctx)
8974
8975	if len(ret) == 0 {
8976		panic("no return value specified for GetKeybindings")
8977	}
8978
8979	var r0 port.KeybindingsConfig
8980	var r1 error
8981	if returnFunc, ok := ret.Get(0).(func(context.Context) (port.KeybindingsConfig, error)); ok {
8982		return returnFunc(ctx)
8983	}
8984	if returnFunc, ok := ret.Get(0).(func(context.Context) port.KeybindingsConfig); ok {
8985		r0 = returnFunc(ctx)
8986	} else {
8987		r0 = ret.Get(0).(port.KeybindingsConfig)
8988	}
8989	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
8990		r1 = returnFunc(ctx)
8991	} else {
8992		r1 = ret.Error(1)
8993	}
8994	return r0, r1
8995}
8996
8997// MockKeybindingsProvider_GetKeybindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetKeybindings'
8998type MockKeybindingsProvider_GetKeybindings_Call struct {
8999	*mock.Call
9000}
9001
9002// GetKeybindings is a helper method to define mock.On call
9003//   - ctx context.Context
9004func (_e *MockKeybindingsProvider_Expecter) GetKeybindings(ctx interface{}) *MockKeybindingsProvider_GetKeybindings_Call {
9005	return &MockKeybindingsProvider_GetKeybindings_Call{Call: _e.mock.On("GetKeybindings", ctx)}
9006}
9007
9008func (_c *MockKeybindingsProvider_GetKeybindings_Call) Run(run func(ctx context.Context)) *MockKeybindingsProvider_GetKeybindings_Call {
9009	_c.Call.Run(func(args mock.Arguments) {
9010		var arg0 context.Context
9011		if args[0] != nil {
9012			arg0 = args[0].(context.Context)
9013		}
9014		run(
9015			arg0,
9016		)
9017	})
9018	return _c
9019}
9020
9021func (_c *MockKeybindingsProvider_GetKeybindings_Call) Return(keybindingsConfig port.KeybindingsConfig, err error) *MockKeybindingsProvider_GetKeybindings_Call {
9022	_c.Call.Return(keybindingsConfig, err)
9023	return _c
9024}
9025
9026func (_c *MockKeybindingsProvider_GetKeybindings_Call) RunAndReturn(run func(ctx context.Context) (port.KeybindingsConfig, error)) *MockKeybindingsProvider_GetKeybindings_Call {
9027	_c.Call.Return(run)
9028	return _c
9029}
9030
9031// NewMockKeybindingsSaver creates a new instance of MockKeybindingsSaver. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
9032// The first argument is typically a *testing.T value.
9033func NewMockKeybindingsSaver(t interface {
9034	mock.TestingT
9035	Cleanup(func())
9036}) *MockKeybindingsSaver {
9037	mock := &MockKeybindingsSaver{}
9038	mock.Mock.Test(t)
9039
9040	t.Cleanup(func() { mock.AssertExpectations(t) })
9041
9042	return mock
9043}
9044
9045// MockKeybindingsSaver is an autogenerated mock type for the KeybindingsSaver type
9046type MockKeybindingsSaver struct {
9047	mock.Mock
9048}
9049
9050type MockKeybindingsSaver_Expecter struct {
9051	mock *mock.Mock
9052}
9053
9054func (_m *MockKeybindingsSaver) EXPECT() *MockKeybindingsSaver_Expecter {
9055	return &MockKeybindingsSaver_Expecter{mock: &_m.Mock}
9056}
9057
9058// ResetAllKeybindings provides a mock function for the type MockKeybindingsSaver
9059func (_mock *MockKeybindingsSaver) ResetAllKeybindings(ctx context.Context) error {
9060	ret := _mock.Called(ctx)
9061
9062	if len(ret) == 0 {
9063		panic("no return value specified for ResetAllKeybindings")
9064	}
9065
9066	var r0 error
9067	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
9068		r0 = returnFunc(ctx)
9069	} else {
9070		r0 = ret.Error(0)
9071	}
9072	return r0
9073}
9074
9075// MockKeybindingsSaver_ResetAllKeybindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetAllKeybindings'
9076type MockKeybindingsSaver_ResetAllKeybindings_Call struct {
9077	*mock.Call
9078}
9079
9080// ResetAllKeybindings is a helper method to define mock.On call
9081//   - ctx context.Context
9082func (_e *MockKeybindingsSaver_Expecter) ResetAllKeybindings(ctx interface{}) *MockKeybindingsSaver_ResetAllKeybindings_Call {
9083	return &MockKeybindingsSaver_ResetAllKeybindings_Call{Call: _e.mock.On("ResetAllKeybindings", ctx)}
9084}
9085
9086func (_c *MockKeybindingsSaver_ResetAllKeybindings_Call) Run(run func(ctx context.Context)) *MockKeybindingsSaver_ResetAllKeybindings_Call {
9087	_c.Call.Run(func(args mock.Arguments) {
9088		var arg0 context.Context
9089		if args[0] != nil {
9090			arg0 = args[0].(context.Context)
9091		}
9092		run(
9093			arg0,
9094		)
9095	})
9096	return _c
9097}
9098
9099func (_c *MockKeybindingsSaver_ResetAllKeybindings_Call) Return(err error) *MockKeybindingsSaver_ResetAllKeybindings_Call {
9100	_c.Call.Return(err)
9101	return _c
9102}
9103
9104func (_c *MockKeybindingsSaver_ResetAllKeybindings_Call) RunAndReturn(run func(ctx context.Context) error) *MockKeybindingsSaver_ResetAllKeybindings_Call {
9105	_c.Call.Return(run)
9106	return _c
9107}
9108
9109// ResetKeybinding provides a mock function for the type MockKeybindingsSaver
9110func (_mock *MockKeybindingsSaver) ResetKeybinding(ctx context.Context, req port.ResetKeybindingRequest) error {
9111	ret := _mock.Called(ctx, req)
9112
9113	if len(ret) == 0 {
9114		panic("no return value specified for ResetKeybinding")
9115	}
9116
9117	var r0 error
9118	if returnFunc, ok := ret.Get(0).(func(context.Context, port.ResetKeybindingRequest) error); ok {
9119		r0 = returnFunc(ctx, req)
9120	} else {
9121		r0 = ret.Error(0)
9122	}
9123	return r0
9124}
9125
9126// MockKeybindingsSaver_ResetKeybinding_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetKeybinding'
9127type MockKeybindingsSaver_ResetKeybinding_Call struct {
9128	*mock.Call
9129}
9130
9131// ResetKeybinding is a helper method to define mock.On call
9132//   - ctx context.Context
9133//   - req port.ResetKeybindingRequest
9134func (_e *MockKeybindingsSaver_Expecter) ResetKeybinding(ctx interface{}, req interface{}) *MockKeybindingsSaver_ResetKeybinding_Call {
9135	return &MockKeybindingsSaver_ResetKeybinding_Call{Call: _e.mock.On("ResetKeybinding", ctx, req)}
9136}
9137
9138func (_c *MockKeybindingsSaver_ResetKeybinding_Call) Run(run func(ctx context.Context, req port.ResetKeybindingRequest)) *MockKeybindingsSaver_ResetKeybinding_Call {
9139	_c.Call.Run(func(args mock.Arguments) {
9140		var arg0 context.Context
9141		if args[0] != nil {
9142			arg0 = args[0].(context.Context)
9143		}
9144		var arg1 port.ResetKeybindingRequest
9145		if args[1] != nil {
9146			arg1 = args[1].(port.ResetKeybindingRequest)
9147		}
9148		run(
9149			arg0,
9150			arg1,
9151		)
9152	})
9153	return _c
9154}
9155
9156func (_c *MockKeybindingsSaver_ResetKeybinding_Call) Return(err error) *MockKeybindingsSaver_ResetKeybinding_Call {
9157	_c.Call.Return(err)
9158	return _c
9159}
9160
9161func (_c *MockKeybindingsSaver_ResetKeybinding_Call) RunAndReturn(run func(ctx context.Context, req port.ResetKeybindingRequest) error) *MockKeybindingsSaver_ResetKeybinding_Call {
9162	_c.Call.Return(run)
9163	return _c
9164}
9165
9166// SetKeybinding provides a mock function for the type MockKeybindingsSaver
9167func (_mock *MockKeybindingsSaver) SetKeybinding(ctx context.Context, req port.SetKeybindingRequest) error {
9168	ret := _mock.Called(ctx, req)
9169
9170	if len(ret) == 0 {
9171		panic("no return value specified for SetKeybinding")
9172	}
9173
9174	var r0 error
9175	if returnFunc, ok := ret.Get(0).(func(context.Context, port.SetKeybindingRequest) error); ok {
9176		r0 = returnFunc(ctx, req)
9177	} else {
9178		r0 = ret.Error(0)
9179	}
9180	return r0
9181}
9182
9183// MockKeybindingsSaver_SetKeybinding_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetKeybinding'
9184type MockKeybindingsSaver_SetKeybinding_Call struct {
9185	*mock.Call
9186}
9187
9188// SetKeybinding is a helper method to define mock.On call
9189//   - ctx context.Context
9190//   - req port.SetKeybindingRequest
9191func (_e *MockKeybindingsSaver_Expecter) SetKeybinding(ctx interface{}, req interface{}) *MockKeybindingsSaver_SetKeybinding_Call {
9192	return &MockKeybindingsSaver_SetKeybinding_Call{Call: _e.mock.On("SetKeybinding", ctx, req)}
9193}
9194
9195func (_c *MockKeybindingsSaver_SetKeybinding_Call) Run(run func(ctx context.Context, req port.SetKeybindingRequest)) *MockKeybindingsSaver_SetKeybinding_Call {
9196	_c.Call.Run(func(args mock.Arguments) {
9197		var arg0 context.Context
9198		if args[0] != nil {
9199			arg0 = args[0].(context.Context)
9200		}
9201		var arg1 port.SetKeybindingRequest
9202		if args[1] != nil {
9203			arg1 = args[1].(port.SetKeybindingRequest)
9204		}
9205		run(
9206			arg0,
9207			arg1,
9208		)
9209	})
9210	return _c
9211}
9212
9213func (_c *MockKeybindingsSaver_SetKeybinding_Call) Return(err error) *MockKeybindingsSaver_SetKeybinding_Call {
9214	_c.Call.Return(err)
9215	return _c
9216}
9217
9218func (_c *MockKeybindingsSaver_SetKeybinding_Call) RunAndReturn(run func(ctx context.Context, req port.SetKeybindingRequest) error) *MockKeybindingsSaver_SetKeybinding_Call {
9219	_c.Call.Return(run)
9220	return _c
9221}
9222
9223// NewMockKeybindingsGetter creates a new instance of MockKeybindingsGetter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
9224// The first argument is typically a *testing.T value.
9225func NewMockKeybindingsGetter(t interface {
9226	mock.TestingT
9227	Cleanup(func())
9228}) *MockKeybindingsGetter {
9229	mock := &MockKeybindingsGetter{}
9230	mock.Mock.Test(t)
9231
9232	t.Cleanup(func() { mock.AssertExpectations(t) })
9233
9234	return mock
9235}
9236
9237// MockKeybindingsGetter is an autogenerated mock type for the KeybindingsGetter type
9238type MockKeybindingsGetter struct {
9239	mock.Mock
9240}
9241
9242type MockKeybindingsGetter_Expecter struct {
9243	mock *mock.Mock
9244}
9245
9246func (_m *MockKeybindingsGetter) EXPECT() *MockKeybindingsGetter_Expecter {
9247	return &MockKeybindingsGetter_Expecter{mock: &_m.Mock}
9248}
9249
9250// Execute provides a mock function for the type MockKeybindingsGetter
9251func (_mock *MockKeybindingsGetter) Execute(ctx context.Context) (port.KeybindingsConfig, error) {
9252	ret := _mock.Called(ctx)
9253
9254	if len(ret) == 0 {
9255		panic("no return value specified for Execute")
9256	}
9257
9258	var r0 port.KeybindingsConfig
9259	var r1 error
9260	if returnFunc, ok := ret.Get(0).(func(context.Context) (port.KeybindingsConfig, error)); ok {
9261		return returnFunc(ctx)
9262	}
9263	if returnFunc, ok := ret.Get(0).(func(context.Context) port.KeybindingsConfig); ok {
9264		r0 = returnFunc(ctx)
9265	} else {
9266		r0 = ret.Get(0).(port.KeybindingsConfig)
9267	}
9268	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
9269		r1 = returnFunc(ctx)
9270	} else {
9271		r1 = ret.Error(1)
9272	}
9273	return r0, r1
9274}
9275
9276// MockKeybindingsGetter_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'
9277type MockKeybindingsGetter_Execute_Call struct {
9278	*mock.Call
9279}
9280
9281// Execute is a helper method to define mock.On call
9282//   - ctx context.Context
9283func (_e *MockKeybindingsGetter_Expecter) Execute(ctx interface{}) *MockKeybindingsGetter_Execute_Call {
9284	return &MockKeybindingsGetter_Execute_Call{Call: _e.mock.On("Execute", ctx)}
9285}
9286
9287func (_c *MockKeybindingsGetter_Execute_Call) Run(run func(ctx context.Context)) *MockKeybindingsGetter_Execute_Call {
9288	_c.Call.Run(func(args mock.Arguments) {
9289		var arg0 context.Context
9290		if args[0] != nil {
9291			arg0 = args[0].(context.Context)
9292		}
9293		run(
9294			arg0,
9295		)
9296	})
9297	return _c
9298}
9299
9300func (_c *MockKeybindingsGetter_Execute_Call) Return(keybindingsConfig port.KeybindingsConfig, err error) *MockKeybindingsGetter_Execute_Call {
9301	_c.Call.Return(keybindingsConfig, err)
9302	return _c
9303}
9304
9305func (_c *MockKeybindingsGetter_Execute_Call) RunAndReturn(run func(ctx context.Context) (port.KeybindingsConfig, error)) *MockKeybindingsGetter_Execute_Call {
9306	_c.Call.Return(run)
9307	return _c
9308}
9309
9310// NewMockKeybindingSetter creates a new instance of MockKeybindingSetter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
9311// The first argument is typically a *testing.T value.
9312func NewMockKeybindingSetter(t interface {
9313	mock.TestingT
9314	Cleanup(func())
9315}) *MockKeybindingSetter {
9316	mock := &MockKeybindingSetter{}
9317	mock.Mock.Test(t)
9318
9319	t.Cleanup(func() { mock.AssertExpectations(t) })
9320
9321	return mock
9322}
9323
9324// MockKeybindingSetter is an autogenerated mock type for the KeybindingSetter type
9325type MockKeybindingSetter struct {
9326	mock.Mock
9327}
9328
9329type MockKeybindingSetter_Expecter struct {
9330	mock *mock.Mock
9331}
9332
9333func (_m *MockKeybindingSetter) EXPECT() *MockKeybindingSetter_Expecter {
9334	return &MockKeybindingSetter_Expecter{mock: &_m.Mock}
9335}
9336
9337// Execute provides a mock function for the type MockKeybindingSetter
9338func (_mock *MockKeybindingSetter) Execute(ctx context.Context, req port.SetKeybindingRequest) (port.SetKeybindingResponse, error) {
9339	ret := _mock.Called(ctx, req)
9340
9341	if len(ret) == 0 {
9342		panic("no return value specified for Execute")
9343	}
9344
9345	var r0 port.SetKeybindingResponse
9346	var r1 error
9347	if returnFunc, ok := ret.Get(0).(func(context.Context, port.SetKeybindingRequest) (port.SetKeybindingResponse, error)); ok {
9348		return returnFunc(ctx, req)
9349	}
9350	if returnFunc, ok := ret.Get(0).(func(context.Context, port.SetKeybindingRequest) port.SetKeybindingResponse); ok {
9351		r0 = returnFunc(ctx, req)
9352	} else {
9353		r0 = ret.Get(0).(port.SetKeybindingResponse)
9354	}
9355	if returnFunc, ok := ret.Get(1).(func(context.Context, port.SetKeybindingRequest) error); ok {
9356		r1 = returnFunc(ctx, req)
9357	} else {
9358		r1 = ret.Error(1)
9359	}
9360	return r0, r1
9361}
9362
9363// MockKeybindingSetter_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'
9364type MockKeybindingSetter_Execute_Call struct {
9365	*mock.Call
9366}
9367
9368// Execute is a helper method to define mock.On call
9369//   - ctx context.Context
9370//   - req port.SetKeybindingRequest
9371func (_e *MockKeybindingSetter_Expecter) Execute(ctx interface{}, req interface{}) *MockKeybindingSetter_Execute_Call {
9372	return &MockKeybindingSetter_Execute_Call{Call: _e.mock.On("Execute", ctx, req)}
9373}
9374
9375func (_c *MockKeybindingSetter_Execute_Call) Run(run func(ctx context.Context, req port.SetKeybindingRequest)) *MockKeybindingSetter_Execute_Call {
9376	_c.Call.Run(func(args mock.Arguments) {
9377		var arg0 context.Context
9378		if args[0] != nil {
9379			arg0 = args[0].(context.Context)
9380		}
9381		var arg1 port.SetKeybindingRequest
9382		if args[1] != nil {
9383			arg1 = args[1].(port.SetKeybindingRequest)
9384		}
9385		run(
9386			arg0,
9387			arg1,
9388		)
9389	})
9390	return _c
9391}
9392
9393func (_c *MockKeybindingSetter_Execute_Call) Return(setKeybindingResponse port.SetKeybindingResponse, err error) *MockKeybindingSetter_Execute_Call {
9394	_c.Call.Return(setKeybindingResponse, err)
9395	return _c
9396}
9397
9398func (_c *MockKeybindingSetter_Execute_Call) RunAndReturn(run func(ctx context.Context, req port.SetKeybindingRequest) (port.SetKeybindingResponse, error)) *MockKeybindingSetter_Execute_Call {
9399	_c.Call.Return(run)
9400	return _c
9401}
9402
9403// NewMockKeybindingResetter creates a new instance of MockKeybindingResetter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
9404// The first argument is typically a *testing.T value.
9405func NewMockKeybindingResetter(t interface {
9406	mock.TestingT
9407	Cleanup(func())
9408}) *MockKeybindingResetter {
9409	mock := &MockKeybindingResetter{}
9410	mock.Mock.Test(t)
9411
9412	t.Cleanup(func() { mock.AssertExpectations(t) })
9413
9414	return mock
9415}
9416
9417// MockKeybindingResetter is an autogenerated mock type for the KeybindingResetter type
9418type MockKeybindingResetter struct {
9419	mock.Mock
9420}
9421
9422type MockKeybindingResetter_Expecter struct {
9423	mock *mock.Mock
9424}
9425
9426func (_m *MockKeybindingResetter) EXPECT() *MockKeybindingResetter_Expecter {
9427	return &MockKeybindingResetter_Expecter{mock: &_m.Mock}
9428}
9429
9430// Execute provides a mock function for the type MockKeybindingResetter
9431func (_mock *MockKeybindingResetter) Execute(ctx context.Context, req port.ResetKeybindingRequest) error {
9432	ret := _mock.Called(ctx, req)
9433
9434	if len(ret) == 0 {
9435		panic("no return value specified for Execute")
9436	}
9437
9438	var r0 error
9439	if returnFunc, ok := ret.Get(0).(func(context.Context, port.ResetKeybindingRequest) error); ok {
9440		r0 = returnFunc(ctx, req)
9441	} else {
9442		r0 = ret.Error(0)
9443	}
9444	return r0
9445}
9446
9447// MockKeybindingResetter_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'
9448type MockKeybindingResetter_Execute_Call struct {
9449	*mock.Call
9450}
9451
9452// Execute is a helper method to define mock.On call
9453//   - ctx context.Context
9454//   - req port.ResetKeybindingRequest
9455func (_e *MockKeybindingResetter_Expecter) Execute(ctx interface{}, req interface{}) *MockKeybindingResetter_Execute_Call {
9456	return &MockKeybindingResetter_Execute_Call{Call: _e.mock.On("Execute", ctx, req)}
9457}
9458
9459func (_c *MockKeybindingResetter_Execute_Call) Run(run func(ctx context.Context, req port.ResetKeybindingRequest)) *MockKeybindingResetter_Execute_Call {
9460	_c.Call.Run(func(args mock.Arguments) {
9461		var arg0 context.Context
9462		if args[0] != nil {
9463			arg0 = args[0].(context.Context)
9464		}
9465		var arg1 port.ResetKeybindingRequest
9466		if args[1] != nil {
9467			arg1 = args[1].(port.ResetKeybindingRequest)
9468		}
9469		run(
9470			arg0,
9471			arg1,
9472		)
9473	})
9474	return _c
9475}
9476
9477func (_c *MockKeybindingResetter_Execute_Call) Return(err error) *MockKeybindingResetter_Execute_Call {
9478	_c.Call.Return(err)
9479	return _c
9480}
9481
9482func (_c *MockKeybindingResetter_Execute_Call) RunAndReturn(run func(ctx context.Context, req port.ResetKeybindingRequest) error) *MockKeybindingResetter_Execute_Call {
9483	_c.Call.Return(run)
9484	return _c
9485}
9486
9487// NewMockAllKeybindingsResetter creates a new instance of MockAllKeybindingsResetter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
9488// The first argument is typically a *testing.T value.
9489func NewMockAllKeybindingsResetter(t interface {
9490	mock.TestingT
9491	Cleanup(func())
9492}) *MockAllKeybindingsResetter {
9493	mock := &MockAllKeybindingsResetter{}
9494	mock.Mock.Test(t)
9495
9496	t.Cleanup(func() { mock.AssertExpectations(t) })
9497
9498	return mock
9499}
9500
9501// MockAllKeybindingsResetter is an autogenerated mock type for the AllKeybindingsResetter type
9502type MockAllKeybindingsResetter struct {
9503	mock.Mock
9504}
9505
9506type MockAllKeybindingsResetter_Expecter struct {
9507	mock *mock.Mock
9508}
9509
9510func (_m *MockAllKeybindingsResetter) EXPECT() *MockAllKeybindingsResetter_Expecter {
9511	return &MockAllKeybindingsResetter_Expecter{mock: &_m.Mock}
9512}
9513
9514// Execute provides a mock function for the type MockAllKeybindingsResetter
9515func (_mock *MockAllKeybindingsResetter) Execute(ctx context.Context) error {
9516	ret := _mock.Called(ctx)
9517
9518	if len(ret) == 0 {
9519		panic("no return value specified for Execute")
9520	}
9521
9522	var r0 error
9523	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
9524		r0 = returnFunc(ctx)
9525	} else {
9526		r0 = ret.Error(0)
9527	}
9528	return r0
9529}
9530
9531// MockAllKeybindingsResetter_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'
9532type MockAllKeybindingsResetter_Execute_Call struct {
9533	*mock.Call
9534}
9535
9536// Execute is a helper method to define mock.On call
9537//   - ctx context.Context
9538func (_e *MockAllKeybindingsResetter_Expecter) Execute(ctx interface{}) *MockAllKeybindingsResetter_Execute_Call {
9539	return &MockAllKeybindingsResetter_Execute_Call{Call: _e.mock.On("Execute", ctx)}
9540}
9541
9542func (_c *MockAllKeybindingsResetter_Execute_Call) Run(run func(ctx context.Context)) *MockAllKeybindingsResetter_Execute_Call {
9543	_c.Call.Run(func(args mock.Arguments) {
9544		var arg0 context.Context
9545		if args[0] != nil {
9546			arg0 = args[0].(context.Context)
9547		}
9548		run(
9549			arg0,
9550		)
9551	})
9552	return _c
9553}
9554
9555func (_c *MockAllKeybindingsResetter_Execute_Call) Return(err error) *MockAllKeybindingsResetter_Execute_Call {
9556	_c.Call.Return(err)
9557	return _c
9558}
9559
9560func (_c *MockAllKeybindingsResetter_Execute_Call) RunAndReturn(run func(ctx context.Context) error) *MockAllKeybindingsResetter_Execute_Call {
9561	_c.Call.Return(run)
9562	return _c
9563}
9564
9565// NewMockMediaDiagnostics creates a new instance of MockMediaDiagnostics. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
9566// The first argument is typically a *testing.T value.
9567func NewMockMediaDiagnostics(t interface {
9568	mock.TestingT
9569	Cleanup(func())
9570}) *MockMediaDiagnostics {
9571	mock := &MockMediaDiagnostics{}
9572	mock.Mock.Test(t)
9573
9574	t.Cleanup(func() { mock.AssertExpectations(t) })
9575
9576	return mock
9577}
9578
9579// MockMediaDiagnostics is an autogenerated mock type for the MediaDiagnostics type
9580type MockMediaDiagnostics struct {
9581	mock.Mock
9582}
9583
9584type MockMediaDiagnostics_Expecter struct {
9585	mock *mock.Mock
9586}
9587
9588func (_m *MockMediaDiagnostics) EXPECT() *MockMediaDiagnostics_Expecter {
9589	return &MockMediaDiagnostics_Expecter{mock: &_m.Mock}
9590}
9591
9592// RunDiagnostics provides a mock function for the type MockMediaDiagnostics
9593func (_mock *MockMediaDiagnostics) RunDiagnostics(ctx context.Context) *port.MediaDiagnosticsResult {
9594	ret := _mock.Called(ctx)
9595
9596	if len(ret) == 0 {
9597		panic("no return value specified for RunDiagnostics")
9598	}
9599
9600	var r0 *port.MediaDiagnosticsResult
9601	if returnFunc, ok := ret.Get(0).(func(context.Context) *port.MediaDiagnosticsResult); ok {
9602		r0 = returnFunc(ctx)
9603	} else {
9604		if ret.Get(0) != nil {
9605			r0 = ret.Get(0).(*port.MediaDiagnosticsResult)
9606		}
9607	}
9608	return r0
9609}
9610
9611// MockMediaDiagnostics_RunDiagnostics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunDiagnostics'
9612type MockMediaDiagnostics_RunDiagnostics_Call struct {
9613	*mock.Call
9614}
9615
9616// RunDiagnostics is a helper method to define mock.On call
9617//   - ctx context.Context
9618func (_e *MockMediaDiagnostics_Expecter) RunDiagnostics(ctx interface{}) *MockMediaDiagnostics_RunDiagnostics_Call {
9619	return &MockMediaDiagnostics_RunDiagnostics_Call{Call: _e.mock.On("RunDiagnostics", ctx)}
9620}
9621
9622func (_c *MockMediaDiagnostics_RunDiagnostics_Call) Run(run func(ctx context.Context)) *MockMediaDiagnostics_RunDiagnostics_Call {
9623	_c.Call.Run(func(args mock.Arguments) {
9624		var arg0 context.Context
9625		if args[0] != nil {
9626			arg0 = args[0].(context.Context)
9627		}
9628		run(
9629			arg0,
9630		)
9631	})
9632	return _c
9633}
9634
9635func (_c *MockMediaDiagnostics_RunDiagnostics_Call) Return(mediaDiagnosticsResult *port.MediaDiagnosticsResult) *MockMediaDiagnostics_RunDiagnostics_Call {
9636	_c.Call.Return(mediaDiagnosticsResult)
9637	return _c
9638}
9639
9640func (_c *MockMediaDiagnostics_RunDiagnostics_Call) RunAndReturn(run func(ctx context.Context) *port.MediaDiagnosticsResult) *MockMediaDiagnostics_RunDiagnostics_Call {
9641	_c.Call.Return(run)
9642	return _c
9643}
9644
9645// NewMockNotification creates a new instance of MockNotification. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
9646// The first argument is typically a *testing.T value.
9647func NewMockNotification(t interface {
9648	mock.TestingT
9649	Cleanup(func())
9650}) *MockNotification {
9651	mock := &MockNotification{}
9652	mock.Mock.Test(t)
9653
9654	t.Cleanup(func() { mock.AssertExpectations(t) })
9655
9656	return mock
9657}
9658
9659// MockNotification is an autogenerated mock type for the Notification type
9660type MockNotification struct {
9661	mock.Mock
9662}
9663
9664type MockNotification_Expecter struct {
9665	mock *mock.Mock
9666}
9667
9668func (_m *MockNotification) EXPECT() *MockNotification_Expecter {
9669	return &MockNotification_Expecter{mock: &_m.Mock}
9670}
9671
9672// Clear provides a mock function for the type MockNotification
9673func (_mock *MockNotification) Clear(ctx context.Context) {
9674	_mock.Called(ctx)
9675	return
9676}
9677
9678// MockNotification_Clear_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Clear'
9679type MockNotification_Clear_Call struct {
9680	*mock.Call
9681}
9682
9683// Clear is a helper method to define mock.On call
9684//   - ctx context.Context
9685func (_e *MockNotification_Expecter) Clear(ctx interface{}) *MockNotification_Clear_Call {
9686	return &MockNotification_Clear_Call{Call: _e.mock.On("Clear", ctx)}
9687}
9688
9689func (_c *MockNotification_Clear_Call) Run(run func(ctx context.Context)) *MockNotification_Clear_Call {
9690	_c.Call.Run(func(args mock.Arguments) {
9691		var arg0 context.Context
9692		if args[0] != nil {
9693			arg0 = args[0].(context.Context)
9694		}
9695		run(
9696			arg0,
9697		)
9698	})
9699	return _c
9700}
9701
9702func (_c *MockNotification_Clear_Call) Return() *MockNotification_Clear_Call {
9703	_c.Call.Return()
9704	return _c
9705}
9706
9707func (_c *MockNotification_Clear_Call) RunAndReturn(run func(ctx context.Context)) *MockNotification_Clear_Call {
9708	_c.Run(run)
9709	return _c
9710}
9711
9712// Dismiss provides a mock function for the type MockNotification
9713func (_mock *MockNotification) Dismiss(ctx context.Context, id port.NotificationID) {
9714	_mock.Called(ctx, id)
9715	return
9716}
9717
9718// MockNotification_Dismiss_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Dismiss'
9719type MockNotification_Dismiss_Call struct {
9720	*mock.Call
9721}
9722
9723// Dismiss is a helper method to define mock.On call
9724//   - ctx context.Context
9725//   - id port.NotificationID
9726func (_e *MockNotification_Expecter) Dismiss(ctx interface{}, id interface{}) *MockNotification_Dismiss_Call {
9727	return &MockNotification_Dismiss_Call{Call: _e.mock.On("Dismiss", ctx, id)}
9728}
9729
9730func (_c *MockNotification_Dismiss_Call) Run(run func(ctx context.Context, id port.NotificationID)) *MockNotification_Dismiss_Call {
9731	_c.Call.Run(func(args mock.Arguments) {
9732		var arg0 context.Context
9733		if args[0] != nil {
9734			arg0 = args[0].(context.Context)
9735		}
9736		var arg1 port.NotificationID
9737		if args[1] != nil {
9738			arg1 = args[1].(port.NotificationID)
9739		}
9740		run(
9741			arg0,
9742			arg1,
9743		)
9744	})
9745	return _c
9746}
9747
9748func (_c *MockNotification_Dismiss_Call) Return() *MockNotification_Dismiss_Call {
9749	_c.Call.Return()
9750	return _c
9751}
9752
9753func (_c *MockNotification_Dismiss_Call) RunAndReturn(run func(ctx context.Context, id port.NotificationID)) *MockNotification_Dismiss_Call {
9754	_c.Run(run)
9755	return _c
9756}
9757
9758// Show provides a mock function for the type MockNotification
9759func (_mock *MockNotification) Show(ctx context.Context, message string, notifType port.NotificationType, durationMs int) port.NotificationID {
9760	ret := _mock.Called(ctx, message, notifType, durationMs)
9761
9762	if len(ret) == 0 {
9763		panic("no return value specified for Show")
9764	}
9765
9766	var r0 port.NotificationID
9767	if returnFunc, ok := ret.Get(0).(func(context.Context, string, port.NotificationType, int) port.NotificationID); ok {
9768		r0 = returnFunc(ctx, message, notifType, durationMs)
9769	} else {
9770		r0 = ret.Get(0).(port.NotificationID)
9771	}
9772	return r0
9773}
9774
9775// MockNotification_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
9776type MockNotification_Show_Call struct {
9777	*mock.Call
9778}
9779
9780// Show is a helper method to define mock.On call
9781//   - ctx context.Context
9782//   - message string
9783//   - notifType port.NotificationType
9784//   - durationMs int
9785func (_e *MockNotification_Expecter) Show(ctx interface{}, message interface{}, notifType interface{}, durationMs interface{}) *MockNotification_Show_Call {
9786	return &MockNotification_Show_Call{Call: _e.mock.On("Show", ctx, message, notifType, durationMs)}
9787}
9788
9789func (_c *MockNotification_Show_Call) Run(run func(ctx context.Context, message string, notifType port.NotificationType, durationMs int)) *MockNotification_Show_Call {
9790	_c.Call.Run(func(args mock.Arguments) {
9791		var arg0 context.Context
9792		if args[0] != nil {
9793			arg0 = args[0].(context.Context)
9794		}
9795		var arg1 string
9796		if args[1] != nil {
9797			arg1 = args[1].(string)
9798		}
9799		var arg2 port.NotificationType
9800		if args[2] != nil {
9801			arg2 = args[2].(port.NotificationType)
9802		}
9803		var arg3 int
9804		if args[3] != nil {
9805			arg3 = args[3].(int)
9806		}
9807		run(
9808			arg0,
9809			arg1,
9810			arg2,
9811			arg3,
9812		)
9813	})
9814	return _c
9815}
9816
9817func (_c *MockNotification_Show_Call) Return(notificationID port.NotificationID) *MockNotification_Show_Call {
9818	_c.Call.Return(notificationID)
9819	return _c
9820}
9821
9822func (_c *MockNotification_Show_Call) RunAndReturn(run func(ctx context.Context, message string, notifType port.NotificationType, durationMs int) port.NotificationID) *MockNotification_Show_Call {
9823	_c.Call.Return(run)
9824	return _c
9825}
9826
9827// ShowZoom provides a mock function for the type MockNotification
9828func (_mock *MockNotification) ShowZoom(ctx context.Context, zoomPercent int) port.NotificationID {
9829	ret := _mock.Called(ctx, zoomPercent)
9830
9831	if len(ret) == 0 {
9832		panic("no return value specified for ShowZoom")
9833	}
9834
9835	var r0 port.NotificationID
9836	if returnFunc, ok := ret.Get(0).(func(context.Context, int) port.NotificationID); ok {
9837		r0 = returnFunc(ctx, zoomPercent)
9838	} else {
9839		r0 = ret.Get(0).(port.NotificationID)
9840	}
9841	return r0
9842}
9843
9844// MockNotification_ShowZoom_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowZoom'
9845type MockNotification_ShowZoom_Call struct {
9846	*mock.Call
9847}
9848
9849// ShowZoom is a helper method to define mock.On call
9850//   - ctx context.Context
9851//   - zoomPercent int
9852func (_e *MockNotification_Expecter) ShowZoom(ctx interface{}, zoomPercent interface{}) *MockNotification_ShowZoom_Call {
9853	return &MockNotification_ShowZoom_Call{Call: _e.mock.On("ShowZoom", ctx, zoomPercent)}
9854}
9855
9856func (_c *MockNotification_ShowZoom_Call) Run(run func(ctx context.Context, zoomPercent int)) *MockNotification_ShowZoom_Call {
9857	_c.Call.Run(func(args mock.Arguments) {
9858		var arg0 context.Context
9859		if args[0] != nil {
9860			arg0 = args[0].(context.Context)
9861		}
9862		var arg1 int
9863		if args[1] != nil {
9864			arg1 = args[1].(int)
9865		}
9866		run(
9867			arg0,
9868			arg1,
9869		)
9870	})
9871	return _c
9872}
9873
9874func (_c *MockNotification_ShowZoom_Call) Return(notificationID port.NotificationID) *MockNotification_ShowZoom_Call {
9875	_c.Call.Return(notificationID)
9876	return _c
9877}
9878
9879func (_c *MockNotification_ShowZoom_Call) RunAndReturn(run func(ctx context.Context, zoomPercent int) port.NotificationID) *MockNotification_ShowZoom_Call {
9880	_c.Call.Return(run)
9881	return _c
9882}
9883
9884// NewMockOmniboxPreferencesSaver creates a new instance of MockOmniboxPreferencesSaver. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
9885// The first argument is typically a *testing.T value.
9886func NewMockOmniboxPreferencesSaver(t interface {
9887	mock.TestingT
9888	Cleanup(func())
9889}) *MockOmniboxPreferencesSaver {
9890	mock := &MockOmniboxPreferencesSaver{}
9891	mock.Mock.Test(t)
9892
9893	t.Cleanup(func() { mock.AssertExpectations(t) })
9894
9895	return mock
9896}
9897
9898// MockOmniboxPreferencesSaver is an autogenerated mock type for the OmniboxPreferencesSaver type
9899type MockOmniboxPreferencesSaver struct {
9900	mock.Mock
9901}
9902
9903type MockOmniboxPreferencesSaver_Expecter struct {
9904	mock *mock.Mock
9905}
9906
9907func (_m *MockOmniboxPreferencesSaver) EXPECT() *MockOmniboxPreferencesSaver_Expecter {
9908	return &MockOmniboxPreferencesSaver_Expecter{mock: &_m.Mock}
9909}
9910
9911// SaveOmniboxInitialBehavior provides a mock function for the type MockOmniboxPreferencesSaver
9912func (_mock *MockOmniboxPreferencesSaver) SaveOmniboxInitialBehavior(ctx context.Context, behavior entity.OmniboxInitialBehavior) error {
9913	ret := _mock.Called(ctx, behavior)
9914
9915	if len(ret) == 0 {
9916		panic("no return value specified for SaveOmniboxInitialBehavior")
9917	}
9918
9919	var r0 error
9920	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.OmniboxInitialBehavior) error); ok {
9921		r0 = returnFunc(ctx, behavior)
9922	} else {
9923		r0 = ret.Error(0)
9924	}
9925	return r0
9926}
9927
9928// MockOmniboxPreferencesSaver_SaveOmniboxInitialBehavior_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveOmniboxInitialBehavior'
9929type MockOmniboxPreferencesSaver_SaveOmniboxInitialBehavior_Call struct {
9930	*mock.Call
9931}
9932
9933// SaveOmniboxInitialBehavior is a helper method to define mock.On call
9934//   - ctx context.Context
9935//   - behavior entity.OmniboxInitialBehavior
9936func (_e *MockOmniboxPreferencesSaver_Expecter) SaveOmniboxInitialBehavior(ctx interface{}, behavior interface{}) *MockOmniboxPreferencesSaver_SaveOmniboxInitialBehavior_Call {
9937	return &MockOmniboxPreferencesSaver_SaveOmniboxInitialBehavior_Call{Call: _e.mock.On("SaveOmniboxInitialBehavior", ctx, behavior)}
9938}
9939
9940func (_c *MockOmniboxPreferencesSaver_SaveOmniboxInitialBehavior_Call) Run(run func(ctx context.Context, behavior entity.OmniboxInitialBehavior)) *MockOmniboxPreferencesSaver_SaveOmniboxInitialBehavior_Call {
9941	_c.Call.Run(func(args mock.Arguments) {
9942		var arg0 context.Context
9943		if args[0] != nil {
9944			arg0 = args[0].(context.Context)
9945		}
9946		var arg1 entity.OmniboxInitialBehavior
9947		if args[1] != nil {
9948			arg1 = args[1].(entity.OmniboxInitialBehavior)
9949		}
9950		run(
9951			arg0,
9952			arg1,
9953		)
9954	})
9955	return _c
9956}
9957
9958func (_c *MockOmniboxPreferencesSaver_SaveOmniboxInitialBehavior_Call) Return(err error) *MockOmniboxPreferencesSaver_SaveOmniboxInitialBehavior_Call {
9959	_c.Call.Return(err)
9960	return _c
9961}
9962
9963func (_c *MockOmniboxPreferencesSaver_SaveOmniboxInitialBehavior_Call) RunAndReturn(run func(ctx context.Context, behavior entity.OmniboxInitialBehavior) error) *MockOmniboxPreferencesSaver_SaveOmniboxInitialBehavior_Call {
9964	_c.Call.Return(run)
9965	return _c
9966}
9967
9968// NewMockPermissionDialogPresenter creates a new instance of MockPermissionDialogPresenter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
9969// The first argument is typically a *testing.T value.
9970func NewMockPermissionDialogPresenter(t interface {
9971	mock.TestingT
9972	Cleanup(func())
9973}) *MockPermissionDialogPresenter {
9974	mock := &MockPermissionDialogPresenter{}
9975	mock.Mock.Test(t)
9976
9977	t.Cleanup(func() { mock.AssertExpectations(t) })
9978
9979	return mock
9980}
9981
9982// MockPermissionDialogPresenter is an autogenerated mock type for the PermissionDialogPresenter type
9983type MockPermissionDialogPresenter struct {
9984	mock.Mock
9985}
9986
9987type MockPermissionDialogPresenter_Expecter struct {
9988	mock *mock.Mock
9989}
9990
9991func (_m *MockPermissionDialogPresenter) EXPECT() *MockPermissionDialogPresenter_Expecter {
9992	return &MockPermissionDialogPresenter_Expecter{mock: &_m.Mock}
9993}
9994
9995// ShowPermissionDialog provides a mock function for the type MockPermissionDialogPresenter
9996func (_mock *MockPermissionDialogPresenter) ShowPermissionDialog(ctx context.Context, origin string, permTypes []entity.PermissionType, metadata entity.PermissionMetadata, callback func(result port.PermissionDialogResult)) {
9997	_mock.Called(ctx, origin, permTypes, metadata, callback)
9998	return
9999}
10000
10001// MockPermissionDialogPresenter_ShowPermissionDialog_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowPermissionDialog'
10002type MockPermissionDialogPresenter_ShowPermissionDialog_Call struct {
10003	*mock.Call
10004}
10005
10006// ShowPermissionDialog is a helper method to define mock.On call
10007//   - ctx context.Context
10008//   - origin string
10009//   - permTypes []entity.PermissionType
10010//   - metadata entity.PermissionMetadata
10011//   - callback func(result port.PermissionDialogResult)
10012func (_e *MockPermissionDialogPresenter_Expecter) ShowPermissionDialog(ctx interface{}, origin interface{}, permTypes interface{}, metadata interface{}, callback interface{}) *MockPermissionDialogPresenter_ShowPermissionDialog_Call {
10013	return &MockPermissionDialogPresenter_ShowPermissionDialog_Call{Call: _e.mock.On("ShowPermissionDialog", ctx, origin, permTypes, metadata, callback)}
10014}
10015
10016func (_c *MockPermissionDialogPresenter_ShowPermissionDialog_Call) Run(run func(ctx context.Context, origin string, permTypes []entity.PermissionType, metadata entity.PermissionMetadata, callback func(result port.PermissionDialogResult))) *MockPermissionDialogPresenter_ShowPermissionDialog_Call {
10017	_c.Call.Run(func(args mock.Arguments) {
10018		var arg0 context.Context
10019		if args[0] != nil {
10020			arg0 = args[0].(context.Context)
10021		}
10022		var arg1 string
10023		if args[1] != nil {
10024			arg1 = args[1].(string)
10025		}
10026		var arg2 []entity.PermissionType
10027		if args[2] != nil {
10028			arg2 = args[2].([]entity.PermissionType)
10029		}
10030		var arg3 entity.PermissionMetadata
10031		if args[3] != nil {
10032			arg3 = args[3].(entity.PermissionMetadata)
10033		}
10034		var arg4 func(result port.PermissionDialogResult)
10035		if args[4] != nil {
10036			arg4 = args[4].(func(result port.PermissionDialogResult))
10037		}
10038		run(
10039			arg0,
10040			arg1,
10041			arg2,
10042			arg3,
10043			arg4,
10044		)
10045	})
10046	return _c
10047}
10048
10049func (_c *MockPermissionDialogPresenter_ShowPermissionDialog_Call) Return() *MockPermissionDialogPresenter_ShowPermissionDialog_Call {
10050	_c.Call.Return()
10051	return _c
10052}
10053
10054func (_c *MockPermissionDialogPresenter_ShowPermissionDialog_Call) RunAndReturn(run func(ctx context.Context, origin string, permTypes []entity.PermissionType, metadata entity.PermissionMetadata, callback func(result port.PermissionDialogResult))) *MockPermissionDialogPresenter_ShowPermissionDialog_Call {
10055	_c.Run(run)
10056	return _c
10057}
10058
10059// NewMockPermissionRepository creates a new instance of MockPermissionRepository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
10060// The first argument is typically a *testing.T value.
10061func NewMockPermissionRepository(t interface {
10062	mock.TestingT
10063	Cleanup(func())
10064}) *MockPermissionRepository {
10065	mock := &MockPermissionRepository{}
10066	mock.Mock.Test(t)
10067
10068	t.Cleanup(func() { mock.AssertExpectations(t) })
10069
10070	return mock
10071}
10072
10073// MockPermissionRepository is an autogenerated mock type for the PermissionRepository type
10074type MockPermissionRepository struct {
10075	mock.Mock
10076}
10077
10078type MockPermissionRepository_Expecter struct {
10079	mock *mock.Mock
10080}
10081
10082func (_m *MockPermissionRepository) EXPECT() *MockPermissionRepository_Expecter {
10083	return &MockPermissionRepository_Expecter{mock: &_m.Mock}
10084}
10085
10086// Delete provides a mock function for the type MockPermissionRepository
10087func (_mock *MockPermissionRepository) Delete(ctx context.Context, origin string, permType entity.PermissionType) error {
10088	ret := _mock.Called(ctx, origin, permType)
10089
10090	if len(ret) == 0 {
10091		panic("no return value specified for Delete")
10092	}
10093
10094	var r0 error
10095	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.PermissionType) error); ok {
10096		r0 = returnFunc(ctx, origin, permType)
10097	} else {
10098		r0 = ret.Error(0)
10099	}
10100	return r0
10101}
10102
10103// MockPermissionRepository_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
10104type MockPermissionRepository_Delete_Call struct {
10105	*mock.Call
10106}
10107
10108// Delete is a helper method to define mock.On call
10109//   - ctx context.Context
10110//   - origin string
10111//   - permType entity.PermissionType
10112func (_e *MockPermissionRepository_Expecter) Delete(ctx interface{}, origin interface{}, permType interface{}) *MockPermissionRepository_Delete_Call {
10113	return &MockPermissionRepository_Delete_Call{Call: _e.mock.On("Delete", ctx, origin, permType)}
10114}
10115
10116func (_c *MockPermissionRepository_Delete_Call) Run(run func(ctx context.Context, origin string, permType entity.PermissionType)) *MockPermissionRepository_Delete_Call {
10117	_c.Call.Run(func(args mock.Arguments) {
10118		var arg0 context.Context
10119		if args[0] != nil {
10120			arg0 = args[0].(context.Context)
10121		}
10122		var arg1 string
10123		if args[1] != nil {
10124			arg1 = args[1].(string)
10125		}
10126		var arg2 entity.PermissionType
10127		if args[2] != nil {
10128			arg2 = args[2].(entity.PermissionType)
10129		}
10130		run(
10131			arg0,
10132			arg1,
10133			arg2,
10134		)
10135	})
10136	return _c
10137}
10138
10139func (_c *MockPermissionRepository_Delete_Call) Return(err error) *MockPermissionRepository_Delete_Call {
10140	_c.Call.Return(err)
10141	return _c
10142}
10143
10144func (_c *MockPermissionRepository_Delete_Call) RunAndReturn(run func(ctx context.Context, origin string, permType entity.PermissionType) error) *MockPermissionRepository_Delete_Call {
10145	_c.Call.Return(run)
10146	return _c
10147}
10148
10149// Get provides a mock function for the type MockPermissionRepository
10150func (_mock *MockPermissionRepository) Get(ctx context.Context, origin string, permType entity.PermissionType) (*entity.PermissionRecord, error) {
10151	ret := _mock.Called(ctx, origin, permType)
10152
10153	if len(ret) == 0 {
10154		panic("no return value specified for Get")
10155	}
10156
10157	var r0 *entity.PermissionRecord
10158	var r1 error
10159	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.PermissionType) (*entity.PermissionRecord, error)); ok {
10160		return returnFunc(ctx, origin, permType)
10161	}
10162	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.PermissionType) *entity.PermissionRecord); ok {
10163		r0 = returnFunc(ctx, origin, permType)
10164	} else {
10165		if ret.Get(0) != nil {
10166			r0 = ret.Get(0).(*entity.PermissionRecord)
10167		}
10168	}
10169	if returnFunc, ok := ret.Get(1).(func(context.Context, string, entity.PermissionType) error); ok {
10170		r1 = returnFunc(ctx, origin, permType)
10171	} else {
10172		r1 = ret.Error(1)
10173	}
10174	return r0, r1
10175}
10176
10177// MockPermissionRepository_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
10178type MockPermissionRepository_Get_Call struct {
10179	*mock.Call
10180}
10181
10182// Get is a helper method to define mock.On call
10183//   - ctx context.Context
10184//   - origin string
10185//   - permType entity.PermissionType
10186func (_e *MockPermissionRepository_Expecter) Get(ctx interface{}, origin interface{}, permType interface{}) *MockPermissionRepository_Get_Call {
10187	return &MockPermissionRepository_Get_Call{Call: _e.mock.On("Get", ctx, origin, permType)}
10188}
10189
10190func (_c *MockPermissionRepository_Get_Call) Run(run func(ctx context.Context, origin string, permType entity.PermissionType)) *MockPermissionRepository_Get_Call {
10191	_c.Call.Run(func(args mock.Arguments) {
10192		var arg0 context.Context
10193		if args[0] != nil {
10194			arg0 = args[0].(context.Context)
10195		}
10196		var arg1 string
10197		if args[1] != nil {
10198			arg1 = args[1].(string)
10199		}
10200		var arg2 entity.PermissionType
10201		if args[2] != nil {
10202			arg2 = args[2].(entity.PermissionType)
10203		}
10204		run(
10205			arg0,
10206			arg1,
10207			arg2,
10208		)
10209	})
10210	return _c
10211}
10212
10213func (_c *MockPermissionRepository_Get_Call) Return(permissionRecord *entity.PermissionRecord, err error) *MockPermissionRepository_Get_Call {
10214	_c.Call.Return(permissionRecord, err)
10215	return _c
10216}
10217
10218func (_c *MockPermissionRepository_Get_Call) RunAndReturn(run func(ctx context.Context, origin string, permType entity.PermissionType) (*entity.PermissionRecord, error)) *MockPermissionRepository_Get_Call {
10219	_c.Call.Return(run)
10220	return _c
10221}
10222
10223// GetAll provides a mock function for the type MockPermissionRepository
10224func (_mock *MockPermissionRepository) GetAll(ctx context.Context, origin string) ([]*entity.PermissionRecord, error) {
10225	ret := _mock.Called(ctx, origin)
10226
10227	if len(ret) == 0 {
10228		panic("no return value specified for GetAll")
10229	}
10230
10231	var r0 []*entity.PermissionRecord
10232	var r1 error
10233	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*entity.PermissionRecord, error)); ok {
10234		return returnFunc(ctx, origin)
10235	}
10236	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*entity.PermissionRecord); ok {
10237		r0 = returnFunc(ctx, origin)
10238	} else {
10239		if ret.Get(0) != nil {
10240			r0 = ret.Get(0).([]*entity.PermissionRecord)
10241		}
10242	}
10243	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
10244		r1 = returnFunc(ctx, origin)
10245	} else {
10246		r1 = ret.Error(1)
10247	}
10248	return r0, r1
10249}
10250
10251// MockPermissionRepository_GetAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAll'
10252type MockPermissionRepository_GetAll_Call struct {
10253	*mock.Call
10254}
10255
10256// GetAll is a helper method to define mock.On call
10257//   - ctx context.Context
10258//   - origin string
10259func (_e *MockPermissionRepository_Expecter) GetAll(ctx interface{}, origin interface{}) *MockPermissionRepository_GetAll_Call {
10260	return &MockPermissionRepository_GetAll_Call{Call: _e.mock.On("GetAll", ctx, origin)}
10261}
10262
10263func (_c *MockPermissionRepository_GetAll_Call) Run(run func(ctx context.Context, origin string)) *MockPermissionRepository_GetAll_Call {
10264	_c.Call.Run(func(args mock.Arguments) {
10265		var arg0 context.Context
10266		if args[0] != nil {
10267			arg0 = args[0].(context.Context)
10268		}
10269		var arg1 string
10270		if args[1] != nil {
10271			arg1 = args[1].(string)
10272		}
10273		run(
10274			arg0,
10275			arg1,
10276		)
10277	})
10278	return _c
10279}
10280
10281func (_c *MockPermissionRepository_GetAll_Call) Return(permissionRecords []*entity.PermissionRecord, err error) *MockPermissionRepository_GetAll_Call {
10282	_c.Call.Return(permissionRecords, err)
10283	return _c
10284}
10285
10286func (_c *MockPermissionRepository_GetAll_Call) RunAndReturn(run func(ctx context.Context, origin string) ([]*entity.PermissionRecord, error)) *MockPermissionRepository_GetAll_Call {
10287	_c.Call.Return(run)
10288	return _c
10289}
10290
10291// Set provides a mock function for the type MockPermissionRepository
10292func (_mock *MockPermissionRepository) Set(ctx context.Context, record *entity.PermissionRecord) error {
10293	ret := _mock.Called(ctx, record)
10294
10295	if len(ret) == 0 {
10296		panic("no return value specified for Set")
10297	}
10298
10299	var r0 error
10300	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.PermissionRecord) error); ok {
10301		r0 = returnFunc(ctx, record)
10302	} else {
10303		r0 = ret.Error(0)
10304	}
10305	return r0
10306}
10307
10308// MockPermissionRepository_Set_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Set'
10309type MockPermissionRepository_Set_Call struct {
10310	*mock.Call
10311}
10312
10313// Set is a helper method to define mock.On call
10314//   - ctx context.Context
10315//   - record *entity.PermissionRecord
10316func (_e *MockPermissionRepository_Expecter) Set(ctx interface{}, record interface{}) *MockPermissionRepository_Set_Call {
10317	return &MockPermissionRepository_Set_Call{Call: _e.mock.On("Set", ctx, record)}
10318}
10319
10320func (_c *MockPermissionRepository_Set_Call) Run(run func(ctx context.Context, record *entity.PermissionRecord)) *MockPermissionRepository_Set_Call {
10321	_c.Call.Run(func(args mock.Arguments) {
10322		var arg0 context.Context
10323		if args[0] != nil {
10324			arg0 = args[0].(context.Context)
10325		}
10326		var arg1 *entity.PermissionRecord
10327		if args[1] != nil {
10328			arg1 = args[1].(*entity.PermissionRecord)
10329		}
10330		run(
10331			arg0,
10332			arg1,
10333		)
10334	})
10335	return _c
10336}
10337
10338func (_c *MockPermissionRepository_Set_Call) Return(err error) *MockPermissionRepository_Set_Call {
10339	_c.Call.Return(err)
10340	return _c
10341}
10342
10343func (_c *MockPermissionRepository_Set_Call) RunAndReturn(run func(ctx context.Context, record *entity.PermissionRecord) error) *MockPermissionRepository_Set_Call {
10344	_c.Call.Return(run)
10345	return _c
10346}
10347
10348// NewMockRenderingEnvManager creates a new instance of MockRenderingEnvManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
10349// The first argument is typically a *testing.T value.
10350func NewMockRenderingEnvManager(t interface {
10351	mock.TestingT
10352	Cleanup(func())
10353}) *MockRenderingEnvManager {
10354	mock := &MockRenderingEnvManager{}
10355	mock.Mock.Test(t)
10356
10357	t.Cleanup(func() { mock.AssertExpectations(t) })
10358
10359	return mock
10360}
10361
10362// MockRenderingEnvManager is an autogenerated mock type for the RenderingEnvManager type
10363type MockRenderingEnvManager struct {
10364	mock.Mock
10365}
10366
10367type MockRenderingEnvManager_Expecter struct {
10368	mock *mock.Mock
10369}
10370
10371func (_m *MockRenderingEnvManager) EXPECT() *MockRenderingEnvManager_Expecter {
10372	return &MockRenderingEnvManager_Expecter{mock: &_m.Mock}
10373}
10374
10375// DetectGPUVendor provides a mock function for the type MockRenderingEnvManager
10376func (_mock *MockRenderingEnvManager) DetectGPUVendor(ctx context.Context) port.GPUVendor {
10377	ret := _mock.Called(ctx)
10378
10379	if len(ret) == 0 {
10380		panic("no return value specified for DetectGPUVendor")
10381	}
10382
10383	var r0 port.GPUVendor
10384	if returnFunc, ok := ret.Get(0).(func(context.Context) port.GPUVendor); ok {
10385		r0 = returnFunc(ctx)
10386	} else {
10387		r0 = ret.Get(0).(port.GPUVendor)
10388	}
10389	return r0
10390}
10391
10392// MockRenderingEnvManager_DetectGPUVendor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DetectGPUVendor'
10393type MockRenderingEnvManager_DetectGPUVendor_Call struct {
10394	*mock.Call
10395}
10396
10397// DetectGPUVendor is a helper method to define mock.On call
10398//   - ctx context.Context
10399func (_e *MockRenderingEnvManager_Expecter) DetectGPUVendor(ctx interface{}) *MockRenderingEnvManager_DetectGPUVendor_Call {
10400	return &MockRenderingEnvManager_DetectGPUVendor_Call{Call: _e.mock.On("DetectGPUVendor", ctx)}
10401}
10402
10403func (_c *MockRenderingEnvManager_DetectGPUVendor_Call) Run(run func(ctx context.Context)) *MockRenderingEnvManager_DetectGPUVendor_Call {
10404	_c.Call.Run(func(args mock.Arguments) {
10405		var arg0 context.Context
10406		if args[0] != nil {
10407			arg0 = args[0].(context.Context)
10408		}
10409		run(
10410			arg0,
10411		)
10412	})
10413	return _c
10414}
10415
10416func (_c *MockRenderingEnvManager_DetectGPUVendor_Call) Return(gPUVendor port.GPUVendor) *MockRenderingEnvManager_DetectGPUVendor_Call {
10417	_c.Call.Return(gPUVendor)
10418	return _c
10419}
10420
10421func (_c *MockRenderingEnvManager_DetectGPUVendor_Call) RunAndReturn(run func(ctx context.Context) port.GPUVendor) *MockRenderingEnvManager_DetectGPUVendor_Call {
10422	_c.Call.Return(run)
10423	return _c
10424}
10425
10426// GetAppliedVars provides a mock function for the type MockRenderingEnvManager
10427func (_mock *MockRenderingEnvManager) GetAppliedVars() map[string]string {
10428	ret := _mock.Called()
10429
10430	if len(ret) == 0 {
10431		panic("no return value specified for GetAppliedVars")
10432	}
10433
10434	var r0 map[string]string
10435	if returnFunc, ok := ret.Get(0).(func() map[string]string); ok {
10436		r0 = returnFunc()
10437	} else {
10438		if ret.Get(0) != nil {
10439			r0 = ret.Get(0).(map[string]string)
10440		}
10441	}
10442	return r0
10443}
10444
10445// MockRenderingEnvManager_GetAppliedVars_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAppliedVars'
10446type MockRenderingEnvManager_GetAppliedVars_Call struct {
10447	*mock.Call
10448}
10449
10450// GetAppliedVars is a helper method to define mock.On call
10451func (_e *MockRenderingEnvManager_Expecter) GetAppliedVars() *MockRenderingEnvManager_GetAppliedVars_Call {
10452	return &MockRenderingEnvManager_GetAppliedVars_Call{Call: _e.mock.On("GetAppliedVars")}
10453}
10454
10455func (_c *MockRenderingEnvManager_GetAppliedVars_Call) Run(run func()) *MockRenderingEnvManager_GetAppliedVars_Call {
10456	_c.Call.Run(func(args mock.Arguments) {
10457		run()
10458	})
10459	return _c
10460}
10461
10462func (_c *MockRenderingEnvManager_GetAppliedVars_Call) Return(stringToString map[string]string) *MockRenderingEnvManager_GetAppliedVars_Call {
10463	_c.Call.Return(stringToString)
10464	return _c
10465}
10466
10467func (_c *MockRenderingEnvManager_GetAppliedVars_Call) RunAndReturn(run func() map[string]string) *MockRenderingEnvManager_GetAppliedVars_Call {
10468	_c.Call.Return(run)
10469	return _c
10470}
10471
10472// NewMockRuntimeVersionProbe creates a new instance of MockRuntimeVersionProbe. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
10473// The first argument is typically a *testing.T value.
10474func NewMockRuntimeVersionProbe(t interface {
10475	mock.TestingT
10476	Cleanup(func())
10477}) *MockRuntimeVersionProbe {
10478	mock := &MockRuntimeVersionProbe{}
10479	mock.Mock.Test(t)
10480
10481	t.Cleanup(func() { mock.AssertExpectations(t) })
10482
10483	return mock
10484}
10485
10486// MockRuntimeVersionProbe is an autogenerated mock type for the RuntimeVersionProbe type
10487type MockRuntimeVersionProbe struct {
10488	mock.Mock
10489}
10490
10491type MockRuntimeVersionProbe_Expecter struct {
10492	mock *mock.Mock
10493}
10494
10495func (_m *MockRuntimeVersionProbe) EXPECT() *MockRuntimeVersionProbe_Expecter {
10496	return &MockRuntimeVersionProbe_Expecter{mock: &_m.Mock}
10497}
10498
10499// PkgConfigModVersion provides a mock function for the type MockRuntimeVersionProbe
10500func (_mock *MockRuntimeVersionProbe) PkgConfigModVersion(ctx context.Context, pkgName string, prefix string) (string, error) {
10501	ret := _mock.Called(ctx, pkgName, prefix)
10502
10503	if len(ret) == 0 {
10504		panic("no return value specified for PkgConfigModVersion")
10505	}
10506
10507	var r0 string
10508	var r1 error
10509	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
10510		return returnFunc(ctx, pkgName, prefix)
10511	}
10512	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
10513		r0 = returnFunc(ctx, pkgName, prefix)
10514	} else {
10515		r0 = ret.Get(0).(string)
10516	}
10517	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
10518		r1 = returnFunc(ctx, pkgName, prefix)
10519	} else {
10520		r1 = ret.Error(1)
10521	}
10522	return r0, r1
10523}
10524
10525// MockRuntimeVersionProbe_PkgConfigModVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PkgConfigModVersion'
10526type MockRuntimeVersionProbe_PkgConfigModVersion_Call struct {
10527	*mock.Call
10528}
10529
10530// PkgConfigModVersion is a helper method to define mock.On call
10531//   - ctx context.Context
10532//   - pkgName string
10533//   - prefix string
10534func (_e *MockRuntimeVersionProbe_Expecter) PkgConfigModVersion(ctx interface{}, pkgName interface{}, prefix interface{}) *MockRuntimeVersionProbe_PkgConfigModVersion_Call {
10535	return &MockRuntimeVersionProbe_PkgConfigModVersion_Call{Call: _e.mock.On("PkgConfigModVersion", ctx, pkgName, prefix)}
10536}
10537
10538func (_c *MockRuntimeVersionProbe_PkgConfigModVersion_Call) Run(run func(ctx context.Context, pkgName string, prefix string)) *MockRuntimeVersionProbe_PkgConfigModVersion_Call {
10539	_c.Call.Run(func(args mock.Arguments) {
10540		var arg0 context.Context
10541		if args[0] != nil {
10542			arg0 = args[0].(context.Context)
10543		}
10544		var arg1 string
10545		if args[1] != nil {
10546			arg1 = args[1].(string)
10547		}
10548		var arg2 string
10549		if args[2] != nil {
10550			arg2 = args[2].(string)
10551		}
10552		run(
10553			arg0,
10554			arg1,
10555			arg2,
10556		)
10557	})
10558	return _c
10559}
10560
10561func (_c *MockRuntimeVersionProbe_PkgConfigModVersion_Call) Return(s string, err error) *MockRuntimeVersionProbe_PkgConfigModVersion_Call {
10562	_c.Call.Return(s, err)
10563	return _c
10564}
10565
10566func (_c *MockRuntimeVersionProbe_PkgConfigModVersion_Call) RunAndReturn(run func(ctx context.Context, pkgName string, prefix string) (string, error)) *MockRuntimeVersionProbe_PkgConfigModVersion_Call {
10567	_c.Call.Return(run)
10568	return _c
10569}
10570
10571// NewMockSessionLogger creates a new instance of MockSessionLogger. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
10572// The first argument is typically a *testing.T value.
10573func NewMockSessionLogger(t interface {
10574	mock.TestingT
10575	Cleanup(func())
10576}) *MockSessionLogger {
10577	mock := &MockSessionLogger{}
10578	mock.Mock.Test(t)
10579
10580	t.Cleanup(func() { mock.AssertExpectations(t) })
10581
10582	return mock
10583}
10584
10585// MockSessionLogger is an autogenerated mock type for the SessionLogger type
10586type MockSessionLogger struct {
10587	mock.Mock
10588}
10589
10590type MockSessionLogger_Expecter struct {
10591	mock *mock.Mock
10592}
10593
10594func (_m *MockSessionLogger) EXPECT() *MockSessionLogger_Expecter {
10595	return &MockSessionLogger_Expecter{mock: &_m.Mock}
10596}
10597
10598// CreateLogger provides a mock function for the type MockSessionLogger
10599func (_mock *MockSessionLogger) CreateLogger(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig) (zerolog.Logger, func(), error) {
10600	ret := _mock.Called(ctx, sessionID, cfg)
10601
10602	if len(ret) == 0 {
10603		panic("no return value specified for CreateLogger")
10604	}
10605
10606	var r0 zerolog.Logger
10607	var r1 func()
10608	var r2 error
10609	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID, port.SessionLogConfig) (zerolog.Logger, func(), error)); ok {
10610		return returnFunc(ctx, sessionID, cfg)
10611	}
10612	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID, port.SessionLogConfig) zerolog.Logger); ok {
10613		r0 = returnFunc(ctx, sessionID, cfg)
10614	} else {
10615		r0 = ret.Get(0).(zerolog.Logger)
10616	}
10617	if returnFunc, ok := ret.Get(1).(func(context.Context, entity.SessionID, port.SessionLogConfig) func()); ok {
10618		r1 = returnFunc(ctx, sessionID, cfg)
10619	} else {
10620		if ret.Get(1) != nil {
10621			r1 = ret.Get(1).(func())
10622		}
10623	}
10624	if returnFunc, ok := ret.Get(2).(func(context.Context, entity.SessionID, port.SessionLogConfig) error); ok {
10625		r2 = returnFunc(ctx, sessionID, cfg)
10626	} else {
10627		r2 = ret.Error(2)
10628	}
10629	return r0, r1, r2
10630}
10631
10632// MockSessionLogger_CreateLogger_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLogger'
10633type MockSessionLogger_CreateLogger_Call struct {
10634	*mock.Call
10635}
10636
10637// CreateLogger is a helper method to define mock.On call
10638//   - ctx context.Context
10639//   - sessionID entity.SessionID
10640//   - cfg port.SessionLogConfig
10641func (_e *MockSessionLogger_Expecter) CreateLogger(ctx interface{}, sessionID interface{}, cfg interface{}) *MockSessionLogger_CreateLogger_Call {
10642	return &MockSessionLogger_CreateLogger_Call{Call: _e.mock.On("CreateLogger", ctx, sessionID, cfg)}
10643}
10644
10645func (_c *MockSessionLogger_CreateLogger_Call) Run(run func(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig)) *MockSessionLogger_CreateLogger_Call {
10646	_c.Call.Run(func(args mock.Arguments) {
10647		var arg0 context.Context
10648		if args[0] != nil {
10649			arg0 = args[0].(context.Context)
10650		}
10651		var arg1 entity.SessionID
10652		if args[1] != nil {
10653			arg1 = args[1].(entity.SessionID)
10654		}
10655		var arg2 port.SessionLogConfig
10656		if args[2] != nil {
10657			arg2 = args[2].(port.SessionLogConfig)
10658		}
10659		run(
10660			arg0,
10661			arg1,
10662			arg2,
10663		)
10664	})
10665	return _c
10666}
10667
10668func (_c *MockSessionLogger_CreateLogger_Call) Return(logger zerolog.Logger, fn func(), err error) *MockSessionLogger_CreateLogger_Call {
10669	_c.Call.Return(logger, fn, err)
10670	return _c
10671}
10672
10673func (_c *MockSessionLogger_CreateLogger_Call) RunAndReturn(run func(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig) (zerolog.Logger, func(), error)) *MockSessionLogger_CreateLogger_Call {
10674	_c.Call.Return(run)
10675	return _c
10676}
10677
10678// NewMockWindowStateProvider creates a new instance of MockWindowStateProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
10679// The first argument is typically a *testing.T value.
10680func NewMockWindowStateProvider(t interface {
10681	mock.TestingT
10682	Cleanup(func())
10683}) *MockWindowStateProvider {
10684	mock := &MockWindowStateProvider{}
10685	mock.Mock.Test(t)
10686
10687	t.Cleanup(func() { mock.AssertExpectations(t) })
10688
10689	return mock
10690}
10691
10692// MockWindowStateProvider is an autogenerated mock type for the WindowStateProvider type
10693type MockWindowStateProvider struct {
10694	mock.Mock
10695}
10696
10697type MockWindowStateProvider_Expecter struct {
10698	mock *mock.Mock
10699}
10700
10701func (_m *MockWindowStateProvider) EXPECT() *MockWindowStateProvider_Expecter {
10702	return &MockWindowStateProvider_Expecter{mock: &_m.Mock}
10703}
10704
10705// GetActiveWindowIndex provides a mock function for the type MockWindowStateProvider
10706func (_mock *MockWindowStateProvider) GetActiveWindowIndex() int {
10707	ret := _mock.Called()
10708
10709	if len(ret) == 0 {
10710		panic("no return value specified for GetActiveWindowIndex")
10711	}
10712
10713	var r0 int
10714	if returnFunc, ok := ret.Get(0).(func() int); ok {
10715		r0 = returnFunc()
10716	} else {
10717		r0 = ret.Get(0).(int)
10718	}
10719	return r0
10720}
10721
10722// MockWindowStateProvider_GetActiveWindowIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActiveWindowIndex'
10723type MockWindowStateProvider_GetActiveWindowIndex_Call struct {
10724	*mock.Call
10725}
10726
10727// GetActiveWindowIndex is a helper method to define mock.On call
10728func (_e *MockWindowStateProvider_Expecter) GetActiveWindowIndex() *MockWindowStateProvider_GetActiveWindowIndex_Call {
10729	return &MockWindowStateProvider_GetActiveWindowIndex_Call{Call: _e.mock.On("GetActiveWindowIndex")}
10730}
10731
10732func (_c *MockWindowStateProvider_GetActiveWindowIndex_Call) Run(run func()) *MockWindowStateProvider_GetActiveWindowIndex_Call {
10733	_c.Call.Run(func(args mock.Arguments) {
10734		run()
10735	})
10736	return _c
10737}
10738
10739func (_c *MockWindowStateProvider_GetActiveWindowIndex_Call) Return(n int) *MockWindowStateProvider_GetActiveWindowIndex_Call {
10740	_c.Call.Return(n)
10741	return _c
10742}
10743
10744func (_c *MockWindowStateProvider_GetActiveWindowIndex_Call) RunAndReturn(run func() int) *MockWindowStateProvider_GetActiveWindowIndex_Call {
10745	_c.Call.Return(run)
10746	return _c
10747}
10748
10749// GetSessionID provides a mock function for the type MockWindowStateProvider
10750func (_mock *MockWindowStateProvider) GetSessionID() entity.SessionID {
10751	ret := _mock.Called()
10752
10753	if len(ret) == 0 {
10754		panic("no return value specified for GetSessionID")
10755	}
10756
10757	var r0 entity.SessionID
10758	if returnFunc, ok := ret.Get(0).(func() entity.SessionID); ok {
10759		r0 = returnFunc()
10760	} else {
10761		r0 = ret.Get(0).(entity.SessionID)
10762	}
10763	return r0
10764}
10765
10766// MockWindowStateProvider_GetSessionID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSessionID'
10767type MockWindowStateProvider_GetSessionID_Call struct {
10768	*mock.Call
10769}
10770
10771// GetSessionID is a helper method to define mock.On call
10772func (_e *MockWindowStateProvider_Expecter) GetSessionID() *MockWindowStateProvider_GetSessionID_Call {
10773	return &MockWindowStateProvider_GetSessionID_Call{Call: _e.mock.On("GetSessionID")}
10774}
10775
10776func (_c *MockWindowStateProvider_GetSessionID_Call) Run(run func()) *MockWindowStateProvider_GetSessionID_Call {
10777	_c.Call.Run(func(args mock.Arguments) {
10778		run()
10779	})
10780	return _c
10781}
10782
10783func (_c *MockWindowStateProvider_GetSessionID_Call) Return(sessionID entity.SessionID) *MockWindowStateProvider_GetSessionID_Call {
10784	_c.Call.Return(sessionID)
10785	return _c
10786}
10787
10788func (_c *MockWindowStateProvider_GetSessionID_Call) RunAndReturn(run func() entity.SessionID) *MockWindowStateProvider_GetSessionID_Call {
10789	_c.Call.Return(run)
10790	return _c
10791}
10792
10793// GetWindowSnapshotState provides a mock function for the type MockWindowStateProvider
10794func (_mock *MockWindowStateProvider) GetWindowSnapshotState() ([]entity.WindowTabListState, int) {
10795	ret := _mock.Called()
10796
10797	if len(ret) == 0 {
10798		panic("no return value specified for GetWindowSnapshotState")
10799	}
10800
10801	var r0 []entity.WindowTabListState
10802	var r1 int
10803	if returnFunc, ok := ret.Get(0).(func() ([]entity.WindowTabListState, int)); ok {
10804		return returnFunc()
10805	}
10806	if returnFunc, ok := ret.Get(0).(func() []entity.WindowTabListState); ok {
10807		r0 = returnFunc()
10808	} else {
10809		if ret.Get(0) != nil {
10810			r0 = ret.Get(0).([]entity.WindowTabListState)
10811		}
10812	}
10813	if returnFunc, ok := ret.Get(1).(func() int); ok {
10814		r1 = returnFunc()
10815	} else {
10816		r1 = ret.Get(1).(int)
10817	}
10818	return r0, r1
10819}
10820
10821// MockWindowStateProvider_GetWindowSnapshotState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWindowSnapshotState'
10822type MockWindowStateProvider_GetWindowSnapshotState_Call struct {
10823	*mock.Call
10824}
10825
10826// GetWindowSnapshotState is a helper method to define mock.On call
10827func (_e *MockWindowStateProvider_Expecter) GetWindowSnapshotState() *MockWindowStateProvider_GetWindowSnapshotState_Call {
10828	return &MockWindowStateProvider_GetWindowSnapshotState_Call{Call: _e.mock.On("GetWindowSnapshotState")}
10829}
10830
10831func (_c *MockWindowStateProvider_GetWindowSnapshotState_Call) Run(run func()) *MockWindowStateProvider_GetWindowSnapshotState_Call {
10832	_c.Call.Run(func(args mock.Arguments) {
10833		run()
10834	})
10835	return _c
10836}
10837
10838func (_c *MockWindowStateProvider_GetWindowSnapshotState_Call) Return(windowTabListStates []entity.WindowTabListState, n int) *MockWindowStateProvider_GetWindowSnapshotState_Call {
10839	_c.Call.Return(windowTabListStates, n)
10840	return _c
10841}
10842
10843func (_c *MockWindowStateProvider_GetWindowSnapshotState_Call) RunAndReturn(run func() ([]entity.WindowTabListState, int)) *MockWindowStateProvider_GetWindowSnapshotState_Call {
10844	_c.Call.Return(run)
10845	return _c
10846}
10847
10848// GetWindowTabLists provides a mock function for the type MockWindowStateProvider
10849func (_mock *MockWindowStateProvider) GetWindowTabLists() []entity.WindowTabListState {
10850	ret := _mock.Called()
10851
10852	if len(ret) == 0 {
10853		panic("no return value specified for GetWindowTabLists")
10854	}
10855
10856	var r0 []entity.WindowTabListState
10857	if returnFunc, ok := ret.Get(0).(func() []entity.WindowTabListState); ok {
10858		r0 = returnFunc()
10859	} else {
10860		if ret.Get(0) != nil {
10861			r0 = ret.Get(0).([]entity.WindowTabListState)
10862		}
10863	}
10864	return r0
10865}
10866
10867// MockWindowStateProvider_GetWindowTabLists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWindowTabLists'
10868type MockWindowStateProvider_GetWindowTabLists_Call struct {
10869	*mock.Call
10870}
10871
10872// GetWindowTabLists is a helper method to define mock.On call
10873func (_e *MockWindowStateProvider_Expecter) GetWindowTabLists() *MockWindowStateProvider_GetWindowTabLists_Call {
10874	return &MockWindowStateProvider_GetWindowTabLists_Call{Call: _e.mock.On("GetWindowTabLists")}
10875}
10876
10877func (_c *MockWindowStateProvider_GetWindowTabLists_Call) Run(run func()) *MockWindowStateProvider_GetWindowTabLists_Call {
10878	_c.Call.Run(func(args mock.Arguments) {
10879		run()
10880	})
10881	return _c
10882}
10883
10884func (_c *MockWindowStateProvider_GetWindowTabLists_Call) Return(windowTabListStates []entity.WindowTabListState) *MockWindowStateProvider_GetWindowTabLists_Call {
10885	_c.Call.Return(windowTabListStates)
10886	return _c
10887}
10888
10889func (_c *MockWindowStateProvider_GetWindowTabLists_Call) RunAndReturn(run func() []entity.WindowTabListState) *MockWindowStateProvider_GetWindowTabLists_Call {
10890	_c.Call.Return(run)
10891	return _c
10892}
10893
10894// NewMockSessionSpawner creates a new instance of MockSessionSpawner. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
10895// The first argument is typically a *testing.T value.
10896func NewMockSessionSpawner(t interface {
10897	mock.TestingT
10898	Cleanup(func())
10899}) *MockSessionSpawner {
10900	mock := &MockSessionSpawner{}
10901	mock.Mock.Test(t)
10902
10903	t.Cleanup(func() { mock.AssertExpectations(t) })
10904
10905	return mock
10906}
10907
10908// MockSessionSpawner is an autogenerated mock type for the SessionSpawner type
10909type MockSessionSpawner struct {
10910	mock.Mock
10911}
10912
10913type MockSessionSpawner_Expecter struct {
10914	mock *mock.Mock
10915}
10916
10917func (_m *MockSessionSpawner) EXPECT() *MockSessionSpawner_Expecter {
10918	return &MockSessionSpawner_Expecter{mock: &_m.Mock}
10919}
10920
10921// SpawnWithSession provides a mock function for the type MockSessionSpawner
10922func (_mock *MockSessionSpawner) SpawnWithSession(sessionID entity.SessionID) error {
10923	ret := _mock.Called(sessionID)
10924
10925	if len(ret) == 0 {
10926		panic("no return value specified for SpawnWithSession")
10927	}
10928
10929	var r0 error
10930	if returnFunc, ok := ret.Get(0).(func(entity.SessionID) error); ok {
10931		r0 = returnFunc(sessionID)
10932	} else {
10933		r0 = ret.Error(0)
10934	}
10935	return r0
10936}
10937
10938// MockSessionSpawner_SpawnWithSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SpawnWithSession'
10939type MockSessionSpawner_SpawnWithSession_Call struct {
10940	*mock.Call
10941}
10942
10943// SpawnWithSession is a helper method to define mock.On call
10944//   - sessionID entity.SessionID
10945func (_e *MockSessionSpawner_Expecter) SpawnWithSession(sessionID interface{}) *MockSessionSpawner_SpawnWithSession_Call {
10946	return &MockSessionSpawner_SpawnWithSession_Call{Call: _e.mock.On("SpawnWithSession", sessionID)}
10947}
10948
10949func (_c *MockSessionSpawner_SpawnWithSession_Call) Run(run func(sessionID entity.SessionID)) *MockSessionSpawner_SpawnWithSession_Call {
10950	_c.Call.Run(func(args mock.Arguments) {
10951		var arg0 entity.SessionID
10952		if args[0] != nil {
10953			arg0 = args[0].(entity.SessionID)
10954		}
10955		run(
10956			arg0,
10957		)
10958	})
10959	return _c
10960}
10961
10962func (_c *MockSessionSpawner_SpawnWithSession_Call) Return(err error) *MockSessionSpawner_SpawnWithSession_Call {
10963	_c.Call.Return(err)
10964	return _c
10965}
10966
10967func (_c *MockSessionSpawner_SpawnWithSession_Call) RunAndReturn(run func(sessionID entity.SessionID) error) *MockSessionSpawner_SpawnWithSession_Call {
10968	_c.Call.Return(run)
10969	return _c
10970}
10971
10972// NewMockSnapshotService creates a new instance of MockSnapshotService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
10973// The first argument is typically a *testing.T value.
10974func NewMockSnapshotService(t interface {
10975	mock.TestingT
10976	Cleanup(func())
10977}) *MockSnapshotService {
10978	mock := &MockSnapshotService{}
10979	mock.Mock.Test(t)
10980
10981	t.Cleanup(func() { mock.AssertExpectations(t) })
10982
10983	return mock
10984}
10985
10986// MockSnapshotService is an autogenerated mock type for the SnapshotService type
10987type MockSnapshotService struct {
10988	mock.Mock
10989}
10990
10991type MockSnapshotService_Expecter struct {
10992	mock *mock.Mock
10993}
10994
10995func (_m *MockSnapshotService) EXPECT() *MockSnapshotService_Expecter {
10996	return &MockSnapshotService_Expecter{mock: &_m.Mock}
10997}
10998
10999// MarkDirty provides a mock function for the type MockSnapshotService
11000func (_mock *MockSnapshotService) MarkDirty() {
11001	_mock.Called()
11002	return
11003}
11004
11005// MockSnapshotService_MarkDirty_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarkDirty'
11006type MockSnapshotService_MarkDirty_Call struct {
11007	*mock.Call
11008}
11009
11010// MarkDirty is a helper method to define mock.On call
11011func (_e *MockSnapshotService_Expecter) MarkDirty() *MockSnapshotService_MarkDirty_Call {
11012	return &MockSnapshotService_MarkDirty_Call{Call: _e.mock.On("MarkDirty")}
11013}
11014
11015func (_c *MockSnapshotService_MarkDirty_Call) Run(run func()) *MockSnapshotService_MarkDirty_Call {
11016	_c.Call.Run(func(args mock.Arguments) {
11017		run()
11018	})
11019	return _c
11020}
11021
11022func (_c *MockSnapshotService_MarkDirty_Call) Return() *MockSnapshotService_MarkDirty_Call {
11023	_c.Call.Return()
11024	return _c
11025}
11026
11027func (_c *MockSnapshotService_MarkDirty_Call) RunAndReturn(run func()) *MockSnapshotService_MarkDirty_Call {
11028	_c.Run(run)
11029	return _c
11030}
11031
11032// SaveNow provides a mock function for the type MockSnapshotService
11033func (_mock *MockSnapshotService) SaveNow(ctx context.Context) error {
11034	ret := _mock.Called(ctx)
11035
11036	if len(ret) == 0 {
11037		panic("no return value specified for SaveNow")
11038	}
11039
11040	var r0 error
11041	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
11042		r0 = returnFunc(ctx)
11043	} else {
11044		r0 = ret.Error(0)
11045	}
11046	return r0
11047}
11048
11049// MockSnapshotService_SaveNow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveNow'
11050type MockSnapshotService_SaveNow_Call struct {
11051	*mock.Call
11052}
11053
11054// SaveNow is a helper method to define mock.On call
11055//   - ctx context.Context
11056func (_e *MockSnapshotService_Expecter) SaveNow(ctx interface{}) *MockSnapshotService_SaveNow_Call {
11057	return &MockSnapshotService_SaveNow_Call{Call: _e.mock.On("SaveNow", ctx)}
11058}
11059
11060func (_c *MockSnapshotService_SaveNow_Call) Run(run func(ctx context.Context)) *MockSnapshotService_SaveNow_Call {
11061	_c.Call.Run(func(args mock.Arguments) {
11062		var arg0 context.Context
11063		if args[0] != nil {
11064			arg0 = args[0].(context.Context)
11065		}
11066		run(
11067			arg0,
11068		)
11069	})
11070	return _c
11071}
11072
11073func (_c *MockSnapshotService_SaveNow_Call) Return(err error) *MockSnapshotService_SaveNow_Call {
11074	_c.Call.Return(err)
11075	return _c
11076}
11077
11078func (_c *MockSnapshotService_SaveNow_Call) RunAndReturn(run func(ctx context.Context) error) *MockSnapshotService_SaveNow_Call {
11079	_c.Call.Return(run)
11080	return _c
11081}
11082
11083// SetReady provides a mock function for the type MockSnapshotService
11084func (_mock *MockSnapshotService) SetReady() {
11085	_mock.Called()
11086	return
11087}
11088
11089// MockSnapshotService_SetReady_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetReady'
11090type MockSnapshotService_SetReady_Call struct {
11091	*mock.Call
11092}
11093
11094// SetReady is a helper method to define mock.On call
11095func (_e *MockSnapshotService_Expecter) SetReady() *MockSnapshotService_SetReady_Call {
11096	return &MockSnapshotService_SetReady_Call{Call: _e.mock.On("SetReady")}
11097}
11098
11099func (_c *MockSnapshotService_SetReady_Call) Run(run func()) *MockSnapshotService_SetReady_Call {
11100	_c.Call.Run(func(args mock.Arguments) {
11101		run()
11102	})
11103	return _c
11104}
11105
11106func (_c *MockSnapshotService_SetReady_Call) Return() *MockSnapshotService_SetReady_Call {
11107	_c.Call.Return()
11108	return _c
11109}
11110
11111func (_c *MockSnapshotService_SetReady_Call) RunAndReturn(run func()) *MockSnapshotService_SetReady_Call {
11112	_c.Run(run)
11113	return _c
11114}
11115
11116// Start provides a mock function for the type MockSnapshotService
11117func (_mock *MockSnapshotService) Start(ctx context.Context) {
11118	_mock.Called(ctx)
11119	return
11120}
11121
11122// MockSnapshotService_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'
11123type MockSnapshotService_Start_Call struct {
11124	*mock.Call
11125}
11126
11127// Start is a helper method to define mock.On call
11128//   - ctx context.Context
11129func (_e *MockSnapshotService_Expecter) Start(ctx interface{}) *MockSnapshotService_Start_Call {
11130	return &MockSnapshotService_Start_Call{Call: _e.mock.On("Start", ctx)}
11131}
11132
11133func (_c *MockSnapshotService_Start_Call) Run(run func(ctx context.Context)) *MockSnapshotService_Start_Call {
11134	_c.Call.Run(func(args mock.Arguments) {
11135		var arg0 context.Context
11136		if args[0] != nil {
11137			arg0 = args[0].(context.Context)
11138		}
11139		run(
11140			arg0,
11141		)
11142	})
11143	return _c
11144}
11145
11146func (_c *MockSnapshotService_Start_Call) Return() *MockSnapshotService_Start_Call {
11147	_c.Call.Return()
11148	return _c
11149}
11150
11151func (_c *MockSnapshotService_Start_Call) RunAndReturn(run func(ctx context.Context)) *MockSnapshotService_Start_Call {
11152	_c.Run(run)
11153	return _c
11154}
11155
11156// Stop provides a mock function for the type MockSnapshotService
11157func (_mock *MockSnapshotService) Stop(ctx context.Context) error {
11158	ret := _mock.Called(ctx)
11159
11160	if len(ret) == 0 {
11161		panic("no return value specified for Stop")
11162	}
11163
11164	var r0 error
11165	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
11166		r0 = returnFunc(ctx)
11167	} else {
11168		r0 = ret.Error(0)
11169	}
11170	return r0
11171}
11172
11173// MockSnapshotService_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
11174type MockSnapshotService_Stop_Call struct {
11175	*mock.Call
11176}
11177
11178// Stop is a helper method to define mock.On call
11179//   - ctx context.Context
11180func (_e *MockSnapshotService_Expecter) Stop(ctx interface{}) *MockSnapshotService_Stop_Call {
11181	return &MockSnapshotService_Stop_Call{Call: _e.mock.On("Stop", ctx)}
11182}
11183
11184func (_c *MockSnapshotService_Stop_Call) Run(run func(ctx context.Context)) *MockSnapshotService_Stop_Call {
11185	_c.Call.Run(func(args mock.Arguments) {
11186		var arg0 context.Context
11187		if args[0] != nil {
11188			arg0 = args[0].(context.Context)
11189		}
11190		run(
11191			arg0,
11192		)
11193	})
11194	return _c
11195}
11196
11197func (_c *MockSnapshotService_Stop_Call) Return(err error) *MockSnapshotService_Stop_Call {
11198	_c.Call.Return(err)
11199	return _c
11200}
11201
11202func (_c *MockSnapshotService_Stop_Call) RunAndReturn(run func(ctx context.Context) error) *MockSnapshotService_Stop_Call {
11203	_c.Call.Return(run)
11204	return _c
11205}
11206
11207// NewMockTextInputTarget creates a new instance of MockTextInputTarget. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
11208// The first argument is typically a *testing.T value.
11209func NewMockTextInputTarget(t interface {
11210	mock.TestingT
11211	Cleanup(func())
11212}) *MockTextInputTarget {
11213	mock := &MockTextInputTarget{}
11214	mock.Mock.Test(t)
11215
11216	t.Cleanup(func() { mock.AssertExpectations(t) })
11217
11218	return mock
11219}
11220
11221// MockTextInputTarget is an autogenerated mock type for the TextInputTarget type
11222type MockTextInputTarget struct {
11223	mock.Mock
11224}
11225
11226type MockTextInputTarget_Expecter struct {
11227	mock *mock.Mock
11228}
11229
11230func (_m *MockTextInputTarget) EXPECT() *MockTextInputTarget_Expecter {
11231	return &MockTextInputTarget_Expecter{mock: &_m.Mock}
11232}
11233
11234// DeleteBeforeCursor provides a mock function for the type MockTextInputTarget
11235func (_mock *MockTextInputTarget) DeleteBeforeCursor(ctx context.Context, n int) error {
11236	ret := _mock.Called(ctx, n)
11237
11238	if len(ret) == 0 {
11239		panic("no return value specified for DeleteBeforeCursor")
11240	}
11241
11242	var r0 error
11243	if returnFunc, ok := ret.Get(0).(func(context.Context, int) error); ok {
11244		r0 = returnFunc(ctx, n)
11245	} else {
11246		r0 = ret.Error(0)
11247	}
11248	return r0
11249}
11250
11251// MockTextInputTarget_DeleteBeforeCursor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBeforeCursor'
11252type MockTextInputTarget_DeleteBeforeCursor_Call struct {
11253	*mock.Call
11254}
11255
11256// DeleteBeforeCursor is a helper method to define mock.On call
11257//   - ctx context.Context
11258//   - n int
11259func (_e *MockTextInputTarget_Expecter) DeleteBeforeCursor(ctx interface{}, n interface{}) *MockTextInputTarget_DeleteBeforeCursor_Call {
11260	return &MockTextInputTarget_DeleteBeforeCursor_Call{Call: _e.mock.On("DeleteBeforeCursor", ctx, n)}
11261}
11262
11263func (_c *MockTextInputTarget_DeleteBeforeCursor_Call) Run(run func(ctx context.Context, n int)) *MockTextInputTarget_DeleteBeforeCursor_Call {
11264	_c.Call.Run(func(args mock.Arguments) {
11265		var arg0 context.Context
11266		if args[0] != nil {
11267			arg0 = args[0].(context.Context)
11268		}
11269		var arg1 int
11270		if args[1] != nil {
11271			arg1 = args[1].(int)
11272		}
11273		run(
11274			arg0,
11275			arg1,
11276		)
11277	})
11278	return _c
11279}
11280
11281func (_c *MockTextInputTarget_DeleteBeforeCursor_Call) Return(err error) *MockTextInputTarget_DeleteBeforeCursor_Call {
11282	_c.Call.Return(err)
11283	return _c
11284}
11285
11286func (_c *MockTextInputTarget_DeleteBeforeCursor_Call) RunAndReturn(run func(ctx context.Context, n int) error) *MockTextInputTarget_DeleteBeforeCursor_Call {
11287	_c.Call.Return(run)
11288	return _c
11289}
11290
11291// InsertText provides a mock function for the type MockTextInputTarget
11292func (_mock *MockTextInputTarget) InsertText(ctx context.Context, text string) error {
11293	ret := _mock.Called(ctx, text)
11294
11295	if len(ret) == 0 {
11296		panic("no return value specified for InsertText")
11297	}
11298
11299	var r0 error
11300	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
11301		r0 = returnFunc(ctx, text)
11302	} else {
11303		r0 = ret.Error(0)
11304	}
11305	return r0
11306}
11307
11308// MockTextInputTarget_InsertText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InsertText'
11309type MockTextInputTarget_InsertText_Call struct {
11310	*mock.Call
11311}
11312
11313// InsertText is a helper method to define mock.On call
11314//   - ctx context.Context
11315//   - text string
11316func (_e *MockTextInputTarget_Expecter) InsertText(ctx interface{}, text interface{}) *MockTextInputTarget_InsertText_Call {
11317	return &MockTextInputTarget_InsertText_Call{Call: _e.mock.On("InsertText", ctx, text)}
11318}
11319
11320func (_c *MockTextInputTarget_InsertText_Call) Run(run func(ctx context.Context, text string)) *MockTextInputTarget_InsertText_Call {
11321	_c.Call.Run(func(args mock.Arguments) {
11322		var arg0 context.Context
11323		if args[0] != nil {
11324			arg0 = args[0].(context.Context)
11325		}
11326		var arg1 string
11327		if args[1] != nil {
11328			arg1 = args[1].(string)
11329		}
11330		run(
11331			arg0,
11332			arg1,
11333		)
11334	})
11335	return _c
11336}
11337
11338func (_c *MockTextInputTarget_InsertText_Call) Return(err error) *MockTextInputTarget_InsertText_Call {
11339	_c.Call.Return(err)
11340	return _c
11341}
11342
11343func (_c *MockTextInputTarget_InsertText_Call) RunAndReturn(run func(ctx context.Context, text string) error) *MockTextInputTarget_InsertText_Call {
11344	_c.Call.Return(run)
11345	return _c
11346}
11347
11348// NewMockFocusable creates a new instance of MockFocusable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
11349// The first argument is typically a *testing.T value.
11350func NewMockFocusable(t interface {
11351	mock.TestingT
11352	Cleanup(func())
11353}) *MockFocusable {
11354	mock := &MockFocusable{}
11355	mock.Mock.Test(t)
11356
11357	t.Cleanup(func() { mock.AssertExpectations(t) })
11358
11359	return mock
11360}
11361
11362// MockFocusable is an autogenerated mock type for the Focusable type
11363type MockFocusable struct {
11364	mock.Mock
11365}
11366
11367type MockFocusable_Expecter struct {
11368	mock *mock.Mock
11369}
11370
11371func (_m *MockFocusable) EXPECT() *MockFocusable_Expecter {
11372	return &MockFocusable_Expecter{mock: &_m.Mock}
11373}
11374
11375// Focus provides a mock function for the type MockFocusable
11376func (_mock *MockFocusable) Focus(ctx context.Context) {
11377	_mock.Called(ctx)
11378	return
11379}
11380
11381// MockFocusable_Focus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Focus'
11382type MockFocusable_Focus_Call struct {
11383	*mock.Call
11384}
11385
11386// Focus is a helper method to define mock.On call
11387//   - ctx context.Context
11388func (_e *MockFocusable_Expecter) Focus(ctx interface{}) *MockFocusable_Focus_Call {
11389	return &MockFocusable_Focus_Call{Call: _e.mock.On("Focus", ctx)}
11390}
11391
11392func (_c *MockFocusable_Focus_Call) Run(run func(ctx context.Context)) *MockFocusable_Focus_Call {
11393	_c.Call.Run(func(args mock.Arguments) {
11394		var arg0 context.Context
11395		if args[0] != nil {
11396			arg0 = args[0].(context.Context)
11397		}
11398		run(
11399			arg0,
11400		)
11401	})
11402	return _c
11403}
11404
11405func (_c *MockFocusable_Focus_Call) Return() *MockFocusable_Focus_Call {
11406	_c.Call.Return()
11407	return _c
11408}
11409
11410func (_c *MockFocusable_Focus_Call) RunAndReturn(run func(ctx context.Context)) *MockFocusable_Focus_Call {
11411	_c.Run(run)
11412	return _c
11413}
11414
11415// NewMockEntryInputTarget creates a new instance of MockEntryInputTarget. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
11416// The first argument is typically a *testing.T value.
11417func NewMockEntryInputTarget(t interface {
11418	mock.TestingT
11419	Cleanup(func())
11420}) *MockEntryInputTarget {
11421	mock := &MockEntryInputTarget{}
11422	mock.Mock.Test(t)
11423
11424	t.Cleanup(func() { mock.AssertExpectations(t) })
11425
11426	return mock
11427}
11428
11429// MockEntryInputTarget is an autogenerated mock type for the EntryInputTarget type
11430type MockEntryInputTarget struct {
11431	mock.Mock
11432}
11433
11434type MockEntryInputTarget_Expecter struct {
11435	mock *mock.Mock
11436}
11437
11438func (_m *MockEntryInputTarget) EXPECT() *MockEntryInputTarget_Expecter {
11439	return &MockEntryInputTarget_Expecter{mock: &_m.Mock}
11440}
11441
11442// DeleteBeforeCursor provides a mock function for the type MockEntryInputTarget
11443func (_mock *MockEntryInputTarget) DeleteBeforeCursor(ctx context.Context, n int) error {
11444	ret := _mock.Called(ctx, n)
11445
11446	if len(ret) == 0 {
11447		panic("no return value specified for DeleteBeforeCursor")
11448	}
11449
11450	var r0 error
11451	if returnFunc, ok := ret.Get(0).(func(context.Context, int) error); ok {
11452		r0 = returnFunc(ctx, n)
11453	} else {
11454		r0 = ret.Error(0)
11455	}
11456	return r0
11457}
11458
11459// MockEntryInputTarget_DeleteBeforeCursor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBeforeCursor'
11460type MockEntryInputTarget_DeleteBeforeCursor_Call struct {
11461	*mock.Call
11462}
11463
11464// DeleteBeforeCursor is a helper method to define mock.On call
11465//   - ctx context.Context
11466//   - n int
11467func (_e *MockEntryInputTarget_Expecter) DeleteBeforeCursor(ctx interface{}, n interface{}) *MockEntryInputTarget_DeleteBeforeCursor_Call {
11468	return &MockEntryInputTarget_DeleteBeforeCursor_Call{Call: _e.mock.On("DeleteBeforeCursor", ctx, n)}
11469}
11470
11471func (_c *MockEntryInputTarget_DeleteBeforeCursor_Call) Run(run func(ctx context.Context, n int)) *MockEntryInputTarget_DeleteBeforeCursor_Call {
11472	_c.Call.Run(func(args mock.Arguments) {
11473		var arg0 context.Context
11474		if args[0] != nil {
11475			arg0 = args[0].(context.Context)
11476		}
11477		var arg1 int
11478		if args[1] != nil {
11479			arg1 = args[1].(int)
11480		}
11481		run(
11482			arg0,
11483			arg1,
11484		)
11485	})
11486	return _c
11487}
11488
11489func (_c *MockEntryInputTarget_DeleteBeforeCursor_Call) Return(err error) *MockEntryInputTarget_DeleteBeforeCursor_Call {
11490	_c.Call.Return(err)
11491	return _c
11492}
11493
11494func (_c *MockEntryInputTarget_DeleteBeforeCursor_Call) RunAndReturn(run func(ctx context.Context, n int) error) *MockEntryInputTarget_DeleteBeforeCursor_Call {
11495	_c.Call.Return(run)
11496	return _c
11497}
11498
11499// InsertText provides a mock function for the type MockEntryInputTarget
11500func (_mock *MockEntryInputTarget) InsertText(ctx context.Context, text string) error {
11501	ret := _mock.Called(ctx, text)
11502
11503	if len(ret) == 0 {
11504		panic("no return value specified for InsertText")
11505	}
11506
11507	var r0 error
11508	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
11509		r0 = returnFunc(ctx, text)
11510	} else {
11511		r0 = ret.Error(0)
11512	}
11513	return r0
11514}
11515
11516// MockEntryInputTarget_InsertText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InsertText'
11517type MockEntryInputTarget_InsertText_Call struct {
11518	*mock.Call
11519}
11520
11521// InsertText is a helper method to define mock.On call
11522//   - ctx context.Context
11523//   - text string
11524func (_e *MockEntryInputTarget_Expecter) InsertText(ctx interface{}, text interface{}) *MockEntryInputTarget_InsertText_Call {
11525	return &MockEntryInputTarget_InsertText_Call{Call: _e.mock.On("InsertText", ctx, text)}
11526}
11527
11528func (_c *MockEntryInputTarget_InsertText_Call) Run(run func(ctx context.Context, text string)) *MockEntryInputTarget_InsertText_Call {
11529	_c.Call.Run(func(args mock.Arguments) {
11530		var arg0 context.Context
11531		if args[0] != nil {
11532			arg0 = args[0].(context.Context)
11533		}
11534		var arg1 string
11535		if args[1] != nil {
11536			arg1 = args[1].(string)
11537		}
11538		run(
11539			arg0,
11540			arg1,
11541		)
11542	})
11543	return _c
11544}
11545
11546func (_c *MockEntryInputTarget_InsertText_Call) Return(err error) *MockEntryInputTarget_InsertText_Call {
11547	_c.Call.Return(err)
11548	return _c
11549}
11550
11551func (_c *MockEntryInputTarget_InsertText_Call) RunAndReturn(run func(ctx context.Context, text string) error) *MockEntryInputTarget_InsertText_Call {
11552	_c.Call.Return(run)
11553	return _c
11554}
11555
11556// IsGTKEntryTarget provides a mock function for the type MockEntryInputTarget
11557func (_mock *MockEntryInputTarget) IsGTKEntryTarget() bool {
11558	ret := _mock.Called()
11559
11560	if len(ret) == 0 {
11561		panic("no return value specified for IsGTKEntryTarget")
11562	}
11563
11564	var r0 bool
11565	if returnFunc, ok := ret.Get(0).(func() bool); ok {
11566		r0 = returnFunc()
11567	} else {
11568		r0 = ret.Get(0).(bool)
11569	}
11570	return r0
11571}
11572
11573// MockEntryInputTarget_IsGTKEntryTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsGTKEntryTarget'
11574type MockEntryInputTarget_IsGTKEntryTarget_Call struct {
11575	*mock.Call
11576}
11577
11578// IsGTKEntryTarget is a helper method to define mock.On call
11579func (_e *MockEntryInputTarget_Expecter) IsGTKEntryTarget() *MockEntryInputTarget_IsGTKEntryTarget_Call {
11580	return &MockEntryInputTarget_IsGTKEntryTarget_Call{Call: _e.mock.On("IsGTKEntryTarget")}
11581}
11582
11583func (_c *MockEntryInputTarget_IsGTKEntryTarget_Call) Run(run func()) *MockEntryInputTarget_IsGTKEntryTarget_Call {
11584	_c.Call.Run(func(args mock.Arguments) {
11585		run()
11586	})
11587	return _c
11588}
11589
11590func (_c *MockEntryInputTarget_IsGTKEntryTarget_Call) Return(b bool) *MockEntryInputTarget_IsGTKEntryTarget_Call {
11591	_c.Call.Return(b)
11592	return _c
11593}
11594
11595func (_c *MockEntryInputTarget_IsGTKEntryTarget_Call) RunAndReturn(run func() bool) *MockEntryInputTarget_IsGTKEntryTarget_Call {
11596	_c.Call.Return(run)
11597	return _c
11598}
11599
11600// NewMockFocusedInputProvider creates a new instance of MockFocusedInputProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
11601// The first argument is typically a *testing.T value.
11602func NewMockFocusedInputProvider(t interface {
11603	mock.TestingT
11604	Cleanup(func())
11605}) *MockFocusedInputProvider {
11606	mock := &MockFocusedInputProvider{}
11607	mock.Mock.Test(t)
11608
11609	t.Cleanup(func() { mock.AssertExpectations(t) })
11610
11611	return mock
11612}
11613
11614// MockFocusedInputProvider is an autogenerated mock type for the FocusedInputProvider type
11615type MockFocusedInputProvider struct {
11616	mock.Mock
11617}
11618
11619type MockFocusedInputProvider_Expecter struct {
11620	mock *mock.Mock
11621}
11622
11623func (_m *MockFocusedInputProvider) EXPECT() *MockFocusedInputProvider_Expecter {
11624	return &MockFocusedInputProvider_Expecter{mock: &_m.Mock}
11625}
11626
11627// GetFocusedInput provides a mock function for the type MockFocusedInputProvider
11628func (_mock *MockFocusedInputProvider) GetFocusedInput() port.TextInputTarget {
11629	ret := _mock.Called()
11630
11631	if len(ret) == 0 {
11632		panic("no return value specified for GetFocusedInput")
11633	}
11634
11635	var r0 port.TextInputTarget
11636	if returnFunc, ok := ret.Get(0).(func() port.TextInputTarget); ok {
11637		r0 = returnFunc()
11638	} else {
11639		if ret.Get(0) != nil {
11640			r0 = ret.Get(0).(port.TextInputTarget)
11641		}
11642	}
11643	return r0
11644}
11645
11646// MockFocusedInputProvider_GetFocusedInput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFocusedInput'
11647type MockFocusedInputProvider_GetFocusedInput_Call struct {
11648	*mock.Call
11649}
11650
11651// GetFocusedInput is a helper method to define mock.On call
11652func (_e *MockFocusedInputProvider_Expecter) GetFocusedInput() *MockFocusedInputProvider_GetFocusedInput_Call {
11653	return &MockFocusedInputProvider_GetFocusedInput_Call{Call: _e.mock.On("GetFocusedInput")}
11654}
11655
11656func (_c *MockFocusedInputProvider_GetFocusedInput_Call) Run(run func()) *MockFocusedInputProvider_GetFocusedInput_Call {
11657	_c.Call.Run(func(args mock.Arguments) {
11658		run()
11659	})
11660	return _c
11661}
11662
11663func (_c *MockFocusedInputProvider_GetFocusedInput_Call) Return(textInputTarget port.TextInputTarget) *MockFocusedInputProvider_GetFocusedInput_Call {
11664	_c.Call.Return(textInputTarget)
11665	return _c
11666}
11667
11668func (_c *MockFocusedInputProvider_GetFocusedInput_Call) RunAndReturn(run func() port.TextInputTarget) *MockFocusedInputProvider_GetFocusedInput_Call {
11669	_c.Call.Return(run)
11670	return _c
11671}
11672
11673// SetFocusedInput provides a mock function for the type MockFocusedInputProvider
11674func (_mock *MockFocusedInputProvider) SetFocusedInput(target port.TextInputTarget) {
11675	_mock.Called(target)
11676	return
11677}
11678
11679// MockFocusedInputProvider_SetFocusedInput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusedInput'
11680type MockFocusedInputProvider_SetFocusedInput_Call struct {
11681	*mock.Call
11682}
11683
11684// SetFocusedInput is a helper method to define mock.On call
11685//   - target port.TextInputTarget
11686func (_e *MockFocusedInputProvider_Expecter) SetFocusedInput(target interface{}) *MockFocusedInputProvider_SetFocusedInput_Call {
11687	return &MockFocusedInputProvider_SetFocusedInput_Call{Call: _e.mock.On("SetFocusedInput", target)}
11688}
11689
11690func (_c *MockFocusedInputProvider_SetFocusedInput_Call) Run(run func(target port.TextInputTarget)) *MockFocusedInputProvider_SetFocusedInput_Call {
11691	_c.Call.Run(func(args mock.Arguments) {
11692		var arg0 port.TextInputTarget
11693		if args[0] != nil {
11694			arg0 = args[0].(port.TextInputTarget)
11695		}
11696		run(
11697			arg0,
11698		)
11699	})
11700	return _c
11701}
11702
11703func (_c *MockFocusedInputProvider_SetFocusedInput_Call) Return() *MockFocusedInputProvider_SetFocusedInput_Call {
11704	_c.Call.Return()
11705	return _c
11706}
11707
11708func (_c *MockFocusedInputProvider_SetFocusedInput_Call) RunAndReturn(run func(target port.TextInputTarget)) *MockFocusedInputProvider_SetFocusedInput_Call {
11709	_c.Run(run)
11710	return _c
11711}
11712
11713// NewMockUpdateChecker creates a new instance of MockUpdateChecker. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
11714// The first argument is typically a *testing.T value.
11715func NewMockUpdateChecker(t interface {
11716	mock.TestingT
11717	Cleanup(func())
11718}) *MockUpdateChecker {
11719	mock := &MockUpdateChecker{}
11720	mock.Mock.Test(t)
11721
11722	t.Cleanup(func() { mock.AssertExpectations(t) })
11723
11724	return mock
11725}
11726
11727// MockUpdateChecker is an autogenerated mock type for the UpdateChecker type
11728type MockUpdateChecker struct {
11729	mock.Mock
11730}
11731
11732type MockUpdateChecker_Expecter struct {
11733	mock *mock.Mock
11734}
11735
11736func (_m *MockUpdateChecker) EXPECT() *MockUpdateChecker_Expecter {
11737	return &MockUpdateChecker_Expecter{mock: &_m.Mock}
11738}
11739
11740// CheckForUpdate provides a mock function for the type MockUpdateChecker
11741func (_mock *MockUpdateChecker) CheckForUpdate(ctx context.Context, currentVersion string) (*entity.UpdateInfo, error) {
11742	ret := _mock.Called(ctx, currentVersion)
11743
11744	if len(ret) == 0 {
11745		panic("no return value specified for CheckForUpdate")
11746	}
11747
11748	var r0 *entity.UpdateInfo
11749	var r1 error
11750	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.UpdateInfo, error)); ok {
11751		return returnFunc(ctx, currentVersion)
11752	}
11753	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.UpdateInfo); ok {
11754		r0 = returnFunc(ctx, currentVersion)
11755	} else {
11756		if ret.Get(0) != nil {
11757			r0 = ret.Get(0).(*entity.UpdateInfo)
11758		}
11759	}
11760	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
11761		r1 = returnFunc(ctx, currentVersion)
11762	} else {
11763		r1 = ret.Error(1)
11764	}
11765	return r0, r1
11766}
11767
11768// MockUpdateChecker_CheckForUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckForUpdate'
11769type MockUpdateChecker_CheckForUpdate_Call struct {
11770	*mock.Call
11771}
11772
11773// CheckForUpdate is a helper method to define mock.On call
11774//   - ctx context.Context
11775//   - currentVersion string
11776func (_e *MockUpdateChecker_Expecter) CheckForUpdate(ctx interface{}, currentVersion interface{}) *MockUpdateChecker_CheckForUpdate_Call {
11777	return &MockUpdateChecker_CheckForUpdate_Call{Call: _e.mock.On("CheckForUpdate", ctx, currentVersion)}
11778}
11779
11780func (_c *MockUpdateChecker_CheckForUpdate_Call) Run(run func(ctx context.Context, currentVersion string)) *MockUpdateChecker_CheckForUpdate_Call {
11781	_c.Call.Run(func(args mock.Arguments) {
11782		var arg0 context.Context
11783		if args[0] != nil {
11784			arg0 = args[0].(context.Context)
11785		}
11786		var arg1 string
11787		if args[1] != nil {
11788			arg1 = args[1].(string)
11789		}
11790		run(
11791			arg0,
11792			arg1,
11793		)
11794	})
11795	return _c
11796}
11797
11798func (_c *MockUpdateChecker_CheckForUpdate_Call) Return(updateInfo *entity.UpdateInfo, err error) *MockUpdateChecker_CheckForUpdate_Call {
11799	_c.Call.Return(updateInfo, err)
11800	return _c
11801}
11802
11803func (_c *MockUpdateChecker_CheckForUpdate_Call) RunAndReturn(run func(ctx context.Context, currentVersion string) (*entity.UpdateInfo, error)) *MockUpdateChecker_CheckForUpdate_Call {
11804	_c.Call.Return(run)
11805	return _c
11806}
11807
11808// NewMockUpdateDownloader creates a new instance of MockUpdateDownloader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
11809// The first argument is typically a *testing.T value.
11810func NewMockUpdateDownloader(t interface {
11811	mock.TestingT
11812	Cleanup(func())
11813}) *MockUpdateDownloader {
11814	mock := &MockUpdateDownloader{}
11815	mock.Mock.Test(t)
11816
11817	t.Cleanup(func() { mock.AssertExpectations(t) })
11818
11819	return mock
11820}
11821
11822// MockUpdateDownloader is an autogenerated mock type for the UpdateDownloader type
11823type MockUpdateDownloader struct {
11824	mock.Mock
11825}
11826
11827type MockUpdateDownloader_Expecter struct {
11828	mock *mock.Mock
11829}
11830
11831func (_m *MockUpdateDownloader) EXPECT() *MockUpdateDownloader_Expecter {
11832	return &MockUpdateDownloader_Expecter{mock: &_m.Mock}
11833}
11834
11835// Download provides a mock function for the type MockUpdateDownloader
11836func (_mock *MockUpdateDownloader) Download(ctx context.Context, downloadURL string, destDir string) (string, error) {
11837	ret := _mock.Called(ctx, downloadURL, destDir)
11838
11839	if len(ret) == 0 {
11840		panic("no return value specified for Download")
11841	}
11842
11843	var r0 string
11844	var r1 error
11845	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
11846		return returnFunc(ctx, downloadURL, destDir)
11847	}
11848	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
11849		r0 = returnFunc(ctx, downloadURL, destDir)
11850	} else {
11851		r0 = ret.Get(0).(string)
11852	}
11853	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
11854		r1 = returnFunc(ctx, downloadURL, destDir)
11855	} else {
11856		r1 = ret.Error(1)
11857	}
11858	return r0, r1
11859}
11860
11861// MockUpdateDownloader_Download_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Download'
11862type MockUpdateDownloader_Download_Call struct {
11863	*mock.Call
11864}
11865
11866// Download is a helper method to define mock.On call
11867//   - ctx context.Context
11868//   - downloadURL string
11869//   - destDir string
11870func (_e *MockUpdateDownloader_Expecter) Download(ctx interface{}, downloadURL interface{}, destDir interface{}) *MockUpdateDownloader_Download_Call {
11871	return &MockUpdateDownloader_Download_Call{Call: _e.mock.On("Download", ctx, downloadURL, destDir)}
11872}
11873
11874func (_c *MockUpdateDownloader_Download_Call) Run(run func(ctx context.Context, downloadURL string, destDir string)) *MockUpdateDownloader_Download_Call {
11875	_c.Call.Run(func(args mock.Arguments) {
11876		var arg0 context.Context
11877		if args[0] != nil {
11878			arg0 = args[0].(context.Context)
11879		}
11880		var arg1 string
11881		if args[1] != nil {
11882			arg1 = args[1].(string)
11883		}
11884		var arg2 string
11885		if args[2] != nil {
11886			arg2 = args[2].(string)
11887		}
11888		run(
11889			arg0,
11890			arg1,
11891			arg2,
11892		)
11893	})
11894	return _c
11895}
11896
11897func (_c *MockUpdateDownloader_Download_Call) Return(archivePath string, err error) *MockUpdateDownloader_Download_Call {
11898	_c.Call.Return(archivePath, err)
11899	return _c
11900}
11901
11902func (_c *MockUpdateDownloader_Download_Call) RunAndReturn(run func(ctx context.Context, downloadURL string, destDir string) (string, error)) *MockUpdateDownloader_Download_Call {
11903	_c.Call.Return(run)
11904	return _c
11905}
11906
11907// Extract provides a mock function for the type MockUpdateDownloader
11908func (_mock *MockUpdateDownloader) Extract(ctx context.Context, archivePath string, destDir string) (string, error) {
11909	ret := _mock.Called(ctx, archivePath, destDir)
11910
11911	if len(ret) == 0 {
11912		panic("no return value specified for Extract")
11913	}
11914
11915	var r0 string
11916	var r1 error
11917	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
11918		return returnFunc(ctx, archivePath, destDir)
11919	}
11920	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
11921		r0 = returnFunc(ctx, archivePath, destDir)
11922	} else {
11923		r0 = ret.Get(0).(string)
11924	}
11925	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
11926		r1 = returnFunc(ctx, archivePath, destDir)
11927	} else {
11928		r1 = ret.Error(1)
11929	}
11930	return r0, r1
11931}
11932
11933// MockUpdateDownloader_Extract_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Extract'
11934type MockUpdateDownloader_Extract_Call struct {
11935	*mock.Call
11936}
11937
11938// Extract is a helper method to define mock.On call
11939//   - ctx context.Context
11940//   - archivePath string
11941//   - destDir string
11942func (_e *MockUpdateDownloader_Expecter) Extract(ctx interface{}, archivePath interface{}, destDir interface{}) *MockUpdateDownloader_Extract_Call {
11943	return &MockUpdateDownloader_Extract_Call{Call: _e.mock.On("Extract", ctx, archivePath, destDir)}
11944}
11945
11946func (_c *MockUpdateDownloader_Extract_Call) Run(run func(ctx context.Context, archivePath string, destDir string)) *MockUpdateDownloader_Extract_Call {
11947	_c.Call.Run(func(args mock.Arguments) {
11948		var arg0 context.Context
11949		if args[0] != nil {
11950			arg0 = args[0].(context.Context)
11951		}
11952		var arg1 string
11953		if args[1] != nil {
11954			arg1 = args[1].(string)
11955		}
11956		var arg2 string
11957		if args[2] != nil {
11958			arg2 = args[2].(string)
11959		}
11960		run(
11961			arg0,
11962			arg1,
11963			arg2,
11964		)
11965	})
11966	return _c
11967}
11968
11969func (_c *MockUpdateDownloader_Extract_Call) Return(binaryPath string, err error) *MockUpdateDownloader_Extract_Call {
11970	_c.Call.Return(binaryPath, err)
11971	return _c
11972}
11973
11974func (_c *MockUpdateDownloader_Extract_Call) RunAndReturn(run func(ctx context.Context, archivePath string, destDir string) (string, error)) *MockUpdateDownloader_Extract_Call {
11975	_c.Call.Return(run)
11976	return _c
11977}
11978
11979// NewMockUpdateApplier creates a new instance of MockUpdateApplier. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
11980// The first argument is typically a *testing.T value.
11981func NewMockUpdateApplier(t interface {
11982	mock.TestingT
11983	Cleanup(func())
11984}) *MockUpdateApplier {
11985	mock := &MockUpdateApplier{}
11986	mock.Mock.Test(t)
11987
11988	t.Cleanup(func() { mock.AssertExpectations(t) })
11989
11990	return mock
11991}
11992
11993// MockUpdateApplier is an autogenerated mock type for the UpdateApplier type
11994type MockUpdateApplier struct {
11995	mock.Mock
11996}
11997
11998type MockUpdateApplier_Expecter struct {
11999	mock *mock.Mock
12000}
12001
12002func (_m *MockUpdateApplier) EXPECT() *MockUpdateApplier_Expecter {
12003	return &MockUpdateApplier_Expecter{mock: &_m.Mock}
12004}
12005
12006// ApplyOnExit provides a mock function for the type MockUpdateApplier
12007func (_mock *MockUpdateApplier) ApplyOnExit(ctx context.Context) (string, error) {
12008	ret := _mock.Called(ctx)
12009
12010	if len(ret) == 0 {
12011		panic("no return value specified for ApplyOnExit")
12012	}
12013
12014	var r0 string
12015	var r1 error
12016	if returnFunc, ok := ret.Get(0).(func(context.Context) (string, error)); ok {
12017		return returnFunc(ctx)
12018	}
12019	if returnFunc, ok := ret.Get(0).(func(context.Context) string); ok {
12020		r0 = returnFunc(ctx)
12021	} else {
12022		r0 = ret.Get(0).(string)
12023	}
12024	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
12025		r1 = returnFunc(ctx)
12026	} else {
12027		r1 = ret.Error(1)
12028	}
12029	return r0, r1
12030}
12031
12032// MockUpdateApplier_ApplyOnExit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApplyOnExit'
12033type MockUpdateApplier_ApplyOnExit_Call struct {
12034	*mock.Call
12035}
12036
12037// ApplyOnExit is a helper method to define mock.On call
12038//   - ctx context.Context
12039func (_e *MockUpdateApplier_Expecter) ApplyOnExit(ctx interface{}) *MockUpdateApplier_ApplyOnExit_Call {
12040	return &MockUpdateApplier_ApplyOnExit_Call{Call: _e.mock.On("ApplyOnExit", ctx)}
12041}
12042
12043func (_c *MockUpdateApplier_ApplyOnExit_Call) Run(run func(ctx context.Context)) *MockUpdateApplier_ApplyOnExit_Call {
12044	_c.Call.Run(func(args mock.Arguments) {
12045		var arg0 context.Context
12046		if args[0] != nil {
12047			arg0 = args[0].(context.Context)
12048		}
12049		run(
12050			arg0,
12051		)
12052	})
12053	return _c
12054}
12055
12056func (_c *MockUpdateApplier_ApplyOnExit_Call) Return(backupPath string, err error) *MockUpdateApplier_ApplyOnExit_Call {
12057	_c.Call.Return(backupPath, err)
12058	return _c
12059}
12060
12061func (_c *MockUpdateApplier_ApplyOnExit_Call) RunAndReturn(run func(ctx context.Context) (string, error)) *MockUpdateApplier_ApplyOnExit_Call {
12062	_c.Call.Return(run)
12063	return _c
12064}
12065
12066// CanSelfUpdate provides a mock function for the type MockUpdateApplier
12067func (_mock *MockUpdateApplier) CanSelfUpdate(ctx context.Context) bool {
12068	ret := _mock.Called(ctx)
12069
12070	if len(ret) == 0 {
12071		panic("no return value specified for CanSelfUpdate")
12072	}
12073
12074	var r0 bool
12075	if returnFunc, ok := ret.Get(0).(func(context.Context) bool); ok {
12076		r0 = returnFunc(ctx)
12077	} else {
12078		r0 = ret.Get(0).(bool)
12079	}
12080	return r0
12081}
12082
12083// MockUpdateApplier_CanSelfUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanSelfUpdate'
12084type MockUpdateApplier_CanSelfUpdate_Call struct {
12085	*mock.Call
12086}
12087
12088// CanSelfUpdate is a helper method to define mock.On call
12089//   - ctx context.Context
12090func (_e *MockUpdateApplier_Expecter) CanSelfUpdate(ctx interface{}) *MockUpdateApplier_CanSelfUpdate_Call {
12091	return &MockUpdateApplier_CanSelfUpdate_Call{Call: _e.mock.On("CanSelfUpdate", ctx)}
12092}
12093
12094func (_c *MockUpdateApplier_CanSelfUpdate_Call) Run(run func(ctx context.Context)) *MockUpdateApplier_CanSelfUpdate_Call {
12095	_c.Call.Run(func(args mock.Arguments) {
12096		var arg0 context.Context
12097		if args[0] != nil {
12098			arg0 = args[0].(context.Context)
12099		}
12100		run(
12101			arg0,
12102		)
12103	})
12104	return _c
12105}
12106
12107func (_c *MockUpdateApplier_CanSelfUpdate_Call) Return(b bool) *MockUpdateApplier_CanSelfUpdate_Call {
12108	_c.Call.Return(b)
12109	return _c
12110}
12111
12112func (_c *MockUpdateApplier_CanSelfUpdate_Call) RunAndReturn(run func(ctx context.Context) bool) *MockUpdateApplier_CanSelfUpdate_Call {
12113	_c.Call.Return(run)
12114	return _c
12115}
12116
12117// ClearStagedUpdate provides a mock function for the type MockUpdateApplier
12118func (_mock *MockUpdateApplier) ClearStagedUpdate(ctx context.Context) error {
12119	ret := _mock.Called(ctx)
12120
12121	if len(ret) == 0 {
12122		panic("no return value specified for ClearStagedUpdate")
12123	}
12124
12125	var r0 error
12126	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
12127		r0 = returnFunc(ctx)
12128	} else {
12129		r0 = ret.Error(0)
12130	}
12131	return r0
12132}
12133
12134// MockUpdateApplier_ClearStagedUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearStagedUpdate'
12135type MockUpdateApplier_ClearStagedUpdate_Call struct {
12136	*mock.Call
12137}
12138
12139// ClearStagedUpdate is a helper method to define mock.On call
12140//   - ctx context.Context
12141func (_e *MockUpdateApplier_Expecter) ClearStagedUpdate(ctx interface{}) *MockUpdateApplier_ClearStagedUpdate_Call {
12142	return &MockUpdateApplier_ClearStagedUpdate_Call{Call: _e.mock.On("ClearStagedUpdate", ctx)}
12143}
12144
12145func (_c *MockUpdateApplier_ClearStagedUpdate_Call) Run(run func(ctx context.Context)) *MockUpdateApplier_ClearStagedUpdate_Call {
12146	_c.Call.Run(func(args mock.Arguments) {
12147		var arg0 context.Context
12148		if args[0] != nil {
12149			arg0 = args[0].(context.Context)
12150		}
12151		run(
12152			arg0,
12153		)
12154	})
12155	return _c
12156}
12157
12158func (_c *MockUpdateApplier_ClearStagedUpdate_Call) Return(err error) *MockUpdateApplier_ClearStagedUpdate_Call {
12159	_c.Call.Return(err)
12160	return _c
12161}
12162
12163func (_c *MockUpdateApplier_ClearStagedUpdate_Call) RunAndReturn(run func(ctx context.Context) error) *MockUpdateApplier_ClearStagedUpdate_Call {
12164	_c.Call.Return(run)
12165	return _c
12166}
12167
12168// GetBinaryPath provides a mock function for the type MockUpdateApplier
12169func (_mock *MockUpdateApplier) GetBinaryPath() (string, error) {
12170	ret := _mock.Called()
12171
12172	if len(ret) == 0 {
12173		panic("no return value specified for GetBinaryPath")
12174	}
12175
12176	var r0 string
12177	var r1 error
12178	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
12179		return returnFunc()
12180	}
12181	if returnFunc, ok := ret.Get(0).(func() string); ok {
12182		r0 = returnFunc()
12183	} else {
12184		r0 = ret.Get(0).(string)
12185	}
12186	if returnFunc, ok := ret.Get(1).(func() error); ok {
12187		r1 = returnFunc()
12188	} else {
12189		r1 = ret.Error(1)
12190	}
12191	return r0, r1
12192}
12193
12194// MockUpdateApplier_GetBinaryPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBinaryPath'
12195type MockUpdateApplier_GetBinaryPath_Call struct {
12196	*mock.Call
12197}
12198
12199// GetBinaryPath is a helper method to define mock.On call
12200func (_e *MockUpdateApplier_Expecter) GetBinaryPath() *MockUpdateApplier_GetBinaryPath_Call {
12201	return &MockUpdateApplier_GetBinaryPath_Call{Call: _e.mock.On("GetBinaryPath")}
12202}
12203
12204func (_c *MockUpdateApplier_GetBinaryPath_Call) Run(run func()) *MockUpdateApplier_GetBinaryPath_Call {
12205	_c.Call.Run(func(args mock.Arguments) {
12206		run()
12207	})
12208	return _c
12209}
12210
12211func (_c *MockUpdateApplier_GetBinaryPath_Call) Return(s string, err error) *MockUpdateApplier_GetBinaryPath_Call {
12212	_c.Call.Return(s, err)
12213	return _c
12214}
12215
12216func (_c *MockUpdateApplier_GetBinaryPath_Call) RunAndReturn(run func() (string, error)) *MockUpdateApplier_GetBinaryPath_Call {
12217	_c.Call.Return(run)
12218	return _c
12219}
12220
12221// HasStagedUpdate provides a mock function for the type MockUpdateApplier
12222func (_mock *MockUpdateApplier) HasStagedUpdate(ctx context.Context) bool {
12223	ret := _mock.Called(ctx)
12224
12225	if len(ret) == 0 {
12226		panic("no return value specified for HasStagedUpdate")
12227	}
12228
12229	var r0 bool
12230	if returnFunc, ok := ret.Get(0).(func(context.Context) bool); ok {
12231		r0 = returnFunc(ctx)
12232	} else {
12233		r0 = ret.Get(0).(bool)
12234	}
12235	return r0
12236}
12237
12238// MockUpdateApplier_HasStagedUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasStagedUpdate'
12239type MockUpdateApplier_HasStagedUpdate_Call struct {
12240	*mock.Call
12241}
12242
12243// HasStagedUpdate is a helper method to define mock.On call
12244//   - ctx context.Context
12245func (_e *MockUpdateApplier_Expecter) HasStagedUpdate(ctx interface{}) *MockUpdateApplier_HasStagedUpdate_Call {
12246	return &MockUpdateApplier_HasStagedUpdate_Call{Call: _e.mock.On("HasStagedUpdate", ctx)}
12247}
12248
12249func (_c *MockUpdateApplier_HasStagedUpdate_Call) Run(run func(ctx context.Context)) *MockUpdateApplier_HasStagedUpdate_Call {
12250	_c.Call.Run(func(args mock.Arguments) {
12251		var arg0 context.Context
12252		if args[0] != nil {
12253			arg0 = args[0].(context.Context)
12254		}
12255		run(
12256			arg0,
12257		)
12258	})
12259	return _c
12260}
12261
12262func (_c *MockUpdateApplier_HasStagedUpdate_Call) Return(b bool) *MockUpdateApplier_HasStagedUpdate_Call {
12263	_c.Call.Return(b)
12264	return _c
12265}
12266
12267func (_c *MockUpdateApplier_HasStagedUpdate_Call) RunAndReturn(run func(ctx context.Context) bool) *MockUpdateApplier_HasStagedUpdate_Call {
12268	_c.Call.Return(run)
12269	return _c
12270}
12271
12272// SelfUpdateBlockedReason provides a mock function for the type MockUpdateApplier
12273func (_mock *MockUpdateApplier) SelfUpdateBlockedReason(ctx context.Context) port.SelfUpdateBlockedReason {
12274	ret := _mock.Called(ctx)
12275
12276	if len(ret) == 0 {
12277		panic("no return value specified for SelfUpdateBlockedReason")
12278	}
12279
12280	var r0 port.SelfUpdateBlockedReason
12281	if returnFunc, ok := ret.Get(0).(func(context.Context) port.SelfUpdateBlockedReason); ok {
12282		r0 = returnFunc(ctx)
12283	} else {
12284		r0 = ret.Get(0).(port.SelfUpdateBlockedReason)
12285	}
12286	return r0
12287}
12288
12289// MockUpdateApplier_SelfUpdateBlockedReason_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelfUpdateBlockedReason'
12290type MockUpdateApplier_SelfUpdateBlockedReason_Call struct {
12291	*mock.Call
12292}
12293
12294// SelfUpdateBlockedReason is a helper method to define mock.On call
12295//   - ctx context.Context
12296func (_e *MockUpdateApplier_Expecter) SelfUpdateBlockedReason(ctx interface{}) *MockUpdateApplier_SelfUpdateBlockedReason_Call {
12297	return &MockUpdateApplier_SelfUpdateBlockedReason_Call{Call: _e.mock.On("SelfUpdateBlockedReason", ctx)}
12298}
12299
12300func (_c *MockUpdateApplier_SelfUpdateBlockedReason_Call) Run(run func(ctx context.Context)) *MockUpdateApplier_SelfUpdateBlockedReason_Call {
12301	_c.Call.Run(func(args mock.Arguments) {
12302		var arg0 context.Context
12303		if args[0] != nil {
12304			arg0 = args[0].(context.Context)
12305		}
12306		run(
12307			arg0,
12308		)
12309	})
12310	return _c
12311}
12312
12313func (_c *MockUpdateApplier_SelfUpdateBlockedReason_Call) Return(selfUpdateBlockedReason port.SelfUpdateBlockedReason) *MockUpdateApplier_SelfUpdateBlockedReason_Call {
12314	_c.Call.Return(selfUpdateBlockedReason)
12315	return _c
12316}
12317
12318func (_c *MockUpdateApplier_SelfUpdateBlockedReason_Call) RunAndReturn(run func(ctx context.Context) port.SelfUpdateBlockedReason) *MockUpdateApplier_SelfUpdateBlockedReason_Call {
12319	_c.Call.Return(run)
12320	return _c
12321}
12322
12323// StageUpdate provides a mock function for the type MockUpdateApplier
12324func (_mock *MockUpdateApplier) StageUpdate(ctx context.Context, newBinaryPath string) error {
12325	ret := _mock.Called(ctx, newBinaryPath)
12326
12327	if len(ret) == 0 {
12328		panic("no return value specified for StageUpdate")
12329	}
12330
12331	var r0 error
12332	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
12333		r0 = returnFunc(ctx, newBinaryPath)
12334	} else {
12335		r0 = ret.Error(0)
12336	}
12337	return r0
12338}
12339
12340// MockUpdateApplier_StageUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StageUpdate'
12341type MockUpdateApplier_StageUpdate_Call struct {
12342	*mock.Call
12343}
12344
12345// StageUpdate is a helper method to define mock.On call
12346//   - ctx context.Context
12347//   - newBinaryPath string
12348func (_e *MockUpdateApplier_Expecter) StageUpdate(ctx interface{}, newBinaryPath interface{}) *MockUpdateApplier_StageUpdate_Call {
12349	return &MockUpdateApplier_StageUpdate_Call{Call: _e.mock.On("StageUpdate", ctx, newBinaryPath)}
12350}
12351
12352func (_c *MockUpdateApplier_StageUpdate_Call) Run(run func(ctx context.Context, newBinaryPath string)) *MockUpdateApplier_StageUpdate_Call {
12353	_c.Call.Run(func(args mock.Arguments) {
12354		var arg0 context.Context
12355		if args[0] != nil {
12356			arg0 = args[0].(context.Context)
12357		}
12358		var arg1 string
12359		if args[1] != nil {
12360			arg1 = args[1].(string)
12361		}
12362		run(
12363			arg0,
12364			arg1,
12365		)
12366	})
12367	return _c
12368}
12369
12370func (_c *MockUpdateApplier_StageUpdate_Call) Return(err error) *MockUpdateApplier_StageUpdate_Call {
12371	_c.Call.Return(err)
12372	return _c
12373}
12374
12375func (_c *MockUpdateApplier_StageUpdate_Call) RunAndReturn(run func(ctx context.Context, newBinaryPath string) error) *MockUpdateApplier_StageUpdate_Call {
12376	_c.Call.Return(run)
12377	return _c
12378}
12379
12380// NewMockSystemviewConfigReader creates a new instance of MockSystemviewConfigReader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
12381// The first argument is typically a *testing.T value.
12382func NewMockSystemviewConfigReader(t interface {
12383	mock.TestingT
12384	Cleanup(func())
12385}) *MockSystemviewConfigReader {
12386	mock := &MockSystemviewConfigReader{}
12387	mock.Mock.Test(t)
12388
12389	t.Cleanup(func() { mock.AssertExpectations(t) })
12390
12391	return mock
12392}
12393
12394// MockSystemviewConfigReader is an autogenerated mock type for the SystemviewConfigReader type
12395type MockSystemviewConfigReader struct {
12396	mock.Mock
12397}
12398
12399type MockSystemviewConfigReader_Expecter struct {
12400	mock *mock.Mock
12401}
12402
12403func (_m *MockSystemviewConfigReader) EXPECT() *MockSystemviewConfigReader_Expecter {
12404	return &MockSystemviewConfigReader_Expecter{mock: &_m.Mock}
12405}
12406
12407// Current provides a mock function for the type MockSystemviewConfigReader
12408func (_mock *MockSystemviewConfigReader) Current(ctx context.Context) (dto.SystemviewConfigPayload, error) {
12409	ret := _mock.Called(ctx)
12410
12411	if len(ret) == 0 {
12412		panic("no return value specified for Current")
12413	}
12414
12415	var r0 dto.SystemviewConfigPayload
12416	var r1 error
12417	if returnFunc, ok := ret.Get(0).(func(context.Context) (dto.SystemviewConfigPayload, error)); ok {
12418		return returnFunc(ctx)
12419	}
12420	if returnFunc, ok := ret.Get(0).(func(context.Context) dto.SystemviewConfigPayload); ok {
12421		r0 = returnFunc(ctx)
12422	} else {
12423		r0 = ret.Get(0).(dto.SystemviewConfigPayload)
12424	}
12425	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
12426		r1 = returnFunc(ctx)
12427	} else {
12428		r1 = ret.Error(1)
12429	}
12430	return r0, r1
12431}
12432
12433// MockSystemviewConfigReader_Current_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Current'
12434type MockSystemviewConfigReader_Current_Call struct {
12435	*mock.Call
12436}
12437
12438// Current is a helper method to define mock.On call
12439//   - ctx context.Context
12440func (_e *MockSystemviewConfigReader_Expecter) Current(ctx interface{}) *MockSystemviewConfigReader_Current_Call {
12441	return &MockSystemviewConfigReader_Current_Call{Call: _e.mock.On("Current", ctx)}
12442}
12443
12444func (_c *MockSystemviewConfigReader_Current_Call) Run(run func(ctx context.Context)) *MockSystemviewConfigReader_Current_Call {
12445	_c.Call.Run(func(args mock.Arguments) {
12446		var arg0 context.Context
12447		if args[0] != nil {
12448			arg0 = args[0].(context.Context)
12449		}
12450		run(
12451			arg0,
12452		)
12453	})
12454	return _c
12455}
12456
12457func (_c *MockSystemviewConfigReader_Current_Call) Return(systemviewConfigPayload dto.SystemviewConfigPayload, err error) *MockSystemviewConfigReader_Current_Call {
12458	_c.Call.Return(systemviewConfigPayload, err)
12459	return _c
12460}
12461
12462func (_c *MockSystemviewConfigReader_Current_Call) RunAndReturn(run func(ctx context.Context) (dto.SystemviewConfigPayload, error)) *MockSystemviewConfigReader_Current_Call {
12463	_c.Call.Return(run)
12464	return _c
12465}
12466
12467// Default provides a mock function for the type MockSystemviewConfigReader
12468func (_mock *MockSystemviewConfigReader) Default(ctx context.Context) (dto.SystemviewConfigPayload, error) {
12469	ret := _mock.Called(ctx)
12470
12471	if len(ret) == 0 {
12472		panic("no return value specified for Default")
12473	}
12474
12475	var r0 dto.SystemviewConfigPayload
12476	var r1 error
12477	if returnFunc, ok := ret.Get(0).(func(context.Context) (dto.SystemviewConfigPayload, error)); ok {
12478		return returnFunc(ctx)
12479	}
12480	if returnFunc, ok := ret.Get(0).(func(context.Context) dto.SystemviewConfigPayload); ok {
12481		r0 = returnFunc(ctx)
12482	} else {
12483		r0 = ret.Get(0).(dto.SystemviewConfigPayload)
12484	}
12485	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
12486		r1 = returnFunc(ctx)
12487	} else {
12488		r1 = ret.Error(1)
12489	}
12490	return r0, r1
12491}
12492
12493// MockSystemviewConfigReader_Default_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Default'
12494type MockSystemviewConfigReader_Default_Call struct {
12495	*mock.Call
12496}
12497
12498// Default is a helper method to define mock.On call
12499//   - ctx context.Context
12500func (_e *MockSystemviewConfigReader_Expecter) Default(ctx interface{}) *MockSystemviewConfigReader_Default_Call {
12501	return &MockSystemviewConfigReader_Default_Call{Call: _e.mock.On("Default", ctx)}
12502}
12503
12504func (_c *MockSystemviewConfigReader_Default_Call) Run(run func(ctx context.Context)) *MockSystemviewConfigReader_Default_Call {
12505	_c.Call.Run(func(args mock.Arguments) {
12506		var arg0 context.Context
12507		if args[0] != nil {
12508			arg0 = args[0].(context.Context)
12509		}
12510		run(
12511			arg0,
12512		)
12513	})
12514	return _c
12515}
12516
12517func (_c *MockSystemviewConfigReader_Default_Call) Return(systemviewConfigPayload dto.SystemviewConfigPayload, err error) *MockSystemviewConfigReader_Default_Call {
12518	_c.Call.Return(systemviewConfigPayload, err)
12519	return _c
12520}
12521
12522func (_c *MockSystemviewConfigReader_Default_Call) RunAndReturn(run func(ctx context.Context) (dto.SystemviewConfigPayload, error)) *MockSystemviewConfigReader_Default_Call {
12523	_c.Call.Return(run)
12524	return _c
12525}
12526
12527// NewMockWebUIConfigSaver creates a new instance of MockWebUIConfigSaver. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
12528// The first argument is typically a *testing.T value.
12529func NewMockWebUIConfigSaver(t interface {
12530	mock.TestingT
12531	Cleanup(func())
12532}) *MockWebUIConfigSaver {
12533	mock := &MockWebUIConfigSaver{}
12534	mock.Mock.Test(t)
12535
12536	t.Cleanup(func() { mock.AssertExpectations(t) })
12537
12538	return mock
12539}
12540
12541// MockWebUIConfigSaver is an autogenerated mock type for the WebUIConfigSaver type
12542type MockWebUIConfigSaver struct {
12543	mock.Mock
12544}
12545
12546type MockWebUIConfigSaver_Expecter struct {
12547	mock *mock.Mock
12548}
12549
12550func (_m *MockWebUIConfigSaver) EXPECT() *MockWebUIConfigSaver_Expecter {
12551	return &MockWebUIConfigSaver_Expecter{mock: &_m.Mock}
12552}
12553
12554// SaveWebUIConfig provides a mock function for the type MockWebUIConfigSaver
12555func (_mock *MockWebUIConfigSaver) SaveWebUIConfig(ctx context.Context, cfg dto.WebUIConfig) error {
12556	ret := _mock.Called(ctx, cfg)
12557
12558	if len(ret) == 0 {
12559		panic("no return value specified for SaveWebUIConfig")
12560	}
12561
12562	var r0 error
12563	if returnFunc, ok := ret.Get(0).(func(context.Context, dto.WebUIConfig) error); ok {
12564		r0 = returnFunc(ctx, cfg)
12565	} else {
12566		r0 = ret.Error(0)
12567	}
12568	return r0
12569}
12570
12571// MockWebUIConfigSaver_SaveWebUIConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveWebUIConfig'
12572type MockWebUIConfigSaver_SaveWebUIConfig_Call struct {
12573	*mock.Call
12574}
12575
12576// SaveWebUIConfig is a helper method to define mock.On call
12577//   - ctx context.Context
12578//   - cfg dto.WebUIConfig
12579func (_e *MockWebUIConfigSaver_Expecter) SaveWebUIConfig(ctx interface{}, cfg interface{}) *MockWebUIConfigSaver_SaveWebUIConfig_Call {
12580	return &MockWebUIConfigSaver_SaveWebUIConfig_Call{Call: _e.mock.On("SaveWebUIConfig", ctx, cfg)}
12581}
12582
12583func (_c *MockWebUIConfigSaver_SaveWebUIConfig_Call) Run(run func(ctx context.Context, cfg dto.WebUIConfig)) *MockWebUIConfigSaver_SaveWebUIConfig_Call {
12584	_c.Call.Run(func(args mock.Arguments) {
12585		var arg0 context.Context
12586		if args[0] != nil {
12587			arg0 = args[0].(context.Context)
12588		}
12589		var arg1 dto.WebUIConfig
12590		if args[1] != nil {
12591			arg1 = args[1].(dto.WebUIConfig)
12592		}
12593		run(
12594			arg0,
12595			arg1,
12596		)
12597	})
12598	return _c
12599}
12600
12601func (_c *MockWebUIConfigSaver_SaveWebUIConfig_Call) Return(err error) *MockWebUIConfigSaver_SaveWebUIConfig_Call {
12602	_c.Call.Return(err)
12603	return _c
12604}
12605
12606func (_c *MockWebUIConfigSaver_SaveWebUIConfig_Call) RunAndReturn(run func(ctx context.Context, cfg dto.WebUIConfig) error) *MockWebUIConfigSaver_SaveWebUIConfig_Call {
12607	_c.Call.Return(run)
12608	return _c
12609}
12610
12611// 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.
12612// The first argument is typically a *testing.T value.
12613func NewMockTexture(t interface {
12614	mock.TestingT
12615	Cleanup(func())
12616}) *MockTexture {
12617	mock := &MockTexture{}
12618	mock.Mock.Test(t)
12619
12620	t.Cleanup(func() { mock.AssertExpectations(t) })
12621
12622	return mock
12623}
12624
12625// MockTexture is an autogenerated mock type for the Texture type
12626type MockTexture struct {
12627	mock.Mock
12628}
12629
12630type MockTexture_Expecter struct {
12631	mock *mock.Mock
12632}
12633
12634func (_m *MockTexture) EXPECT() *MockTexture_Expecter {
12635	return &MockTexture_Expecter{mock: &_m.Mock}
12636}
12637
12638// GoPointer provides a mock function for the type MockTexture
12639func (_mock *MockTexture) GoPointer() uintptr {
12640	ret := _mock.Called()
12641
12642	if len(ret) == 0 {
12643		panic("no return value specified for GoPointer")
12644	}
12645
12646	var r0 uintptr
12647	if returnFunc, ok := ret.Get(0).(func() uintptr); ok {
12648		r0 = returnFunc()
12649	} else {
12650		r0 = ret.Get(0).(uintptr)
12651	}
12652	return r0
12653}
12654
12655// MockTexture_GoPointer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoPointer'
12656type MockTexture_GoPointer_Call struct {
12657	*mock.Call
12658}
12659
12660// GoPointer is a helper method to define mock.On call
12661func (_e *MockTexture_Expecter) GoPointer() *MockTexture_GoPointer_Call {
12662	return &MockTexture_GoPointer_Call{Call: _e.mock.On("GoPointer")}
12663}
12664
12665func (_c *MockTexture_GoPointer_Call) Run(run func()) *MockTexture_GoPointer_Call {
12666	_c.Call.Run(func(args mock.Arguments) {
12667		run()
12668	})
12669	return _c
12670}
12671
12672func (_c *MockTexture_GoPointer_Call) Return(v uintptr) *MockTexture_GoPointer_Call {
12673	_c.Call.Return(v)
12674	return _c
12675}
12676
12677func (_c *MockTexture_GoPointer_Call) RunAndReturn(run func() uintptr) *MockTexture_GoPointer_Call {
12678	_c.Call.Return(run)
12679	return _c
12680}
12681
12682// 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.
12683// The first argument is typically a *testing.T value.
12684func NewMockFindController(t interface {
12685	mock.TestingT
12686	Cleanup(func())
12687}) *MockFindController {
12688	mock := &MockFindController{}
12689	mock.Mock.Test(t)
12690
12691	t.Cleanup(func() { mock.AssertExpectations(t) })
12692
12693	return mock
12694}
12695
12696// MockFindController is an autogenerated mock type for the FindController type
12697type MockFindController struct {
12698	mock.Mock
12699}
12700
12701type MockFindController_Expecter struct {
12702	mock *mock.Mock
12703}
12704
12705func (_m *MockFindController) EXPECT() *MockFindController_Expecter {
12706	return &MockFindController_Expecter{mock: &_m.Mock}
12707}
12708
12709// CountMatches provides a mock function for the type MockFindController
12710func (_mock *MockFindController) CountMatches(text string, options port.FindOptions, maxMatches uint) {
12711	_mock.Called(text, options, maxMatches)
12712	return
12713}
12714
12715// MockFindController_CountMatches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountMatches'
12716type MockFindController_CountMatches_Call struct {
12717	*mock.Call
12718}
12719
12720// CountMatches is a helper method to define mock.On call
12721//   - text string
12722//   - options port.FindOptions
12723//   - maxMatches uint
12724func (_e *MockFindController_Expecter) CountMatches(text interface{}, options interface{}, maxMatches interface{}) *MockFindController_CountMatches_Call {
12725	return &MockFindController_CountMatches_Call{Call: _e.mock.On("CountMatches", text, options, maxMatches)}
12726}
12727
12728func (_c *MockFindController_CountMatches_Call) Run(run func(text string, options port.FindOptions, maxMatches uint)) *MockFindController_CountMatches_Call {
12729	_c.Call.Run(func(args mock.Arguments) {
12730		var arg0 string
12731		if args[0] != nil {
12732			arg0 = args[0].(string)
12733		}
12734		var arg1 port.FindOptions
12735		if args[1] != nil {
12736			arg1 = args[1].(port.FindOptions)
12737		}
12738		var arg2 uint
12739		if args[2] != nil {
12740			arg2 = args[2].(uint)
12741		}
12742		run(
12743			arg0,
12744			arg1,
12745			arg2,
12746		)
12747	})
12748	return _c
12749}
12750
12751func (_c *MockFindController_CountMatches_Call) Return() *MockFindController_CountMatches_Call {
12752	_c.Call.Return()
12753	return _c
12754}
12755
12756func (_c *MockFindController_CountMatches_Call) RunAndReturn(run func(text string, options port.FindOptions, maxMatches uint)) *MockFindController_CountMatches_Call {
12757	_c.Run(run)
12758	return _c
12759}
12760
12761// DisconnectSignal provides a mock function for the type MockFindController
12762func (_mock *MockFindController) DisconnectSignal(id uint) {
12763	_mock.Called(id)
12764	return
12765}
12766
12767// MockFindController_DisconnectSignal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisconnectSignal'
12768type MockFindController_DisconnectSignal_Call struct {
12769	*mock.Call
12770}
12771
12772// DisconnectSignal is a helper method to define mock.On call
12773//   - id uint
12774func (_e *MockFindController_Expecter) DisconnectSignal(id interface{}) *MockFindController_DisconnectSignal_Call {
12775	return &MockFindController_DisconnectSignal_Call{Call: _e.mock.On("DisconnectSignal", id)}
12776}
12777
12778func (_c *MockFindController_DisconnectSignal_Call) Run(run func(id uint)) *MockFindController_DisconnectSignal_Call {
12779	_c.Call.Run(func(args mock.Arguments) {
12780		var arg0 uint
12781		if args[0] != nil {
12782			arg0 = args[0].(uint)
12783		}
12784		run(
12785			arg0,
12786		)
12787	})
12788	return _c
12789}
12790
12791func (_c *MockFindController_DisconnectSignal_Call) Return() *MockFindController_DisconnectSignal_Call {
12792	_c.Call.Return()
12793	return _c
12794}
12795
12796func (_c *MockFindController_DisconnectSignal_Call) RunAndReturn(run func(id uint)) *MockFindController_DisconnectSignal_Call {
12797	_c.Run(run)
12798	return _c
12799}
12800
12801// GetSearchText provides a mock function for the type MockFindController
12802func (_mock *MockFindController) GetSearchText() string {
12803	ret := _mock.Called()
12804
12805	if len(ret) == 0 {
12806		panic("no return value specified for GetSearchText")
12807	}
12808
12809	var r0 string
12810	if returnFunc, ok := ret.Get(0).(func() string); ok {
12811		r0 = returnFunc()
12812	} else {
12813		r0 = ret.Get(0).(string)
12814	}
12815	return r0
12816}
12817
12818// MockFindController_GetSearchText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSearchText'
12819type MockFindController_GetSearchText_Call struct {
12820	*mock.Call
12821}
12822
12823// GetSearchText is a helper method to define mock.On call
12824func (_e *MockFindController_Expecter) GetSearchText() *MockFindController_GetSearchText_Call {
12825	return &MockFindController_GetSearchText_Call{Call: _e.mock.On("GetSearchText")}
12826}
12827
12828func (_c *MockFindController_GetSearchText_Call) Run(run func()) *MockFindController_GetSearchText_Call {
12829	_c.Call.Run(func(args mock.Arguments) {
12830		run()
12831	})
12832	return _c
12833}
12834
12835func (_c *MockFindController_GetSearchText_Call) Return(s string) *MockFindController_GetSearchText_Call {
12836	_c.Call.Return(s)
12837	return _c
12838}
12839
12840func (_c *MockFindController_GetSearchText_Call) RunAndReturn(run func() string) *MockFindController_GetSearchText_Call {
12841	_c.Call.Return(run)
12842	return _c
12843}
12844
12845// OnCountedMatches provides a mock function for the type MockFindController
12846func (_mock *MockFindController) OnCountedMatches(callback func(matchCount uint)) uint {
12847	ret := _mock.Called(callback)
12848
12849	if len(ret) == 0 {
12850		panic("no return value specified for OnCountedMatches")
12851	}
12852
12853	var r0 uint
12854	if returnFunc, ok := ret.Get(0).(func(func(matchCount uint)) uint); ok {
12855		r0 = returnFunc(callback)
12856	} else {
12857		r0 = ret.Get(0).(uint)
12858	}
12859	return r0
12860}
12861
12862// MockFindController_OnCountedMatches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnCountedMatches'
12863type MockFindController_OnCountedMatches_Call struct {
12864	*mock.Call
12865}
12866
12867// OnCountedMatches is a helper method to define mock.On call
12868//   - callback func(matchCount uint)
12869func (_e *MockFindController_Expecter) OnCountedMatches(callback interface{}) *MockFindController_OnCountedMatches_Call {
12870	return &MockFindController_OnCountedMatches_Call{Call: _e.mock.On("OnCountedMatches", callback)}
12871}
12872
12873func (_c *MockFindController_OnCountedMatches_Call) Run(run func(callback func(matchCount uint))) *MockFindController_OnCountedMatches_Call {
12874	_c.Call.Run(func(args mock.Arguments) {
12875		var arg0 func(matchCount uint)
12876		if args[0] != nil {
12877			arg0 = args[0].(func(matchCount uint))
12878		}
12879		run(
12880			arg0,
12881		)
12882	})
12883	return _c
12884}
12885
12886func (_c *MockFindController_OnCountedMatches_Call) Return(v uint) *MockFindController_OnCountedMatches_Call {
12887	_c.Call.Return(v)
12888	return _c
12889}
12890
12891func (_c *MockFindController_OnCountedMatches_Call) RunAndReturn(run func(callback func(matchCount uint)) uint) *MockFindController_OnCountedMatches_Call {
12892	_c.Call.Return(run)
12893	return _c
12894}
12895
12896// OnFailedToFindText provides a mock function for the type MockFindController
12897func (_mock *MockFindController) OnFailedToFindText(callback func()) uint {
12898	ret := _mock.Called(callback)
12899
12900	if len(ret) == 0 {
12901		panic("no return value specified for OnFailedToFindText")
12902	}
12903
12904	var r0 uint
12905	if returnFunc, ok := ret.Get(0).(func(func()) uint); ok {
12906		r0 = returnFunc(callback)
12907	} else {
12908		r0 = ret.Get(0).(uint)
12909	}
12910	return r0
12911}
12912
12913// MockFindController_OnFailedToFindText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnFailedToFindText'
12914type MockFindController_OnFailedToFindText_Call struct {
12915	*mock.Call
12916}
12917
12918// OnFailedToFindText is a helper method to define mock.On call
12919//   - callback func()
12920func (_e *MockFindController_Expecter) OnFailedToFindText(callback interface{}) *MockFindController_OnFailedToFindText_Call {
12921	return &MockFindController_OnFailedToFindText_Call{Call: _e.mock.On("OnFailedToFindText", callback)}
12922}
12923
12924func (_c *MockFindController_OnFailedToFindText_Call) Run(run func(callback func())) *MockFindController_OnFailedToFindText_Call {
12925	_c.Call.Run(func(args mock.Arguments) {
12926		var arg0 func()
12927		if args[0] != nil {
12928			arg0 = args[0].(func())
12929		}
12930		run(
12931			arg0,
12932		)
12933	})
12934	return _c
12935}
12936
12937func (_c *MockFindController_OnFailedToFindText_Call) Return(v uint) *MockFindController_OnFailedToFindText_Call {
12938	_c.Call.Return(v)
12939	return _c
12940}
12941
12942func (_c *MockFindController_OnFailedToFindText_Call) RunAndReturn(run func(callback func()) uint) *MockFindController_OnFailedToFindText_Call {
12943	_c.Call.Return(run)
12944	return _c
12945}
12946
12947// OnFoundText provides a mock function for the type MockFindController
12948func (_mock *MockFindController) OnFoundText(callback func(matchCount uint)) uint {
12949	ret := _mock.Called(callback)
12950
12951	if len(ret) == 0 {
12952		panic("no return value specified for OnFoundText")
12953	}
12954
12955	var r0 uint
12956	if returnFunc, ok := ret.Get(0).(func(func(matchCount uint)) uint); ok {
12957		r0 = returnFunc(callback)
12958	} else {
12959		r0 = ret.Get(0).(uint)
12960	}
12961	return r0
12962}
12963
12964// MockFindController_OnFoundText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnFoundText'
12965type MockFindController_OnFoundText_Call struct {
12966	*mock.Call
12967}
12968
12969// OnFoundText is a helper method to define mock.On call
12970//   - callback func(matchCount uint)
12971func (_e *MockFindController_Expecter) OnFoundText(callback interface{}) *MockFindController_OnFoundText_Call {
12972	return &MockFindController_OnFoundText_Call{Call: _e.mock.On("OnFoundText", callback)}
12973}
12974
12975func (_c *MockFindController_OnFoundText_Call) Run(run func(callback func(matchCount uint))) *MockFindController_OnFoundText_Call {
12976	_c.Call.Run(func(args mock.Arguments) {
12977		var arg0 func(matchCount uint)
12978		if args[0] != nil {
12979			arg0 = args[0].(func(matchCount uint))
12980		}
12981		run(
12982			arg0,
12983		)
12984	})
12985	return _c
12986}
12987
12988func (_c *MockFindController_OnFoundText_Call) Return(v uint) *MockFindController_OnFoundText_Call {
12989	_c.Call.Return(v)
12990	return _c
12991}
12992
12993func (_c *MockFindController_OnFoundText_Call) RunAndReturn(run func(callback func(matchCount uint)) uint) *MockFindController_OnFoundText_Call {
12994	_c.Call.Return(run)
12995	return _c
12996}
12997
12998// Search provides a mock function for the type MockFindController
12999func (_mock *MockFindController) Search(text string, options port.FindOptions, maxMatches uint) {
13000	_mock.Called(text, options, maxMatches)
13001	return
13002}
13003
13004// MockFindController_Search_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Search'
13005type MockFindController_Search_Call struct {
13006	*mock.Call
13007}
13008
13009// Search is a helper method to define mock.On call
13010//   - text string
13011//   - options port.FindOptions
13012//   - maxMatches uint
13013func (_e *MockFindController_Expecter) Search(text interface{}, options interface{}, maxMatches interface{}) *MockFindController_Search_Call {
13014	return &MockFindController_Search_Call{Call: _e.mock.On("Search", text, options, maxMatches)}
13015}
13016
13017func (_c *MockFindController_Search_Call) Run(run func(text string, options port.FindOptions, maxMatches uint)) *MockFindController_Search_Call {
13018	_c.Call.Run(func(args mock.Arguments) {
13019		var arg0 string
13020		if args[0] != nil {
13021			arg0 = args[0].(string)
13022		}
13023		var arg1 port.FindOptions
13024		if args[1] != nil {
13025			arg1 = args[1].(port.FindOptions)
13026		}
13027		var arg2 uint
13028		if args[2] != nil {
13029			arg2 = args[2].(uint)
13030		}
13031		run(
13032			arg0,
13033			arg1,
13034			arg2,
13035		)
13036	})
13037	return _c
13038}
13039
13040func (_c *MockFindController_Search_Call) Return() *MockFindController_Search_Call {
13041	_c.Call.Return()
13042	return _c
13043}
13044
13045func (_c *MockFindController_Search_Call) RunAndReturn(run func(text string, options port.FindOptions, maxMatches uint)) *MockFindController_Search_Call {
13046	_c.Run(run)
13047	return _c
13048}
13049
13050// SearchFinish provides a mock function for the type MockFindController
13051func (_mock *MockFindController) SearchFinish() {
13052	_mock.Called()
13053	return
13054}
13055
13056// MockFindController_SearchFinish_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchFinish'
13057type MockFindController_SearchFinish_Call struct {
13058	*mock.Call
13059}
13060
13061// SearchFinish is a helper method to define mock.On call
13062func (_e *MockFindController_Expecter) SearchFinish() *MockFindController_SearchFinish_Call {
13063	return &MockFindController_SearchFinish_Call{Call: _e.mock.On("SearchFinish")}
13064}
13065
13066func (_c *MockFindController_SearchFinish_Call) Run(run func()) *MockFindController_SearchFinish_Call {
13067	_c.Call.Run(func(args mock.Arguments) {
13068		run()
13069	})
13070	return _c
13071}
13072
13073func (_c *MockFindController_SearchFinish_Call) Return() *MockFindController_SearchFinish_Call {
13074	_c.Call.Return()
13075	return _c
13076}
13077
13078func (_c *MockFindController_SearchFinish_Call) RunAndReturn(run func()) *MockFindController_SearchFinish_Call {
13079	_c.Run(run)
13080	return _c
13081}
13082
13083// SearchNext provides a mock function for the type MockFindController
13084func (_mock *MockFindController) SearchNext() {
13085	_mock.Called()
13086	return
13087}
13088
13089// MockFindController_SearchNext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchNext'
13090type MockFindController_SearchNext_Call struct {
13091	*mock.Call
13092}
13093
13094// SearchNext is a helper method to define mock.On call
13095func (_e *MockFindController_Expecter) SearchNext() *MockFindController_SearchNext_Call {
13096	return &MockFindController_SearchNext_Call{Call: _e.mock.On("SearchNext")}
13097}
13098
13099func (_c *MockFindController_SearchNext_Call) Run(run func()) *MockFindController_SearchNext_Call {
13100	_c.Call.Run(func(args mock.Arguments) {
13101		run()
13102	})
13103	return _c
13104}
13105
13106func (_c *MockFindController_SearchNext_Call) Return() *MockFindController_SearchNext_Call {
13107	_c.Call.Return()
13108	return _c
13109}
13110
13111func (_c *MockFindController_SearchNext_Call) RunAndReturn(run func()) *MockFindController_SearchNext_Call {
13112	_c.Run(run)
13113	return _c
13114}
13115
13116// SearchPrevious provides a mock function for the type MockFindController
13117func (_mock *MockFindController) SearchPrevious() {
13118	_mock.Called()
13119	return
13120}
13121
13122// MockFindController_SearchPrevious_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchPrevious'
13123type MockFindController_SearchPrevious_Call struct {
13124	*mock.Call
13125}
13126
13127// SearchPrevious is a helper method to define mock.On call
13128func (_e *MockFindController_Expecter) SearchPrevious() *MockFindController_SearchPrevious_Call {
13129	return &MockFindController_SearchPrevious_Call{Call: _e.mock.On("SearchPrevious")}
13130}
13131
13132func (_c *MockFindController_SearchPrevious_Call) Run(run func()) *MockFindController_SearchPrevious_Call {
13133	_c.Call.Run(func(args mock.Arguments) {
13134		run()
13135	})
13136	return _c
13137}
13138
13139func (_c *MockFindController_SearchPrevious_Call) Return() *MockFindController_SearchPrevious_Call {
13140	_c.Call.Return()
13141	return _c
13142}
13143
13144func (_c *MockFindController_SearchPrevious_Call) RunAndReturn(run func()) *MockFindController_SearchPrevious_Call {
13145	_c.Run(run)
13146	return _c
13147}
13148
13149// 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.
13150// The first argument is typically a *testing.T value.
13151func NewMockWebView(t interface {
13152	mock.TestingT
13153	Cleanup(func())
13154}) *MockWebView {
13155	mock := &MockWebView{}
13156	mock.Mock.Test(t)
13157
13158	t.Cleanup(func() { mock.AssertExpectations(t) })
13159
13160	return mock
13161}
13162
13163// MockWebView is an autogenerated mock type for the WebView type
13164type MockWebView struct {
13165	mock.Mock
13166}
13167
13168type MockWebView_Expecter struct {
13169	mock *mock.Mock
13170}
13171
13172func (_m *MockWebView) EXPECT() *MockWebView_Expecter {
13173	return &MockWebView_Expecter{mock: &_m.Mock}
13174}
13175
13176// CanGoBack provides a mock function for the type MockWebView
13177func (_mock *MockWebView) CanGoBack() bool {
13178	ret := _mock.Called()
13179
13180	if len(ret) == 0 {
13181		panic("no return value specified for CanGoBack")
13182	}
13183
13184	var r0 bool
13185	if returnFunc, ok := ret.Get(0).(func() bool); ok {
13186		r0 = returnFunc()
13187	} else {
13188		r0 = ret.Get(0).(bool)
13189	}
13190	return r0
13191}
13192
13193// MockWebView_CanGoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanGoBack'
13194type MockWebView_CanGoBack_Call struct {
13195	*mock.Call
13196}
13197
13198// CanGoBack is a helper method to define mock.On call
13199func (_e *MockWebView_Expecter) CanGoBack() *MockWebView_CanGoBack_Call {
13200	return &MockWebView_CanGoBack_Call{Call: _e.mock.On("CanGoBack")}
13201}
13202
13203func (_c *MockWebView_CanGoBack_Call) Run(run func()) *MockWebView_CanGoBack_Call {
13204	_c.Call.Run(func(args mock.Arguments) {
13205		run()
13206	})
13207	return _c
13208}
13209
13210func (_c *MockWebView_CanGoBack_Call) Return(b bool) *MockWebView_CanGoBack_Call {
13211	_c.Call.Return(b)
13212	return _c
13213}
13214
13215func (_c *MockWebView_CanGoBack_Call) RunAndReturn(run func() bool) *MockWebView_CanGoBack_Call {
13216	_c.Call.Return(run)
13217	return _c
13218}
13219
13220// CanGoForward provides a mock function for the type MockWebView
13221func (_mock *MockWebView) CanGoForward() bool {
13222	ret := _mock.Called()
13223
13224	if len(ret) == 0 {
13225		panic("no return value specified for CanGoForward")
13226	}
13227
13228	var r0 bool
13229	if returnFunc, ok := ret.Get(0).(func() bool); ok {
13230		r0 = returnFunc()
13231	} else {
13232		r0 = ret.Get(0).(bool)
13233	}
13234	return r0
13235}
13236
13237// MockWebView_CanGoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanGoForward'
13238type MockWebView_CanGoForward_Call struct {
13239	*mock.Call
13240}
13241
13242// CanGoForward is a helper method to define mock.On call
13243func (_e *MockWebView_Expecter) CanGoForward() *MockWebView_CanGoForward_Call {
13244	return &MockWebView_CanGoForward_Call{Call: _e.mock.On("CanGoForward")}
13245}
13246
13247func (_c *MockWebView_CanGoForward_Call) Run(run func()) *MockWebView_CanGoForward_Call {
13248	_c.Call.Run(func(args mock.Arguments) {
13249		run()
13250	})
13251	return _c
13252}
13253
13254func (_c *MockWebView_CanGoForward_Call) Return(b bool) *MockWebView_CanGoForward_Call {
13255	_c.Call.Return(b)
13256	return _c
13257}
13258
13259func (_c *MockWebView_CanGoForward_Call) RunAndReturn(run func() bool) *MockWebView_CanGoForward_Call {
13260	_c.Call.Return(run)
13261	return _c
13262}
13263
13264// Destroy provides a mock function for the type MockWebView
13265func (_mock *MockWebView) Destroy() {
13266	_mock.Called()
13267	return
13268}
13269
13270// MockWebView_Destroy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Destroy'
13271type MockWebView_Destroy_Call struct {
13272	*mock.Call
13273}
13274
13275// Destroy is a helper method to define mock.On call
13276func (_e *MockWebView_Expecter) Destroy() *MockWebView_Destroy_Call {
13277	return &MockWebView_Destroy_Call{Call: _e.mock.On("Destroy")}
13278}
13279
13280func (_c *MockWebView_Destroy_Call) Run(run func()) *MockWebView_Destroy_Call {
13281	_c.Call.Run(func(args mock.Arguments) {
13282		run()
13283	})
13284	return _c
13285}
13286
13287func (_c *MockWebView_Destroy_Call) Return() *MockWebView_Destroy_Call {
13288	_c.Call.Return()
13289	return _c
13290}
13291
13292func (_c *MockWebView_Destroy_Call) RunAndReturn(run func()) *MockWebView_Destroy_Call {
13293	_c.Run(run)
13294	return _c
13295}
13296
13297// EstimatedProgress provides a mock function for the type MockWebView
13298func (_mock *MockWebView) EstimatedProgress() float64 {
13299	ret := _mock.Called()
13300
13301	if len(ret) == 0 {
13302		panic("no return value specified for EstimatedProgress")
13303	}
13304
13305	var r0 float64
13306	if returnFunc, ok := ret.Get(0).(func() float64); ok {
13307		r0 = returnFunc()
13308	} else {
13309		r0 = ret.Get(0).(float64)
13310	}
13311	return r0
13312}
13313
13314// MockWebView_EstimatedProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EstimatedProgress'
13315type MockWebView_EstimatedProgress_Call struct {
13316	*mock.Call
13317}
13318
13319// EstimatedProgress is a helper method to define mock.On call
13320func (_e *MockWebView_Expecter) EstimatedProgress() *MockWebView_EstimatedProgress_Call {
13321	return &MockWebView_EstimatedProgress_Call{Call: _e.mock.On("EstimatedProgress")}
13322}
13323
13324func (_c *MockWebView_EstimatedProgress_Call) Run(run func()) *MockWebView_EstimatedProgress_Call {
13325	_c.Call.Run(func(args mock.Arguments) {
13326		run()
13327	})
13328	return _c
13329}
13330
13331func (_c *MockWebView_EstimatedProgress_Call) Return(f float64) *MockWebView_EstimatedProgress_Call {
13332	_c.Call.Return(f)
13333	return _c
13334}
13335
13336func (_c *MockWebView_EstimatedProgress_Call) RunAndReturn(run func() float64) *MockWebView_EstimatedProgress_Call {
13337	_c.Call.Return(run)
13338	return _c
13339}
13340
13341// Favicon provides a mock function for the type MockWebView
13342func (_mock *MockWebView) Favicon() port.Texture {
13343	ret := _mock.Called()
13344
13345	if len(ret) == 0 {
13346		panic("no return value specified for Favicon")
13347	}
13348
13349	var r0 port.Texture
13350	if returnFunc, ok := ret.Get(0).(func() port.Texture); ok {
13351		r0 = returnFunc()
13352	} else {
13353		if ret.Get(0) != nil {
13354			r0 = ret.Get(0).(port.Texture)
13355		}
13356	}
13357	return r0
13358}
13359
13360// MockWebView_Favicon_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Favicon'
13361type MockWebView_Favicon_Call struct {
13362	*mock.Call
13363}
13364
13365// Favicon is a helper method to define mock.On call
13366func (_e *MockWebView_Expecter) Favicon() *MockWebView_Favicon_Call {
13367	return &MockWebView_Favicon_Call{Call: _e.mock.On("Favicon")}
13368}
13369
13370func (_c *MockWebView_Favicon_Call) Run(run func()) *MockWebView_Favicon_Call {
13371	_c.Call.Run(func(args mock.Arguments) {
13372		run()
13373	})
13374	return _c
13375}
13376
13377func (_c *MockWebView_Favicon_Call) Return(texture port.Texture) *MockWebView_Favicon_Call {
13378	_c.Call.Return(texture)
13379	return _c
13380}
13381
13382func (_c *MockWebView_Favicon_Call) RunAndReturn(run func() port.Texture) *MockWebView_Favicon_Call {
13383	_c.Call.Return(run)
13384	return _c
13385}
13386
13387// Generation provides a mock function for the type MockWebView
13388func (_mock *MockWebView) Generation() uint64 {
13389	ret := _mock.Called()
13390
13391	if len(ret) == 0 {
13392		panic("no return value specified for Generation")
13393	}
13394
13395	var r0 uint64
13396	if returnFunc, ok := ret.Get(0).(func() uint64); ok {
13397		r0 = returnFunc()
13398	} else {
13399		r0 = ret.Get(0).(uint64)
13400	}
13401	return r0
13402}
13403
13404// MockWebView_Generation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Generation'
13405type MockWebView_Generation_Call struct {
13406	*mock.Call
13407}
13408
13409// Generation is a helper method to define mock.On call
13410func (_e *MockWebView_Expecter) Generation() *MockWebView_Generation_Call {
13411	return &MockWebView_Generation_Call{Call: _e.mock.On("Generation")}
13412}
13413
13414func (_c *MockWebView_Generation_Call) Run(run func()) *MockWebView_Generation_Call {
13415	_c.Call.Run(func(args mock.Arguments) {
13416		run()
13417	})
13418	return _c
13419}
13420
13421func (_c *MockWebView_Generation_Call) Return(v uint64) *MockWebView_Generation_Call {
13422	_c.Call.Return(v)
13423	return _c
13424}
13425
13426func (_c *MockWebView_Generation_Call) RunAndReturn(run func() uint64) *MockWebView_Generation_Call {
13427	_c.Call.Return(run)
13428	return _c
13429}
13430
13431// GetFindController provides a mock function for the type MockWebView
13432func (_mock *MockWebView) GetFindController() port.FindController {
13433	ret := _mock.Called()
13434
13435	if len(ret) == 0 {
13436		panic("no return value specified for GetFindController")
13437	}
13438
13439	var r0 port.FindController
13440	if returnFunc, ok := ret.Get(0).(func() port.FindController); ok {
13441		r0 = returnFunc()
13442	} else {
13443		if ret.Get(0) != nil {
13444			r0 = ret.Get(0).(port.FindController)
13445		}
13446	}
13447	return r0
13448}
13449
13450// MockWebView_GetFindController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFindController'
13451type MockWebView_GetFindController_Call struct {
13452	*mock.Call
13453}
13454
13455// GetFindController is a helper method to define mock.On call
13456func (_e *MockWebView_Expecter) GetFindController() *MockWebView_GetFindController_Call {
13457	return &MockWebView_GetFindController_Call{Call: _e.mock.On("GetFindController")}
13458}
13459
13460func (_c *MockWebView_GetFindController_Call) Run(run func()) *MockWebView_GetFindController_Call {
13461	_c.Call.Run(func(args mock.Arguments) {
13462		run()
13463	})
13464	return _c
13465}
13466
13467func (_c *MockWebView_GetFindController_Call) Return(findController port.FindController) *MockWebView_GetFindController_Call {
13468	_c.Call.Return(findController)
13469	return _c
13470}
13471
13472func (_c *MockWebView_GetFindController_Call) RunAndReturn(run func() port.FindController) *MockWebView_GetFindController_Call {
13473	_c.Call.Return(run)
13474	return _c
13475}
13476
13477// GetZoomLevel provides a mock function for the type MockWebView
13478func (_mock *MockWebView) GetZoomLevel() float64 {
13479	ret := _mock.Called()
13480
13481	if len(ret) == 0 {
13482		panic("no return value specified for GetZoomLevel")
13483	}
13484
13485	var r0 float64
13486	if returnFunc, ok := ret.Get(0).(func() float64); ok {
13487		r0 = returnFunc()
13488	} else {
13489		r0 = ret.Get(0).(float64)
13490	}
13491	return r0
13492}
13493
13494// MockWebView_GetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetZoomLevel'
13495type MockWebView_GetZoomLevel_Call struct {
13496	*mock.Call
13497}
13498
13499// GetZoomLevel is a helper method to define mock.On call
13500func (_e *MockWebView_Expecter) GetZoomLevel() *MockWebView_GetZoomLevel_Call {
13501	return &MockWebView_GetZoomLevel_Call{Call: _e.mock.On("GetZoomLevel")}
13502}
13503
13504func (_c *MockWebView_GetZoomLevel_Call) Run(run func()) *MockWebView_GetZoomLevel_Call {
13505	_c.Call.Run(func(args mock.Arguments) {
13506		run()
13507	})
13508	return _c
13509}
13510
13511func (_c *MockWebView_GetZoomLevel_Call) Return(f float64) *MockWebView_GetZoomLevel_Call {
13512	_c.Call.Return(f)
13513	return _c
13514}
13515
13516func (_c *MockWebView_GetZoomLevel_Call) RunAndReturn(run func() float64) *MockWebView_GetZoomLevel_Call {
13517	_c.Call.Return(run)
13518	return _c
13519}
13520
13521// GoBack provides a mock function for the type MockWebView
13522func (_mock *MockWebView) GoBack(ctx context.Context) error {
13523	ret := _mock.Called(ctx)
13524
13525	if len(ret) == 0 {
13526		panic("no return value specified for GoBack")
13527	}
13528
13529	var r0 error
13530	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
13531		r0 = returnFunc(ctx)
13532	} else {
13533		r0 = ret.Error(0)
13534	}
13535	return r0
13536}
13537
13538// MockWebView_GoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoBack'
13539type MockWebView_GoBack_Call struct {
13540	*mock.Call
13541}
13542
13543// GoBack is a helper method to define mock.On call
13544//   - ctx context.Context
13545func (_e *MockWebView_Expecter) GoBack(ctx interface{}) *MockWebView_GoBack_Call {
13546	return &MockWebView_GoBack_Call{Call: _e.mock.On("GoBack", ctx)}
13547}
13548
13549func (_c *MockWebView_GoBack_Call) Run(run func(ctx context.Context)) *MockWebView_GoBack_Call {
13550	_c.Call.Run(func(args mock.Arguments) {
13551		var arg0 context.Context
13552		if args[0] != nil {
13553			arg0 = args[0].(context.Context)
13554		}
13555		run(
13556			arg0,
13557		)
13558	})
13559	return _c
13560}
13561
13562func (_c *MockWebView_GoBack_Call) Return(err error) *MockWebView_GoBack_Call {
13563	_c.Call.Return(err)
13564	return _c
13565}
13566
13567func (_c *MockWebView_GoBack_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_GoBack_Call {
13568	_c.Call.Return(run)
13569	return _c
13570}
13571
13572// GoForward provides a mock function for the type MockWebView
13573func (_mock *MockWebView) GoForward(ctx context.Context) error {
13574	ret := _mock.Called(ctx)
13575
13576	if len(ret) == 0 {
13577		panic("no return value specified for GoForward")
13578	}
13579
13580	var r0 error
13581	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
13582		r0 = returnFunc(ctx)
13583	} else {
13584		r0 = ret.Error(0)
13585	}
13586	return r0
13587}
13588
13589// MockWebView_GoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoForward'
13590type MockWebView_GoForward_Call struct {
13591	*mock.Call
13592}
13593
13594// GoForward is a helper method to define mock.On call
13595//   - ctx context.Context
13596func (_e *MockWebView_Expecter) GoForward(ctx interface{}) *MockWebView_GoForward_Call {
13597	return &MockWebView_GoForward_Call{Call: _e.mock.On("GoForward", ctx)}
13598}
13599
13600func (_c *MockWebView_GoForward_Call) Run(run func(ctx context.Context)) *MockWebView_GoForward_Call {
13601	_c.Call.Run(func(args mock.Arguments) {
13602		var arg0 context.Context
13603		if args[0] != nil {
13604			arg0 = args[0].(context.Context)
13605		}
13606		run(
13607			arg0,
13608		)
13609	})
13610	return _c
13611}
13612
13613func (_c *MockWebView_GoForward_Call) Return(err error) *MockWebView_GoForward_Call {
13614	_c.Call.Return(err)
13615	return _c
13616}
13617
13618func (_c *MockWebView_GoForward_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_GoForward_Call {
13619	_c.Call.Return(run)
13620	return _c
13621}
13622
13623// ID provides a mock function for the type MockWebView
13624func (_mock *MockWebView) ID() port.WebViewID {
13625	ret := _mock.Called()
13626
13627	if len(ret) == 0 {
13628		panic("no return value specified for ID")
13629	}
13630
13631	var r0 port.WebViewID
13632	if returnFunc, ok := ret.Get(0).(func() port.WebViewID); ok {
13633		r0 = returnFunc()
13634	} else {
13635		r0 = ret.Get(0).(port.WebViewID)
13636	}
13637	return r0
13638}
13639
13640// MockWebView_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID'
13641type MockWebView_ID_Call struct {
13642	*mock.Call
13643}
13644
13645// ID is a helper method to define mock.On call
13646func (_e *MockWebView_Expecter) ID() *MockWebView_ID_Call {
13647	return &MockWebView_ID_Call{Call: _e.mock.On("ID")}
13648}
13649
13650func (_c *MockWebView_ID_Call) Run(run func()) *MockWebView_ID_Call {
13651	_c.Call.Run(func(args mock.Arguments) {
13652		run()
13653	})
13654	return _c
13655}
13656
13657func (_c *MockWebView_ID_Call) Return(webViewID port.WebViewID) *MockWebView_ID_Call {
13658	_c.Call.Return(webViewID)
13659	return _c
13660}
13661
13662func (_c *MockWebView_ID_Call) RunAndReturn(run func() port.WebViewID) *MockWebView_ID_Call {
13663	_c.Call.Return(run)
13664	return _c
13665}
13666
13667// IsDestroyed provides a mock function for the type MockWebView
13668func (_mock *MockWebView) IsDestroyed() bool {
13669	ret := _mock.Called()
13670
13671	if len(ret) == 0 {
13672		panic("no return value specified for IsDestroyed")
13673	}
13674
13675	var r0 bool
13676	if returnFunc, ok := ret.Get(0).(func() bool); ok {
13677		r0 = returnFunc()
13678	} else {
13679		r0 = ret.Get(0).(bool)
13680	}
13681	return r0
13682}
13683
13684// MockWebView_IsDestroyed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsDestroyed'
13685type MockWebView_IsDestroyed_Call struct {
13686	*mock.Call
13687}
13688
13689// IsDestroyed is a helper method to define mock.On call
13690func (_e *MockWebView_Expecter) IsDestroyed() *MockWebView_IsDestroyed_Call {
13691	return &MockWebView_IsDestroyed_Call{Call: _e.mock.On("IsDestroyed")}
13692}
13693
13694func (_c *MockWebView_IsDestroyed_Call) Run(run func()) *MockWebView_IsDestroyed_Call {
13695	_c.Call.Run(func(args mock.Arguments) {
13696		run()
13697	})
13698	return _c
13699}
13700
13701func (_c *MockWebView_IsDestroyed_Call) Return(b bool) *MockWebView_IsDestroyed_Call {
13702	_c.Call.Return(b)
13703	return _c
13704}
13705
13706func (_c *MockWebView_IsDestroyed_Call) RunAndReturn(run func() bool) *MockWebView_IsDestroyed_Call {
13707	_c.Call.Return(run)
13708	return _c
13709}
13710
13711// IsFullscreen provides a mock function for the type MockWebView
13712func (_mock *MockWebView) IsFullscreen() bool {
13713	ret := _mock.Called()
13714
13715	if len(ret) == 0 {
13716		panic("no return value specified for IsFullscreen")
13717	}
13718
13719	var r0 bool
13720	if returnFunc, ok := ret.Get(0).(func() bool); ok {
13721		r0 = returnFunc()
13722	} else {
13723		r0 = ret.Get(0).(bool)
13724	}
13725	return r0
13726}
13727
13728// MockWebView_IsFullscreen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsFullscreen'
13729type MockWebView_IsFullscreen_Call struct {
13730	*mock.Call
13731}
13732
13733// IsFullscreen is a helper method to define mock.On call
13734func (_e *MockWebView_Expecter) IsFullscreen() *MockWebView_IsFullscreen_Call {
13735	return &MockWebView_IsFullscreen_Call{Call: _e.mock.On("IsFullscreen")}
13736}
13737
13738func (_c *MockWebView_IsFullscreen_Call) Run(run func()) *MockWebView_IsFullscreen_Call {
13739	_c.Call.Run(func(args mock.Arguments) {
13740		run()
13741	})
13742	return _c
13743}
13744
13745func (_c *MockWebView_IsFullscreen_Call) Return(b bool) *MockWebView_IsFullscreen_Call {
13746	_c.Call.Return(b)
13747	return _c
13748}
13749
13750func (_c *MockWebView_IsFullscreen_Call) RunAndReturn(run func() bool) *MockWebView_IsFullscreen_Call {
13751	_c.Call.Return(run)
13752	return _c
13753}
13754
13755// IsLoading provides a mock function for the type MockWebView
13756func (_mock *MockWebView) IsLoading() bool {
13757	ret := _mock.Called()
13758
13759	if len(ret) == 0 {
13760		panic("no return value specified for IsLoading")
13761	}
13762
13763	var r0 bool
13764	if returnFunc, ok := ret.Get(0).(func() bool); ok {
13765		r0 = returnFunc()
13766	} else {
13767		r0 = ret.Get(0).(bool)
13768	}
13769	return r0
13770}
13771
13772// MockWebView_IsLoading_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsLoading'
13773type MockWebView_IsLoading_Call struct {
13774	*mock.Call
13775}
13776
13777// IsLoading is a helper method to define mock.On call
13778func (_e *MockWebView_Expecter) IsLoading() *MockWebView_IsLoading_Call {
13779	return &MockWebView_IsLoading_Call{Call: _e.mock.On("IsLoading")}
13780}
13781
13782func (_c *MockWebView_IsLoading_Call) Run(run func()) *MockWebView_IsLoading_Call {
13783	_c.Call.Run(func(args mock.Arguments) {
13784		run()
13785	})
13786	return _c
13787}
13788
13789func (_c *MockWebView_IsLoading_Call) Return(b bool) *MockWebView_IsLoading_Call {
13790	_c.Call.Return(b)
13791	return _c
13792}
13793
13794func (_c *MockWebView_IsLoading_Call) RunAndReturn(run func() bool) *MockWebView_IsLoading_Call {
13795	_c.Call.Return(run)
13796	return _c
13797}
13798
13799// IsPlayingAudio provides a mock function for the type MockWebView
13800func (_mock *MockWebView) IsPlayingAudio() bool {
13801	ret := _mock.Called()
13802
13803	if len(ret) == 0 {
13804		panic("no return value specified for IsPlayingAudio")
13805	}
13806
13807	var r0 bool
13808	if returnFunc, ok := ret.Get(0).(func() bool); ok {
13809		r0 = returnFunc()
13810	} else {
13811		r0 = ret.Get(0).(bool)
13812	}
13813	return r0
13814}
13815
13816// MockWebView_IsPlayingAudio_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsPlayingAudio'
13817type MockWebView_IsPlayingAudio_Call struct {
13818	*mock.Call
13819}
13820
13821// IsPlayingAudio is a helper method to define mock.On call
13822func (_e *MockWebView_Expecter) IsPlayingAudio() *MockWebView_IsPlayingAudio_Call {
13823	return &MockWebView_IsPlayingAudio_Call{Call: _e.mock.On("IsPlayingAudio")}
13824}
13825
13826func (_c *MockWebView_IsPlayingAudio_Call) Run(run func()) *MockWebView_IsPlayingAudio_Call {
13827	_c.Call.Run(func(args mock.Arguments) {
13828		run()
13829	})
13830	return _c
13831}
13832
13833func (_c *MockWebView_IsPlayingAudio_Call) Return(b bool) *MockWebView_IsPlayingAudio_Call {
13834	_c.Call.Return(b)
13835	return _c
13836}
13837
13838func (_c *MockWebView_IsPlayingAudio_Call) RunAndReturn(run func() bool) *MockWebView_IsPlayingAudio_Call {
13839	_c.Call.Return(run)
13840	return _c
13841}
13842
13843// LoadHTML provides a mock function for the type MockWebView
13844func (_mock *MockWebView) LoadHTML(ctx context.Context, content string, baseURI string) error {
13845	ret := _mock.Called(ctx, content, baseURI)
13846
13847	if len(ret) == 0 {
13848		panic("no return value specified for LoadHTML")
13849	}
13850
13851	var r0 error
13852	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
13853		r0 = returnFunc(ctx, content, baseURI)
13854	} else {
13855		r0 = ret.Error(0)
13856	}
13857	return r0
13858}
13859
13860// MockWebView_LoadHTML_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadHTML'
13861type MockWebView_LoadHTML_Call struct {
13862	*mock.Call
13863}
13864
13865// LoadHTML is a helper method to define mock.On call
13866//   - ctx context.Context
13867//   - content string
13868//   - baseURI string
13869func (_e *MockWebView_Expecter) LoadHTML(ctx interface{}, content interface{}, baseURI interface{}) *MockWebView_LoadHTML_Call {
13870	return &MockWebView_LoadHTML_Call{Call: _e.mock.On("LoadHTML", ctx, content, baseURI)}
13871}
13872
13873func (_c *MockWebView_LoadHTML_Call) Run(run func(ctx context.Context, content string, baseURI string)) *MockWebView_LoadHTML_Call {
13874	_c.Call.Run(func(args mock.Arguments) {
13875		var arg0 context.Context
13876		if args[0] != nil {
13877			arg0 = args[0].(context.Context)
13878		}
13879		var arg1 string
13880		if args[1] != nil {
13881			arg1 = args[1].(string)
13882		}
13883		var arg2 string
13884		if args[2] != nil {
13885			arg2 = args[2].(string)
13886		}
13887		run(
13888			arg0,
13889			arg1,
13890			arg2,
13891		)
13892	})
13893	return _c
13894}
13895
13896func (_c *MockWebView_LoadHTML_Call) Return(err error) *MockWebView_LoadHTML_Call {
13897	_c.Call.Return(err)
13898	return _c
13899}
13900
13901func (_c *MockWebView_LoadHTML_Call) RunAndReturn(run func(ctx context.Context, content string, baseURI string) error) *MockWebView_LoadHTML_Call {
13902	_c.Call.Return(run)
13903	return _c
13904}
13905
13906// LoadURI provides a mock function for the type MockWebView
13907func (_mock *MockWebView) LoadURI(ctx context.Context, uri string) error {
13908	ret := _mock.Called(ctx, uri)
13909
13910	if len(ret) == 0 {
13911		panic("no return value specified for LoadURI")
13912	}
13913
13914	var r0 error
13915	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
13916		r0 = returnFunc(ctx, uri)
13917	} else {
13918		r0 = ret.Error(0)
13919	}
13920	return r0
13921}
13922
13923// MockWebView_LoadURI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadURI'
13924type MockWebView_LoadURI_Call struct {
13925	*mock.Call
13926}
13927
13928// LoadURI is a helper method to define mock.On call
13929//   - ctx context.Context
13930//   - uri string
13931func (_e *MockWebView_Expecter) LoadURI(ctx interface{}, uri interface{}) *MockWebView_LoadURI_Call {
13932	return &MockWebView_LoadURI_Call{Call: _e.mock.On("LoadURI", ctx, uri)}
13933}
13934
13935func (_c *MockWebView_LoadURI_Call) Run(run func(ctx context.Context, uri string)) *MockWebView_LoadURI_Call {
13936	_c.Call.Run(func(args mock.Arguments) {
13937		var arg0 context.Context
13938		if args[0] != nil {
13939			arg0 = args[0].(context.Context)
13940		}
13941		var arg1 string
13942		if args[1] != nil {
13943			arg1 = args[1].(string)
13944		}
13945		run(
13946			arg0,
13947			arg1,
13948		)
13949	})
13950	return _c
13951}
13952
13953func (_c *MockWebView_LoadURI_Call) Return(err error) *MockWebView_LoadURI_Call {
13954	_c.Call.Return(err)
13955	return _c
13956}
13957
13958func (_c *MockWebView_LoadURI_Call) RunAndReturn(run func(ctx context.Context, uri string) error) *MockWebView_LoadURI_Call {
13959	_c.Call.Return(run)
13960	return _c
13961}
13962
13963// Reload provides a mock function for the type MockWebView
13964func (_mock *MockWebView) Reload(ctx context.Context) error {
13965	ret := _mock.Called(ctx)
13966
13967	if len(ret) == 0 {
13968		panic("no return value specified for Reload")
13969	}
13970
13971	var r0 error
13972	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
13973		r0 = returnFunc(ctx)
13974	} else {
13975		r0 = ret.Error(0)
13976	}
13977	return r0
13978}
13979
13980// MockWebView_Reload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reload'
13981type MockWebView_Reload_Call struct {
13982	*mock.Call
13983}
13984
13985// Reload is a helper method to define mock.On call
13986//   - ctx context.Context
13987func (_e *MockWebView_Expecter) Reload(ctx interface{}) *MockWebView_Reload_Call {
13988	return &MockWebView_Reload_Call{Call: _e.mock.On("Reload", ctx)}
13989}
13990
13991func (_c *MockWebView_Reload_Call) Run(run func(ctx context.Context)) *MockWebView_Reload_Call {
13992	_c.Call.Run(func(args mock.Arguments) {
13993		var arg0 context.Context
13994		if args[0] != nil {
13995			arg0 = args[0].(context.Context)
13996		}
13997		run(
13998			arg0,
13999		)
14000	})
14001	return _c
14002}
14003
14004func (_c *MockWebView_Reload_Call) Return(err error) *MockWebView_Reload_Call {
14005	_c.Call.Return(err)
14006	return _c
14007}
14008
14009func (_c *MockWebView_Reload_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_Reload_Call {
14010	_c.Call.Return(run)
14011	return _c
14012}
14013
14014// ReloadBypassCache provides a mock function for the type MockWebView
14015func (_mock *MockWebView) ReloadBypassCache(ctx context.Context) error {
14016	ret := _mock.Called(ctx)
14017
14018	if len(ret) == 0 {
14019		panic("no return value specified for ReloadBypassCache")
14020	}
14021
14022	var r0 error
14023	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
14024		r0 = returnFunc(ctx)
14025	} else {
14026		r0 = ret.Error(0)
14027	}
14028	return r0
14029}
14030
14031// MockWebView_ReloadBypassCache_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReloadBypassCache'
14032type MockWebView_ReloadBypassCache_Call struct {
14033	*mock.Call
14034}
14035
14036// ReloadBypassCache is a helper method to define mock.On call
14037//   - ctx context.Context
14038func (_e *MockWebView_Expecter) ReloadBypassCache(ctx interface{}) *MockWebView_ReloadBypassCache_Call {
14039	return &MockWebView_ReloadBypassCache_Call{Call: _e.mock.On("ReloadBypassCache", ctx)}
14040}
14041
14042func (_c *MockWebView_ReloadBypassCache_Call) Run(run func(ctx context.Context)) *MockWebView_ReloadBypassCache_Call {
14043	_c.Call.Run(func(args mock.Arguments) {
14044		var arg0 context.Context
14045		if args[0] != nil {
14046			arg0 = args[0].(context.Context)
14047		}
14048		run(
14049			arg0,
14050		)
14051	})
14052	return _c
14053}
14054
14055func (_c *MockWebView_ReloadBypassCache_Call) Return(err error) *MockWebView_ReloadBypassCache_Call {
14056	_c.Call.Return(err)
14057	return _c
14058}
14059
14060func (_c *MockWebView_ReloadBypassCache_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_ReloadBypassCache_Call {
14061	_c.Call.Return(run)
14062	return _c
14063}
14064
14065// ResetBackgroundToDefault provides a mock function for the type MockWebView
14066func (_mock *MockWebView) ResetBackgroundToDefault() {
14067	_mock.Called()
14068	return
14069}
14070
14071// MockWebView_ResetBackgroundToDefault_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetBackgroundToDefault'
14072type MockWebView_ResetBackgroundToDefault_Call struct {
14073	*mock.Call
14074}
14075
14076// ResetBackgroundToDefault is a helper method to define mock.On call
14077func (_e *MockWebView_Expecter) ResetBackgroundToDefault() *MockWebView_ResetBackgroundToDefault_Call {
14078	return &MockWebView_ResetBackgroundToDefault_Call{Call: _e.mock.On("ResetBackgroundToDefault")}
14079}
14080
14081func (_c *MockWebView_ResetBackgroundToDefault_Call) Run(run func()) *MockWebView_ResetBackgroundToDefault_Call {
14082	_c.Call.Run(func(args mock.Arguments) {
14083		run()
14084	})
14085	return _c
14086}
14087
14088func (_c *MockWebView_ResetBackgroundToDefault_Call) Return() *MockWebView_ResetBackgroundToDefault_Call {
14089	_c.Call.Return()
14090	return _c
14091}
14092
14093func (_c *MockWebView_ResetBackgroundToDefault_Call) RunAndReturn(run func()) *MockWebView_ResetBackgroundToDefault_Call {
14094	_c.Run(run)
14095	return _c
14096}
14097
14098// RunJavaScript provides a mock function for the type MockWebView
14099func (_mock *MockWebView) RunJavaScript(ctx context.Context, script string) {
14100	_mock.Called(ctx, script)
14101	return
14102}
14103
14104// MockWebView_RunJavaScript_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunJavaScript'
14105type MockWebView_RunJavaScript_Call struct {
14106	*mock.Call
14107}
14108
14109// RunJavaScript is a helper method to define mock.On call
14110//   - ctx context.Context
14111//   - script string
14112func (_e *MockWebView_Expecter) RunJavaScript(ctx interface{}, script interface{}) *MockWebView_RunJavaScript_Call {
14113	return &MockWebView_RunJavaScript_Call{Call: _e.mock.On("RunJavaScript", ctx, script)}
14114}
14115
14116func (_c *MockWebView_RunJavaScript_Call) Run(run func(ctx context.Context, script string)) *MockWebView_RunJavaScript_Call {
14117	_c.Call.Run(func(args mock.Arguments) {
14118		var arg0 context.Context
14119		if args[0] != nil {
14120			arg0 = args[0].(context.Context)
14121		}
14122		var arg1 string
14123		if args[1] != nil {
14124			arg1 = args[1].(string)
14125		}
14126		run(
14127			arg0,
14128			arg1,
14129		)
14130	})
14131	return _c
14132}
14133
14134func (_c *MockWebView_RunJavaScript_Call) Return() *MockWebView_RunJavaScript_Call {
14135	_c.Call.Return()
14136	return _c
14137}
14138
14139func (_c *MockWebView_RunJavaScript_Call) RunAndReturn(run func(ctx context.Context, script string)) *MockWebView_RunJavaScript_Call {
14140	_c.Run(run)
14141	return _c
14142}
14143
14144// SetBackgroundColor provides a mock function for the type MockWebView
14145func (_mock *MockWebView) SetBackgroundColor(r float64, g float64, b float64, a float64) {
14146	_mock.Called(r, g, b, a)
14147	return
14148}
14149
14150// MockWebView_SetBackgroundColor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetBackgroundColor'
14151type MockWebView_SetBackgroundColor_Call struct {
14152	*mock.Call
14153}
14154
14155// SetBackgroundColor is a helper method to define mock.On call
14156//   - r float64
14157//   - g float64
14158//   - b float64
14159//   - a float64
14160func (_e *MockWebView_Expecter) SetBackgroundColor(r interface{}, g interface{}, b interface{}, a interface{}) *MockWebView_SetBackgroundColor_Call {
14161	return &MockWebView_SetBackgroundColor_Call{Call: _e.mock.On("SetBackgroundColor", r, g, b, a)}
14162}
14163
14164func (_c *MockWebView_SetBackgroundColor_Call) Run(run func(r float64, g float64, b float64, a float64)) *MockWebView_SetBackgroundColor_Call {
14165	_c.Call.Run(func(args mock.Arguments) {
14166		var arg0 float64
14167		if args[0] != nil {
14168			arg0 = args[0].(float64)
14169		}
14170		var arg1 float64
14171		if args[1] != nil {
14172			arg1 = args[1].(float64)
14173		}
14174		var arg2 float64
14175		if args[2] != nil {
14176			arg2 = args[2].(float64)
14177		}
14178		var arg3 float64
14179		if args[3] != nil {
14180			arg3 = args[3].(float64)
14181		}
14182		run(
14183			arg0,
14184			arg1,
14185			arg2,
14186			arg3,
14187		)
14188	})
14189	return _c
14190}
14191
14192func (_c *MockWebView_SetBackgroundColor_Call) Return() *MockWebView_SetBackgroundColor_Call {
14193	_c.Call.Return()
14194	return _c
14195}
14196
14197func (_c *MockWebView_SetBackgroundColor_Call) RunAndReturn(run func(r float64, g float64, b float64, a float64)) *MockWebView_SetBackgroundColor_Call {
14198	_c.Run(run)
14199	return _c
14200}
14201
14202// SetCallbacks provides a mock function for the type MockWebView
14203func (_mock *MockWebView) SetCallbacks(callbacks *port.WebViewCallbacks) {
14204	_mock.Called(callbacks)
14205	return
14206}
14207
14208// MockWebView_SetCallbacks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCallbacks'
14209type MockWebView_SetCallbacks_Call struct {
14210	*mock.Call
14211}
14212
14213// SetCallbacks is a helper method to define mock.On call
14214//   - callbacks *port.WebViewCallbacks
14215func (_e *MockWebView_Expecter) SetCallbacks(callbacks interface{}) *MockWebView_SetCallbacks_Call {
14216	return &MockWebView_SetCallbacks_Call{Call: _e.mock.On("SetCallbacks", callbacks)}
14217}
14218
14219func (_c *MockWebView_SetCallbacks_Call) Run(run func(callbacks *port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
14220	_c.Call.Run(func(args mock.Arguments) {
14221		var arg0 *port.WebViewCallbacks
14222		if args[0] != nil {
14223			arg0 = args[0].(*port.WebViewCallbacks)
14224		}
14225		run(
14226			arg0,
14227		)
14228	})
14229	return _c
14230}
14231
14232func (_c *MockWebView_SetCallbacks_Call) Return() *MockWebView_SetCallbacks_Call {
14233	_c.Call.Return()
14234	return _c
14235}
14236
14237func (_c *MockWebView_SetCallbacks_Call) RunAndReturn(run func(callbacks *port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
14238	_c.Run(run)
14239	return _c
14240}
14241
14242// SetZoomLevel provides a mock function for the type MockWebView
14243func (_mock *MockWebView) SetZoomLevel(ctx context.Context, level float64) error {
14244	ret := _mock.Called(ctx, level)
14245
14246	if len(ret) == 0 {
14247		panic("no return value specified for SetZoomLevel")
14248	}
14249
14250	var r0 error
14251	if returnFunc, ok := ret.Get(0).(func(context.Context, float64) error); ok {
14252		r0 = returnFunc(ctx, level)
14253	} else {
14254		r0 = ret.Error(0)
14255	}
14256	return r0
14257}
14258
14259// MockWebView_SetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetZoomLevel'
14260type MockWebView_SetZoomLevel_Call struct {
14261	*mock.Call
14262}
14263
14264// SetZoomLevel is a helper method to define mock.On call
14265//   - ctx context.Context
14266//   - level float64
14267func (_e *MockWebView_Expecter) SetZoomLevel(ctx interface{}, level interface{}) *MockWebView_SetZoomLevel_Call {
14268	return &MockWebView_SetZoomLevel_Call{Call: _e.mock.On("SetZoomLevel", ctx, level)}
14269}
14270
14271func (_c *MockWebView_SetZoomLevel_Call) Run(run func(ctx context.Context, level float64)) *MockWebView_SetZoomLevel_Call {
14272	_c.Call.Run(func(args mock.Arguments) {
14273		var arg0 context.Context
14274		if args[0] != nil {
14275			arg0 = args[0].(context.Context)
14276		}
14277		var arg1 float64
14278		if args[1] != nil {
14279			arg1 = args[1].(float64)
14280		}
14281		run(
14282			arg0,
14283			arg1,
14284		)
14285	})
14286	return _c
14287}
14288
14289func (_c *MockWebView_SetZoomLevel_Call) Return(err error) *MockWebView_SetZoomLevel_Call {
14290	_c.Call.Return(err)
14291	return _c
14292}
14293
14294func (_c *MockWebView_SetZoomLevel_Call) RunAndReturn(run func(ctx context.Context, level float64) error) *MockWebView_SetZoomLevel_Call {
14295	_c.Call.Return(run)
14296	return _c
14297}
14298
14299// State provides a mock function for the type MockWebView
14300func (_mock *MockWebView) State() port.WebViewState {
14301	ret := _mock.Called()
14302
14303	if len(ret) == 0 {
14304		panic("no return value specified for State")
14305	}
14306
14307	var r0 port.WebViewState
14308	if returnFunc, ok := ret.Get(0).(func() port.WebViewState); ok {
14309		r0 = returnFunc()
14310	} else {
14311		r0 = ret.Get(0).(port.WebViewState)
14312	}
14313	return r0
14314}
14315
14316// MockWebView_State_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'State'
14317type MockWebView_State_Call struct {
14318	*mock.Call
14319}
14320
14321// State is a helper method to define mock.On call
14322func (_e *MockWebView_Expecter) State() *MockWebView_State_Call {
14323	return &MockWebView_State_Call{Call: _e.mock.On("State")}
14324}
14325
14326func (_c *MockWebView_State_Call) Run(run func()) *MockWebView_State_Call {
14327	_c.Call.Run(func(args mock.Arguments) {
14328		run()
14329	})
14330	return _c
14331}
14332
14333func (_c *MockWebView_State_Call) Return(webViewState port.WebViewState) *MockWebView_State_Call {
14334	_c.Call.Return(webViewState)
14335	return _c
14336}
14337
14338func (_c *MockWebView_State_Call) RunAndReturn(run func() port.WebViewState) *MockWebView_State_Call {
14339	_c.Call.Return(run)
14340	return _c
14341}
14342
14343// Stop provides a mock function for the type MockWebView
14344func (_mock *MockWebView) Stop(ctx context.Context) error {
14345	ret := _mock.Called(ctx)
14346
14347	if len(ret) == 0 {
14348		panic("no return value specified for Stop")
14349	}
14350
14351	var r0 error
14352	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
14353		r0 = returnFunc(ctx)
14354	} else {
14355		r0 = ret.Error(0)
14356	}
14357	return r0
14358}
14359
14360// MockWebView_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
14361type MockWebView_Stop_Call struct {
14362	*mock.Call
14363}
14364
14365// Stop is a helper method to define mock.On call
14366//   - ctx context.Context
14367func (_e *MockWebView_Expecter) Stop(ctx interface{}) *MockWebView_Stop_Call {
14368	return &MockWebView_Stop_Call{Call: _e.mock.On("Stop", ctx)}
14369}
14370
14371func (_c *MockWebView_Stop_Call) Run(run func(ctx context.Context)) *MockWebView_Stop_Call {
14372	_c.Call.Run(func(args mock.Arguments) {
14373		var arg0 context.Context
14374		if args[0] != nil {
14375			arg0 = args[0].(context.Context)
14376		}
14377		run(
14378			arg0,
14379		)
14380	})
14381	return _c
14382}
14383
14384func (_c *MockWebView_Stop_Call) Return(err error) *MockWebView_Stop_Call {
14385	_c.Call.Return(err)
14386	return _c
14387}
14388
14389func (_c *MockWebView_Stop_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_Stop_Call {
14390	_c.Call.Return(run)
14391	return _c
14392}
14393
14394// Title provides a mock function for the type MockWebView
14395func (_mock *MockWebView) Title() string {
14396	ret := _mock.Called()
14397
14398	if len(ret) == 0 {
14399		panic("no return value specified for Title")
14400	}
14401
14402	var r0 string
14403	if returnFunc, ok := ret.Get(0).(func() string); ok {
14404		r0 = returnFunc()
14405	} else {
14406		r0 = ret.Get(0).(string)
14407	}
14408	return r0
14409}
14410
14411// MockWebView_Title_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Title'
14412type MockWebView_Title_Call struct {
14413	*mock.Call
14414}
14415
14416// Title is a helper method to define mock.On call
14417func (_e *MockWebView_Expecter) Title() *MockWebView_Title_Call {
14418	return &MockWebView_Title_Call{Call: _e.mock.On("Title")}
14419}
14420
14421func (_c *MockWebView_Title_Call) Run(run func()) *MockWebView_Title_Call {
14422	_c.Call.Run(func(args mock.Arguments) {
14423		run()
14424	})
14425	return _c
14426}
14427
14428func (_c *MockWebView_Title_Call) Return(s string) *MockWebView_Title_Call {
14429	_c.Call.Return(s)
14430	return _c
14431}
14432
14433func (_c *MockWebView_Title_Call) RunAndReturn(run func() string) *MockWebView_Title_Call {
14434	_c.Call.Return(run)
14435	return _c
14436}
14437
14438// URI provides a mock function for the type MockWebView
14439func (_mock *MockWebView) URI() string {
14440	ret := _mock.Called()
14441
14442	if len(ret) == 0 {
14443		panic("no return value specified for URI")
14444	}
14445
14446	var r0 string
14447	if returnFunc, ok := ret.Get(0).(func() string); ok {
14448		r0 = returnFunc()
14449	} else {
14450		r0 = ret.Get(0).(string)
14451	}
14452	return r0
14453}
14454
14455// MockWebView_URI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'URI'
14456type MockWebView_URI_Call struct {
14457	*mock.Call
14458}
14459
14460// URI is a helper method to define mock.On call
14461func (_e *MockWebView_Expecter) URI() *MockWebView_URI_Call {
14462	return &MockWebView_URI_Call{Call: _e.mock.On("URI")}
14463}
14464
14465func (_c *MockWebView_URI_Call) Run(run func()) *MockWebView_URI_Call {
14466	_c.Call.Run(func(args mock.Arguments) {
14467		run()
14468	})
14469	return _c
14470}
14471
14472func (_c *MockWebView_URI_Call) Return(s string) *MockWebView_URI_Call {
14473	_c.Call.Return(s)
14474	return _c
14475}
14476
14477func (_c *MockWebView_URI_Call) RunAndReturn(run func() string) *MockWebView_URI_Call {
14478	_c.Call.Return(run)
14479	return _c
14480}
14481
14482// 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.
14483// The first argument is typically a *testing.T value.
14484func NewMockWebViewPool(t interface {
14485	mock.TestingT
14486	Cleanup(func())
14487}) *MockWebViewPool {
14488	mock := &MockWebViewPool{}
14489	mock.Mock.Test(t)
14490
14491	t.Cleanup(func() { mock.AssertExpectations(t) })
14492
14493	return mock
14494}
14495
14496// MockWebViewPool is an autogenerated mock type for the WebViewPool type
14497type MockWebViewPool struct {
14498	mock.Mock
14499}
14500
14501type MockWebViewPool_Expecter struct {
14502	mock *mock.Mock
14503}
14504
14505func (_m *MockWebViewPool) EXPECT() *MockWebViewPool_Expecter {
14506	return &MockWebViewPool_Expecter{mock: &_m.Mock}
14507}
14508
14509// Acquire provides a mock function for the type MockWebViewPool
14510func (_mock *MockWebViewPool) Acquire(ctx context.Context) (port.WebView, error) {
14511	ret := _mock.Called(ctx)
14512
14513	if len(ret) == 0 {
14514		panic("no return value specified for Acquire")
14515	}
14516
14517	var r0 port.WebView
14518	var r1 error
14519	if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
14520		return returnFunc(ctx)
14521	}
14522	if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
14523		r0 = returnFunc(ctx)
14524	} else {
14525		if ret.Get(0) != nil {
14526			r0 = ret.Get(0).(port.WebView)
14527		}
14528	}
14529	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
14530		r1 = returnFunc(ctx)
14531	} else {
14532		r1 = ret.Error(1)
14533	}
14534	return r0, r1
14535}
14536
14537// MockWebViewPool_Acquire_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Acquire'
14538type MockWebViewPool_Acquire_Call struct {
14539	*mock.Call
14540}
14541
14542// Acquire is a helper method to define mock.On call
14543//   - ctx context.Context
14544func (_e *MockWebViewPool_Expecter) Acquire(ctx interface{}) *MockWebViewPool_Acquire_Call {
14545	return &MockWebViewPool_Acquire_Call{Call: _e.mock.On("Acquire", ctx)}
14546}
14547
14548func (_c *MockWebViewPool_Acquire_Call) Run(run func(ctx context.Context)) *MockWebViewPool_Acquire_Call {
14549	_c.Call.Run(func(args mock.Arguments) {
14550		var arg0 context.Context
14551		if args[0] != nil {
14552			arg0 = args[0].(context.Context)
14553		}
14554		run(
14555			arg0,
14556		)
14557	})
14558	return _c
14559}
14560
14561func (_c *MockWebViewPool_Acquire_Call) Return(webView port.WebView, err error) *MockWebViewPool_Acquire_Call {
14562	_c.Call.Return(webView, err)
14563	return _c
14564}
14565
14566func (_c *MockWebViewPool_Acquire_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) *MockWebViewPool_Acquire_Call {
14567	_c.Call.Return(run)
14568	return _c
14569}
14570
14571// Close provides a mock function for the type MockWebViewPool
14572func (_mock *MockWebViewPool) Close() {
14573	_mock.Called()
14574	return
14575}
14576
14577// MockWebViewPool_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
14578type MockWebViewPool_Close_Call struct {
14579	*mock.Call
14580}
14581
14582// Close is a helper method to define mock.On call
14583func (_e *MockWebViewPool_Expecter) Close() *MockWebViewPool_Close_Call {
14584	return &MockWebViewPool_Close_Call{Call: _e.mock.On("Close")}
14585}
14586
14587func (_c *MockWebViewPool_Close_Call) Run(run func()) *MockWebViewPool_Close_Call {
14588	_c.Call.Run(func(args mock.Arguments) {
14589		run()
14590	})
14591	return _c
14592}
14593
14594func (_c *MockWebViewPool_Close_Call) Return() *MockWebViewPool_Close_Call {
14595	_c.Call.Return()
14596	return _c
14597}
14598
14599func (_c *MockWebViewPool_Close_Call) RunAndReturn(run func()) *MockWebViewPool_Close_Call {
14600	_c.Run(run)
14601	return _c
14602}
14603
14604// Prewarm provides a mock function for the type MockWebViewPool
14605func (_mock *MockWebViewPool) Prewarm(count int) {
14606	_mock.Called(count)
14607	return
14608}
14609
14610// MockWebViewPool_Prewarm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Prewarm'
14611type MockWebViewPool_Prewarm_Call struct {
14612	*mock.Call
14613}
14614
14615// Prewarm is a helper method to define mock.On call
14616//   - count int
14617func (_e *MockWebViewPool_Expecter) Prewarm(count interface{}) *MockWebViewPool_Prewarm_Call {
14618	return &MockWebViewPool_Prewarm_Call{Call: _e.mock.On("Prewarm", count)}
14619}
14620
14621func (_c *MockWebViewPool_Prewarm_Call) Run(run func(count int)) *MockWebViewPool_Prewarm_Call {
14622	_c.Call.Run(func(args mock.Arguments) {
14623		var arg0 int
14624		if args[0] != nil {
14625			arg0 = args[0].(int)
14626		}
14627		run(
14628			arg0,
14629		)
14630	})
14631	return _c
14632}
14633
14634func (_c *MockWebViewPool_Prewarm_Call) Return() *MockWebViewPool_Prewarm_Call {
14635	_c.Call.Return()
14636	return _c
14637}
14638
14639func (_c *MockWebViewPool_Prewarm_Call) RunAndReturn(run func(count int)) *MockWebViewPool_Prewarm_Call {
14640	_c.Run(run)
14641	return _c
14642}
14643
14644// PrewarmAsync provides a mock function for the type MockWebViewPool
14645func (_mock *MockWebViewPool) PrewarmAsync(ctx context.Context, count int) {
14646	_mock.Called(ctx, count)
14647	return
14648}
14649
14650// MockWebViewPool_PrewarmAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrewarmAsync'
14651type MockWebViewPool_PrewarmAsync_Call struct {
14652	*mock.Call
14653}
14654
14655// PrewarmAsync is a helper method to define mock.On call
14656//   - ctx context.Context
14657//   - count int
14658func (_e *MockWebViewPool_Expecter) PrewarmAsync(ctx interface{}, count interface{}) *MockWebViewPool_PrewarmAsync_Call {
14659	return &MockWebViewPool_PrewarmAsync_Call{Call: _e.mock.On("PrewarmAsync", ctx, count)}
14660}
14661
14662func (_c *MockWebViewPool_PrewarmAsync_Call) Run(run func(ctx context.Context, count int)) *MockWebViewPool_PrewarmAsync_Call {
14663	_c.Call.Run(func(args mock.Arguments) {
14664		var arg0 context.Context
14665		if args[0] != nil {
14666			arg0 = args[0].(context.Context)
14667		}
14668		var arg1 int
14669		if args[1] != nil {
14670			arg1 = args[1].(int)
14671		}
14672		run(
14673			arg0,
14674			arg1,
14675		)
14676	})
14677	return _c
14678}
14679
14680func (_c *MockWebViewPool_PrewarmAsync_Call) Return() *MockWebViewPool_PrewarmAsync_Call {
14681	_c.Call.Return()
14682	return _c
14683}
14684
14685func (_c *MockWebViewPool_PrewarmAsync_Call) RunAndReturn(run func(ctx context.Context, count int)) *MockWebViewPool_PrewarmAsync_Call {
14686	_c.Run(run)
14687	return _c
14688}
14689
14690// Release provides a mock function for the type MockWebViewPool
14691func (_mock *MockWebViewPool) Release(wv port.WebView) {
14692	_mock.Called(wv)
14693	return
14694}
14695
14696// MockWebViewPool_Release_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Release'
14697type MockWebViewPool_Release_Call struct {
14698	*mock.Call
14699}
14700
14701// Release is a helper method to define mock.On call
14702//   - wv port.WebView
14703func (_e *MockWebViewPool_Expecter) Release(wv interface{}) *MockWebViewPool_Release_Call {
14704	return &MockWebViewPool_Release_Call{Call: _e.mock.On("Release", wv)}
14705}
14706
14707func (_c *MockWebViewPool_Release_Call) Run(run func(wv port.WebView)) *MockWebViewPool_Release_Call {
14708	_c.Call.Run(func(args mock.Arguments) {
14709		var arg0 port.WebView
14710		if args[0] != nil {
14711			arg0 = args[0].(port.WebView)
14712		}
14713		run(
14714			arg0,
14715		)
14716	})
14717	return _c
14718}
14719
14720func (_c *MockWebViewPool_Release_Call) Return() *MockWebViewPool_Release_Call {
14721	_c.Call.Return()
14722	return _c
14723}
14724
14725func (_c *MockWebViewPool_Release_Call) RunAndReturn(run func(wv port.WebView)) *MockWebViewPool_Release_Call {
14726	_c.Run(run)
14727	return _c
14728}
14729
14730// Size provides a mock function for the type MockWebViewPool
14731func (_mock *MockWebViewPool) Size() int {
14732	ret := _mock.Called()
14733
14734	if len(ret) == 0 {
14735		panic("no return value specified for Size")
14736	}
14737
14738	var r0 int
14739	if returnFunc, ok := ret.Get(0).(func() int); ok {
14740		r0 = returnFunc()
14741	} else {
14742		r0 = ret.Get(0).(int)
14743	}
14744	return r0
14745}
14746
14747// MockWebViewPool_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size'
14748type MockWebViewPool_Size_Call struct {
14749	*mock.Call
14750}
14751
14752// Size is a helper method to define mock.On call
14753func (_e *MockWebViewPool_Expecter) Size() *MockWebViewPool_Size_Call {
14754	return &MockWebViewPool_Size_Call{Call: _e.mock.On("Size")}
14755}
14756
14757func (_c *MockWebViewPool_Size_Call) Run(run func()) *MockWebViewPool_Size_Call {
14758	_c.Call.Run(func(args mock.Arguments) {
14759		run()
14760	})
14761	return _c
14762}
14763
14764func (_c *MockWebViewPool_Size_Call) Return(n int) *MockWebViewPool_Size_Call {
14765	_c.Call.Return(n)
14766	return _c
14767}
14768
14769func (_c *MockWebViewPool_Size_Call) RunAndReturn(run func() int) *MockWebViewPool_Size_Call {
14770	_c.Call.Return(run)
14771	return _c
14772}
14773
14774// 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.
14775// The first argument is typically a *testing.T value.
14776func NewMockWebViewFactory(t interface {
14777	mock.TestingT
14778	Cleanup(func())
14779}) *MockWebViewFactory {
14780	mock := &MockWebViewFactory{}
14781	mock.Mock.Test(t)
14782
14783	t.Cleanup(func() { mock.AssertExpectations(t) })
14784
14785	return mock
14786}
14787
14788// MockWebViewFactory is an autogenerated mock type for the WebViewFactory type
14789type MockWebViewFactory struct {
14790	mock.Mock
14791}
14792
14793type MockWebViewFactory_Expecter struct {
14794	mock *mock.Mock
14795}
14796
14797func (_m *MockWebViewFactory) EXPECT() *MockWebViewFactory_Expecter {
14798	return &MockWebViewFactory_Expecter{mock: &_m.Mock}
14799}
14800
14801// Create provides a mock function for the type MockWebViewFactory
14802func (_mock *MockWebViewFactory) Create(ctx context.Context) (port.WebView, error) {
14803	ret := _mock.Called(ctx)
14804
14805	if len(ret) == 0 {
14806		panic("no return value specified for Create")
14807	}
14808
14809	var r0 port.WebView
14810	var r1 error
14811	if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
14812		return returnFunc(ctx)
14813	}
14814	if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
14815		r0 = returnFunc(ctx)
14816	} else {
14817		if ret.Get(0) != nil {
14818			r0 = ret.Get(0).(port.WebView)
14819		}
14820	}
14821	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
14822		r1 = returnFunc(ctx)
14823	} else {
14824		r1 = ret.Error(1)
14825	}
14826	return r0, r1
14827}
14828
14829// MockWebViewFactory_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
14830type MockWebViewFactory_Create_Call struct {
14831	*mock.Call
14832}
14833
14834// Create is a helper method to define mock.On call
14835//   - ctx context.Context
14836func (_e *MockWebViewFactory_Expecter) Create(ctx interface{}) *MockWebViewFactory_Create_Call {
14837	return &MockWebViewFactory_Create_Call{Call: _e.mock.On("Create", ctx)}
14838}
14839
14840func (_c *MockWebViewFactory_Create_Call) Run(run func(ctx context.Context)) *MockWebViewFactory_Create_Call {
14841	_c.Call.Run(func(args mock.Arguments) {
14842		var arg0 context.Context
14843		if args[0] != nil {
14844			arg0 = args[0].(context.Context)
14845		}
14846		run(
14847			arg0,
14848		)
14849	})
14850	return _c
14851}
14852
14853func (_c *MockWebViewFactory_Create_Call) Return(webView port.WebView, err error) *MockWebViewFactory_Create_Call {
14854	_c.Call.Return(webView, err)
14855	return _c
14856}
14857
14858func (_c *MockWebViewFactory_Create_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) *MockWebViewFactory_Create_Call {
14859	_c.Call.Return(run)
14860	return _c
14861}
14862
14863// CreateRelated provides a mock function for the type MockWebViewFactory
14864func (_mock *MockWebViewFactory) CreateRelated(ctx context.Context, parentID port.WebViewID) (port.WebView, error) {
14865	ret := _mock.Called(ctx, parentID)
14866
14867	if len(ret) == 0 {
14868		panic("no return value specified for CreateRelated")
14869	}
14870
14871	var r0 port.WebView
14872	var r1 error
14873	if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) (port.WebView, error)); ok {
14874		return returnFunc(ctx, parentID)
14875	}
14876	if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) port.WebView); ok {
14877		r0 = returnFunc(ctx, parentID)
14878	} else {
14879		if ret.Get(0) != nil {
14880			r0 = ret.Get(0).(port.WebView)
14881		}
14882	}
14883	if returnFunc, ok := ret.Get(1).(func(context.Context, port.WebViewID) error); ok {
14884		r1 = returnFunc(ctx, parentID)
14885	} else {
14886		r1 = ret.Error(1)
14887	}
14888	return r0, r1
14889}
14890
14891// MockWebViewFactory_CreateRelated_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRelated'
14892type MockWebViewFactory_CreateRelated_Call struct {
14893	*mock.Call
14894}
14895
14896// CreateRelated is a helper method to define mock.On call
14897//   - ctx context.Context
14898//   - parentID port.WebViewID
14899func (_e *MockWebViewFactory_Expecter) CreateRelated(ctx interface{}, parentID interface{}) *MockWebViewFactory_CreateRelated_Call {
14900	return &MockWebViewFactory_CreateRelated_Call{Call: _e.mock.On("CreateRelated", ctx, parentID)}
14901}
14902
14903func (_c *MockWebViewFactory_CreateRelated_Call) Run(run func(ctx context.Context, parentID port.WebViewID)) *MockWebViewFactory_CreateRelated_Call {
14904	_c.Call.Run(func(args mock.Arguments) {
14905		var arg0 context.Context
14906		if args[0] != nil {
14907			arg0 = args[0].(context.Context)
14908		}
14909		var arg1 port.WebViewID
14910		if args[1] != nil {
14911			arg1 = args[1].(port.WebViewID)
14912		}
14913		run(
14914			arg0,
14915			arg1,
14916		)
14917	})
14918	return _c
14919}
14920
14921func (_c *MockWebViewFactory_CreateRelated_Call) Return(webView port.WebView, err error) *MockWebViewFactory_CreateRelated_Call {
14922	_c.Call.Return(webView, err)
14923	return _c
14924}
14925
14926func (_c *MockWebViewFactory_CreateRelated_Call) RunAndReturn(run func(ctx context.Context, parentID port.WebViewID) (port.WebView, error)) *MockWebViewFactory_CreateRelated_Call {
14927	_c.Call.Return(run)
14928	return _c
14929}
14930
14931// 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.
14932// The first argument is typically a *testing.T value.
14933func NewMockDevToolsOpener(t interface {
14934	mock.TestingT
14935	Cleanup(func())
14936}) *MockDevToolsOpener {
14937	mock := &MockDevToolsOpener{}
14938	mock.Mock.Test(t)
14939
14940	t.Cleanup(func() { mock.AssertExpectations(t) })
14941
14942	return mock
14943}
14944
14945// MockDevToolsOpener is an autogenerated mock type for the DevToolsOpener type
14946type MockDevToolsOpener struct {
14947	mock.Mock
14948}
14949
14950type MockDevToolsOpener_Expecter struct {
14951	mock *mock.Mock
14952}
14953
14954func (_m *MockDevToolsOpener) EXPECT() *MockDevToolsOpener_Expecter {
14955	return &MockDevToolsOpener_Expecter{mock: &_m.Mock}
14956}
14957
14958// OpenDevTools provides a mock function for the type MockDevToolsOpener
14959func (_mock *MockDevToolsOpener) OpenDevTools() {
14960	_mock.Called()
14961	return
14962}
14963
14964// MockDevToolsOpener_OpenDevTools_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenDevTools'
14965type MockDevToolsOpener_OpenDevTools_Call struct {
14966	*mock.Call
14967}
14968
14969// OpenDevTools is a helper method to define mock.On call
14970func (_e *MockDevToolsOpener_Expecter) OpenDevTools() *MockDevToolsOpener_OpenDevTools_Call {
14971	return &MockDevToolsOpener_OpenDevTools_Call{Call: _e.mock.On("OpenDevTools")}
14972}
14973
14974func (_c *MockDevToolsOpener_OpenDevTools_Call) Run(run func()) *MockDevToolsOpener_OpenDevTools_Call {
14975	_c.Call.Run(func(args mock.Arguments) {
14976		run()
14977	})
14978	return _c
14979}
14980
14981func (_c *MockDevToolsOpener_OpenDevTools_Call) Return() *MockDevToolsOpener_OpenDevTools_Call {
14982	_c.Call.Return()
14983	return _c
14984}
14985
14986func (_c *MockDevToolsOpener_OpenDevTools_Call) RunAndReturn(run func()) *MockDevToolsOpener_OpenDevTools_Call {
14987	_c.Run(run)
14988	return _c
14989}
14990
14991// 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.
14992// The first argument is typically a *testing.T value.
14993func NewMockPrinter(t interface {
14994	mock.TestingT
14995	Cleanup(func())
14996}) *MockPrinter {
14997	mock := &MockPrinter{}
14998	mock.Mock.Test(t)
14999
15000	t.Cleanup(func() { mock.AssertExpectations(t) })
15001
15002	return mock
15003}
15004
15005// MockPrinter is an autogenerated mock type for the Printer type
15006type MockPrinter struct {
15007	mock.Mock
15008}
15009
15010type MockPrinter_Expecter struct {
15011	mock *mock.Mock
15012}
15013
15014func (_m *MockPrinter) EXPECT() *MockPrinter_Expecter {
15015	return &MockPrinter_Expecter{mock: &_m.Mock}
15016}
15017
15018// PrintPage provides a mock function for the type MockPrinter
15019func (_mock *MockPrinter) PrintPage() {
15020	_mock.Called()
15021	return
15022}
15023
15024// MockPrinter_PrintPage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrintPage'
15025type MockPrinter_PrintPage_Call struct {
15026	*mock.Call
15027}
15028
15029// PrintPage is a helper method to define mock.On call
15030func (_e *MockPrinter_Expecter) PrintPage() *MockPrinter_PrintPage_Call {
15031	return &MockPrinter_PrintPage_Call{Call: _e.mock.On("PrintPage")}
15032}
15033
15034func (_c *MockPrinter_PrintPage_Call) Run(run func()) *MockPrinter_PrintPage_Call {
15035	_c.Call.Run(func(args mock.Arguments) {
15036		run()
15037	})
15038	return _c
15039}
15040
15041func (_c *MockPrinter_PrintPage_Call) Return() *MockPrinter_PrintPage_Call {
15042	_c.Call.Return()
15043	return _c
15044}
15045
15046func (_c *MockPrinter_PrintPage_Call) RunAndReturn(run func()) *MockPrinter_PrintPage_Call {
15047	_c.Run(run)
15048	return _c
15049}
15050
15051// 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.
15052// The first argument is typically a *testing.T value.
15053func NewMockPopupLifecycleCapable(t interface {
15054	mock.TestingT
15055	Cleanup(func())
15056}) *MockPopupLifecycleCapable {
15057	mock := &MockPopupLifecycleCapable{}
15058	mock.Mock.Test(t)
15059
15060	t.Cleanup(func() { mock.AssertExpectations(t) })
15061
15062	return mock
15063}
15064
15065// MockPopupLifecycleCapable is an autogenerated mock type for the PopupLifecycleCapable type
15066type MockPopupLifecycleCapable struct {
15067	mock.Mock
15068}
15069
15070type MockPopupLifecycleCapable_Expecter struct {
15071	mock *mock.Mock
15072}
15073
15074func (_m *MockPopupLifecycleCapable) EXPECT() *MockPopupLifecycleCapable_Expecter {
15075	return &MockPopupLifecycleCapable_Expecter{mock: &_m.Mock}
15076}
15077
15078// PrimePopupNavigation provides a mock function for the type MockPopupLifecycleCapable
15079func (_mock *MockPopupLifecycleCapable) PrimePopupNavigation(uri string) {
15080	_mock.Called(uri)
15081	return
15082}
15083
15084// MockPopupLifecycleCapable_PrimePopupNavigation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrimePopupNavigation'
15085type MockPopupLifecycleCapable_PrimePopupNavigation_Call struct {
15086	*mock.Call
15087}
15088
15089// PrimePopupNavigation is a helper method to define mock.On call
15090//   - uri string
15091func (_e *MockPopupLifecycleCapable_Expecter) PrimePopupNavigation(uri interface{}) *MockPopupLifecycleCapable_PrimePopupNavigation_Call {
15092	return &MockPopupLifecycleCapable_PrimePopupNavigation_Call{Call: _e.mock.On("PrimePopupNavigation", uri)}
15093}
15094
15095func (_c *MockPopupLifecycleCapable_PrimePopupNavigation_Call) Run(run func(uri string)) *MockPopupLifecycleCapable_PrimePopupNavigation_Call {
15096	_c.Call.Run(func(args mock.Arguments) {
15097		var arg0 string
15098		if args[0] != nil {
15099			arg0 = args[0].(string)
15100		}
15101		run(
15102			arg0,
15103		)
15104	})
15105	return _c
15106}
15107
15108func (_c *MockPopupLifecycleCapable_PrimePopupNavigation_Call) Return() *MockPopupLifecycleCapable_PrimePopupNavigation_Call {
15109	_c.Call.Return()
15110	return _c
15111}
15112
15113func (_c *MockPopupLifecycleCapable_PrimePopupNavigation_Call) RunAndReturn(run func(uri string)) *MockPopupLifecycleCapable_PrimePopupNavigation_Call {
15114	_c.Run(run)
15115	return _c
15116}
15117
15118// SetOnClose provides a mock function for the type MockPopupLifecycleCapable
15119func (_mock *MockPopupLifecycleCapable) SetOnClose(fn func()) {
15120	_mock.Called(fn)
15121	return
15122}
15123
15124// MockPopupLifecycleCapable_SetOnClose_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetOnClose'
15125type MockPopupLifecycleCapable_SetOnClose_Call struct {
15126	*mock.Call
15127}
15128
15129// SetOnClose is a helper method to define mock.On call
15130//   - fn func()
15131func (_e *MockPopupLifecycleCapable_Expecter) SetOnClose(fn interface{}) *MockPopupLifecycleCapable_SetOnClose_Call {
15132	return &MockPopupLifecycleCapable_SetOnClose_Call{Call: _e.mock.On("SetOnClose", fn)}
15133}
15134
15135func (_c *MockPopupLifecycleCapable_SetOnClose_Call) Run(run func(fn func())) *MockPopupLifecycleCapable_SetOnClose_Call {
15136	_c.Call.Run(func(args mock.Arguments) {
15137		var arg0 func()
15138		if args[0] != nil {
15139			arg0 = args[0].(func())
15140		}
15141		run(
15142			arg0,
15143		)
15144	})
15145	return _c
15146}
15147
15148func (_c *MockPopupLifecycleCapable_SetOnClose_Call) Return() *MockPopupLifecycleCapable_SetOnClose_Call {
15149	_c.Call.Return()
15150	return _c
15151}
15152
15153func (_c *MockPopupLifecycleCapable_SetOnClose_Call) RunAndReturn(run func(fn func())) *MockPopupLifecycleCapable_SetOnClose_Call {
15154	_c.Run(run)
15155	return _c
15156}
15157
15158// SetOnReadyToShow provides a mock function for the type MockPopupLifecycleCapable
15159func (_mock *MockPopupLifecycleCapable) SetOnReadyToShow(fn func()) {
15160	_mock.Called(fn)
15161	return
15162}
15163
15164// MockPopupLifecycleCapable_SetOnReadyToShow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetOnReadyToShow'
15165type MockPopupLifecycleCapable_SetOnReadyToShow_Call struct {
15166	*mock.Call
15167}
15168
15169// SetOnReadyToShow is a helper method to define mock.On call
15170//   - fn func()
15171func (_e *MockPopupLifecycleCapable_Expecter) SetOnReadyToShow(fn interface{}) *MockPopupLifecycleCapable_SetOnReadyToShow_Call {
15172	return &MockPopupLifecycleCapable_SetOnReadyToShow_Call{Call: _e.mock.On("SetOnReadyToShow", fn)}
15173}
15174
15175func (_c *MockPopupLifecycleCapable_SetOnReadyToShow_Call) Run(run func(fn func())) *MockPopupLifecycleCapable_SetOnReadyToShow_Call {
15176	_c.Call.Run(func(args mock.Arguments) {
15177		var arg0 func()
15178		if args[0] != nil {
15179			arg0 = args[0].(func())
15180		}
15181		run(
15182			arg0,
15183		)
15184	})
15185	return _c
15186}
15187
15188func (_c *MockPopupLifecycleCapable_SetOnReadyToShow_Call) Return() *MockPopupLifecycleCapable_SetOnReadyToShow_Call {
15189	_c.Call.Return()
15190	return _c
15191}
15192
15193func (_c *MockPopupLifecycleCapable_SetOnReadyToShow_Call) RunAndReturn(run func(fn func())) *MockPopupLifecycleCapable_SetOnReadyToShow_Call {
15194	_c.Run(run)
15195	return _c
15196}
15197
15198// Show provides a mock function for the type MockPopupLifecycleCapable
15199func (_mock *MockPopupLifecycleCapable) Show() {
15200	_mock.Called()
15201	return
15202}
15203
15204// MockPopupLifecycleCapable_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
15205type MockPopupLifecycleCapable_Show_Call struct {
15206	*mock.Call
15207}
15208
15209// Show is a helper method to define mock.On call
15210func (_e *MockPopupLifecycleCapable_Expecter) Show() *MockPopupLifecycleCapable_Show_Call {
15211	return &MockPopupLifecycleCapable_Show_Call{Call: _e.mock.On("Show")}
15212}
15213
15214func (_c *MockPopupLifecycleCapable_Show_Call) Run(run func()) *MockPopupLifecycleCapable_Show_Call {
15215	_c.Call.Run(func(args mock.Arguments) {
15216		run()
15217	})
15218	return _c
15219}
15220
15221func (_c *MockPopupLifecycleCapable_Show_Call) Return() *MockPopupLifecycleCapable_Show_Call {
15222	_c.Call.Return()
15223	return _c
15224}
15225
15226func (_c *MockPopupLifecycleCapable_Show_Call) RunAndReturn(run func()) *MockPopupLifecycleCapable_Show_Call {
15227	_c.Run(run)
15228	return _c
15229}
15230
15231// 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.
15232// The first argument is typically a *testing.T value.
15233func NewMockPopupOpenerCapable(t interface {
15234	mock.TestingT
15235	Cleanup(func())
15236}) *MockPopupOpenerCapable {
15237	mock := &MockPopupOpenerCapable{}
15238	mock.Mock.Test(t)
15239
15240	t.Cleanup(func() { mock.AssertExpectations(t) })
15241
15242	return mock
15243}
15244
15245// MockPopupOpenerCapable is an autogenerated mock type for the PopupOpenerCapable type
15246type MockPopupOpenerCapable struct {
15247	mock.Mock
15248}
15249
15250type MockPopupOpenerCapable_Expecter struct {
15251	mock *mock.Mock
15252}
15253
15254func (_m *MockPopupOpenerCapable) EXPECT() *MockPopupOpenerCapable_Expecter {
15255	return &MockPopupOpenerCapable_Expecter{mock: &_m.Mock}
15256}
15257
15258// AddOpenerMessageCallback provides a mock function for the type MockPopupOpenerCapable
15259func (_mock *MockPopupOpenerCapable) AddOpenerMessageCallback(fn func()) {
15260	_mock.Called(fn)
15261	return
15262}
15263
15264// MockPopupOpenerCapable_AddOpenerMessageCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddOpenerMessageCallback'
15265type MockPopupOpenerCapable_AddOpenerMessageCallback_Call struct {
15266	*mock.Call
15267}
15268
15269// AddOpenerMessageCallback is a helper method to define mock.On call
15270//   - fn func()
15271func (_e *MockPopupOpenerCapable_Expecter) AddOpenerMessageCallback(fn interface{}) *MockPopupOpenerCapable_AddOpenerMessageCallback_Call {
15272	return &MockPopupOpenerCapable_AddOpenerMessageCallback_Call{Call: _e.mock.On("AddOpenerMessageCallback", fn)}
15273}
15274
15275func (_c *MockPopupOpenerCapable_AddOpenerMessageCallback_Call) Run(run func(fn func())) *MockPopupOpenerCapable_AddOpenerMessageCallback_Call {
15276	_c.Call.Run(func(args mock.Arguments) {
15277		var arg0 func()
15278		if args[0] != nil {
15279			arg0 = args[0].(func())
15280		}
15281		run(
15282			arg0,
15283		)
15284	})
15285	return _c
15286}
15287
15288func (_c *MockPopupOpenerCapable_AddOpenerMessageCallback_Call) Return() *MockPopupOpenerCapable_AddOpenerMessageCallback_Call {
15289	_c.Call.Return()
15290	return _c
15291}
15292
15293func (_c *MockPopupOpenerCapable_AddOpenerMessageCallback_Call) RunAndReturn(run func(fn func())) *MockPopupOpenerCapable_AddOpenerMessageCallback_Call {
15294	_c.Run(run)
15295	return _c
15296}
15297
15298// AddOpenerNavigationCallback provides a mock function for the type MockPopupOpenerCapable
15299func (_mock *MockPopupOpenerCapable) AddOpenerNavigationCallback(fn func(uri string)) {
15300	_mock.Called(fn)
15301	return
15302}
15303
15304// MockPopupOpenerCapable_AddOpenerNavigationCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddOpenerNavigationCallback'
15305type MockPopupOpenerCapable_AddOpenerNavigationCallback_Call struct {
15306	*mock.Call
15307}
15308
15309// AddOpenerNavigationCallback is a helper method to define mock.On call
15310//   - fn func(uri string)
15311func (_e *MockPopupOpenerCapable_Expecter) AddOpenerNavigationCallback(fn interface{}) *MockPopupOpenerCapable_AddOpenerNavigationCallback_Call {
15312	return &MockPopupOpenerCapable_AddOpenerNavigationCallback_Call{Call: _e.mock.On("AddOpenerNavigationCallback", fn)}
15313}
15314
15315func (_c *MockPopupOpenerCapable_AddOpenerNavigationCallback_Call) Run(run func(fn func(uri string))) *MockPopupOpenerCapable_AddOpenerNavigationCallback_Call {
15316	_c.Call.Run(func(args mock.Arguments) {
15317		var arg0 func(uri string)
15318		if args[0] != nil {
15319			arg0 = args[0].(func(uri string))
15320		}
15321		run(
15322			arg0,
15323		)
15324	})
15325	return _c
15326}
15327
15328func (_c *MockPopupOpenerCapable_AddOpenerNavigationCallback_Call) Return() *MockPopupOpenerCapable_AddOpenerNavigationCallback_Call {
15329	_c.Call.Return()
15330	return _c
15331}
15332
15333func (_c *MockPopupOpenerCapable_AddOpenerNavigationCallback_Call) RunAndReturn(run func(fn func(uri string))) *MockPopupOpenerCapable_AddOpenerNavigationCallback_Call {
15334	_c.Run(run)
15335	return _c
15336}
15337
15338// EnablePopupOpenerBridge provides a mock function for the type MockPopupOpenerCapable
15339func (_mock *MockPopupOpenerCapable) EnablePopupOpenerBridge(parent port.WebView, noJavaScriptAccess bool) {
15340	_mock.Called(parent, noJavaScriptAccess)
15341	return
15342}
15343
15344// MockPopupOpenerCapable_EnablePopupOpenerBridge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnablePopupOpenerBridge'
15345type MockPopupOpenerCapable_EnablePopupOpenerBridge_Call struct {
15346	*mock.Call
15347}
15348
15349// EnablePopupOpenerBridge is a helper method to define mock.On call
15350//   - parent port.WebView
15351//   - noJavaScriptAccess bool
15352func (_e *MockPopupOpenerCapable_Expecter) EnablePopupOpenerBridge(parent interface{}, noJavaScriptAccess interface{}) *MockPopupOpenerCapable_EnablePopupOpenerBridge_Call {
15353	return &MockPopupOpenerCapable_EnablePopupOpenerBridge_Call{Call: _e.mock.On("EnablePopupOpenerBridge", parent, noJavaScriptAccess)}
15354}
15355
15356func (_c *MockPopupOpenerCapable_EnablePopupOpenerBridge_Call) Run(run func(parent port.WebView, noJavaScriptAccess bool)) *MockPopupOpenerCapable_EnablePopupOpenerBridge_Call {
15357	_c.Call.Run(func(args mock.Arguments) {
15358		var arg0 port.WebView
15359		if args[0] != nil {
15360			arg0 = args[0].(port.WebView)
15361		}
15362		var arg1 bool
15363		if args[1] != nil {
15364			arg1 = args[1].(bool)
15365		}
15366		run(
15367			arg0,
15368			arg1,
15369		)
15370	})
15371	return _c
15372}
15373
15374func (_c *MockPopupOpenerCapable_EnablePopupOpenerBridge_Call) Return() *MockPopupOpenerCapable_EnablePopupOpenerBridge_Call {
15375	_c.Call.Return()
15376	return _c
15377}
15378
15379func (_c *MockPopupOpenerCapable_EnablePopupOpenerBridge_Call) RunAndReturn(run func(parent port.WebView, noJavaScriptAccess bool)) *MockPopupOpenerCapable_EnablePopupOpenerBridge_Call {
15380	_c.Run(run)
15381	return _c
15382}
15383
15384// HasActivePopupOpenerBridge provides a mock function for the type MockPopupOpenerCapable
15385func (_mock *MockPopupOpenerCapable) HasActivePopupOpenerBridge() bool {
15386	ret := _mock.Called()
15387
15388	if len(ret) == 0 {
15389		panic("no return value specified for HasActivePopupOpenerBridge")
15390	}
15391
15392	var r0 bool
15393	if returnFunc, ok := ret.Get(0).(func() bool); ok {
15394		r0 = returnFunc()
15395	} else {
15396		r0 = ret.Get(0).(bool)
15397	}
15398	return r0
15399}
15400
15401// MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasActivePopupOpenerBridge'
15402type MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call struct {
15403	*mock.Call
15404}
15405
15406// HasActivePopupOpenerBridge is a helper method to define mock.On call
15407func (_e *MockPopupOpenerCapable_Expecter) HasActivePopupOpenerBridge() *MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call {
15408	return &MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call{Call: _e.mock.On("HasActivePopupOpenerBridge")}
15409}
15410
15411func (_c *MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call) Run(run func()) *MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call {
15412	_c.Call.Run(func(args mock.Arguments) {
15413		run()
15414	})
15415	return _c
15416}
15417
15418func (_c *MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call) Return(b bool) *MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call {
15419	_c.Call.Return(b)
15420	return _c
15421}
15422
15423func (_c *MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call) RunAndReturn(run func() bool) *MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call {
15424	_c.Call.Return(run)
15425	return _c
15426}
15427
15428// 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.
15429// The first argument is typically a *testing.T value.
15430func NewMockOAuthCallbackCapable(t interface {
15431	mock.TestingT
15432	Cleanup(func())
15433}) *MockOAuthCallbackCapable {
15434	mock := &MockOAuthCallbackCapable{}
15435	mock.Mock.Test(t)
15436
15437	t.Cleanup(func() { mock.AssertExpectations(t) })
15438
15439	return mock
15440}
15441
15442// MockOAuthCallbackCapable is an autogenerated mock type for the OAuthCallbackCapable type
15443type MockOAuthCallbackCapable struct {
15444	mock.Mock
15445}
15446
15447type MockOAuthCallbackCapable_Expecter struct {
15448	mock *mock.Mock
15449}
15450
15451func (_m *MockOAuthCallbackCapable) EXPECT() *MockOAuthCallbackCapable_Expecter {
15452	return &MockOAuthCallbackCapable_Expecter{mock: &_m.Mock}
15453}
15454
15455// AddCloseCallback provides a mock function for the type MockOAuthCallbackCapable
15456func (_mock *MockOAuthCallbackCapable) AddCloseCallback(fn func()) {
15457	_mock.Called(fn)
15458	return
15459}
15460
15461// MockOAuthCallbackCapable_AddCloseCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCloseCallback'
15462type MockOAuthCallbackCapable_AddCloseCallback_Call struct {
15463	*mock.Call
15464}
15465
15466// AddCloseCallback is a helper method to define mock.On call
15467//   - fn func()
15468func (_e *MockOAuthCallbackCapable_Expecter) AddCloseCallback(fn interface{}) *MockOAuthCallbackCapable_AddCloseCallback_Call {
15469	return &MockOAuthCallbackCapable_AddCloseCallback_Call{Call: _e.mock.On("AddCloseCallback", fn)}
15470}
15471
15472func (_c *MockOAuthCallbackCapable_AddCloseCallback_Call) Run(run func(fn func())) *MockOAuthCallbackCapable_AddCloseCallback_Call {
15473	_c.Call.Run(func(args mock.Arguments) {
15474		var arg0 func()
15475		if args[0] != nil {
15476			arg0 = args[0].(func())
15477		}
15478		run(
15479			arg0,
15480		)
15481	})
15482	return _c
15483}
15484
15485func (_c *MockOAuthCallbackCapable_AddCloseCallback_Call) Return() *MockOAuthCallbackCapable_AddCloseCallback_Call {
15486	_c.Call.Return()
15487	return _c
15488}
15489
15490func (_c *MockOAuthCallbackCapable_AddCloseCallback_Call) RunAndReturn(run func(fn func())) *MockOAuthCallbackCapable_AddCloseCallback_Call {
15491	_c.Run(run)
15492	return _c
15493}
15494
15495// AddNavigationCallback provides a mock function for the type MockOAuthCallbackCapable
15496func (_mock *MockOAuthCallbackCapable) AddNavigationCallback(fn func(uri string)) {
15497	_mock.Called(fn)
15498	return
15499}
15500
15501// MockOAuthCallbackCapable_AddNavigationCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddNavigationCallback'
15502type MockOAuthCallbackCapable_AddNavigationCallback_Call struct {
15503	*mock.Call
15504}
15505
15506// AddNavigationCallback is a helper method to define mock.On call
15507//   - fn func(uri string)
15508func (_e *MockOAuthCallbackCapable_Expecter) AddNavigationCallback(fn interface{}) *MockOAuthCallbackCapable_AddNavigationCallback_Call {
15509	return &MockOAuthCallbackCapable_AddNavigationCallback_Call{Call: _e.mock.On("AddNavigationCallback", fn)}
15510}
15511
15512func (_c *MockOAuthCallbackCapable_AddNavigationCallback_Call) Run(run func(fn func(uri string))) *MockOAuthCallbackCapable_AddNavigationCallback_Call {
15513	_c.Call.Run(func(args mock.Arguments) {
15514		var arg0 func(uri string)
15515		if args[0] != nil {
15516			arg0 = args[0].(func(uri string))
15517		}
15518		run(
15519			arg0,
15520		)
15521	})
15522	return _c
15523}
15524
15525func (_c *MockOAuthCallbackCapable_AddNavigationCallback_Call) Return() *MockOAuthCallbackCapable_AddNavigationCallback_Call {
15526	_c.Call.Return()
15527	return _c
15528}
15529
15530func (_c *MockOAuthCallbackCapable_AddNavigationCallback_Call) RunAndReturn(run func(fn func(uri string))) *MockOAuthCallbackCapable_AddNavigationCallback_Call {
15531	_c.Run(run)
15532	return _c
15533}
15534
15535// Close provides a mock function for the type MockOAuthCallbackCapable
15536func (_mock *MockOAuthCallbackCapable) Close() {
15537	_mock.Called()
15538	return
15539}
15540
15541// MockOAuthCallbackCapable_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
15542type MockOAuthCallbackCapable_Close_Call struct {
15543	*mock.Call
15544}
15545
15546// Close is a helper method to define mock.On call
15547func (_e *MockOAuthCallbackCapable_Expecter) Close() *MockOAuthCallbackCapable_Close_Call {
15548	return &MockOAuthCallbackCapable_Close_Call{Call: _e.mock.On("Close")}
15549}
15550
15551func (_c *MockOAuthCallbackCapable_Close_Call) Run(run func()) *MockOAuthCallbackCapable_Close_Call {
15552	_c.Call.Run(func(args mock.Arguments) {
15553		run()
15554	})
15555	return _c
15556}
15557
15558func (_c *MockOAuthCallbackCapable_Close_Call) Return() *MockOAuthCallbackCapable_Close_Call {
15559	_c.Call.Return()
15560	return _c
15561}
15562
15563func (_c *MockOAuthCallbackCapable_Close_Call) RunAndReturn(run func()) *MockOAuthCallbackCapable_Close_Call {
15564	_c.Run(run)
15565	return _c
15566}
15567
15568// 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.
15569// The first argument is typically a *testing.T value.
15570func NewMockTextInputTargetProvider(t interface {
15571	mock.TestingT
15572	Cleanup(func())
15573}) *MockTextInputTargetProvider {
15574	mock := &MockTextInputTargetProvider{}
15575	mock.Mock.Test(t)
15576
15577	t.Cleanup(func() { mock.AssertExpectations(t) })
15578
15579	return mock
15580}
15581
15582// MockTextInputTargetProvider is an autogenerated mock type for the TextInputTargetProvider type
15583type MockTextInputTargetProvider struct {
15584	mock.Mock
15585}
15586
15587type MockTextInputTargetProvider_Expecter struct {
15588	mock *mock.Mock
15589}
15590
15591func (_m *MockTextInputTargetProvider) EXPECT() *MockTextInputTargetProvider_Expecter {
15592	return &MockTextInputTargetProvider_Expecter{mock: &_m.Mock}
15593}
15594
15595// TextInputTarget provides a mock function for the type MockTextInputTargetProvider
15596func (_mock *MockTextInputTargetProvider) TextInputTarget() port.TextInputTarget {
15597	ret := _mock.Called()
15598
15599	if len(ret) == 0 {
15600		panic("no return value specified for TextInputTarget")
15601	}
15602
15603	var r0 port.TextInputTarget
15604	if returnFunc, ok := ret.Get(0).(func() port.TextInputTarget); ok {
15605		r0 = returnFunc()
15606	} else {
15607		if ret.Get(0) != nil {
15608			r0 = ret.Get(0).(port.TextInputTarget)
15609		}
15610	}
15611	return r0
15612}
15613
15614// MockTextInputTargetProvider_TextInputTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TextInputTarget'
15615type MockTextInputTargetProvider_TextInputTarget_Call struct {
15616	*mock.Call
15617}
15618
15619// TextInputTarget is a helper method to define mock.On call
15620func (_e *MockTextInputTargetProvider_Expecter) TextInputTarget() *MockTextInputTargetProvider_TextInputTarget_Call {
15621	return &MockTextInputTargetProvider_TextInputTarget_Call{Call: _e.mock.On("TextInputTarget")}
15622}
15623
15624func (_c *MockTextInputTargetProvider_TextInputTarget_Call) Run(run func()) *MockTextInputTargetProvider_TextInputTarget_Call {
15625	_c.Call.Run(func(args mock.Arguments) {
15626		run()
15627	})
15628	return _c
15629}
15630
15631func (_c *MockTextInputTargetProvider_TextInputTarget_Call) Return(textInputTarget port.TextInputTarget) *MockTextInputTargetProvider_TextInputTarget_Call {
15632	_c.Call.Return(textInputTarget)
15633	return _c
15634}
15635
15636func (_c *MockTextInputTargetProvider_TextInputTarget_Call) RunAndReturn(run func() port.TextInputTarget) *MockTextInputTargetProvider_TextInputTarget_Call {
15637	_c.Call.Return(run)
15638	return _c
15639}
15640
15641// NewMockXDGPaths creates a new instance of MockXDGPaths. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15642// The first argument is typically a *testing.T value.
15643func NewMockXDGPaths(t interface {
15644	mock.TestingT
15645	Cleanup(func())
15646}) *MockXDGPaths {
15647	mock := &MockXDGPaths{}
15648	mock.Mock.Test(t)
15649
15650	t.Cleanup(func() { mock.AssertExpectations(t) })
15651
15652	return mock
15653}
15654
15655// MockXDGPaths is an autogenerated mock type for the XDGPaths type
15656type MockXDGPaths struct {
15657	mock.Mock
15658}
15659
15660type MockXDGPaths_Expecter struct {
15661	mock *mock.Mock
15662}
15663
15664func (_m *MockXDGPaths) EXPECT() *MockXDGPaths_Expecter {
15665	return &MockXDGPaths_Expecter{mock: &_m.Mock}
15666}
15667
15668// CacheDir provides a mock function for the type MockXDGPaths
15669func (_mock *MockXDGPaths) CacheDir() (string, error) {
15670	ret := _mock.Called()
15671
15672	if len(ret) == 0 {
15673		panic("no return value specified for CacheDir")
15674	}
15675
15676	var r0 string
15677	var r1 error
15678	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
15679		return returnFunc()
15680	}
15681	if returnFunc, ok := ret.Get(0).(func() string); ok {
15682		r0 = returnFunc()
15683	} else {
15684		r0 = ret.Get(0).(string)
15685	}
15686	if returnFunc, ok := ret.Get(1).(func() error); ok {
15687		r1 = returnFunc()
15688	} else {
15689		r1 = ret.Error(1)
15690	}
15691	return r0, r1
15692}
15693
15694// MockXDGPaths_CacheDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CacheDir'
15695type MockXDGPaths_CacheDir_Call struct {
15696	*mock.Call
15697}
15698
15699// CacheDir is a helper method to define mock.On call
15700func (_e *MockXDGPaths_Expecter) CacheDir() *MockXDGPaths_CacheDir_Call {
15701	return &MockXDGPaths_CacheDir_Call{Call: _e.mock.On("CacheDir")}
15702}
15703
15704func (_c *MockXDGPaths_CacheDir_Call) Run(run func()) *MockXDGPaths_CacheDir_Call {
15705	_c.Call.Run(func(args mock.Arguments) {
15706		run()
15707	})
15708	return _c
15709}
15710
15711func (_c *MockXDGPaths_CacheDir_Call) Return(s string, err error) *MockXDGPaths_CacheDir_Call {
15712	_c.Call.Return(s, err)
15713	return _c
15714}
15715
15716func (_c *MockXDGPaths_CacheDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_CacheDir_Call {
15717	_c.Call.Return(run)
15718	return _c
15719}
15720
15721// ConfigDir provides a mock function for the type MockXDGPaths
15722func (_mock *MockXDGPaths) ConfigDir() (string, error) {
15723	ret := _mock.Called()
15724
15725	if len(ret) == 0 {
15726		panic("no return value specified for ConfigDir")
15727	}
15728
15729	var r0 string
15730	var r1 error
15731	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
15732		return returnFunc()
15733	}
15734	if returnFunc, ok := ret.Get(0).(func() string); ok {
15735		r0 = returnFunc()
15736	} else {
15737		r0 = ret.Get(0).(string)
15738	}
15739	if returnFunc, ok := ret.Get(1).(func() error); ok {
15740		r1 = returnFunc()
15741	} else {
15742		r1 = ret.Error(1)
15743	}
15744	return r0, r1
15745}
15746
15747// MockXDGPaths_ConfigDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigDir'
15748type MockXDGPaths_ConfigDir_Call struct {
15749	*mock.Call
15750}
15751
15752// ConfigDir is a helper method to define mock.On call
15753func (_e *MockXDGPaths_Expecter) ConfigDir() *MockXDGPaths_ConfigDir_Call {
15754	return &MockXDGPaths_ConfigDir_Call{Call: _e.mock.On("ConfigDir")}
15755}
15756
15757func (_c *MockXDGPaths_ConfigDir_Call) Run(run func()) *MockXDGPaths_ConfigDir_Call {
15758	_c.Call.Run(func(args mock.Arguments) {
15759		run()
15760	})
15761	return _c
15762}
15763
15764func (_c *MockXDGPaths_ConfigDir_Call) Return(s string, err error) *MockXDGPaths_ConfigDir_Call {
15765	_c.Call.Return(s, err)
15766	return _c
15767}
15768
15769func (_c *MockXDGPaths_ConfigDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_ConfigDir_Call {
15770	_c.Call.Return(run)
15771	return _c
15772}
15773
15774// DataDir provides a mock function for the type MockXDGPaths
15775func (_mock *MockXDGPaths) DataDir() (string, error) {
15776	ret := _mock.Called()
15777
15778	if len(ret) == 0 {
15779		panic("no return value specified for DataDir")
15780	}
15781
15782	var r0 string
15783	var r1 error
15784	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
15785		return returnFunc()
15786	}
15787	if returnFunc, ok := ret.Get(0).(func() string); ok {
15788		r0 = returnFunc()
15789	} else {
15790		r0 = ret.Get(0).(string)
15791	}
15792	if returnFunc, ok := ret.Get(1).(func() error); ok {
15793		r1 = returnFunc()
15794	} else {
15795		r1 = ret.Error(1)
15796	}
15797	return r0, r1
15798}
15799
15800// MockXDGPaths_DataDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DataDir'
15801type MockXDGPaths_DataDir_Call struct {
15802	*mock.Call
15803}
15804
15805// DataDir is a helper method to define mock.On call
15806func (_e *MockXDGPaths_Expecter) DataDir() *MockXDGPaths_DataDir_Call {
15807	return &MockXDGPaths_DataDir_Call{Call: _e.mock.On("DataDir")}
15808}
15809
15810func (_c *MockXDGPaths_DataDir_Call) Run(run func()) *MockXDGPaths_DataDir_Call {
15811	_c.Call.Run(func(args mock.Arguments) {
15812		run()
15813	})
15814	return _c
15815}
15816
15817func (_c *MockXDGPaths_DataDir_Call) Return(s string, err error) *MockXDGPaths_DataDir_Call {
15818	_c.Call.Return(s, err)
15819	return _c
15820}
15821
15822func (_c *MockXDGPaths_DataDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_DataDir_Call {
15823	_c.Call.Return(run)
15824	return _c
15825}
15826
15827// DownloadDir provides a mock function for the type MockXDGPaths
15828func (_mock *MockXDGPaths) DownloadDir() (string, error) {
15829	ret := _mock.Called()
15830
15831	if len(ret) == 0 {
15832		panic("no return value specified for DownloadDir")
15833	}
15834
15835	var r0 string
15836	var r1 error
15837	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
15838		return returnFunc()
15839	}
15840	if returnFunc, ok := ret.Get(0).(func() string); ok {
15841		r0 = returnFunc()
15842	} else {
15843		r0 = ret.Get(0).(string)
15844	}
15845	if returnFunc, ok := ret.Get(1).(func() error); ok {
15846		r1 = returnFunc()
15847	} else {
15848		r1 = ret.Error(1)
15849	}
15850	return r0, r1
15851}
15852
15853// MockXDGPaths_DownloadDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadDir'
15854type MockXDGPaths_DownloadDir_Call struct {
15855	*mock.Call
15856}
15857
15858// DownloadDir is a helper method to define mock.On call
15859func (_e *MockXDGPaths_Expecter) DownloadDir() *MockXDGPaths_DownloadDir_Call {
15860	return &MockXDGPaths_DownloadDir_Call{Call: _e.mock.On("DownloadDir")}
15861}
15862
15863func (_c *MockXDGPaths_DownloadDir_Call) Run(run func()) *MockXDGPaths_DownloadDir_Call {
15864	_c.Call.Run(func(args mock.Arguments) {
15865		run()
15866	})
15867	return _c
15868}
15869
15870func (_c *MockXDGPaths_DownloadDir_Call) Return(s string, err error) *MockXDGPaths_DownloadDir_Call {
15871	_c.Call.Return(s, err)
15872	return _c
15873}
15874
15875func (_c *MockXDGPaths_DownloadDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_DownloadDir_Call {
15876	_c.Call.Return(run)
15877	return _c
15878}
15879
15880// FilterCacheDir provides a mock function for the type MockXDGPaths
15881func (_mock *MockXDGPaths) FilterCacheDir() (string, error) {
15882	ret := _mock.Called()
15883
15884	if len(ret) == 0 {
15885		panic("no return value specified for FilterCacheDir")
15886	}
15887
15888	var r0 string
15889	var r1 error
15890	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
15891		return returnFunc()
15892	}
15893	if returnFunc, ok := ret.Get(0).(func() string); ok {
15894		r0 = returnFunc()
15895	} else {
15896		r0 = ret.Get(0).(string)
15897	}
15898	if returnFunc, ok := ret.Get(1).(func() error); ok {
15899		r1 = returnFunc()
15900	} else {
15901		r1 = ret.Error(1)
15902	}
15903	return r0, r1
15904}
15905
15906// MockXDGPaths_FilterCacheDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FilterCacheDir'
15907type MockXDGPaths_FilterCacheDir_Call struct {
15908	*mock.Call
15909}
15910
15911// FilterCacheDir is a helper method to define mock.On call
15912func (_e *MockXDGPaths_Expecter) FilterCacheDir() *MockXDGPaths_FilterCacheDir_Call {
15913	return &MockXDGPaths_FilterCacheDir_Call{Call: _e.mock.On("FilterCacheDir")}
15914}
15915
15916func (_c *MockXDGPaths_FilterCacheDir_Call) Run(run func()) *MockXDGPaths_FilterCacheDir_Call {
15917	_c.Call.Run(func(args mock.Arguments) {
15918		run()
15919	})
15920	return _c
15921}
15922
15923func (_c *MockXDGPaths_FilterCacheDir_Call) Return(s string, err error) *MockXDGPaths_FilterCacheDir_Call {
15924	_c.Call.Return(s, err)
15925	return _c
15926}
15927
15928func (_c *MockXDGPaths_FilterCacheDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_FilterCacheDir_Call {
15929	_c.Call.Return(run)
15930	return _c
15931}
15932
15933// FilterJSONDir provides a mock function for the type MockXDGPaths
15934func (_mock *MockXDGPaths) FilterJSONDir() (string, error) {
15935	ret := _mock.Called()
15936
15937	if len(ret) == 0 {
15938		panic("no return value specified for FilterJSONDir")
15939	}
15940
15941	var r0 string
15942	var r1 error
15943	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
15944		return returnFunc()
15945	}
15946	if returnFunc, ok := ret.Get(0).(func() string); ok {
15947		r0 = returnFunc()
15948	} else {
15949		r0 = ret.Get(0).(string)
15950	}
15951	if returnFunc, ok := ret.Get(1).(func() error); ok {
15952		r1 = returnFunc()
15953	} else {
15954		r1 = ret.Error(1)
15955	}
15956	return r0, r1
15957}
15958
15959// MockXDGPaths_FilterJSONDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FilterJSONDir'
15960type MockXDGPaths_FilterJSONDir_Call struct {
15961	*mock.Call
15962}
15963
15964// FilterJSONDir is a helper method to define mock.On call
15965func (_e *MockXDGPaths_Expecter) FilterJSONDir() *MockXDGPaths_FilterJSONDir_Call {
15966	return &MockXDGPaths_FilterJSONDir_Call{Call: _e.mock.On("FilterJSONDir")}
15967}
15968
15969func (_c *MockXDGPaths_FilterJSONDir_Call) Run(run func()) *MockXDGPaths_FilterJSONDir_Call {
15970	_c.Call.Run(func(args mock.Arguments) {
15971		run()
15972	})
15973	return _c
15974}
15975
15976func (_c *MockXDGPaths_FilterJSONDir_Call) Return(s string, err error) *MockXDGPaths_FilterJSONDir_Call {
15977	_c.Call.Return(s, err)
15978	return _c
15979}
15980
15981func (_c *MockXDGPaths_FilterJSONDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_FilterJSONDir_Call {
15982	_c.Call.Return(run)
15983	return _c
15984}
15985
15986// FilterStoreDir provides a mock function for the type MockXDGPaths
15987func (_mock *MockXDGPaths) FilterStoreDir() (string, error) {
15988	ret := _mock.Called()
15989
15990	if len(ret) == 0 {
15991		panic("no return value specified for FilterStoreDir")
15992	}
15993
15994	var r0 string
15995	var r1 error
15996	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
15997		return returnFunc()
15998	}
15999	if returnFunc, ok := ret.Get(0).(func() string); ok {
16000		r0 = returnFunc()
16001	} else {
16002		r0 = ret.Get(0).(string)
16003	}
16004	if returnFunc, ok := ret.Get(1).(func() error); ok {
16005		r1 = returnFunc()
16006	} else {
16007		r1 = ret.Error(1)
16008	}
16009	return r0, r1
16010}
16011
16012// MockXDGPaths_FilterStoreDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FilterStoreDir'
16013type MockXDGPaths_FilterStoreDir_Call struct {
16014	*mock.Call
16015}
16016
16017// FilterStoreDir is a helper method to define mock.On call
16018func (_e *MockXDGPaths_Expecter) FilterStoreDir() *MockXDGPaths_FilterStoreDir_Call {
16019	return &MockXDGPaths_FilterStoreDir_Call{Call: _e.mock.On("FilterStoreDir")}
16020}
16021
16022func (_c *MockXDGPaths_FilterStoreDir_Call) Run(run func()) *MockXDGPaths_FilterStoreDir_Call {
16023	_c.Call.Run(func(args mock.Arguments) {
16024		run()
16025	})
16026	return _c
16027}
16028
16029func (_c *MockXDGPaths_FilterStoreDir_Call) Return(s string, err error) *MockXDGPaths_FilterStoreDir_Call {
16030	_c.Call.Return(s, err)
16031	return _c
16032}
16033
16034func (_c *MockXDGPaths_FilterStoreDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_FilterStoreDir_Call {
16035	_c.Call.Return(run)
16036	return _c
16037}
16038
16039// ManDir provides a mock function for the type MockXDGPaths
16040func (_mock *MockXDGPaths) ManDir() (string, error) {
16041	ret := _mock.Called()
16042
16043	if len(ret) == 0 {
16044		panic("no return value specified for ManDir")
16045	}
16046
16047	var r0 string
16048	var r1 error
16049	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
16050		return returnFunc()
16051	}
16052	if returnFunc, ok := ret.Get(0).(func() string); ok {
16053		r0 = returnFunc()
16054	} else {
16055		r0 = ret.Get(0).(string)
16056	}
16057	if returnFunc, ok := ret.Get(1).(func() error); ok {
16058		r1 = returnFunc()
16059	} else {
16060		r1 = ret.Error(1)
16061	}
16062	return r0, r1
16063}
16064
16065// MockXDGPaths_ManDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ManDir'
16066type MockXDGPaths_ManDir_Call struct {
16067	*mock.Call
16068}
16069
16070// ManDir is a helper method to define mock.On call
16071func (_e *MockXDGPaths_Expecter) ManDir() *MockXDGPaths_ManDir_Call {
16072	return &MockXDGPaths_ManDir_Call{Call: _e.mock.On("ManDir")}
16073}
16074
16075func (_c *MockXDGPaths_ManDir_Call) Run(run func()) *MockXDGPaths_ManDir_Call {
16076	_c.Call.Run(func(args mock.Arguments) {
16077		run()
16078	})
16079	return _c
16080}
16081
16082func (_c *MockXDGPaths_ManDir_Call) Return(s string, err error) *MockXDGPaths_ManDir_Call {
16083	_c.Call.Return(s, err)
16084	return _c
16085}
16086
16087func (_c *MockXDGPaths_ManDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_ManDir_Call {
16088	_c.Call.Return(run)
16089	return _c
16090}
16091
16092// RuntimeDir provides a mock function for the type MockXDGPaths
16093func (_mock *MockXDGPaths) RuntimeDir() (string, error) {
16094	ret := _mock.Called()
16095
16096	if len(ret) == 0 {
16097		panic("no return value specified for RuntimeDir")
16098	}
16099
16100	var r0 string
16101	var r1 error
16102	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
16103		return returnFunc()
16104	}
16105	if returnFunc, ok := ret.Get(0).(func() string); ok {
16106		r0 = returnFunc()
16107	} else {
16108		r0 = ret.Get(0).(string)
16109	}
16110	if returnFunc, ok := ret.Get(1).(func() error); ok {
16111		r1 = returnFunc()
16112	} else {
16113		r1 = ret.Error(1)
16114	}
16115	return r0, r1
16116}
16117
16118// MockXDGPaths_RuntimeDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RuntimeDir'
16119type MockXDGPaths_RuntimeDir_Call struct {
16120	*mock.Call
16121}
16122
16123// RuntimeDir is a helper method to define mock.On call
16124func (_e *MockXDGPaths_Expecter) RuntimeDir() *MockXDGPaths_RuntimeDir_Call {
16125	return &MockXDGPaths_RuntimeDir_Call{Call: _e.mock.On("RuntimeDir")}
16126}
16127
16128func (_c *MockXDGPaths_RuntimeDir_Call) Run(run func()) *MockXDGPaths_RuntimeDir_Call {
16129	_c.Call.Run(func(args mock.Arguments) {
16130		run()
16131	})
16132	return _c
16133}
16134
16135func (_c *MockXDGPaths_RuntimeDir_Call) Return(s string, err error) *MockXDGPaths_RuntimeDir_Call {
16136	_c.Call.Return(s, err)
16137	return _c
16138}
16139
16140func (_c *MockXDGPaths_RuntimeDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_RuntimeDir_Call {
16141	_c.Call.Return(run)
16142	return _c
16143}
16144
16145// StateDir provides a mock function for the type MockXDGPaths
16146func (_mock *MockXDGPaths) StateDir() (string, error) {
16147	ret := _mock.Called()
16148
16149	if len(ret) == 0 {
16150		panic("no return value specified for StateDir")
16151	}
16152
16153	var r0 string
16154	var r1 error
16155	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
16156		return returnFunc()
16157	}
16158	if returnFunc, ok := ret.Get(0).(func() string); ok {
16159		r0 = returnFunc()
16160	} else {
16161		r0 = ret.Get(0).(string)
16162	}
16163	if returnFunc, ok := ret.Get(1).(func() error); ok {
16164		r1 = returnFunc()
16165	} else {
16166		r1 = ret.Error(1)
16167	}
16168	return r0, r1
16169}
16170
16171// MockXDGPaths_StateDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StateDir'
16172type MockXDGPaths_StateDir_Call struct {
16173	*mock.Call
16174}
16175
16176// StateDir is a helper method to define mock.On call
16177func (_e *MockXDGPaths_Expecter) StateDir() *MockXDGPaths_StateDir_Call {
16178	return &MockXDGPaths_StateDir_Call{Call: _e.mock.On("StateDir")}
16179}
16180
16181func (_c *MockXDGPaths_StateDir_Call) Run(run func()) *MockXDGPaths_StateDir_Call {
16182	_c.Call.Run(func(args mock.Arguments) {
16183		run()
16184	})
16185	return _c
16186}
16187
16188func (_c *MockXDGPaths_StateDir_Call) Return(s string, err error) *MockXDGPaths_StateDir_Call {
16189	_c.Call.Return(s, err)
16190	return _c
16191}
16192
16193func (_c *MockXDGPaths_StateDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_StateDir_Call {
16194	_c.Call.Return(run)
16195	return _c
16196}