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

package mocks

import (
	"reflect"

	"github.com/nicholas-fedor/shoutrrr/pkg/format"
	mock "github.com/stretchr/testify/mock"
)

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

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

	return mock
}

// MockNode is an autogenerated mock type for the Node type
type MockNode struct {
	mock.Mock
}

type MockNode_Expecter struct {
	mock *mock.Mock
}

func (_m *MockNode) EXPECT() *MockNode_Expecter {
	return &MockNode_Expecter{mock: &_m.Mock}
}

// Field provides a mock function for the type MockNode
func (_mock *MockNode) Field() *format.FieldInfo {
	ret := _mock.Called()

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

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

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

// Field is a helper method to define mock.On call
func (_e *MockNode_Expecter) Field() *MockNode_Field_Call {
	return &MockNode_Field_Call{Call: _e.mock.On("Field")}
}

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

func (_c *MockNode_Field_Call) Return(fieldInfo *format.FieldInfo) *MockNode_Field_Call {
	_c.Call.Return(fieldInfo)
	return _c
}

func (_c *MockNode_Field_Call) RunAndReturn(run func() *format.FieldInfo) *MockNode_Field_Call {
	_c.Call.Return(run)
	return _c
}

// TokenType provides a mock function for the type MockNode
func (_mock *MockNode) TokenType() format.NodeTokenType {
	ret := _mock.Called()

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

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

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

// TokenType is a helper method to define mock.On call
func (_e *MockNode_Expecter) TokenType() *MockNode_TokenType_Call {
	return &MockNode_TokenType_Call{Call: _e.mock.On("TokenType")}
}

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

func (_c *MockNode_TokenType_Call) Return(nodeTokenType format.NodeTokenType) *MockNode_TokenType_Call {
	_c.Call.Return(nodeTokenType)
	return _c
}

func (_c *MockNode_TokenType_Call) RunAndReturn(run func() format.NodeTokenType) *MockNode_TokenType_Call {
	_c.Call.Return(run)
	return _c
}

// Update provides a mock function for the type MockNode
func (_mock *MockNode) Update(tv reflect.Value) {
	_mock.Called(tv)
	return
}

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

// Update is a helper method to define mock.On call
//   - tv reflect.Value
func (_e *MockNode_Expecter) Update(tv interface{}) *MockNode_Update_Call {
	return &MockNode_Update_Call{Call: _e.mock.On("Update", tv)}
}

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

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

func (_c *MockNode_Update_Call) RunAndReturn(run func(tv reflect.Value)) *MockNode_Update_Call {
	_c.Run(run)
	return _c
}
