// Code generated by mockery v2.53.4. DO NOT EDIT.

package utils

import (
	mock "github.com/stretchr/testify/mock"
	runtime "k8s.io/apimachinery/pkg/runtime"

	schema "k8s.io/apimachinery/pkg/runtime/schema"

	time "time"

	types "k8s.io/apimachinery/pkg/types"

	v0alpha1 "github.com/grafana/grafana/pkg/apimachinery/apis/common/v0alpha1"

	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

// MockGrafanaMetaAccessor is an autogenerated mock type for the GrafanaMetaAccessor type
type MockGrafanaMetaAccessor struct {
	mock.Mock
}

type MockGrafanaMetaAccessor_Expecter struct {
	mock *mock.Mock
}

func (_m *MockGrafanaMetaAccessor) EXPECT() *MockGrafanaMetaAccessor_Expecter {
	return &MockGrafanaMetaAccessor_Expecter{mock: &_m.Mock}
}

// FindTitle provides a mock function with given fields: defaultTitle
func (_m *MockGrafanaMetaAccessor) FindTitle(defaultTitle string) string {
	ret := _m.Called(defaultTitle)

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

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

	return r0
}

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

// FindTitle is a helper method to define mock.On call
//   - defaultTitle string
func (_e *MockGrafanaMetaAccessor_Expecter) FindTitle(defaultTitle interface{}) *MockGrafanaMetaAccessor_FindTitle_Call {
	return &MockGrafanaMetaAccessor_FindTitle_Call{Call: _e.mock.On("FindTitle", defaultTitle)}
}

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

func (_c *MockGrafanaMetaAccessor_FindTitle_Call) Return(_a0 string) *MockGrafanaMetaAccessor_FindTitle_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetAnnotation provides a mock function with given fields: key
func (_m *MockGrafanaMetaAccessor) GetAnnotation(key string) string {
	ret := _m.Called(key)

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

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

	return r0
}

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

// GetAnnotation is a helper method to define mock.On call
//   - key string
func (_e *MockGrafanaMetaAccessor_Expecter) GetAnnotation(key interface{}) *MockGrafanaMetaAccessor_GetAnnotation_Call {
	return &MockGrafanaMetaAccessor_GetAnnotation_Call{Call: _e.mock.On("GetAnnotation", key)}
}

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

func (_c *MockGrafanaMetaAccessor_GetAnnotation_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetAnnotation_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetAnnotations provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetAnnotations() map[string]string {
	ret := _m.Called()

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

	var r0 map[string]string
	if rf, ok := ret.Get(0).(func() map[string]string); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]string)
		}
	}

	return r0
}

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

// GetAnnotations is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetAnnotations() *MockGrafanaMetaAccessor_GetAnnotations_Call {
	return &MockGrafanaMetaAccessor_GetAnnotations_Call{Call: _e.mock.On("GetAnnotations")}
}

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

func (_c *MockGrafanaMetaAccessor_GetAnnotations_Call) Return(_a0 map[string]string) *MockGrafanaMetaAccessor_GetAnnotations_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGrafanaMetaAccessor_GetAnnotations_Call) RunAndReturn(run func() map[string]string) *MockGrafanaMetaAccessor_GetAnnotations_Call {
	_c.Call.Return(run)
	return _c
}

// GetBlob provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetBlob() *BlobInfo {
	ret := _m.Called()

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

	var r0 *BlobInfo
	if rf, ok := ret.Get(0).(func() *BlobInfo); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*BlobInfo)
		}
	}

	return r0
}

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

// GetBlob is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetBlob() *MockGrafanaMetaAccessor_GetBlob_Call {
	return &MockGrafanaMetaAccessor_GetBlob_Call{Call: _e.mock.On("GetBlob")}
}

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

func (_c *MockGrafanaMetaAccessor_GetBlob_Call) Return(_a0 *BlobInfo) *MockGrafanaMetaAccessor_GetBlob_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGrafanaMetaAccessor_GetBlob_Call) RunAndReturn(run func() *BlobInfo) *MockGrafanaMetaAccessor_GetBlob_Call {
	_c.Call.Return(run)
	return _c
}

// GetCreatedBy provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetCreatedBy() string {
	ret := _m.Called()

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

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

	return r0
}

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

// GetCreatedBy is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetCreatedBy() *MockGrafanaMetaAccessor_GetCreatedBy_Call {
	return &MockGrafanaMetaAccessor_GetCreatedBy_Call{Call: _e.mock.On("GetCreatedBy")}
}

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

func (_c *MockGrafanaMetaAccessor_GetCreatedBy_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetCreatedBy_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetCreationTimestamp provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetCreationTimestamp() v1.Time {
	ret := _m.Called()

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

	var r0 v1.Time
	if rf, ok := ret.Get(0).(func() v1.Time); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(v1.Time)
	}

	return r0
}

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

// GetCreationTimestamp is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetCreationTimestamp() *MockGrafanaMetaAccessor_GetCreationTimestamp_Call {
	return &MockGrafanaMetaAccessor_GetCreationTimestamp_Call{Call: _e.mock.On("GetCreationTimestamp")}
}

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

func (_c *MockGrafanaMetaAccessor_GetCreationTimestamp_Call) Return(_a0 v1.Time) *MockGrafanaMetaAccessor_GetCreationTimestamp_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGrafanaMetaAccessor_GetCreationTimestamp_Call) RunAndReturn(run func() v1.Time) *MockGrafanaMetaAccessor_GetCreationTimestamp_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeletionGracePeriodSeconds provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetDeletionGracePeriodSeconds() *int64 {
	ret := _m.Called()

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

	var r0 *int64
	if rf, ok := ret.Get(0).(func() *int64); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*int64)
		}
	}

	return r0
}

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

// GetDeletionGracePeriodSeconds is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetDeletionGracePeriodSeconds() *MockGrafanaMetaAccessor_GetDeletionGracePeriodSeconds_Call {
	return &MockGrafanaMetaAccessor_GetDeletionGracePeriodSeconds_Call{Call: _e.mock.On("GetDeletionGracePeriodSeconds")}
}

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

func (_c *MockGrafanaMetaAccessor_GetDeletionGracePeriodSeconds_Call) Return(_a0 *int64) *MockGrafanaMetaAccessor_GetDeletionGracePeriodSeconds_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGrafanaMetaAccessor_GetDeletionGracePeriodSeconds_Call) RunAndReturn(run func() *int64) *MockGrafanaMetaAccessor_GetDeletionGracePeriodSeconds_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeletionTimestamp provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetDeletionTimestamp() *v1.Time {
	ret := _m.Called()

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

	var r0 *v1.Time
	if rf, ok := ret.Get(0).(func() *v1.Time); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v1.Time)
		}
	}

	return r0
}

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

// GetDeletionTimestamp is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetDeletionTimestamp() *MockGrafanaMetaAccessor_GetDeletionTimestamp_Call {
	return &MockGrafanaMetaAccessor_GetDeletionTimestamp_Call{Call: _e.mock.On("GetDeletionTimestamp")}
}

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

func (_c *MockGrafanaMetaAccessor_GetDeletionTimestamp_Call) Return(_a0 *v1.Time) *MockGrafanaMetaAccessor_GetDeletionTimestamp_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGrafanaMetaAccessor_GetDeletionTimestamp_Call) RunAndReturn(run func() *v1.Time) *MockGrafanaMetaAccessor_GetDeletionTimestamp_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeprecatedInternalID provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetDeprecatedInternalID() int64 {
	ret := _m.Called()

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

	var r0 int64
	if rf, ok := ret.Get(0).(func() int64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int64)
	}

	return r0
}

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

// GetDeprecatedInternalID is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetDeprecatedInternalID() *MockGrafanaMetaAccessor_GetDeprecatedInternalID_Call {
	return &MockGrafanaMetaAccessor_GetDeprecatedInternalID_Call{Call: _e.mock.On("GetDeprecatedInternalID")}
}

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

func (_c *MockGrafanaMetaAccessor_GetDeprecatedInternalID_Call) Return(_a0 int64) *MockGrafanaMetaAccessor_GetDeprecatedInternalID_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGrafanaMetaAccessor_GetDeprecatedInternalID_Call) RunAndReturn(run func() int64) *MockGrafanaMetaAccessor_GetDeprecatedInternalID_Call {
	_c.Call.Return(run)
	return _c
}

// GetFinalizers provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetFinalizers() []string {
	ret := _m.Called()

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

	var r0 []string
	if rf, ok := ret.Get(0).(func() []string); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}

	return r0
}

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

// GetFinalizers is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetFinalizers() *MockGrafanaMetaAccessor_GetFinalizers_Call {
	return &MockGrafanaMetaAccessor_GetFinalizers_Call{Call: _e.mock.On("GetFinalizers")}
}

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

func (_c *MockGrafanaMetaAccessor_GetFinalizers_Call) Return(_a0 []string) *MockGrafanaMetaAccessor_GetFinalizers_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGrafanaMetaAccessor_GetFinalizers_Call) RunAndReturn(run func() []string) *MockGrafanaMetaAccessor_GetFinalizers_Call {
	_c.Call.Return(run)
	return _c
}

// GetFolder provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetFolder() string {
	ret := _m.Called()

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

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

	return r0
}

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

// GetFolder is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetFolder() *MockGrafanaMetaAccessor_GetFolder_Call {
	return &MockGrafanaMetaAccessor_GetFolder_Call{Call: _e.mock.On("GetFolder")}
}

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

func (_c *MockGrafanaMetaAccessor_GetFolder_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetFolder_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetFullpath provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetFullpath() string {
	ret := _m.Called()

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

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

	return r0
}

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

// GetFullpath is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetFullpath() *MockGrafanaMetaAccessor_GetFullpath_Call {
	return &MockGrafanaMetaAccessor_GetFullpath_Call{Call: _e.mock.On("GetFullpath")}
}

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

func (_c *MockGrafanaMetaAccessor_GetFullpath_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetFullpath_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetFullpathUIDs provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetFullpathUIDs() string {
	ret := _m.Called()

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

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

	return r0
}

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

// GetFullpathUIDs is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetFullpathUIDs() *MockGrafanaMetaAccessor_GetFullpathUIDs_Call {
	return &MockGrafanaMetaAccessor_GetFullpathUIDs_Call{Call: _e.mock.On("GetFullpathUIDs")}
}

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

func (_c *MockGrafanaMetaAccessor_GetFullpathUIDs_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetFullpathUIDs_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetGenerateName provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetGenerateName() string {
	ret := _m.Called()

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

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

	return r0
}

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

// GetGenerateName is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetGenerateName() *MockGrafanaMetaAccessor_GetGenerateName_Call {
	return &MockGrafanaMetaAccessor_GetGenerateName_Call{Call: _e.mock.On("GetGenerateName")}
}

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

func (_c *MockGrafanaMetaAccessor_GetGenerateName_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetGenerateName_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetGeneration provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetGeneration() int64 {
	ret := _m.Called()

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

	var r0 int64
	if rf, ok := ret.Get(0).(func() int64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int64)
	}

	return r0
}

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

// GetGeneration is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetGeneration() *MockGrafanaMetaAccessor_GetGeneration_Call {
	return &MockGrafanaMetaAccessor_GetGeneration_Call{Call: _e.mock.On("GetGeneration")}
}

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

func (_c *MockGrafanaMetaAccessor_GetGeneration_Call) Return(_a0 int64) *MockGrafanaMetaAccessor_GetGeneration_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGrafanaMetaAccessor_GetGeneration_Call) RunAndReturn(run func() int64) *MockGrafanaMetaAccessor_GetGeneration_Call {
	_c.Call.Return(run)
	return _c
}

// GetGroupVersionKind provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetGroupVersionKind() schema.GroupVersionKind {
	ret := _m.Called()

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

	var r0 schema.GroupVersionKind
	if rf, ok := ret.Get(0).(func() schema.GroupVersionKind); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(schema.GroupVersionKind)
	}

	return r0
}

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

// GetGroupVersionKind is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetGroupVersionKind() *MockGrafanaMetaAccessor_GetGroupVersionKind_Call {
	return &MockGrafanaMetaAccessor_GetGroupVersionKind_Call{Call: _e.mock.On("GetGroupVersionKind")}
}

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

func (_c *MockGrafanaMetaAccessor_GetGroupVersionKind_Call) Return(_a0 schema.GroupVersionKind) *MockGrafanaMetaAccessor_GetGroupVersionKind_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGrafanaMetaAccessor_GetGroupVersionKind_Call) RunAndReturn(run func() schema.GroupVersionKind) *MockGrafanaMetaAccessor_GetGroupVersionKind_Call {
	_c.Call.Return(run)
	return _c
}

// GetLabels provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetLabels() map[string]string {
	ret := _m.Called()

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

	var r0 map[string]string
	if rf, ok := ret.Get(0).(func() map[string]string); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]string)
		}
	}

	return r0
}

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

// GetLabels is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetLabels() *MockGrafanaMetaAccessor_GetLabels_Call {
	return &MockGrafanaMetaAccessor_GetLabels_Call{Call: _e.mock.On("GetLabels")}
}

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

func (_c *MockGrafanaMetaAccessor_GetLabels_Call) Return(_a0 map[string]string) *MockGrafanaMetaAccessor_GetLabels_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGrafanaMetaAccessor_GetLabels_Call) RunAndReturn(run func() map[string]string) *MockGrafanaMetaAccessor_GetLabels_Call {
	_c.Call.Return(run)
	return _c
}

// GetManagedFields provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetManagedFields() []v1.ManagedFieldsEntry {
	ret := _m.Called()

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

	var r0 []v1.ManagedFieldsEntry
	if rf, ok := ret.Get(0).(func() []v1.ManagedFieldsEntry); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]v1.ManagedFieldsEntry)
		}
	}

	return r0
}

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

// GetManagedFields is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetManagedFields() *MockGrafanaMetaAccessor_GetManagedFields_Call {
	return &MockGrafanaMetaAccessor_GetManagedFields_Call{Call: _e.mock.On("GetManagedFields")}
}

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

func (_c *MockGrafanaMetaAccessor_GetManagedFields_Call) Return(_a0 []v1.ManagedFieldsEntry) *MockGrafanaMetaAccessor_GetManagedFields_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGrafanaMetaAccessor_GetManagedFields_Call) RunAndReturn(run func() []v1.ManagedFieldsEntry) *MockGrafanaMetaAccessor_GetManagedFields_Call {
	_c.Call.Return(run)
	return _c
}

// GetManagerProperties provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetManagerProperties() (ManagerProperties, bool) {
	ret := _m.Called()

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

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

	if rf, ok := ret.Get(1).(func() bool); ok {
		r1 = rf()
	} else {
		r1 = ret.Get(1).(bool)
	}

	return r0, r1
}

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

// GetManagerProperties is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetManagerProperties() *MockGrafanaMetaAccessor_GetManagerProperties_Call {
	return &MockGrafanaMetaAccessor_GetManagerProperties_Call{Call: _e.mock.On("GetManagerProperties")}
}

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

func (_c *MockGrafanaMetaAccessor_GetManagerProperties_Call) Return(_a0 ManagerProperties, _a1 bool) *MockGrafanaMetaAccessor_GetManagerProperties_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockGrafanaMetaAccessor_GetManagerProperties_Call) RunAndReturn(run func() (ManagerProperties, bool)) *MockGrafanaMetaAccessor_GetManagerProperties_Call {
	_c.Call.Return(run)
	return _c
}

// GetMessage provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetMessage() string {
	ret := _m.Called()

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

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

	return r0
}

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

// GetMessage is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetMessage() *MockGrafanaMetaAccessor_GetMessage_Call {
	return &MockGrafanaMetaAccessor_GetMessage_Call{Call: _e.mock.On("GetMessage")}
}

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

func (_c *MockGrafanaMetaAccessor_GetMessage_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetMessage_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetName provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetName() string {
	ret := _m.Called()

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

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

	return r0
}

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

// GetName is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetName() *MockGrafanaMetaAccessor_GetName_Call {
	return &MockGrafanaMetaAccessor_GetName_Call{Call: _e.mock.On("GetName")}
}

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

func (_c *MockGrafanaMetaAccessor_GetName_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetName_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetNamespace provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetNamespace() string {
	ret := _m.Called()

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

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

	return r0
}

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

// GetNamespace is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetNamespace() *MockGrafanaMetaAccessor_GetNamespace_Call {
	return &MockGrafanaMetaAccessor_GetNamespace_Call{Call: _e.mock.On("GetNamespace")}
}

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

func (_c *MockGrafanaMetaAccessor_GetNamespace_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetNamespace_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetOwnerReferences provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetOwnerReferences() []v1.OwnerReference {
	ret := _m.Called()

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

	var r0 []v1.OwnerReference
	if rf, ok := ret.Get(0).(func() []v1.OwnerReference); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]v1.OwnerReference)
		}
	}

	return r0
}

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

// GetOwnerReferences is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetOwnerReferences() *MockGrafanaMetaAccessor_GetOwnerReferences_Call {
	return &MockGrafanaMetaAccessor_GetOwnerReferences_Call{Call: _e.mock.On("GetOwnerReferences")}
}

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

func (_c *MockGrafanaMetaAccessor_GetOwnerReferences_Call) Return(_a0 []v1.OwnerReference) *MockGrafanaMetaAccessor_GetOwnerReferences_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGrafanaMetaAccessor_GetOwnerReferences_Call) RunAndReturn(run func() []v1.OwnerReference) *MockGrafanaMetaAccessor_GetOwnerReferences_Call {
	_c.Call.Return(run)
	return _c
}

// GetResourceVersion provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetResourceVersion() string {
	ret := _m.Called()

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

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

	return r0
}

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

// GetResourceVersion is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetResourceVersion() *MockGrafanaMetaAccessor_GetResourceVersion_Call {
	return &MockGrafanaMetaAccessor_GetResourceVersion_Call{Call: _e.mock.On("GetResourceVersion")}
}

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

func (_c *MockGrafanaMetaAccessor_GetResourceVersion_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetResourceVersion_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetResourceVersionInt64 provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetResourceVersionInt64() (int64, error) {
	ret := _m.Called()

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

	var r0 int64
	var r1 error
	if rf, ok := ret.Get(0).(func() (int64, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() int64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int64)
	}

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetResourceVersionInt64 is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetResourceVersionInt64() *MockGrafanaMetaAccessor_GetResourceVersionInt64_Call {
	return &MockGrafanaMetaAccessor_GetResourceVersionInt64_Call{Call: _e.mock.On("GetResourceVersionInt64")}
}

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

func (_c *MockGrafanaMetaAccessor_GetResourceVersionInt64_Call) Return(_a0 int64, _a1 error) *MockGrafanaMetaAccessor_GetResourceVersionInt64_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockGrafanaMetaAccessor_GetResourceVersionInt64_Call) RunAndReturn(run func() (int64, error)) *MockGrafanaMetaAccessor_GetResourceVersionInt64_Call {
	_c.Call.Return(run)
	return _c
}

// GetRuntimeObject provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetRuntimeObject() (runtime.Object, bool) {
	ret := _m.Called()

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

	var r0 runtime.Object
	var r1 bool
	if rf, ok := ret.Get(0).(func() (runtime.Object, bool)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() runtime.Object); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(runtime.Object)
		}
	}

	if rf, ok := ret.Get(1).(func() bool); ok {
		r1 = rf()
	} else {
		r1 = ret.Get(1).(bool)
	}

	return r0, r1
}

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

// GetRuntimeObject is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetRuntimeObject() *MockGrafanaMetaAccessor_GetRuntimeObject_Call {
	return &MockGrafanaMetaAccessor_GetRuntimeObject_Call{Call: _e.mock.On("GetRuntimeObject")}
}

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

func (_c *MockGrafanaMetaAccessor_GetRuntimeObject_Call) Return(_a0 runtime.Object, _a1 bool) *MockGrafanaMetaAccessor_GetRuntimeObject_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockGrafanaMetaAccessor_GetRuntimeObject_Call) RunAndReturn(run func() (runtime.Object, bool)) *MockGrafanaMetaAccessor_GetRuntimeObject_Call {
	_c.Call.Return(run)
	return _c
}

// GetSecureValues provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetSecureValues() (map[string]v0alpha1.InlineSecureValue, error) {
	ret := _m.Called()

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

	var r0 map[string]v0alpha1.InlineSecureValue
	var r1 error
	if rf, ok := ret.Get(0).(func() (map[string]v0alpha1.InlineSecureValue, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() map[string]v0alpha1.InlineSecureValue); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]v0alpha1.InlineSecureValue)
		}
	}

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetSecureValues is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetSecureValues() *MockGrafanaMetaAccessor_GetSecureValues_Call {
	return &MockGrafanaMetaAccessor_GetSecureValues_Call{Call: _e.mock.On("GetSecureValues")}
}

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

func (_c *MockGrafanaMetaAccessor_GetSecureValues_Call) Return(_a0 map[string]v0alpha1.InlineSecureValue, _a1 error) *MockGrafanaMetaAccessor_GetSecureValues_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockGrafanaMetaAccessor_GetSecureValues_Call) RunAndReturn(run func() (map[string]v0alpha1.InlineSecureValue, error)) *MockGrafanaMetaAccessor_GetSecureValues_Call {
	_c.Call.Return(run)
	return _c
}

// GetSelfLink provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetSelfLink() string {
	ret := _m.Called()

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

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

	return r0
}

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

// GetSelfLink is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetSelfLink() *MockGrafanaMetaAccessor_GetSelfLink_Call {
	return &MockGrafanaMetaAccessor_GetSelfLink_Call{Call: _e.mock.On("GetSelfLink")}
}

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

func (_c *MockGrafanaMetaAccessor_GetSelfLink_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetSelfLink_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetSourceProperties provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetSourceProperties() (SourceProperties, bool) {
	ret := _m.Called()

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

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

	if rf, ok := ret.Get(1).(func() bool); ok {
		r1 = rf()
	} else {
		r1 = ret.Get(1).(bool)
	}

	return r0, r1
}

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

// GetSourceProperties is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetSourceProperties() *MockGrafanaMetaAccessor_GetSourceProperties_Call {
	return &MockGrafanaMetaAccessor_GetSourceProperties_Call{Call: _e.mock.On("GetSourceProperties")}
}

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

func (_c *MockGrafanaMetaAccessor_GetSourceProperties_Call) Return(_a0 SourceProperties, _a1 bool) *MockGrafanaMetaAccessor_GetSourceProperties_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockGrafanaMetaAccessor_GetSourceProperties_Call) RunAndReturn(run func() (SourceProperties, bool)) *MockGrafanaMetaAccessor_GetSourceProperties_Call {
	_c.Call.Return(run)
	return _c
}

// GetSpec provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetSpec() (interface{}, error) {
	ret := _m.Called()

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

	var r0 interface{}
	var r1 error
	if rf, ok := ret.Get(0).(func() (interface{}, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() interface{}); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(interface{})
		}
	}

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetSpec is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetSpec() *MockGrafanaMetaAccessor_GetSpec_Call {
	return &MockGrafanaMetaAccessor_GetSpec_Call{Call: _e.mock.On("GetSpec")}
}

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

func (_c *MockGrafanaMetaAccessor_GetSpec_Call) Return(_a0 interface{}, _a1 error) *MockGrafanaMetaAccessor_GetSpec_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockGrafanaMetaAccessor_GetSpec_Call) RunAndReturn(run func() (interface{}, error)) *MockGrafanaMetaAccessor_GetSpec_Call {
	_c.Call.Return(run)
	return _c
}

// GetStatus provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetStatus() (interface{}, error) {
	ret := _m.Called()

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

	var r0 interface{}
	var r1 error
	if rf, ok := ret.Get(0).(func() (interface{}, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() interface{}); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(interface{})
		}
	}

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetStatus is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetStatus() *MockGrafanaMetaAccessor_GetStatus_Call {
	return &MockGrafanaMetaAccessor_GetStatus_Call{Call: _e.mock.On("GetStatus")}
}

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

func (_c *MockGrafanaMetaAccessor_GetStatus_Call) Return(_a0 interface{}, _a1 error) *MockGrafanaMetaAccessor_GetStatus_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockGrafanaMetaAccessor_GetStatus_Call) RunAndReturn(run func() (interface{}, error)) *MockGrafanaMetaAccessor_GetStatus_Call {
	_c.Call.Return(run)
	return _c
}

// GetUID provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetUID() types.UID {
	ret := _m.Called()

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

	var r0 types.UID
	if rf, ok := ret.Get(0).(func() types.UID); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(types.UID)
	}

	return r0
}

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

// GetUID is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetUID() *MockGrafanaMetaAccessor_GetUID_Call {
	return &MockGrafanaMetaAccessor_GetUID_Call{Call: _e.mock.On("GetUID")}
}

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

func (_c *MockGrafanaMetaAccessor_GetUID_Call) Return(_a0 types.UID) *MockGrafanaMetaAccessor_GetUID_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGrafanaMetaAccessor_GetUID_Call) RunAndReturn(run func() types.UID) *MockGrafanaMetaAccessor_GetUID_Call {
	_c.Call.Return(run)
	return _c
}

// GetUpdatedBy provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetUpdatedBy() string {
	ret := _m.Called()

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

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

	return r0
}

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

// GetUpdatedBy is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetUpdatedBy() *MockGrafanaMetaAccessor_GetUpdatedBy_Call {
	return &MockGrafanaMetaAccessor_GetUpdatedBy_Call{Call: _e.mock.On("GetUpdatedBy")}
}

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

func (_c *MockGrafanaMetaAccessor_GetUpdatedBy_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetUpdatedBy_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetUpdatedTimestamp provides a mock function with no fields
func (_m *MockGrafanaMetaAccessor) GetUpdatedTimestamp() (*time.Time, error) {
	ret := _m.Called()

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

	var r0 *time.Time
	var r1 error
	if rf, ok := ret.Get(0).(func() (*time.Time, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() *time.Time); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*time.Time)
		}
	}

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetUpdatedTimestamp is a helper method to define mock.On call
func (_e *MockGrafanaMetaAccessor_Expecter) GetUpdatedTimestamp() *MockGrafanaMetaAccessor_GetUpdatedTimestamp_Call {
	return &MockGrafanaMetaAccessor_GetUpdatedTimestamp_Call{Call: _e.mock.On("GetUpdatedTimestamp")}
}

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

func (_c *MockGrafanaMetaAccessor_GetUpdatedTimestamp_Call) Return(_a0 *time.Time, _a1 error) *MockGrafanaMetaAccessor_GetUpdatedTimestamp_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockGrafanaMetaAccessor_GetUpdatedTimestamp_Call) RunAndReturn(run func() (*time.Time, error)) *MockGrafanaMetaAccessor_GetUpdatedTimestamp_Call {
	_c.Call.Return(run)
	return _c
}

// SetAnnotation provides a mock function with given fields: key, val
func (_m *MockGrafanaMetaAccessor) SetAnnotation(key string, val string) {
	_m.Called(key, val)
}

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

// SetAnnotation is a helper method to define mock.On call
//   - key string
//   - val string
func (_e *MockGrafanaMetaAccessor_Expecter) SetAnnotation(key interface{}, val interface{}) *MockGrafanaMetaAccessor_SetAnnotation_Call {
	return &MockGrafanaMetaAccessor_SetAnnotation_Call{Call: _e.mock.On("SetAnnotation", key, val)}
}

func (_c *MockGrafanaMetaAccessor_SetAnnotation_Call) Run(run func(key string, val string)) *MockGrafanaMetaAccessor_SetAnnotation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string))
	})
	return _c
}

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

func (_c *MockGrafanaMetaAccessor_SetAnnotation_Call) RunAndReturn(run func(string, string)) *MockGrafanaMetaAccessor_SetAnnotation_Call {
	_c.Run(run)
	return _c
}

// SetAnnotations provides a mock function with given fields: annotations
func (_m *MockGrafanaMetaAccessor) SetAnnotations(annotations map[string]string) {
	_m.Called(annotations)
}

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

// SetAnnotations is a helper method to define mock.On call
//   - annotations map[string]string
func (_e *MockGrafanaMetaAccessor_Expecter) SetAnnotations(annotations interface{}) *MockGrafanaMetaAccessor_SetAnnotations_Call {
	return &MockGrafanaMetaAccessor_SetAnnotations_Call{Call: _e.mock.On("SetAnnotations", annotations)}
}

func (_c *MockGrafanaMetaAccessor_SetAnnotations_Call) Run(run func(annotations map[string]string)) *MockGrafanaMetaAccessor_SetAnnotations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(map[string]string))
	})
	return _c
}

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

func (_c *MockGrafanaMetaAccessor_SetAnnotations_Call) RunAndReturn(run func(map[string]string)) *MockGrafanaMetaAccessor_SetAnnotations_Call {
	_c.Run(run)
	return _c
}

// SetBlob provides a mock function with given fields: v
func (_m *MockGrafanaMetaAccessor) SetBlob(v *BlobInfo) {
	_m.Called(v)
}

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

// SetBlob is a helper method to define mock.On call
//   - v *BlobInfo
func (_e *MockGrafanaMetaAccessor_Expecter) SetBlob(v interface{}) *MockGrafanaMetaAccessor_SetBlob_Call {
	return &MockGrafanaMetaAccessor_SetBlob_Call{Call: _e.mock.On("SetBlob", v)}
}

func (_c *MockGrafanaMetaAccessor_SetBlob_Call) Run(run func(v *BlobInfo)) *MockGrafanaMetaAccessor_SetBlob_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*BlobInfo))
	})
	return _c
}

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

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

// SetCreatedBy provides a mock function with given fields: user
func (_m *MockGrafanaMetaAccessor) SetCreatedBy(user string) {
	_m.Called(user)
}

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

// SetCreatedBy is a helper method to define mock.On call
//   - user string
func (_e *MockGrafanaMetaAccessor_Expecter) SetCreatedBy(user interface{}) *MockGrafanaMetaAccessor_SetCreatedBy_Call {
	return &MockGrafanaMetaAccessor_SetCreatedBy_Call{Call: _e.mock.On("SetCreatedBy", user)}
}

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

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

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

// SetCreationTimestamp provides a mock function with given fields: timestamp
func (_m *MockGrafanaMetaAccessor) SetCreationTimestamp(timestamp v1.Time) {
	_m.Called(timestamp)
}

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

// SetCreationTimestamp is a helper method to define mock.On call
//   - timestamp v1.Time
func (_e *MockGrafanaMetaAccessor_Expecter) SetCreationTimestamp(timestamp interface{}) *MockGrafanaMetaAccessor_SetCreationTimestamp_Call {
	return &MockGrafanaMetaAccessor_SetCreationTimestamp_Call{Call: _e.mock.On("SetCreationTimestamp", timestamp)}
}

func (_c *MockGrafanaMetaAccessor_SetCreationTimestamp_Call) Run(run func(timestamp v1.Time)) *MockGrafanaMetaAccessor_SetCreationTimestamp_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(v1.Time))
	})
	return _c
}

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

func (_c *MockGrafanaMetaAccessor_SetCreationTimestamp_Call) RunAndReturn(run func(v1.Time)) *MockGrafanaMetaAccessor_SetCreationTimestamp_Call {
	_c.Run(run)
	return _c
}

// SetDeletionGracePeriodSeconds provides a mock function with given fields: _a0
func (_m *MockGrafanaMetaAccessor) SetDeletionGracePeriodSeconds(_a0 *int64) {
	_m.Called(_a0)
}

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

// SetDeletionGracePeriodSeconds is a helper method to define mock.On call
//   - _a0 *int64
func (_e *MockGrafanaMetaAccessor_Expecter) SetDeletionGracePeriodSeconds(_a0 interface{}) *MockGrafanaMetaAccessor_SetDeletionGracePeriodSeconds_Call {
	return &MockGrafanaMetaAccessor_SetDeletionGracePeriodSeconds_Call{Call: _e.mock.On("SetDeletionGracePeriodSeconds", _a0)}
}

func (_c *MockGrafanaMetaAccessor_SetDeletionGracePeriodSeconds_Call) Run(run func(_a0 *int64)) *MockGrafanaMetaAccessor_SetDeletionGracePeriodSeconds_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*int64))
	})
	return _c
}

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

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

// SetDeletionTimestamp provides a mock function with given fields: timestamp
func (_m *MockGrafanaMetaAccessor) SetDeletionTimestamp(timestamp *v1.Time) {
	_m.Called(timestamp)
}

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

// SetDeletionTimestamp is a helper method to define mock.On call
//   - timestamp *v1.Time
func (_e *MockGrafanaMetaAccessor_Expecter) SetDeletionTimestamp(timestamp interface{}) *MockGrafanaMetaAccessor_SetDeletionTimestamp_Call {
	return &MockGrafanaMetaAccessor_SetDeletionTimestamp_Call{Call: _e.mock.On("SetDeletionTimestamp", timestamp)}
}

func (_c *MockGrafanaMetaAccessor_SetDeletionTimestamp_Call) Run(run func(timestamp *v1.Time)) *MockGrafanaMetaAccessor_SetDeletionTimestamp_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*v1.Time))
	})
	return _c
}

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

func (_c *MockGrafanaMetaAccessor_SetDeletionTimestamp_Call) RunAndReturn(run func(*v1.Time)) *MockGrafanaMetaAccessor_SetDeletionTimestamp_Call {
	_c.Run(run)
	return _c
}

// SetDeprecatedInternalID provides a mock function with given fields: id
func (_m *MockGrafanaMetaAccessor) SetDeprecatedInternalID(id int64) {
	_m.Called(id)
}

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

// SetDeprecatedInternalID is a helper method to define mock.On call
//   - id int64
func (_e *MockGrafanaMetaAccessor_Expecter) SetDeprecatedInternalID(id interface{}) *MockGrafanaMetaAccessor_SetDeprecatedInternalID_Call {
	return &MockGrafanaMetaAccessor_SetDeprecatedInternalID_Call{Call: _e.mock.On("SetDeprecatedInternalID", id)}
}

func (_c *MockGrafanaMetaAccessor_SetDeprecatedInternalID_Call) Run(run func(id int64)) *MockGrafanaMetaAccessor_SetDeprecatedInternalID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

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

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

// SetFinalizers provides a mock function with given fields: finalizers
func (_m *MockGrafanaMetaAccessor) SetFinalizers(finalizers []string) {
	_m.Called(finalizers)
}

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

// SetFinalizers is a helper method to define mock.On call
//   - finalizers []string
func (_e *MockGrafanaMetaAccessor_Expecter) SetFinalizers(finalizers interface{}) *MockGrafanaMetaAccessor_SetFinalizers_Call {
	return &MockGrafanaMetaAccessor_SetFinalizers_Call{Call: _e.mock.On("SetFinalizers", finalizers)}
}

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

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

func (_c *MockGrafanaMetaAccessor_SetFinalizers_Call) RunAndReturn(run func([]string)) *MockGrafanaMetaAccessor_SetFinalizers_Call {
	_c.Run(run)
	return _c
}

// SetFolder provides a mock function with given fields: uid
func (_m *MockGrafanaMetaAccessor) SetFolder(uid string) {
	_m.Called(uid)
}

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

// SetFolder is a helper method to define mock.On call
//   - uid string
func (_e *MockGrafanaMetaAccessor_Expecter) SetFolder(uid interface{}) *MockGrafanaMetaAccessor_SetFolder_Call {
	return &MockGrafanaMetaAccessor_SetFolder_Call{Call: _e.mock.On("SetFolder", uid)}
}

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

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

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

// SetFullpath provides a mock function with given fields: path
func (_m *MockGrafanaMetaAccessor) SetFullpath(path string) {
	_m.Called(path)
}

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

// SetFullpath is a helper method to define mock.On call
//   - path string
func (_e *MockGrafanaMetaAccessor_Expecter) SetFullpath(path interface{}) *MockGrafanaMetaAccessor_SetFullpath_Call {
	return &MockGrafanaMetaAccessor_SetFullpath_Call{Call: _e.mock.On("SetFullpath", path)}
}

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

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

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

// SetFullpathUIDs provides a mock function with given fields: uids
func (_m *MockGrafanaMetaAccessor) SetFullpathUIDs(uids string) {
	_m.Called(uids)
}

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

// SetFullpathUIDs is a helper method to define mock.On call
//   - uids string
func (_e *MockGrafanaMetaAccessor_Expecter) SetFullpathUIDs(uids interface{}) *MockGrafanaMetaAccessor_SetFullpathUIDs_Call {
	return &MockGrafanaMetaAccessor_SetFullpathUIDs_Call{Call: _e.mock.On("SetFullpathUIDs", uids)}
}

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

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

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

// SetGenerateName provides a mock function with given fields: name
func (_m *MockGrafanaMetaAccessor) SetGenerateName(name string) {
	_m.Called(name)
}

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

// SetGenerateName is a helper method to define mock.On call
//   - name string
func (_e *MockGrafanaMetaAccessor_Expecter) SetGenerateName(name interface{}) *MockGrafanaMetaAccessor_SetGenerateName_Call {
	return &MockGrafanaMetaAccessor_SetGenerateName_Call{Call: _e.mock.On("SetGenerateName", name)}
}

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

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

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

// SetGeneration provides a mock function with given fields: generation
func (_m *MockGrafanaMetaAccessor) SetGeneration(generation int64) {
	_m.Called(generation)
}

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

// SetGeneration is a helper method to define mock.On call
//   - generation int64
func (_e *MockGrafanaMetaAccessor_Expecter) SetGeneration(generation interface{}) *MockGrafanaMetaAccessor_SetGeneration_Call {
	return &MockGrafanaMetaAccessor_SetGeneration_Call{Call: _e.mock.On("SetGeneration", generation)}
}

func (_c *MockGrafanaMetaAccessor_SetGeneration_Call) Run(run func(generation int64)) *MockGrafanaMetaAccessor_SetGeneration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

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

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

// SetLabels provides a mock function with given fields: labels
func (_m *MockGrafanaMetaAccessor) SetLabels(labels map[string]string) {
	_m.Called(labels)
}

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

// SetLabels is a helper method to define mock.On call
//   - labels map[string]string
func (_e *MockGrafanaMetaAccessor_Expecter) SetLabels(labels interface{}) *MockGrafanaMetaAccessor_SetLabels_Call {
	return &MockGrafanaMetaAccessor_SetLabels_Call{Call: _e.mock.On("SetLabels", labels)}
}

func (_c *MockGrafanaMetaAccessor_SetLabels_Call) Run(run func(labels map[string]string)) *MockGrafanaMetaAccessor_SetLabels_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(map[string]string))
	})
	return _c
}

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

func (_c *MockGrafanaMetaAccessor_SetLabels_Call) RunAndReturn(run func(map[string]string)) *MockGrafanaMetaAccessor_SetLabels_Call {
	_c.Run(run)
	return _c
}

// SetManagedFields provides a mock function with given fields: managedFields
func (_m *MockGrafanaMetaAccessor) SetManagedFields(managedFields []v1.ManagedFieldsEntry) {
	_m.Called(managedFields)
}

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

// SetManagedFields is a helper method to define mock.On call
//   - managedFields []v1.ManagedFieldsEntry
func (_e *MockGrafanaMetaAccessor_Expecter) SetManagedFields(managedFields interface{}) *MockGrafanaMetaAccessor_SetManagedFields_Call {
	return &MockGrafanaMetaAccessor_SetManagedFields_Call{Call: _e.mock.On("SetManagedFields", managedFields)}
}

func (_c *MockGrafanaMetaAccessor_SetManagedFields_Call) Run(run func(managedFields []v1.ManagedFieldsEntry)) *MockGrafanaMetaAccessor_SetManagedFields_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].([]v1.ManagedFieldsEntry))
	})
	return _c
}

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

func (_c *MockGrafanaMetaAccessor_SetManagedFields_Call) RunAndReturn(run func([]v1.ManagedFieldsEntry)) *MockGrafanaMetaAccessor_SetManagedFields_Call {
	_c.Run(run)
	return _c
}

// SetManagerProperties provides a mock function with given fields: _a0
func (_m *MockGrafanaMetaAccessor) SetManagerProperties(_a0 ManagerProperties) {
	_m.Called(_a0)
}

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

// SetManagerProperties is a helper method to define mock.On call
//   - _a0 ManagerProperties
func (_e *MockGrafanaMetaAccessor_Expecter) SetManagerProperties(_a0 interface{}) *MockGrafanaMetaAccessor_SetManagerProperties_Call {
	return &MockGrafanaMetaAccessor_SetManagerProperties_Call{Call: _e.mock.On("SetManagerProperties", _a0)}
}

func (_c *MockGrafanaMetaAccessor_SetManagerProperties_Call) Run(run func(_a0 ManagerProperties)) *MockGrafanaMetaAccessor_SetManagerProperties_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(ManagerProperties))
	})
	return _c
}

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

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

// SetMessage provides a mock function with given fields: msg
func (_m *MockGrafanaMetaAccessor) SetMessage(msg string) {
	_m.Called(msg)
}

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

// SetMessage is a helper method to define mock.On call
//   - msg string
func (_e *MockGrafanaMetaAccessor_Expecter) SetMessage(msg interface{}) *MockGrafanaMetaAccessor_SetMessage_Call {
	return &MockGrafanaMetaAccessor_SetMessage_Call{Call: _e.mock.On("SetMessage", msg)}
}

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

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

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

// SetName provides a mock function with given fields: name
func (_m *MockGrafanaMetaAccessor) SetName(name string) {
	_m.Called(name)
}

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

// SetName is a helper method to define mock.On call
//   - name string
func (_e *MockGrafanaMetaAccessor_Expecter) SetName(name interface{}) *MockGrafanaMetaAccessor_SetName_Call {
	return &MockGrafanaMetaAccessor_SetName_Call{Call: _e.mock.On("SetName", name)}
}

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

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

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

// SetNamespace provides a mock function with given fields: namespace
func (_m *MockGrafanaMetaAccessor) SetNamespace(namespace string) {
	_m.Called(namespace)
}

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

// SetNamespace is a helper method to define mock.On call
//   - namespace string
func (_e *MockGrafanaMetaAccessor_Expecter) SetNamespace(namespace interface{}) *MockGrafanaMetaAccessor_SetNamespace_Call {
	return &MockGrafanaMetaAccessor_SetNamespace_Call{Call: _e.mock.On("SetNamespace", namespace)}
}

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

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

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

// SetOwnerReferences provides a mock function with given fields: _a0
func (_m *MockGrafanaMetaAccessor) SetOwnerReferences(_a0 []v1.OwnerReference) {
	_m.Called(_a0)
}

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

// SetOwnerReferences is a helper method to define mock.On call
//   - _a0 []v1.OwnerReference
func (_e *MockGrafanaMetaAccessor_Expecter) SetOwnerReferences(_a0 interface{}) *MockGrafanaMetaAccessor_SetOwnerReferences_Call {
	return &MockGrafanaMetaAccessor_SetOwnerReferences_Call{Call: _e.mock.On("SetOwnerReferences", _a0)}
}

func (_c *MockGrafanaMetaAccessor_SetOwnerReferences_Call) Run(run func(_a0 []v1.OwnerReference)) *MockGrafanaMetaAccessor_SetOwnerReferences_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].([]v1.OwnerReference))
	})
	return _c
}

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

func (_c *MockGrafanaMetaAccessor_SetOwnerReferences_Call) RunAndReturn(run func([]v1.OwnerReference)) *MockGrafanaMetaAccessor_SetOwnerReferences_Call {
	_c.Run(run)
	return _c
}

// SetResourceVersion provides a mock function with given fields: version
func (_m *MockGrafanaMetaAccessor) SetResourceVersion(version string) {
	_m.Called(version)
}

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

// SetResourceVersion is a helper method to define mock.On call
//   - version string
func (_e *MockGrafanaMetaAccessor_Expecter) SetResourceVersion(version interface{}) *MockGrafanaMetaAccessor_SetResourceVersion_Call {
	return &MockGrafanaMetaAccessor_SetResourceVersion_Call{Call: _e.mock.On("SetResourceVersion", version)}
}

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

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

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

// SetResourceVersionInt64 provides a mock function with given fields: _a0
func (_m *MockGrafanaMetaAccessor) SetResourceVersionInt64(_a0 int64) {
	_m.Called(_a0)
}

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

// SetResourceVersionInt64 is a helper method to define mock.On call
//   - _a0 int64
func (_e *MockGrafanaMetaAccessor_Expecter) SetResourceVersionInt64(_a0 interface{}) *MockGrafanaMetaAccessor_SetResourceVersionInt64_Call {
	return &MockGrafanaMetaAccessor_SetResourceVersionInt64_Call{Call: _e.mock.On("SetResourceVersionInt64", _a0)}
}

func (_c *MockGrafanaMetaAccessor_SetResourceVersionInt64_Call) Run(run func(_a0 int64)) *MockGrafanaMetaAccessor_SetResourceVersionInt64_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

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

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

// SetSecureValues provides a mock function with given fields: _a0
func (_m *MockGrafanaMetaAccessor) SetSecureValues(_a0 map[string]v0alpha1.InlineSecureValue) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(map[string]v0alpha1.InlineSecureValue) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SetSecureValues is a helper method to define mock.On call
//   - _a0 map[string]v0alpha1.InlineSecureValue
func (_e *MockGrafanaMetaAccessor_Expecter) SetSecureValues(_a0 interface{}) *MockGrafanaMetaAccessor_SetSecureValues_Call {
	return &MockGrafanaMetaAccessor_SetSecureValues_Call{Call: _e.mock.On("SetSecureValues", _a0)}
}

func (_c *MockGrafanaMetaAccessor_SetSecureValues_Call) Run(run func(_a0 map[string]v0alpha1.InlineSecureValue)) *MockGrafanaMetaAccessor_SetSecureValues_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(map[string]v0alpha1.InlineSecureValue))
	})
	return _c
}

func (_c *MockGrafanaMetaAccessor_SetSecureValues_Call) Return(_a0 error) *MockGrafanaMetaAccessor_SetSecureValues_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGrafanaMetaAccessor_SetSecureValues_Call) RunAndReturn(run func(map[string]v0alpha1.InlineSecureValue) error) *MockGrafanaMetaAccessor_SetSecureValues_Call {
	_c.Call.Return(run)
	return _c
}

// SetSelfLink provides a mock function with given fields: selfLink
func (_m *MockGrafanaMetaAccessor) SetSelfLink(selfLink string) {
	_m.Called(selfLink)
}

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

// SetSelfLink is a helper method to define mock.On call
//   - selfLink string
func (_e *MockGrafanaMetaAccessor_Expecter) SetSelfLink(selfLink interface{}) *MockGrafanaMetaAccessor_SetSelfLink_Call {
	return &MockGrafanaMetaAccessor_SetSelfLink_Call{Call: _e.mock.On("SetSelfLink", selfLink)}
}

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

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

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

// SetSourceProperties provides a mock function with given fields: _a0
func (_m *MockGrafanaMetaAccessor) SetSourceProperties(_a0 SourceProperties) {
	_m.Called(_a0)
}

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

// SetSourceProperties is a helper method to define mock.On call
//   - _a0 SourceProperties
func (_e *MockGrafanaMetaAccessor_Expecter) SetSourceProperties(_a0 interface{}) *MockGrafanaMetaAccessor_SetSourceProperties_Call {
	return &MockGrafanaMetaAccessor_SetSourceProperties_Call{Call: _e.mock.On("SetSourceProperties", _a0)}
}

func (_c *MockGrafanaMetaAccessor_SetSourceProperties_Call) Run(run func(_a0 SourceProperties)) *MockGrafanaMetaAccessor_SetSourceProperties_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(SourceProperties))
	})
	return _c
}

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

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

// SetSpec provides a mock function with given fields: _a0
func (_m *MockGrafanaMetaAccessor) SetSpec(_a0 interface{}) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(interface{}) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SetSpec is a helper method to define mock.On call
//   - _a0 interface{}
func (_e *MockGrafanaMetaAccessor_Expecter) SetSpec(_a0 interface{}) *MockGrafanaMetaAccessor_SetSpec_Call {
	return &MockGrafanaMetaAccessor_SetSpec_Call{Call: _e.mock.On("SetSpec", _a0)}
}

func (_c *MockGrafanaMetaAccessor_SetSpec_Call) Run(run func(_a0 interface{})) *MockGrafanaMetaAccessor_SetSpec_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(interface{}))
	})
	return _c
}

func (_c *MockGrafanaMetaAccessor_SetSpec_Call) Return(_a0 error) *MockGrafanaMetaAccessor_SetSpec_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGrafanaMetaAccessor_SetSpec_Call) RunAndReturn(run func(interface{}) error) *MockGrafanaMetaAccessor_SetSpec_Call {
	_c.Call.Return(run)
	return _c
}

// SetStatus provides a mock function with given fields: _a0
func (_m *MockGrafanaMetaAccessor) SetStatus(_a0 interface{}) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(interface{}) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SetStatus is a helper method to define mock.On call
//   - _a0 interface{}
func (_e *MockGrafanaMetaAccessor_Expecter) SetStatus(_a0 interface{}) *MockGrafanaMetaAccessor_SetStatus_Call {
	return &MockGrafanaMetaAccessor_SetStatus_Call{Call: _e.mock.On("SetStatus", _a0)}
}

func (_c *MockGrafanaMetaAccessor_SetStatus_Call) Run(run func(_a0 interface{})) *MockGrafanaMetaAccessor_SetStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(interface{}))
	})
	return _c
}

func (_c *MockGrafanaMetaAccessor_SetStatus_Call) Return(_a0 error) *MockGrafanaMetaAccessor_SetStatus_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockGrafanaMetaAccessor_SetStatus_Call) RunAndReturn(run func(interface{}) error) *MockGrafanaMetaAccessor_SetStatus_Call {
	_c.Call.Return(run)
	return _c
}

// SetUID provides a mock function with given fields: uid
func (_m *MockGrafanaMetaAccessor) SetUID(uid types.UID) {
	_m.Called(uid)
}

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

// SetUID is a helper method to define mock.On call
//   - uid types.UID
func (_e *MockGrafanaMetaAccessor_Expecter) SetUID(uid interface{}) *MockGrafanaMetaAccessor_SetUID_Call {
	return &MockGrafanaMetaAccessor_SetUID_Call{Call: _e.mock.On("SetUID", uid)}
}

func (_c *MockGrafanaMetaAccessor_SetUID_Call) Run(run func(uid types.UID)) *MockGrafanaMetaAccessor_SetUID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(types.UID))
	})
	return _c
}

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

func (_c *MockGrafanaMetaAccessor_SetUID_Call) RunAndReturn(run func(types.UID)) *MockGrafanaMetaAccessor_SetUID_Call {
	_c.Run(run)
	return _c
}

// SetUpdatedBy provides a mock function with given fields: user
func (_m *MockGrafanaMetaAccessor) SetUpdatedBy(user string) {
	_m.Called(user)
}

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

// SetUpdatedBy is a helper method to define mock.On call
//   - user string
func (_e *MockGrafanaMetaAccessor_Expecter) SetUpdatedBy(user interface{}) *MockGrafanaMetaAccessor_SetUpdatedBy_Call {
	return &MockGrafanaMetaAccessor_SetUpdatedBy_Call{Call: _e.mock.On("SetUpdatedBy", user)}
}

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

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

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

// SetUpdatedTimestamp provides a mock function with given fields: v
func (_m *MockGrafanaMetaAccessor) SetUpdatedTimestamp(v *time.Time) {
	_m.Called(v)
}

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

// SetUpdatedTimestamp is a helper method to define mock.On call
//   - v *time.Time
func (_e *MockGrafanaMetaAccessor_Expecter) SetUpdatedTimestamp(v interface{}) *MockGrafanaMetaAccessor_SetUpdatedTimestamp_Call {
	return &MockGrafanaMetaAccessor_SetUpdatedTimestamp_Call{Call: _e.mock.On("SetUpdatedTimestamp", v)}
}

func (_c *MockGrafanaMetaAccessor_SetUpdatedTimestamp_Call) Run(run func(v *time.Time)) *MockGrafanaMetaAccessor_SetUpdatedTimestamp_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*time.Time))
	})
	return _c
}

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

func (_c *MockGrafanaMetaAccessor_SetUpdatedTimestamp_Call) RunAndReturn(run func(*time.Time)) *MockGrafanaMetaAccessor_SetUpdatedTimestamp_Call {
	_c.Run(run)
	return _c
}

// SetUpdatedTimestampMillis provides a mock function with given fields: unix
func (_m *MockGrafanaMetaAccessor) SetUpdatedTimestampMillis(unix int64) {
	_m.Called(unix)
}

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

// SetUpdatedTimestampMillis is a helper method to define mock.On call
//   - unix int64
func (_e *MockGrafanaMetaAccessor_Expecter) SetUpdatedTimestampMillis(unix interface{}) *MockGrafanaMetaAccessor_SetUpdatedTimestampMillis_Call {
	return &MockGrafanaMetaAccessor_SetUpdatedTimestampMillis_Call{Call: _e.mock.On("SetUpdatedTimestampMillis", unix)}
}

func (_c *MockGrafanaMetaAccessor_SetUpdatedTimestampMillis_Call) Run(run func(unix int64)) *MockGrafanaMetaAccessor_SetUpdatedTimestampMillis_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

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

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

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

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

	return mock
}