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

package mocks

import (
	"context"

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

// 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.
// The first argument is typically a *testing.T value.
func NewMockWindowStateProvider(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockWindowStateProvider {
	mock := &MockWindowStateProvider{}
	mock.Mock.Test(t)

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

	return mock
}

// MockWindowStateProvider is an autogenerated mock type for the WindowStateProvider type
type MockWindowStateProvider struct {
	mock.Mock
}

type MockWindowStateProvider_Expecter struct {
	mock *mock.Mock
}

func (_m *MockWindowStateProvider) EXPECT() *MockWindowStateProvider_Expecter {
	return &MockWindowStateProvider_Expecter{mock: &_m.Mock}
}

// GetActiveWindowIndex provides a mock function for the type MockWindowStateProvider
func (_mock *MockWindowStateProvider) GetActiveWindowIndex() int {
	ret := _mock.Called()

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

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

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

// GetActiveWindowIndex is a helper method to define mock.On call
func (_e *MockWindowStateProvider_Expecter) GetActiveWindowIndex() *MockWindowStateProvider_GetActiveWindowIndex_Call {
	return &MockWindowStateProvider_GetActiveWindowIndex_Call{Call: _e.mock.On("GetActiveWindowIndex")}
}

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

func (_c *MockWindowStateProvider_GetActiveWindowIndex_Call) Return(n int) *MockWindowStateProvider_GetActiveWindowIndex_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockWindowStateProvider_GetActiveWindowIndex_Call) RunAndReturn(run func() int) *MockWindowStateProvider_GetActiveWindowIndex_Call {
	_c.Call.Return(run)
	return _c
}

// GetSessionID provides a mock function for the type MockWindowStateProvider
func (_mock *MockWindowStateProvider) GetSessionID() entity.SessionID {
	ret := _mock.Called()

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

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

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

// GetSessionID is a helper method to define mock.On call
func (_e *MockWindowStateProvider_Expecter) GetSessionID() *MockWindowStateProvider_GetSessionID_Call {
	return &MockWindowStateProvider_GetSessionID_Call{Call: _e.mock.On("GetSessionID")}
}

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

func (_c *MockWindowStateProvider_GetSessionID_Call) Return(sessionID entity.SessionID) *MockWindowStateProvider_GetSessionID_Call {
	_c.Call.Return(sessionID)
	return _c
}

func (_c *MockWindowStateProvider_GetSessionID_Call) RunAndReturn(run func() entity.SessionID) *MockWindowStateProvider_GetSessionID_Call {
	_c.Call.Return(run)
	return _c
}

// GetWindowSnapshotState provides a mock function for the type MockWindowStateProvider
func (_mock *MockWindowStateProvider) GetWindowSnapshotState() ([]entity.WindowTabListState, int) {
	ret := _mock.Called()

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

	var r0 []entity.WindowTabListState
	var r1 int
	if returnFunc, ok := ret.Get(0).(func() ([]entity.WindowTabListState, int)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() []entity.WindowTabListState); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]entity.WindowTabListState)
		}
	}
	if returnFunc, ok := ret.Get(1).(func() int); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Get(1).(int)
	}
	return r0, r1
}

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

// GetWindowSnapshotState is a helper method to define mock.On call
func (_e *MockWindowStateProvider_Expecter) GetWindowSnapshotState() *MockWindowStateProvider_GetWindowSnapshotState_Call {
	return &MockWindowStateProvider_GetWindowSnapshotState_Call{Call: _e.mock.On("GetWindowSnapshotState")}
}

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

func (_c *MockWindowStateProvider_GetWindowSnapshotState_Call) Return(windowTabListStates []entity.WindowTabListState, n int) *MockWindowStateProvider_GetWindowSnapshotState_Call {
	_c.Call.Return(windowTabListStates, n)
	return _c
}

func (_c *MockWindowStateProvider_GetWindowSnapshotState_Call) RunAndReturn(run func() ([]entity.WindowTabListState, int)) *MockWindowStateProvider_GetWindowSnapshotState_Call {
	_c.Call.Return(run)
	return _c
}

// GetWindowTabLists provides a mock function for the type MockWindowStateProvider
func (_mock *MockWindowStateProvider) GetWindowTabLists() []entity.WindowTabListState {
	ret := _mock.Called()

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

	var r0 []entity.WindowTabListState
	if returnFunc, ok := ret.Get(0).(func() []entity.WindowTabListState); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]entity.WindowTabListState)
		}
	}
	return r0
}

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

// GetWindowTabLists is a helper method to define mock.On call
func (_e *MockWindowStateProvider_Expecter) GetWindowTabLists() *MockWindowStateProvider_GetWindowTabLists_Call {
	return &MockWindowStateProvider_GetWindowTabLists_Call{Call: _e.mock.On("GetWindowTabLists")}
}

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

func (_c *MockWindowStateProvider_GetWindowTabLists_Call) Return(windowTabListStates []entity.WindowTabListState) *MockWindowStateProvider_GetWindowTabLists_Call {
	_c.Call.Return(windowTabListStates)
	return _c
}

func (_c *MockWindowStateProvider_GetWindowTabLists_Call) RunAndReturn(run func() []entity.WindowTabListState) *MockWindowStateProvider_GetWindowTabLists_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockSessionSpawner is an autogenerated mock type for the SessionSpawner type
type MockSessionSpawner struct {
	mock.Mock
}

type MockSessionSpawner_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSessionSpawner) EXPECT() *MockSessionSpawner_Expecter {
	return &MockSessionSpawner_Expecter{mock: &_m.Mock}
}

// SpawnWithSession provides a mock function for the type MockSessionSpawner
func (_mock *MockSessionSpawner) SpawnWithSession(sessionID entity.SessionID) error {
	ret := _mock.Called(sessionID)

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

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

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

// SpawnWithSession is a helper method to define mock.On call
//   - sessionID entity.SessionID
func (_e *MockSessionSpawner_Expecter) SpawnWithSession(sessionID any) *MockSessionSpawner_SpawnWithSession_Call {
	return &MockSessionSpawner_SpawnWithSession_Call{Call: _e.mock.On("SpawnWithSession", sessionID)}
}

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

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

func (_c *MockSessionSpawner_SpawnWithSession_Call) RunAndReturn(run func(sessionID entity.SessionID) error) *MockSessionSpawner_SpawnWithSession_Call {
	_c.Call.Return(run)
	return _c
}

// 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.
// The first argument is typically a *testing.T value.
func NewMockSnapshotService(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockSnapshotService {
	mock := &MockSnapshotService{}
	mock.Mock.Test(t)

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

	return mock
}

// MockSnapshotService is an autogenerated mock type for the SnapshotService type
type MockSnapshotService struct {
	mock.Mock
}

type MockSnapshotService_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSnapshotService) EXPECT() *MockSnapshotService_Expecter {
	return &MockSnapshotService_Expecter{mock: &_m.Mock}
}

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

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

// MarkDirty is a helper method to define mock.On call
func (_e *MockSnapshotService_Expecter) MarkDirty() *MockSnapshotService_MarkDirty_Call {
	return &MockSnapshotService_MarkDirty_Call{Call: _e.mock.On("MarkDirty")}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetReady is a helper method to define mock.On call
func (_e *MockSnapshotService_Expecter) SetReady() *MockSnapshotService_SetReady_Call {
	return &MockSnapshotService_SetReady_Call{Call: _e.mock.On("SetReady")}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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