grafana/pkg/services/dashboards/store_mock.go

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

package dashboards

import (
	context "context"

	folder "github.com/grafana/grafana/pkg/services/folder"
	mock "github.com/stretchr/testify/mock"

	models "github.com/grafana/grafana/pkg/services/alerting/models"

	quota "github.com/grafana/grafana/pkg/services/quota"
)

// FakeDashboardStore is an autogenerated mock type for the Store type
type FakeDashboardStore struct {
	mock.Mock
}

type FakeDashboardStore_Expecter struct {
	mock *mock.Mock
}

func (_m *FakeDashboardStore) EXPECT() *FakeDashboardStore_Expecter {
	return &FakeDashboardStore_Expecter{mock: &_m.Mock}
}

// Count provides a mock function with given fields: _a0, _a1
func (_m *FakeDashboardStore) Count(_a0 context.Context, _a1 *quota.ScopeParameters) (*quota.Map, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *quota.Map
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *quota.ScopeParameters) (*quota.Map, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *quota.ScopeParameters) *quota.Map); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*quota.Map)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *quota.ScopeParameters) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Count is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *quota.ScopeParameters
func (_e *FakeDashboardStore_Expecter) Count(_a0 interface{}, _a1 interface{}) *FakeDashboardStore_Count_Call {
	return &FakeDashboardStore_Count_Call{Call: _e.mock.On("Count", _a0, _a1)}
}

func (_c *FakeDashboardStore_Count_Call) Run(run func(_a0 context.Context, _a1 *quota.ScopeParameters)) *FakeDashboardStore_Count_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*quota.ScopeParameters))
	})
	return _c
}

func (_c *FakeDashboardStore_Count_Call) Return(_a0 *quota.Map, _a1 error) *FakeDashboardStore_Count_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FakeDashboardStore_Count_Call) RunAndReturn(run func(context.Context, *quota.ScopeParameters) (*quota.Map, error)) *FakeDashboardStore_Count_Call {
	_c.Call.Return(run)
	return _c
}

// CountDashboardsInFolder provides a mock function with given fields: ctx, request
func (_m *FakeDashboardStore) CountDashboardsInFolder(ctx context.Context, request *CountDashboardsInFolderRequest) (int64, error) {
	ret := _m.Called(ctx, request)

	var r0 int64
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *CountDashboardsInFolderRequest) (int64, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *CountDashboardsInFolderRequest) int64); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Get(0).(int64)
	}

	if rf, ok := ret.Get(1).(func(context.Context, *CountDashboardsInFolderRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CountDashboardsInFolder is a helper method to define mock.On call
//   - ctx context.Context
//   - request *CountDashboardsInFolderRequest
func (_e *FakeDashboardStore_Expecter) CountDashboardsInFolder(ctx interface{}, request interface{}) *FakeDashboardStore_CountDashboardsInFolder_Call {
	return &FakeDashboardStore_CountDashboardsInFolder_Call{Call: _e.mock.On("CountDashboardsInFolder", ctx, request)}
}

func (_c *FakeDashboardStore_CountDashboardsInFolder_Call) Run(run func(ctx context.Context, request *CountDashboardsInFolderRequest)) *FakeDashboardStore_CountDashboardsInFolder_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*CountDashboardsInFolderRequest))
	})
	return _c
}

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

func (_c *FakeDashboardStore_CountDashboardsInFolder_Call) RunAndReturn(run func(context.Context, *CountDashboardsInFolderRequest) (int64, error)) *FakeDashboardStore_CountDashboardsInFolder_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteACLByUser provides a mock function with given fields: _a0, _a1
func (_m *FakeDashboardStore) DeleteACLByUser(_a0 context.Context, _a1 int64) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

// DeleteACLByUser is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 int64
func (_e *FakeDashboardStore_Expecter) DeleteACLByUser(_a0 interface{}, _a1 interface{}) *FakeDashboardStore_DeleteACLByUser_Call {
	return &FakeDashboardStore_DeleteACLByUser_Call{Call: _e.mock.On("DeleteACLByUser", _a0, _a1)}
}

func (_c *FakeDashboardStore_DeleteACLByUser_Call) Run(run func(_a0 context.Context, _a1 int64)) *FakeDashboardStore_DeleteACLByUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64))
	})
	return _c
}

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

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

// DeleteDashboard provides a mock function with given fields: ctx, cmd
func (_m *FakeDashboardStore) DeleteDashboard(ctx context.Context, cmd *DeleteDashboardCommand) error {
	ret := _m.Called(ctx, cmd)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *DeleteDashboardCommand) error); ok {
		r0 = rf(ctx, cmd)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// DeleteDashboard is a helper method to define mock.On call
//   - ctx context.Context
//   - cmd *DeleteDashboardCommand
func (_e *FakeDashboardStore_Expecter) DeleteDashboard(ctx interface{}, cmd interface{}) *FakeDashboardStore_DeleteDashboard_Call {
	return &FakeDashboardStore_DeleteDashboard_Call{Call: _e.mock.On("DeleteDashboard", ctx, cmd)}
}

func (_c *FakeDashboardStore_DeleteDashboard_Call) Run(run func(ctx context.Context, cmd *DeleteDashboardCommand)) *FakeDashboardStore_DeleteDashboard_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*DeleteDashboardCommand))
	})
	return _c
}

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

func (_c *FakeDashboardStore_DeleteDashboard_Call) RunAndReturn(run func(context.Context, *DeleteDashboardCommand) error) *FakeDashboardStore_DeleteDashboard_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDashboardsInFolder provides a mock function with given fields: ctx, request
func (_m *FakeDashboardStore) DeleteDashboardsInFolder(ctx context.Context, request *DeleteDashboardsInFolderRequest) error {
	ret := _m.Called(ctx, request)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *DeleteDashboardsInFolderRequest) error); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// DeleteDashboardsInFolder is a helper method to define mock.On call
//   - ctx context.Context
//   - request *DeleteDashboardsInFolderRequest
func (_e *FakeDashboardStore_Expecter) DeleteDashboardsInFolder(ctx interface{}, request interface{}) *FakeDashboardStore_DeleteDashboardsInFolder_Call {
	return &FakeDashboardStore_DeleteDashboardsInFolder_Call{Call: _e.mock.On("DeleteDashboardsInFolder", ctx, request)}
}

func (_c *FakeDashboardStore_DeleteDashboardsInFolder_Call) Run(run func(ctx context.Context, request *DeleteDashboardsInFolderRequest)) *FakeDashboardStore_DeleteDashboardsInFolder_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*DeleteDashboardsInFolderRequest))
	})
	return _c
}

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

func (_c *FakeDashboardStore_DeleteDashboardsInFolder_Call) RunAndReturn(run func(context.Context, *DeleteDashboardsInFolderRequest) error) *FakeDashboardStore_DeleteDashboardsInFolder_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteOrphanedProvisionedDashboards provides a mock function with given fields: ctx, cmd
func (_m *FakeDashboardStore) DeleteOrphanedProvisionedDashboards(ctx context.Context, cmd *DeleteOrphanedProvisionedDashboardsCommand) error {
	ret := _m.Called(ctx, cmd)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *DeleteOrphanedProvisionedDashboardsCommand) error); ok {
		r0 = rf(ctx, cmd)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// DeleteOrphanedProvisionedDashboards is a helper method to define mock.On call
//   - ctx context.Context
//   - cmd *DeleteOrphanedProvisionedDashboardsCommand
func (_e *FakeDashboardStore_Expecter) DeleteOrphanedProvisionedDashboards(ctx interface{}, cmd interface{}) *FakeDashboardStore_DeleteOrphanedProvisionedDashboards_Call {
	return &FakeDashboardStore_DeleteOrphanedProvisionedDashboards_Call{Call: _e.mock.On("DeleteOrphanedProvisionedDashboards", ctx, cmd)}
}

func (_c *FakeDashboardStore_DeleteOrphanedProvisionedDashboards_Call) Run(run func(ctx context.Context, cmd *DeleteOrphanedProvisionedDashboardsCommand)) *FakeDashboardStore_DeleteOrphanedProvisionedDashboards_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*DeleteOrphanedProvisionedDashboardsCommand))
	})
	return _c
}

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

func (_c *FakeDashboardStore_DeleteOrphanedProvisionedDashboards_Call) RunAndReturn(run func(context.Context, *DeleteOrphanedProvisionedDashboardsCommand) error) *FakeDashboardStore_DeleteOrphanedProvisionedDashboards_Call {
	_c.Call.Return(run)
	return _c
}

// FindDashboards provides a mock function with given fields: ctx, query
func (_m *FakeDashboardStore) FindDashboards(ctx context.Context, query *FindPersistedDashboardsQuery) ([]DashboardSearchProjection, error) {
	ret := _m.Called(ctx, query)

	var r0 []DashboardSearchProjection
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *FindPersistedDashboardsQuery) ([]DashboardSearchProjection, error)); ok {
		return rf(ctx, query)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *FindPersistedDashboardsQuery) []DashboardSearchProjection); ok {
		r0 = rf(ctx, query)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]DashboardSearchProjection)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *FindPersistedDashboardsQuery) error); ok {
		r1 = rf(ctx, query)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// FindDashboards is a helper method to define mock.On call
//   - ctx context.Context
//   - query *FindPersistedDashboardsQuery
func (_e *FakeDashboardStore_Expecter) FindDashboards(ctx interface{}, query interface{}) *FakeDashboardStore_FindDashboards_Call {
	return &FakeDashboardStore_FindDashboards_Call{Call: _e.mock.On("FindDashboards", ctx, query)}
}

func (_c *FakeDashboardStore_FindDashboards_Call) Run(run func(ctx context.Context, query *FindPersistedDashboardsQuery)) *FakeDashboardStore_FindDashboards_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*FindPersistedDashboardsQuery))
	})
	return _c
}

func (_c *FakeDashboardStore_FindDashboards_Call) Return(_a0 []DashboardSearchProjection, _a1 error) *FakeDashboardStore_FindDashboards_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FakeDashboardStore_FindDashboards_Call) RunAndReturn(run func(context.Context, *FindPersistedDashboardsQuery) ([]DashboardSearchProjection, error)) *FakeDashboardStore_FindDashboards_Call {
	_c.Call.Return(run)
	return _c
}

// GetDashboard provides a mock function with given fields: ctx, query
func (_m *FakeDashboardStore) GetDashboard(ctx context.Context, query *GetDashboardQuery) (*Dashboard, error) {
	ret := _m.Called(ctx, query)

	var r0 *Dashboard
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *GetDashboardQuery) (*Dashboard, error)); ok {
		return rf(ctx, query)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *GetDashboardQuery) *Dashboard); ok {
		r0 = rf(ctx, query)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*Dashboard)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *GetDashboardQuery) error); ok {
		r1 = rf(ctx, query)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetDashboard is a helper method to define mock.On call
//   - ctx context.Context
//   - query *GetDashboardQuery
func (_e *FakeDashboardStore_Expecter) GetDashboard(ctx interface{}, query interface{}) *FakeDashboardStore_GetDashboard_Call {
	return &FakeDashboardStore_GetDashboard_Call{Call: _e.mock.On("GetDashboard", ctx, query)}
}

func (_c *FakeDashboardStore_GetDashboard_Call) Run(run func(ctx context.Context, query *GetDashboardQuery)) *FakeDashboardStore_GetDashboard_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*GetDashboardQuery))
	})
	return _c
}

func (_c *FakeDashboardStore_GetDashboard_Call) Return(_a0 *Dashboard, _a1 error) *FakeDashboardStore_GetDashboard_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FakeDashboardStore_GetDashboard_Call) RunAndReturn(run func(context.Context, *GetDashboardQuery) (*Dashboard, error)) *FakeDashboardStore_GetDashboard_Call {
	_c.Call.Return(run)
	return _c
}

// GetDashboardACLInfoList provides a mock function with given fields: ctx, query
func (_m *FakeDashboardStore) GetDashboardACLInfoList(ctx context.Context, query *GetDashboardACLInfoListQuery) ([]*DashboardACLInfoDTO, error) {
	ret := _m.Called(ctx, query)

	var r0 []*DashboardACLInfoDTO
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *GetDashboardACLInfoListQuery) ([]*DashboardACLInfoDTO, error)); ok {
		return rf(ctx, query)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *GetDashboardACLInfoListQuery) []*DashboardACLInfoDTO); ok {
		r0 = rf(ctx, query)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*DashboardACLInfoDTO)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *GetDashboardACLInfoListQuery) error); ok {
		r1 = rf(ctx, query)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetDashboardACLInfoList is a helper method to define mock.On call
//   - ctx context.Context
//   - query *GetDashboardACLInfoListQuery
func (_e *FakeDashboardStore_Expecter) GetDashboardACLInfoList(ctx interface{}, query interface{}) *FakeDashboardStore_GetDashboardACLInfoList_Call {
	return &FakeDashboardStore_GetDashboardACLInfoList_Call{Call: _e.mock.On("GetDashboardACLInfoList", ctx, query)}
}

func (_c *FakeDashboardStore_GetDashboardACLInfoList_Call) Run(run func(ctx context.Context, query *GetDashboardACLInfoListQuery)) *FakeDashboardStore_GetDashboardACLInfoList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*GetDashboardACLInfoListQuery))
	})
	return _c
}

func (_c *FakeDashboardStore_GetDashboardACLInfoList_Call) Return(_a0 []*DashboardACLInfoDTO, _a1 error) *FakeDashboardStore_GetDashboardACLInfoList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FakeDashboardStore_GetDashboardACLInfoList_Call) RunAndReturn(run func(context.Context, *GetDashboardACLInfoListQuery) ([]*DashboardACLInfoDTO, error)) *FakeDashboardStore_GetDashboardACLInfoList_Call {
	_c.Call.Return(run)
	return _c
}

// GetDashboardTags provides a mock function with given fields: ctx, query
func (_m *FakeDashboardStore) GetDashboardTags(ctx context.Context, query *GetDashboardTagsQuery) ([]*DashboardTagCloudItem, error) {
	ret := _m.Called(ctx, query)

	var r0 []*DashboardTagCloudItem
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *GetDashboardTagsQuery) ([]*DashboardTagCloudItem, error)); ok {
		return rf(ctx, query)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *GetDashboardTagsQuery) []*DashboardTagCloudItem); ok {
		r0 = rf(ctx, query)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*DashboardTagCloudItem)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *GetDashboardTagsQuery) error); ok {
		r1 = rf(ctx, query)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetDashboardTags is a helper method to define mock.On call
//   - ctx context.Context
//   - query *GetDashboardTagsQuery
func (_e *FakeDashboardStore_Expecter) GetDashboardTags(ctx interface{}, query interface{}) *FakeDashboardStore_GetDashboardTags_Call {
	return &FakeDashboardStore_GetDashboardTags_Call{Call: _e.mock.On("GetDashboardTags", ctx, query)}
}

func (_c *FakeDashboardStore_GetDashboardTags_Call) Run(run func(ctx context.Context, query *GetDashboardTagsQuery)) *FakeDashboardStore_GetDashboardTags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*GetDashboardTagsQuery))
	})
	return _c
}

func (_c *FakeDashboardStore_GetDashboardTags_Call) Return(_a0 []*DashboardTagCloudItem, _a1 error) *FakeDashboardStore_GetDashboardTags_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FakeDashboardStore_GetDashboardTags_Call) RunAndReturn(run func(context.Context, *GetDashboardTagsQuery) ([]*DashboardTagCloudItem, error)) *FakeDashboardStore_GetDashboardTags_Call {
	_c.Call.Return(run)
	return _c
}

// GetDashboardUIDByID provides a mock function with given fields: ctx, query
func (_m *FakeDashboardStore) GetDashboardUIDByID(ctx context.Context, query *GetDashboardRefByIDQuery) (*DashboardRef, error) {
	ret := _m.Called(ctx, query)

	var r0 *DashboardRef
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *GetDashboardRefByIDQuery) (*DashboardRef, error)); ok {
		return rf(ctx, query)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *GetDashboardRefByIDQuery) *DashboardRef); ok {
		r0 = rf(ctx, query)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*DashboardRef)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *GetDashboardRefByIDQuery) error); ok {
		r1 = rf(ctx, query)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetDashboardUIDByID is a helper method to define mock.On call
//   - ctx context.Context
//   - query *GetDashboardRefByIDQuery
func (_e *FakeDashboardStore_Expecter) GetDashboardUIDByID(ctx interface{}, query interface{}) *FakeDashboardStore_GetDashboardUIDByID_Call {
	return &FakeDashboardStore_GetDashboardUIDByID_Call{Call: _e.mock.On("GetDashboardUIDByID", ctx, query)}
}

func (_c *FakeDashboardStore_GetDashboardUIDByID_Call) Run(run func(ctx context.Context, query *GetDashboardRefByIDQuery)) *FakeDashboardStore_GetDashboardUIDByID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*GetDashboardRefByIDQuery))
	})
	return _c
}

func (_c *FakeDashboardStore_GetDashboardUIDByID_Call) Return(_a0 *DashboardRef, _a1 error) *FakeDashboardStore_GetDashboardUIDByID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FakeDashboardStore_GetDashboardUIDByID_Call) RunAndReturn(run func(context.Context, *GetDashboardRefByIDQuery) (*DashboardRef, error)) *FakeDashboardStore_GetDashboardUIDByID_Call {
	_c.Call.Return(run)
	return _c
}

// GetDashboards provides a mock function with given fields: ctx, query
func (_m *FakeDashboardStore) GetDashboards(ctx context.Context, query *GetDashboardsQuery) ([]*Dashboard, error) {
	ret := _m.Called(ctx, query)

	var r0 []*Dashboard
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *GetDashboardsQuery) ([]*Dashboard, error)); ok {
		return rf(ctx, query)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *GetDashboardsQuery) []*Dashboard); ok {
		r0 = rf(ctx, query)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*Dashboard)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *GetDashboardsQuery) error); ok {
		r1 = rf(ctx, query)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetDashboards is a helper method to define mock.On call
//   - ctx context.Context
//   - query *GetDashboardsQuery
func (_e *FakeDashboardStore_Expecter) GetDashboards(ctx interface{}, query interface{}) *FakeDashboardStore_GetDashboards_Call {
	return &FakeDashboardStore_GetDashboards_Call{Call: _e.mock.On("GetDashboards", ctx, query)}
}

func (_c *FakeDashboardStore_GetDashboards_Call) Run(run func(ctx context.Context, query *GetDashboardsQuery)) *FakeDashboardStore_GetDashboards_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*GetDashboardsQuery))
	})
	return _c
}

func (_c *FakeDashboardStore_GetDashboards_Call) Return(_a0 []*Dashboard, _a1 error) *FakeDashboardStore_GetDashboards_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FakeDashboardStore_GetDashboards_Call) RunAndReturn(run func(context.Context, *GetDashboardsQuery) ([]*Dashboard, error)) *FakeDashboardStore_GetDashboards_Call {
	_c.Call.Return(run)
	return _c
}

// GetDashboardsByPluginID provides a mock function with given fields: ctx, query
func (_m *FakeDashboardStore) GetDashboardsByPluginID(ctx context.Context, query *GetDashboardsByPluginIDQuery) ([]*Dashboard, error) {
	ret := _m.Called(ctx, query)

	var r0 []*Dashboard
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *GetDashboardsByPluginIDQuery) ([]*Dashboard, error)); ok {
		return rf(ctx, query)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *GetDashboardsByPluginIDQuery) []*Dashboard); ok {
		r0 = rf(ctx, query)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*Dashboard)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *GetDashboardsByPluginIDQuery) error); ok {
		r1 = rf(ctx, query)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetDashboardsByPluginID is a helper method to define mock.On call
//   - ctx context.Context
//   - query *GetDashboardsByPluginIDQuery
func (_e *FakeDashboardStore_Expecter) GetDashboardsByPluginID(ctx interface{}, query interface{}) *FakeDashboardStore_GetDashboardsByPluginID_Call {
	return &FakeDashboardStore_GetDashboardsByPluginID_Call{Call: _e.mock.On("GetDashboardsByPluginID", ctx, query)}
}

func (_c *FakeDashboardStore_GetDashboardsByPluginID_Call) Run(run func(ctx context.Context, query *GetDashboardsByPluginIDQuery)) *FakeDashboardStore_GetDashboardsByPluginID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*GetDashboardsByPluginIDQuery))
	})
	return _c
}

func (_c *FakeDashboardStore_GetDashboardsByPluginID_Call) Return(_a0 []*Dashboard, _a1 error) *FakeDashboardStore_GetDashboardsByPluginID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FakeDashboardStore_GetDashboardsByPluginID_Call) RunAndReturn(run func(context.Context, *GetDashboardsByPluginIDQuery) ([]*Dashboard, error)) *FakeDashboardStore_GetDashboardsByPluginID_Call {
	_c.Call.Return(run)
	return _c
}

// GetProvisionedDashboardData provides a mock function with given fields: ctx, name
func (_m *FakeDashboardStore) GetProvisionedDashboardData(ctx context.Context, name string) ([]*DashboardProvisioning, error) {
	ret := _m.Called(ctx, name)

	var r0 []*DashboardProvisioning
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) ([]*DashboardProvisioning, error)); ok {
		return rf(ctx, name)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) []*DashboardProvisioning); ok {
		r0 = rf(ctx, name)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*DashboardProvisioning)
		}
	}

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

	return r0, r1
}

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

// GetProvisionedDashboardData is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
func (_e *FakeDashboardStore_Expecter) GetProvisionedDashboardData(ctx interface{}, name interface{}) *FakeDashboardStore_GetProvisionedDashboardData_Call {
	return &FakeDashboardStore_GetProvisionedDashboardData_Call{Call: _e.mock.On("GetProvisionedDashboardData", ctx, name)}
}

func (_c *FakeDashboardStore_GetProvisionedDashboardData_Call) Run(run func(ctx context.Context, name string)) *FakeDashboardStore_GetProvisionedDashboardData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *FakeDashboardStore_GetProvisionedDashboardData_Call) Return(_a0 []*DashboardProvisioning, _a1 error) *FakeDashboardStore_GetProvisionedDashboardData_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FakeDashboardStore_GetProvisionedDashboardData_Call) RunAndReturn(run func(context.Context, string) ([]*DashboardProvisioning, error)) *FakeDashboardStore_GetProvisionedDashboardData_Call {
	_c.Call.Return(run)
	return _c
}

// GetProvisionedDataByDashboardID provides a mock function with given fields: ctx, dashboardID
func (_m *FakeDashboardStore) GetProvisionedDataByDashboardID(ctx context.Context, dashboardID int64) (*DashboardProvisioning, error) {
	ret := _m.Called(ctx, dashboardID)

	var r0 *DashboardProvisioning
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, int64) (*DashboardProvisioning, error)); ok {
		return rf(ctx, dashboardID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, int64) *DashboardProvisioning); ok {
		r0 = rf(ctx, dashboardID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*DashboardProvisioning)
		}
	}

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

	return r0, r1
}

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

// GetProvisionedDataByDashboardID is a helper method to define mock.On call
//   - ctx context.Context
//   - dashboardID int64
func (_e *FakeDashboardStore_Expecter) GetProvisionedDataByDashboardID(ctx interface{}, dashboardID interface{}) *FakeDashboardStore_GetProvisionedDataByDashboardID_Call {
	return &FakeDashboardStore_GetProvisionedDataByDashboardID_Call{Call: _e.mock.On("GetProvisionedDataByDashboardID", ctx, dashboardID)}
}

func (_c *FakeDashboardStore_GetProvisionedDataByDashboardID_Call) Run(run func(ctx context.Context, dashboardID int64)) *FakeDashboardStore_GetProvisionedDataByDashboardID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64))
	})
	return _c
}

func (_c *FakeDashboardStore_GetProvisionedDataByDashboardID_Call) Return(_a0 *DashboardProvisioning, _a1 error) *FakeDashboardStore_GetProvisionedDataByDashboardID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FakeDashboardStore_GetProvisionedDataByDashboardID_Call) RunAndReturn(run func(context.Context, int64) (*DashboardProvisioning, error)) *FakeDashboardStore_GetProvisionedDataByDashboardID_Call {
	_c.Call.Return(run)
	return _c
}

// GetProvisionedDataByDashboardUID provides a mock function with given fields: ctx, orgID, dashboardUID
func (_m *FakeDashboardStore) GetProvisionedDataByDashboardUID(ctx context.Context, orgID int64, dashboardUID string) (*DashboardProvisioning, error) {
	ret := _m.Called(ctx, orgID, dashboardUID)

	var r0 *DashboardProvisioning
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, int64, string) (*DashboardProvisioning, error)); ok {
		return rf(ctx, orgID, dashboardUID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, int64, string) *DashboardProvisioning); ok {
		r0 = rf(ctx, orgID, dashboardUID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*DashboardProvisioning)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, int64, string) error); ok {
		r1 = rf(ctx, orgID, dashboardUID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetProvisionedDataByDashboardUID is a helper method to define mock.On call
//   - ctx context.Context
//   - orgID int64
//   - dashboardUID string
func (_e *FakeDashboardStore_Expecter) GetProvisionedDataByDashboardUID(ctx interface{}, orgID interface{}, dashboardUID interface{}) *FakeDashboardStore_GetProvisionedDataByDashboardUID_Call {
	return &FakeDashboardStore_GetProvisionedDataByDashboardUID_Call{Call: _e.mock.On("GetProvisionedDataByDashboardUID", ctx, orgID, dashboardUID)}
}

func (_c *FakeDashboardStore_GetProvisionedDataByDashboardUID_Call) Run(run func(ctx context.Context, orgID int64, dashboardUID string)) *FakeDashboardStore_GetProvisionedDataByDashboardUID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].(string))
	})
	return _c
}

func (_c *FakeDashboardStore_GetProvisionedDataByDashboardUID_Call) Return(_a0 *DashboardProvisioning, _a1 error) *FakeDashboardStore_GetProvisionedDataByDashboardUID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FakeDashboardStore_GetProvisionedDataByDashboardUID_Call) RunAndReturn(run func(context.Context, int64, string) (*DashboardProvisioning, error)) *FakeDashboardStore_GetProvisionedDataByDashboardUID_Call {
	_c.Call.Return(run)
	return _c
}

// HasAdminPermissionInDashboardsOrFolders provides a mock function with given fields: ctx, query
func (_m *FakeDashboardStore) HasAdminPermissionInDashboardsOrFolders(ctx context.Context, query *folder.HasAdminPermissionInDashboardsOrFoldersQuery) (bool, error) {
	ret := _m.Called(ctx, query)

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *folder.HasAdminPermissionInDashboardsOrFoldersQuery) (bool, error)); ok {
		return rf(ctx, query)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *folder.HasAdminPermissionInDashboardsOrFoldersQuery) bool); ok {
		r0 = rf(ctx, query)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, *folder.HasAdminPermissionInDashboardsOrFoldersQuery) error); ok {
		r1 = rf(ctx, query)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// HasAdminPermissionInDashboardsOrFolders is a helper method to define mock.On call
//   - ctx context.Context
//   - query *folder.HasAdminPermissionInDashboardsOrFoldersQuery
func (_e *FakeDashboardStore_Expecter) HasAdminPermissionInDashboardsOrFolders(ctx interface{}, query interface{}) *FakeDashboardStore_HasAdminPermissionInDashboardsOrFolders_Call {
	return &FakeDashboardStore_HasAdminPermissionInDashboardsOrFolders_Call{Call: _e.mock.On("HasAdminPermissionInDashboardsOrFolders", ctx, query)}
}

func (_c *FakeDashboardStore_HasAdminPermissionInDashboardsOrFolders_Call) Run(run func(ctx context.Context, query *folder.HasAdminPermissionInDashboardsOrFoldersQuery)) *FakeDashboardStore_HasAdminPermissionInDashboardsOrFolders_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*folder.HasAdminPermissionInDashboardsOrFoldersQuery))
	})
	return _c
}

func (_c *FakeDashboardStore_HasAdminPermissionInDashboardsOrFolders_Call) Return(_a0 bool, _a1 error) *FakeDashboardStore_HasAdminPermissionInDashboardsOrFolders_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FakeDashboardStore_HasAdminPermissionInDashboardsOrFolders_Call) RunAndReturn(run func(context.Context, *folder.HasAdminPermissionInDashboardsOrFoldersQuery) (bool, error)) *FakeDashboardStore_HasAdminPermissionInDashboardsOrFolders_Call {
	_c.Call.Return(run)
	return _c
}

// HasEditPermissionInFolders provides a mock function with given fields: ctx, query
func (_m *FakeDashboardStore) HasEditPermissionInFolders(ctx context.Context, query *folder.HasEditPermissionInFoldersQuery) (bool, error) {
	ret := _m.Called(ctx, query)

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *folder.HasEditPermissionInFoldersQuery) (bool, error)); ok {
		return rf(ctx, query)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *folder.HasEditPermissionInFoldersQuery) bool); ok {
		r0 = rf(ctx, query)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, *folder.HasEditPermissionInFoldersQuery) error); ok {
		r1 = rf(ctx, query)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// HasEditPermissionInFolders is a helper method to define mock.On call
//   - ctx context.Context
//   - query *folder.HasEditPermissionInFoldersQuery
func (_e *FakeDashboardStore_Expecter) HasEditPermissionInFolders(ctx interface{}, query interface{}) *FakeDashboardStore_HasEditPermissionInFolders_Call {
	return &FakeDashboardStore_HasEditPermissionInFolders_Call{Call: _e.mock.On("HasEditPermissionInFolders", ctx, query)}
}

func (_c *FakeDashboardStore_HasEditPermissionInFolders_Call) Run(run func(ctx context.Context, query *folder.HasEditPermissionInFoldersQuery)) *FakeDashboardStore_HasEditPermissionInFolders_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*folder.HasEditPermissionInFoldersQuery))
	})
	return _c
}

func (_c *FakeDashboardStore_HasEditPermissionInFolders_Call) Return(_a0 bool, _a1 error) *FakeDashboardStore_HasEditPermissionInFolders_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FakeDashboardStore_HasEditPermissionInFolders_Call) RunAndReturn(run func(context.Context, *folder.HasEditPermissionInFoldersQuery) (bool, error)) *FakeDashboardStore_HasEditPermissionInFolders_Call {
	_c.Call.Return(run)
	return _c
}

// SaveAlerts provides a mock function with given fields: ctx, dashID, alerts
func (_m *FakeDashboardStore) SaveAlerts(ctx context.Context, dashID int64, alerts []*models.Alert) error {
	ret := _m.Called(ctx, dashID, alerts)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, int64, []*models.Alert) error); ok {
		r0 = rf(ctx, dashID, alerts)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SaveAlerts is a helper method to define mock.On call
//   - ctx context.Context
//   - dashID int64
//   - alerts []*models.Alert
func (_e *FakeDashboardStore_Expecter) SaveAlerts(ctx interface{}, dashID interface{}, alerts interface{}) *FakeDashboardStore_SaveAlerts_Call {
	return &FakeDashboardStore_SaveAlerts_Call{Call: _e.mock.On("SaveAlerts", ctx, dashID, alerts)}
}

func (_c *FakeDashboardStore_SaveAlerts_Call) Run(run func(ctx context.Context, dashID int64, alerts []*models.Alert)) *FakeDashboardStore_SaveAlerts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].([]*models.Alert))
	})
	return _c
}

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

func (_c *FakeDashboardStore_SaveAlerts_Call) RunAndReturn(run func(context.Context, int64, []*models.Alert) error) *FakeDashboardStore_SaveAlerts_Call {
	_c.Call.Return(run)
	return _c
}

// SaveDashboard provides a mock function with given fields: ctx, cmd
func (_m *FakeDashboardStore) SaveDashboard(ctx context.Context, cmd SaveDashboardCommand) (*Dashboard, error) {
	ret := _m.Called(ctx, cmd)

	var r0 *Dashboard
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, SaveDashboardCommand) (*Dashboard, error)); ok {
		return rf(ctx, cmd)
	}
	if rf, ok := ret.Get(0).(func(context.Context, SaveDashboardCommand) *Dashboard); ok {
		r0 = rf(ctx, cmd)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*Dashboard)
		}
	}

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

	return r0, r1
}

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

// SaveDashboard is a helper method to define mock.On call
//   - ctx context.Context
//   - cmd SaveDashboardCommand
func (_e *FakeDashboardStore_Expecter) SaveDashboard(ctx interface{}, cmd interface{}) *FakeDashboardStore_SaveDashboard_Call {
	return &FakeDashboardStore_SaveDashboard_Call{Call: _e.mock.On("SaveDashboard", ctx, cmd)}
}

func (_c *FakeDashboardStore_SaveDashboard_Call) Run(run func(ctx context.Context, cmd SaveDashboardCommand)) *FakeDashboardStore_SaveDashboard_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(SaveDashboardCommand))
	})
	return _c
}

func (_c *FakeDashboardStore_SaveDashboard_Call) Return(_a0 *Dashboard, _a1 error) *FakeDashboardStore_SaveDashboard_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FakeDashboardStore_SaveDashboard_Call) RunAndReturn(run func(context.Context, SaveDashboardCommand) (*Dashboard, error)) *FakeDashboardStore_SaveDashboard_Call {
	_c.Call.Return(run)
	return _c
}

// SaveProvisionedDashboard provides a mock function with given fields: ctx, cmd, provisioning
func (_m *FakeDashboardStore) SaveProvisionedDashboard(ctx context.Context, cmd SaveDashboardCommand, provisioning *DashboardProvisioning) (*Dashboard, error) {
	ret := _m.Called(ctx, cmd, provisioning)

	var r0 *Dashboard
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, SaveDashboardCommand, *DashboardProvisioning) (*Dashboard, error)); ok {
		return rf(ctx, cmd, provisioning)
	}
	if rf, ok := ret.Get(0).(func(context.Context, SaveDashboardCommand, *DashboardProvisioning) *Dashboard); ok {
		r0 = rf(ctx, cmd, provisioning)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*Dashboard)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, SaveDashboardCommand, *DashboardProvisioning) error); ok {
		r1 = rf(ctx, cmd, provisioning)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SaveProvisionedDashboard is a helper method to define mock.On call
//   - ctx context.Context
//   - cmd SaveDashboardCommand
//   - provisioning *DashboardProvisioning
func (_e *FakeDashboardStore_Expecter) SaveProvisionedDashboard(ctx interface{}, cmd interface{}, provisioning interface{}) *FakeDashboardStore_SaveProvisionedDashboard_Call {
	return &FakeDashboardStore_SaveProvisionedDashboard_Call{Call: _e.mock.On("SaveProvisionedDashboard", ctx, cmd, provisioning)}
}

func (_c *FakeDashboardStore_SaveProvisionedDashboard_Call) Run(run func(ctx context.Context, cmd SaveDashboardCommand, provisioning *DashboardProvisioning)) *FakeDashboardStore_SaveProvisionedDashboard_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(SaveDashboardCommand), args[2].(*DashboardProvisioning))
	})
	return _c
}

func (_c *FakeDashboardStore_SaveProvisionedDashboard_Call) Return(_a0 *Dashboard, _a1 error) *FakeDashboardStore_SaveProvisionedDashboard_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FakeDashboardStore_SaveProvisionedDashboard_Call) RunAndReturn(run func(context.Context, SaveDashboardCommand, *DashboardProvisioning) (*Dashboard, error)) *FakeDashboardStore_SaveProvisionedDashboard_Call {
	_c.Call.Return(run)
	return _c
}

// UnprovisionDashboard provides a mock function with given fields: ctx, id
func (_m *FakeDashboardStore) UnprovisionDashboard(ctx context.Context, id int64) error {
	ret := _m.Called(ctx, id)

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

	return r0
}

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

// UnprovisionDashboard is a helper method to define mock.On call
//   - ctx context.Context
//   - id int64
func (_e *FakeDashboardStore_Expecter) UnprovisionDashboard(ctx interface{}, id interface{}) *FakeDashboardStore_UnprovisionDashboard_Call {
	return &FakeDashboardStore_UnprovisionDashboard_Call{Call: _e.mock.On("UnprovisionDashboard", ctx, id)}
}

func (_c *FakeDashboardStore_UnprovisionDashboard_Call) Run(run func(ctx context.Context, id int64)) *FakeDashboardStore_UnprovisionDashboard_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64))
	})
	return _c
}

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

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

// UpdateDashboardACL provides a mock function with given fields: ctx, uid, items
func (_m *FakeDashboardStore) UpdateDashboardACL(ctx context.Context, uid int64, items []*DashboardACL) error {
	ret := _m.Called(ctx, uid, items)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, int64, []*DashboardACL) error); ok {
		r0 = rf(ctx, uid, items)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// UpdateDashboardACL is a helper method to define mock.On call
//   - ctx context.Context
//   - uid int64
//   - items []*DashboardACL
func (_e *FakeDashboardStore_Expecter) UpdateDashboardACL(ctx interface{}, uid interface{}, items interface{}) *FakeDashboardStore_UpdateDashboardACL_Call {
	return &FakeDashboardStore_UpdateDashboardACL_Call{Call: _e.mock.On("UpdateDashboardACL", ctx, uid, items)}
}

func (_c *FakeDashboardStore_UpdateDashboardACL_Call) Run(run func(ctx context.Context, uid int64, items []*DashboardACL)) *FakeDashboardStore_UpdateDashboardACL_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].([]*DashboardACL))
	})
	return _c
}

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

func (_c *FakeDashboardStore_UpdateDashboardACL_Call) RunAndReturn(run func(context.Context, int64, []*DashboardACL) error) *FakeDashboardStore_UpdateDashboardACL_Call {
	_c.Call.Return(run)
	return _c
}

// ValidateDashboardBeforeSave provides a mock function with given fields: ctx, dashboard, overwrite
func (_m *FakeDashboardStore) ValidateDashboardBeforeSave(ctx context.Context, dashboard *Dashboard, overwrite bool) (bool, error) {
	ret := _m.Called(ctx, dashboard, overwrite)

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *Dashboard, bool) (bool, error)); ok {
		return rf(ctx, dashboard, overwrite)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *Dashboard, bool) bool); ok {
		r0 = rf(ctx, dashboard, overwrite)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, *Dashboard, bool) error); ok {
		r1 = rf(ctx, dashboard, overwrite)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ValidateDashboardBeforeSave is a helper method to define mock.On call
//   - ctx context.Context
//   - dashboard *Dashboard
//   - overwrite bool
func (_e *FakeDashboardStore_Expecter) ValidateDashboardBeforeSave(ctx interface{}, dashboard interface{}, overwrite interface{}) *FakeDashboardStore_ValidateDashboardBeforeSave_Call {
	return &FakeDashboardStore_ValidateDashboardBeforeSave_Call{Call: _e.mock.On("ValidateDashboardBeforeSave", ctx, dashboard, overwrite)}
}

func (_c *FakeDashboardStore_ValidateDashboardBeforeSave_Call) Run(run func(ctx context.Context, dashboard *Dashboard, overwrite bool)) *FakeDashboardStore_ValidateDashboardBeforeSave_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*Dashboard), args[2].(bool))
	})
	return _c
}

func (_c *FakeDashboardStore_ValidateDashboardBeforeSave_Call) Return(_a0 bool, _a1 error) *FakeDashboardStore_ValidateDashboardBeforeSave_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FakeDashboardStore_ValidateDashboardBeforeSave_Call) RunAndReturn(run func(context.Context, *Dashboard, bool) (bool, error)) *FakeDashboardStore_ValidateDashboardBeforeSave_Call {
	_c.Call.Return(run)
	return _c
}

type mockConstructorTestingTNewFakeDashboardStore interface {
	mock.TestingT
	Cleanup(func())
}

// NewFakeDashboardStore creates a new instance of FakeDashboardStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
func NewFakeDashboardStore(t mockConstructorTestingTNewFakeDashboardStore) *FakeDashboardStore {
	mock := &FakeDashboardStore{}
	mock.Mock.Test(t)

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

	return mock
}