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

package neferclient

import (
	mock "github.com/stretchr/testify/mock"
)

// NewMockHandler creates a new instance of MockHandler. 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 NewMockHandler(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockHandler {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockHandler{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockHandler is an autogenerated mock type for the Handler type
type MockHandler struct {
	mock.Mock
}

type MockHandler_Expecter struct {
	mock *mock.Mock
}

func (_m *MockHandler) EXPECT() *MockHandler_Expecter {
	return &MockHandler_Expecter{mock: &_m.Mock}
}

// Closed provides a mock function for the type MockHandler
func (_mock *MockHandler) Closed(id SurfaceID) {
	_mock.Called(id)
	return
}

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

// Closed is a helper method to define mock.On call
//   - id SurfaceID
func (_e *MockHandler_Expecter) Closed(id any) *MockHandler_Closed_Call {
	return &MockHandler_Closed_Call{Call: _e.mock.On("Closed", id)}
}

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

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

func (_c *MockHandler_Closed_Call) RunAndReturn(run func(id SurfaceID)) *MockHandler_Closed_Call {
	_c.Run(run)
	return _c
}

// Configure provides a mock function for the type MockHandler
func (_mock *MockHandler) Configure(id SurfaceID, width int32, height int32) {
	_mock.Called(id, width, height)
	return
}

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

// Configure is a helper method to define mock.On call
//   - id SurfaceID
//   - width int32
//   - height int32
func (_e *MockHandler_Expecter) Configure(id any, width any, height any) *MockHandler_Configure_Call {
	return &MockHandler_Configure_Call{Call: _e.mock.On("Configure", id, width, height)}
}

func (_c *MockHandler_Configure_Call) Run(run func(id SurfaceID, width int32, height int32)) *MockHandler_Configure_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 SurfaceID
		if args[0] != nil {
			arg0 = args[0].(SurfaceID)
		}
		var arg1 int32
		if args[1] != nil {
			arg1 = args[1].(int32)
		}
		var arg2 int32
		if args[2] != nil {
			arg2 = args[2].(int32)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockHandler_Configure_Call) RunAndReturn(run func(id SurfaceID, width int32, height int32)) *MockHandler_Configure_Call {
	_c.Run(run)
	return _c
}

// Error provides a mock function for the type MockHandler
func (_mock *MockHandler) Error(err error) {
	_mock.Called(err)
	return
}

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

// Error is a helper method to define mock.On call
//   - err error
func (_e *MockHandler_Expecter) Error(err any) *MockHandler_Error_Call {
	return &MockHandler_Error_Call{Call: _e.mock.On("Error", err)}
}

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

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

func (_c *MockHandler_Error_Call) RunAndReturn(run func(err error)) *MockHandler_Error_Call {
	_c.Run(run)
	return _c
}

// FDReady provides a mock function for the type MockHandler
func (_mock *MockHandler) FDReady(id uint64) {
	_mock.Called(id)
	return
}

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

// FDReady is a helper method to define mock.On call
//   - id uint64
func (_e *MockHandler_Expecter) FDReady(id any) *MockHandler_FDReady_Call {
	return &MockHandler_FDReady_Call{Call: _e.mock.On("FDReady", id)}
}

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

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

func (_c *MockHandler_FDReady_Call) RunAndReturn(run func(id uint64)) *MockHandler_FDReady_Call {
	_c.Run(run)
	return _c
}

// FeedbackDone provides a mock function for the type MockHandler
func (_mock *MockHandler) FeedbackDone(id SurfaceID) {
	_mock.Called(id)
	return
}

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

// FeedbackDone is a helper method to define mock.On call
//   - id SurfaceID
func (_e *MockHandler_Expecter) FeedbackDone(id any) *MockHandler_FeedbackDone_Call {
	return &MockHandler_FeedbackDone_Call{Call: _e.mock.On("FeedbackDone", id)}
}

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

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

func (_c *MockHandler_FeedbackDone_Call) RunAndReturn(run func(id SurfaceID)) *MockHandler_FeedbackDone_Call {
	_c.Run(run)
	return _c
}

// Frame provides a mock function for the type MockHandler
func (_mock *MockHandler) Frame(id SurfaceID) {
	_mock.Called(id)
	return
}

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

// Frame is a helper method to define mock.On call
//   - id SurfaceID
func (_e *MockHandler_Expecter) Frame(id any) *MockHandler_Frame_Call {
	return &MockHandler_Frame_Call{Call: _e.mock.On("Frame", id)}
}

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

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

func (_c *MockHandler_Frame_Call) RunAndReturn(run func(id SurfaceID)) *MockHandler_Frame_Call {
	_c.Run(run)
	return _c
}

// Key provides a mock function for the type MockHandler
func (_mock *MockHandler) Key(ev *KeyEvent) {
	_mock.Called(ev)
	return
}

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

// Key is a helper method to define mock.On call
//   - ev *KeyEvent
func (_e *MockHandler_Expecter) Key(ev any) *MockHandler_Key_Call {
	return &MockHandler_Key_Call{Call: _e.mock.On("Key", ev)}
}

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

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

func (_c *MockHandler_Key_Call) RunAndReturn(run func(ev *KeyEvent)) *MockHandler_Key_Call {
	_c.Run(run)
	return _c
}

// KeyboardFocus provides a mock function for the type MockHandler
func (_mock *MockHandler) KeyboardFocus(id SurfaceID, focused bool) {
	_mock.Called(id, focused)
	return
}

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

// KeyboardFocus is a helper method to define mock.On call
//   - id SurfaceID
//   - focused bool
func (_e *MockHandler_Expecter) KeyboardFocus(id any, focused any) *MockHandler_KeyboardFocus_Call {
	return &MockHandler_KeyboardFocus_Call{Call: _e.mock.On("KeyboardFocus", id, focused)}
}

func (_c *MockHandler_KeyboardFocus_Call) Run(run func(id SurfaceID, focused bool)) *MockHandler_KeyboardFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 SurfaceID
		if args[0] != nil {
			arg0 = args[0].(SurfaceID)
		}
		var arg1 bool
		if args[1] != nil {
			arg1 = args[1].(bool)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockHandler_KeyboardFocus_Call) RunAndReturn(run func(id SurfaceID, focused bool)) *MockHandler_KeyboardFocus_Call {
	_c.Run(run)
	return _c
}

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

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

// LockFinished is a helper method to define mock.On call
func (_e *MockHandler_Expecter) LockFinished() *MockHandler_LockFinished_Call {
	return &MockHandler_LockFinished_Call{Call: _e.mock.On("LockFinished")}
}

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

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

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

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

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

// Locked is a helper method to define mock.On call
func (_e *MockHandler_Expecter) Locked() *MockHandler_Locked_Call {
	return &MockHandler_Locked_Call{Call: _e.mock.On("Locked")}
}

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

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

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

// OutputAdded provides a mock function for the type MockHandler
func (_mock *MockHandler) OutputAdded(out *Output) {
	_mock.Called(out)
	return
}

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

// OutputAdded is a helper method to define mock.On call
//   - out *Output
func (_e *MockHandler_Expecter) OutputAdded(out any) *MockHandler_OutputAdded_Call {
	return &MockHandler_OutputAdded_Call{Call: _e.mock.On("OutputAdded", out)}
}

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

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

func (_c *MockHandler_OutputAdded_Call) RunAndReturn(run func(out *Output)) *MockHandler_OutputAdded_Call {
	_c.Run(run)
	return _c
}

// OutputRemoved provides a mock function for the type MockHandler
func (_mock *MockHandler) OutputRemoved(global uint32) {
	_mock.Called(global)
	return
}

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

// OutputRemoved is a helper method to define mock.On call
//   - global uint32
func (_e *MockHandler_Expecter) OutputRemoved(global any) *MockHandler_OutputRemoved_Call {
	return &MockHandler_OutputRemoved_Call{Call: _e.mock.On("OutputRemoved", global)}
}

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

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

func (_c *MockHandler_OutputRemoved_Call) RunAndReturn(run func(global uint32)) *MockHandler_OutputRemoved_Call {
	_c.Run(run)
	return _c
}

// Pointer provides a mock function for the type MockHandler
func (_mock *MockHandler) Pointer(ev *PointerEvent) {
	_mock.Called(ev)
	return
}

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

// Pointer is a helper method to define mock.On call
//   - ev *PointerEvent
func (_e *MockHandler_Expecter) Pointer(ev any) *MockHandler_Pointer_Call {
	return &MockHandler_Pointer_Call{Call: _e.mock.On("Pointer", ev)}
}

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

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

func (_c *MockHandler_Pointer_Call) RunAndReturn(run func(ev *PointerEvent)) *MockHandler_Pointer_Call {
	_c.Run(run)
	return _c
}

// PopupDone provides a mock function for the type MockHandler
func (_mock *MockHandler) PopupDone(id SurfaceID) {
	_mock.Called(id)
	return
}

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

// PopupDone is a helper method to define mock.On call
//   - id SurfaceID
func (_e *MockHandler_Expecter) PopupDone(id any) *MockHandler_PopupDone_Call {
	return &MockHandler_PopupDone_Call{Call: _e.mock.On("PopupDone", id)}
}

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

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

func (_c *MockHandler_PopupDone_Call) RunAndReturn(run func(id SurfaceID)) *MockHandler_PopupDone_Call {
	_c.Run(run)
	return _c
}

// Scale provides a mock function for the type MockHandler
func (_mock *MockHandler) Scale(id SurfaceID, scale float64) {
	_mock.Called(id, scale)
	return
}

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

// Scale is a helper method to define mock.On call
//   - id SurfaceID
//   - scale float64
func (_e *MockHandler_Expecter) Scale(id any, scale any) *MockHandler_Scale_Call {
	return &MockHandler_Scale_Call{Call: _e.mock.On("Scale", id, scale)}
}

func (_c *MockHandler_Scale_Call) Run(run func(id SurfaceID, scale float64)) *MockHandler_Scale_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 SurfaceID
		if args[0] != nil {
			arg0 = args[0].(SurfaceID)
		}
		var arg1 float64
		if args[1] != nil {
			arg1 = args[1].(float64)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockHandler_Scale_Call) RunAndReturn(run func(id SurfaceID, scale float64)) *MockHandler_Scale_Call {
	_c.Run(run)
	return _c
}

// SecretChanged provides a mock function for the type MockHandler
func (_mock *MockHandler) SecretChanged(count int) {
	_mock.Called(count)
	return
}

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

// SecretChanged is a helper method to define mock.On call
//   - count int
func (_e *MockHandler_Expecter) SecretChanged(count any) *MockHandler_SecretChanged_Call {
	return &MockHandler_SecretChanged_Call{Call: _e.mock.On("SecretChanged", count)}
}

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

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

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