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

package mocks

import (
	"time"

	"github.com/hashicorp/go-cty/cty"
	mock "github.com/stretchr/testify/mock"
)

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

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

	return mock
}

// MockResourceData is an autogenerated mock type for the ResourceData type
type MockResourceData struct {
	mock.Mock
}

type MockResourceData_Expecter struct {
	mock *mock.Mock
}

func (_m *MockResourceData) EXPECT() *MockResourceData_Expecter {
	return &MockResourceData_Expecter{mock: &_m.Mock}
}

// Get provides a mock function for the type MockResourceData
func (_mock *MockResourceData) Get(s string) any {
	ret := _mock.Called(s)

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

	var r0 any
	if returnFunc, ok := ret.Get(0).(func(string) any); ok {
		r0 = returnFunc(s)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(any)
		}
	}
	return r0
}

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

// Get is a helper method to define mock.On call
//   - s
func (_e *MockResourceData_Expecter) Get(s interface{}) *MockResourceData_Get_Call {
	return &MockResourceData_Get_Call{Call: _e.mock.On("Get", s)}
}

func (_c *MockResourceData_Get_Call) Run(run func(s string)) *MockResourceData_Get_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockResourceData_Get_Call) Return(v any) *MockResourceData_Get_Call {
	_c.Call.Return(v)
	return _c
}

func (_c *MockResourceData_Get_Call) RunAndReturn(run func(s string) any) *MockResourceData_Get_Call {
	_c.Call.Return(run)
	return _c
}

// GetOk provides a mock function for the type MockResourceData
func (_mock *MockResourceData) GetOk(s string) (any, bool) {
	ret := _mock.Called(s)

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

	var r0 any
	var r1 bool
	if returnFunc, ok := ret.Get(0).(func(string) (any, bool)); ok {
		return returnFunc(s)
	}
	if returnFunc, ok := ret.Get(0).(func(string) any); ok {
		r0 = returnFunc(s)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(any)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(string) bool); ok {
		r1 = returnFunc(s)
	} else {
		r1 = ret.Get(1).(bool)
	}
	return r0, r1
}

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

// GetOk is a helper method to define mock.On call
//   - s
func (_e *MockResourceData_Expecter) GetOk(s interface{}) *MockResourceData_GetOk_Call {
	return &MockResourceData_GetOk_Call{Call: _e.mock.On("GetOk", s)}
}

func (_c *MockResourceData_GetOk_Call) Run(run func(s string)) *MockResourceData_GetOk_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockResourceData_GetOk_Call) Return(v any, b bool) *MockResourceData_GetOk_Call {
	_c.Call.Return(v, b)
	return _c
}

func (_c *MockResourceData_GetOk_Call) RunAndReturn(run func(s string) (any, bool)) *MockResourceData_GetOk_Call {
	_c.Call.Return(run)
	return _c
}

// GetRawConfig provides a mock function for the type MockResourceData
func (_mock *MockResourceData) GetRawConfig() cty.Value {
	ret := _mock.Called()

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

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

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

// GetRawConfig is a helper method to define mock.On call
func (_e *MockResourceData_Expecter) GetRawConfig() *MockResourceData_GetRawConfig_Call {
	return &MockResourceData_GetRawConfig_Call{Call: _e.mock.On("GetRawConfig")}
}

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

func (_c *MockResourceData_GetRawConfig_Call) Return(value cty.Value) *MockResourceData_GetRawConfig_Call {
	_c.Call.Return(value)
	return _c
}

func (_c *MockResourceData_GetRawConfig_Call) RunAndReturn(run func() cty.Value) *MockResourceData_GetRawConfig_Call {
	_c.Call.Return(run)
	return _c
}

// HasChange provides a mock function for the type MockResourceData
func (_mock *MockResourceData) HasChange(s string) bool {
	ret := _mock.Called(s)

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

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

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

// HasChange is a helper method to define mock.On call
//   - s
func (_e *MockResourceData_Expecter) HasChange(s interface{}) *MockResourceData_HasChange_Call {
	return &MockResourceData_HasChange_Call{Call: _e.mock.On("HasChange", s)}
}

func (_c *MockResourceData_HasChange_Call) Run(run func(s string)) *MockResourceData_HasChange_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockResourceData_HasChange_Call) Return(b bool) *MockResourceData_HasChange_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockResourceData_HasChange_Call) RunAndReturn(run func(s string) bool) *MockResourceData_HasChange_Call {
	_c.Call.Return(run)
	return _c
}

// Id provides a mock function for the type MockResourceData
func (_mock *MockResourceData) Id() string {
	ret := _mock.Called()

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

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

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

// Id is a helper method to define mock.On call
func (_e *MockResourceData_Expecter) Id() *MockResourceData_Id_Call {
	return &MockResourceData_Id_Call{Call: _e.mock.On("Id")}
}

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

func (_c *MockResourceData_Id_Call) Return(s string) *MockResourceData_Id_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockResourceData_Id_Call) RunAndReturn(run func() string) *MockResourceData_Id_Call {
	_c.Call.Return(run)
	return _c
}

// IsNewResource provides a mock function for the type MockResourceData
func (_mock *MockResourceData) IsNewResource() bool {
	ret := _mock.Called()

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

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

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

// IsNewResource is a helper method to define mock.On call
func (_e *MockResourceData_Expecter) IsNewResource() *MockResourceData_IsNewResource_Call {
	return &MockResourceData_IsNewResource_Call{Call: _e.mock.On("IsNewResource")}
}

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

func (_c *MockResourceData_IsNewResource_Call) Return(b bool) *MockResourceData_IsNewResource_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockResourceData_IsNewResource_Call) RunAndReturn(run func() bool) *MockResourceData_IsNewResource_Call {
	_c.Call.Return(run)
	return _c
}

// Set provides a mock function for the type MockResourceData
func (_mock *MockResourceData) Set(s string, v any) error {
	ret := _mock.Called(s, v)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, any) error); ok {
		r0 = returnFunc(s, v)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Set is a helper method to define mock.On call
//   - s
//   - v
func (_e *MockResourceData_Expecter) Set(s interface{}, v interface{}) *MockResourceData_Set_Call {
	return &MockResourceData_Set_Call{Call: _e.mock.On("Set", s, v)}
}

func (_c *MockResourceData_Set_Call) Run(run func(s string, v any)) *MockResourceData_Set_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(any))
	})
	return _c
}

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

func (_c *MockResourceData_Set_Call) RunAndReturn(run func(s string, v any) error) *MockResourceData_Set_Call {
	_c.Call.Return(run)
	return _c
}

// SetId provides a mock function for the type MockResourceData
func (_mock *MockResourceData) SetId(s string) {
	_mock.Called(s)
	return
}

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

// SetId is a helper method to define mock.On call
//   - s
func (_e *MockResourceData_Expecter) SetId(s interface{}) *MockResourceData_SetId_Call {
	return &MockResourceData_SetId_Call{Call: _e.mock.On("SetId", s)}
}

func (_c *MockResourceData_SetId_Call) Run(run func(s string)) *MockResourceData_SetId_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

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

func (_c *MockResourceData_SetId_Call) RunAndReturn(run func(s string)) *MockResourceData_SetId_Call {
	_c.Run(run)
	return _c
}

// Timeout provides a mock function for the type MockResourceData
func (_mock *MockResourceData) Timeout(s string) time.Duration {
	ret := _mock.Called(s)

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

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

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

// Timeout is a helper method to define mock.On call
//   - s
func (_e *MockResourceData_Expecter) Timeout(s interface{}) *MockResourceData_Timeout_Call {
	return &MockResourceData_Timeout_Call{Call: _e.mock.On("Timeout", s)}
}

func (_c *MockResourceData_Timeout_Call) Run(run func(s string)) *MockResourceData_Timeout_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockResourceData_Timeout_Call) Return(duration time.Duration) *MockResourceData_Timeout_Call {
	_c.Call.Return(duration)
	return _c
}

func (_c *MockResourceData_Timeout_Call) RunAndReturn(run func(s string) time.Duration) *MockResourceData_Timeout_Call {
	_c.Call.Return(run)
	return _c
}
