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

package mocks

import (
	"context"
	"time"

	mock "github.com/stretchr/testify/mock"
	"github.com/tidbcloud/cluster-service-ng/api/cluster-service-ng/v1beta"
	"github.com/tidbcloud/cluster-service-ng/domain/entity"
	"github.com/tidbcloud/cluster-service-ng/pkg/storage/mysql/schema"
	"github.com/tidbcloud/cluster-service-ng/pkg/storage/repo"
)

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

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

	return mock
}

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

type AutoscalePolicyBundleRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *AutoscalePolicyBundleRepo) EXPECT() *AutoscalePolicyBundleRepo_Expecter {
	return &AutoscalePolicyBundleRepo_Expecter{mock: &_m.Mock}
}

// DeleteBundle provides a mock function for the type AutoscalePolicyBundleRepo
func (_mock *AutoscalePolicyBundleRepo) DeleteBundle(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string) error {
	ret := _mock.Called(ctx, scope, subjectID)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string) error); ok {
		r0 = returnFunc(ctx, scope, subjectID)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// DeleteBundle is a helper method to define mock.On call
//   - ctx context.Context
//   - scope cluster_service_ngv1beta.AutoscalePolicyScope
//   - subjectID string
func (_e *AutoscalePolicyBundleRepo_Expecter) DeleteBundle(ctx interface{}, scope interface{}, subjectID interface{}) *AutoscalePolicyBundleRepo_DeleteBundle_Call {
	return &AutoscalePolicyBundleRepo_DeleteBundle_Call{Call: _e.mock.On("DeleteBundle", ctx, scope, subjectID)}
}

func (_c *AutoscalePolicyBundleRepo_DeleteBundle_Call) Run(run func(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string)) *AutoscalePolicyBundleRepo_DeleteBundle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 cluster_service_ngv1beta.AutoscalePolicyScope
		if args[1] != nil {
			arg1 = args[1].(cluster_service_ngv1beta.AutoscalePolicyScope)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *AutoscalePolicyBundleRepo_DeleteBundle_Call) RunAndReturn(run func(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string) error) *AutoscalePolicyBundleRepo_DeleteBundle_Call {
	_c.Call.Return(run)
	return _c
}

// GetBundle provides a mock function for the type AutoscalePolicyBundleRepo
func (_mock *AutoscalePolicyBundleRepo) GetBundle(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string) (*repo.AutoscalePolicyBundleRow, error) {
	ret := _mock.Called(ctx, scope, subjectID)

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

	var r0 *repo.AutoscalePolicyBundleRow
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string) (*repo.AutoscalePolicyBundleRow, error)); ok {
		return returnFunc(ctx, scope, subjectID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string) *repo.AutoscalePolicyBundleRow); ok {
		r0 = returnFunc(ctx, scope, subjectID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*repo.AutoscalePolicyBundleRow)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, cluster_service_ngv1beta.AutoscalePolicyScope, string) error); ok {
		r1 = returnFunc(ctx, scope, subjectID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetBundle is a helper method to define mock.On call
//   - ctx context.Context
//   - scope cluster_service_ngv1beta.AutoscalePolicyScope
//   - subjectID string
func (_e *AutoscalePolicyBundleRepo_Expecter) GetBundle(ctx interface{}, scope interface{}, subjectID interface{}) *AutoscalePolicyBundleRepo_GetBundle_Call {
	return &AutoscalePolicyBundleRepo_GetBundle_Call{Call: _e.mock.On("GetBundle", ctx, scope, subjectID)}
}

func (_c *AutoscalePolicyBundleRepo_GetBundle_Call) Run(run func(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string)) *AutoscalePolicyBundleRepo_GetBundle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 cluster_service_ngv1beta.AutoscalePolicyScope
		if args[1] != nil {
			arg1 = args[1].(cluster_service_ngv1beta.AutoscalePolicyScope)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *AutoscalePolicyBundleRepo_GetBundle_Call) Return(autoscalePolicyBundleRow *repo.AutoscalePolicyBundleRow, err error) *AutoscalePolicyBundleRepo_GetBundle_Call {
	_c.Call.Return(autoscalePolicyBundleRow, err)
	return _c
}

func (_c *AutoscalePolicyBundleRepo_GetBundle_Call) RunAndReturn(run func(ctx context.Context, scope cluster_service_ngv1beta.AutoscalePolicyScope, subjectID string) (*repo.AutoscalePolicyBundleRow, error)) *AutoscalePolicyBundleRepo_GetBundle_Call {
	_c.Call.Return(run)
	return _c
}

// ListBundles provides a mock function for the type AutoscalePolicyBundleRepo
func (_mock *AutoscalePolicyBundleRepo) ListBundles(ctx context.Context, filter repo.AutoscalePolicyBundleFilter, pageSize uint32, pageToken string) ([]*repo.AutoscalePolicyBundleRow, string, error) {
	ret := _mock.Called(ctx, filter, pageSize, pageToken)

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

	var r0 []*repo.AutoscalePolicyBundleRow
	var r1 string
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, repo.AutoscalePolicyBundleFilter, uint32, string) ([]*repo.AutoscalePolicyBundleRow, string, error)); ok {
		return returnFunc(ctx, filter, pageSize, pageToken)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, repo.AutoscalePolicyBundleFilter, uint32, string) []*repo.AutoscalePolicyBundleRow); ok {
		r0 = returnFunc(ctx, filter, pageSize, pageToken)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*repo.AutoscalePolicyBundleRow)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, repo.AutoscalePolicyBundleFilter, uint32, string) string); ok {
		r1 = returnFunc(ctx, filter, pageSize, pageToken)
	} else {
		r1 = ret.Get(1).(string)
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, repo.AutoscalePolicyBundleFilter, uint32, string) error); ok {
		r2 = returnFunc(ctx, filter, pageSize, pageToken)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// ListBundles is a helper method to define mock.On call
//   - ctx context.Context
//   - filter repo.AutoscalePolicyBundleFilter
//   - pageSize uint32
//   - pageToken string
func (_e *AutoscalePolicyBundleRepo_Expecter) ListBundles(ctx interface{}, filter interface{}, pageSize interface{}, pageToken interface{}) *AutoscalePolicyBundleRepo_ListBundles_Call {
	return &AutoscalePolicyBundleRepo_ListBundles_Call{Call: _e.mock.On("ListBundles", ctx, filter, pageSize, pageToken)}
}

func (_c *AutoscalePolicyBundleRepo_ListBundles_Call) Run(run func(ctx context.Context, filter repo.AutoscalePolicyBundleFilter, pageSize uint32, pageToken string)) *AutoscalePolicyBundleRepo_ListBundles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 repo.AutoscalePolicyBundleFilter
		if args[1] != nil {
			arg1 = args[1].(repo.AutoscalePolicyBundleFilter)
		}
		var arg2 uint32
		if args[2] != nil {
			arg2 = args[2].(uint32)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *AutoscalePolicyBundleRepo_ListBundles_Call) Return(autoscalePolicyBundleRows []*repo.AutoscalePolicyBundleRow, s string, err error) *AutoscalePolicyBundleRepo_ListBundles_Call {
	_c.Call.Return(autoscalePolicyBundleRows, s, err)
	return _c
}

func (_c *AutoscalePolicyBundleRepo_ListBundles_Call) RunAndReturn(run func(ctx context.Context, filter repo.AutoscalePolicyBundleFilter, pageSize uint32, pageToken string) ([]*repo.AutoscalePolicyBundleRow, string, error)) *AutoscalePolicyBundleRepo_ListBundles_Call {
	_c.Call.Return(run)
	return _c
}

// UpsertBundle provides a mock function for the type AutoscalePolicyBundleRepo
func (_mock *AutoscalePolicyBundleRepo) UpsertBundle(ctx context.Context, row *repo.AutoscalePolicyBundleRow) error {
	ret := _mock.Called(ctx, row)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *repo.AutoscalePolicyBundleRow) error); ok {
		r0 = returnFunc(ctx, row)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// UpsertBundle is a helper method to define mock.On call
//   - ctx context.Context
//   - row *repo.AutoscalePolicyBundleRow
func (_e *AutoscalePolicyBundleRepo_Expecter) UpsertBundle(ctx interface{}, row interface{}) *AutoscalePolicyBundleRepo_UpsertBundle_Call {
	return &AutoscalePolicyBundleRepo_UpsertBundle_Call{Call: _e.mock.On("UpsertBundle", ctx, row)}
}

func (_c *AutoscalePolicyBundleRepo_UpsertBundle_Call) Run(run func(ctx context.Context, row *repo.AutoscalePolicyBundleRow)) *AutoscalePolicyBundleRepo_UpsertBundle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *repo.AutoscalePolicyBundleRow
		if args[1] != nil {
			arg1 = args[1].(*repo.AutoscalePolicyBundleRow)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *AutoscalePolicyBundleRepo_UpsertBundle_Call) RunAndReturn(run func(ctx context.Context, row *repo.AutoscalePolicyBundleRow) error) *AutoscalePolicyBundleRepo_UpsertBundle_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type AutoscaleRuntimeGuardRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *AutoscaleRuntimeGuardRepo) EXPECT() *AutoscaleRuntimeGuardRepo_Expecter {
	return &AutoscaleRuntimeGuardRepo_Expecter{mock: &_m.Mock}
}

// DeleteGuard provides a mock function for the type AutoscaleRuntimeGuardRepo
func (_mock *AutoscaleRuntimeGuardRepo) DeleteGuard(ctx context.Context, scopeType entity.AutoscaleRuntimeGuardScopeType, scopeID string, guardType entity.AutoscaleRuntimeGuardType, componentType entity.ComponentType) error {
	ret := _mock.Called(ctx, scopeType, scopeID, guardType, componentType)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.AutoscaleRuntimeGuardScopeType, string, entity.AutoscaleRuntimeGuardType, entity.ComponentType) error); ok {
		r0 = returnFunc(ctx, scopeType, scopeID, guardType, componentType)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// DeleteGuard is a helper method to define mock.On call
//   - ctx context.Context
//   - scopeType entity.AutoscaleRuntimeGuardScopeType
//   - scopeID string
//   - guardType entity.AutoscaleRuntimeGuardType
//   - componentType entity.ComponentType
func (_e *AutoscaleRuntimeGuardRepo_Expecter) DeleteGuard(ctx interface{}, scopeType interface{}, scopeID interface{}, guardType interface{}, componentType interface{}) *AutoscaleRuntimeGuardRepo_DeleteGuard_Call {
	return &AutoscaleRuntimeGuardRepo_DeleteGuard_Call{Call: _e.mock.On("DeleteGuard", ctx, scopeType, scopeID, guardType, componentType)}
}

func (_c *AutoscaleRuntimeGuardRepo_DeleteGuard_Call) Run(run func(ctx context.Context, scopeType entity.AutoscaleRuntimeGuardScopeType, scopeID string, guardType entity.AutoscaleRuntimeGuardType, componentType entity.ComponentType)) *AutoscaleRuntimeGuardRepo_DeleteGuard_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 entity.AutoscaleRuntimeGuardScopeType
		if args[1] != nil {
			arg1 = args[1].(entity.AutoscaleRuntimeGuardScopeType)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 entity.AutoscaleRuntimeGuardType
		if args[3] != nil {
			arg3 = args[3].(entity.AutoscaleRuntimeGuardType)
		}
		var arg4 entity.ComponentType
		if args[4] != nil {
			arg4 = args[4].(entity.ComponentType)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *AutoscaleRuntimeGuardRepo_DeleteGuard_Call) RunAndReturn(run func(ctx context.Context, scopeType entity.AutoscaleRuntimeGuardScopeType, scopeID string, guardType entity.AutoscaleRuntimeGuardType, componentType entity.ComponentType) error) *AutoscaleRuntimeGuardRepo_DeleteGuard_Call {
	_c.Call.Return(run)
	return _c
}

// ListGuards provides a mock function for the type AutoscaleRuntimeGuardRepo
func (_mock *AutoscaleRuntimeGuardRepo) ListGuards(ctx context.Context, filter repo.AutoscaleRuntimeGuardFilter) ([]*entity.AutoscaleRuntimeGuard, error) {
	ret := _mock.Called(ctx, filter)

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

	var r0 []*entity.AutoscaleRuntimeGuard
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, repo.AutoscaleRuntimeGuardFilter) ([]*entity.AutoscaleRuntimeGuard, error)); ok {
		return returnFunc(ctx, filter)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, repo.AutoscaleRuntimeGuardFilter) []*entity.AutoscaleRuntimeGuard); ok {
		r0 = returnFunc(ctx, filter)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.AutoscaleRuntimeGuard)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, repo.AutoscaleRuntimeGuardFilter) error); ok {
		r1 = returnFunc(ctx, filter)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListGuards is a helper method to define mock.On call
//   - ctx context.Context
//   - filter repo.AutoscaleRuntimeGuardFilter
func (_e *AutoscaleRuntimeGuardRepo_Expecter) ListGuards(ctx interface{}, filter interface{}) *AutoscaleRuntimeGuardRepo_ListGuards_Call {
	return &AutoscaleRuntimeGuardRepo_ListGuards_Call{Call: _e.mock.On("ListGuards", ctx, filter)}
}

func (_c *AutoscaleRuntimeGuardRepo_ListGuards_Call) Run(run func(ctx context.Context, filter repo.AutoscaleRuntimeGuardFilter)) *AutoscaleRuntimeGuardRepo_ListGuards_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 repo.AutoscaleRuntimeGuardFilter
		if args[1] != nil {
			arg1 = args[1].(repo.AutoscaleRuntimeGuardFilter)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *AutoscaleRuntimeGuardRepo_ListGuards_Call) Return(vs []*entity.AutoscaleRuntimeGuard, err error) *AutoscaleRuntimeGuardRepo_ListGuards_Call {
	_c.Call.Return(vs, err)
	return _c
}

func (_c *AutoscaleRuntimeGuardRepo_ListGuards_Call) RunAndReturn(run func(ctx context.Context, filter repo.AutoscaleRuntimeGuardFilter) ([]*entity.AutoscaleRuntimeGuard, error)) *AutoscaleRuntimeGuardRepo_ListGuards_Call {
	_c.Call.Return(run)
	return _c
}

// UpsertGuard provides a mock function for the type AutoscaleRuntimeGuardRepo
func (_mock *AutoscaleRuntimeGuardRepo) UpsertGuard(ctx context.Context, guard *entity.AutoscaleRuntimeGuard) (*entity.AutoscaleRuntimeGuard, error) {
	ret := _mock.Called(ctx, guard)

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

	var r0 *entity.AutoscaleRuntimeGuard
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.AutoscaleRuntimeGuard) (*entity.AutoscaleRuntimeGuard, error)); ok {
		return returnFunc(ctx, guard)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.AutoscaleRuntimeGuard) *entity.AutoscaleRuntimeGuard); ok {
		r0 = returnFunc(ctx, guard)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.AutoscaleRuntimeGuard)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *entity.AutoscaleRuntimeGuard) error); ok {
		r1 = returnFunc(ctx, guard)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpsertGuard is a helper method to define mock.On call
//   - ctx context.Context
//   - guard *entity.AutoscaleRuntimeGuard
func (_e *AutoscaleRuntimeGuardRepo_Expecter) UpsertGuard(ctx interface{}, guard interface{}) *AutoscaleRuntimeGuardRepo_UpsertGuard_Call {
	return &AutoscaleRuntimeGuardRepo_UpsertGuard_Call{Call: _e.mock.On("UpsertGuard", ctx, guard)}
}

func (_c *AutoscaleRuntimeGuardRepo_UpsertGuard_Call) Run(run func(ctx context.Context, guard *entity.AutoscaleRuntimeGuard)) *AutoscaleRuntimeGuardRepo_UpsertGuard_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.AutoscaleRuntimeGuard
		if args[1] != nil {
			arg1 = args[1].(*entity.AutoscaleRuntimeGuard)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *AutoscaleRuntimeGuardRepo_UpsertGuard_Call) Return(v *entity.AutoscaleRuntimeGuard, err error) *AutoscaleRuntimeGuardRepo_UpsertGuard_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *AutoscaleRuntimeGuardRepo_UpsertGuard_Call) RunAndReturn(run func(ctx context.Context, guard *entity.AutoscaleRuntimeGuard) (*entity.AutoscaleRuntimeGuard, error)) *AutoscaleRuntimeGuardRepo_UpsertGuard_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type BackupGcSettingRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *BackupGcSettingRepo) EXPECT() *BackupGcSettingRepo_Expecter {
	return &BackupGcSettingRepo_Expecter{mock: &_m.Mock}
}

// Create provides a mock function for the type BackupGcSettingRepo
func (_mock *BackupGcSettingRepo) Create(ctx context.Context, backupGcSetting *entity.BackupGcSetting) error {
	ret := _mock.Called(ctx, backupGcSetting)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.BackupGcSetting) error); ok {
		r0 = returnFunc(ctx, backupGcSetting)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - backupGcSetting *entity.BackupGcSetting
func (_e *BackupGcSettingRepo_Expecter) Create(ctx interface{}, backupGcSetting interface{}) *BackupGcSettingRepo_Create_Call {
	return &BackupGcSettingRepo_Create_Call{Call: _e.mock.On("Create", ctx, backupGcSetting)}
}

func (_c *BackupGcSettingRepo_Create_Call) Run(run func(ctx context.Context, backupGcSetting *entity.BackupGcSetting)) *BackupGcSettingRepo_Create_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.BackupGcSetting
		if args[1] != nil {
			arg1 = args[1].(*entity.BackupGcSetting)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *BackupGcSettingRepo_Create_Call) RunAndReturn(run func(ctx context.Context, backupGcSetting *entity.BackupGcSetting) error) *BackupGcSettingRepo_Create_Call {
	_c.Call.Return(run)
	return _c
}

// Delete provides a mock function for the type BackupGcSettingRepo
func (_mock *BackupGcSettingRepo) Delete(ctx context.Context, sharedPoolId string) error {
	ret := _mock.Called(ctx, sharedPoolId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(ctx, sharedPoolId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
func (_e *BackupGcSettingRepo_Expecter) Delete(ctx interface{}, sharedPoolId interface{}) *BackupGcSettingRepo_Delete_Call {
	return &BackupGcSettingRepo_Delete_Call{Call: _e.mock.On("Delete", ctx, sharedPoolId)}
}

func (_c *BackupGcSettingRepo_Delete_Call) Run(run func(ctx context.Context, sharedPoolId string)) *BackupGcSettingRepo_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *BackupGcSettingRepo_Delete_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string) error) *BackupGcSettingRepo_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// List provides a mock function for the type BackupGcSettingRepo
func (_mock *BackupGcSettingRepo) List(ctx context.Context, filter *repo.BackupGcSettingFilter) ([]*entity.BackupGcSetting, error) {
	ret := _mock.Called(ctx, filter)

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

	var r0 []*entity.BackupGcSetting
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *repo.BackupGcSettingFilter) ([]*entity.BackupGcSetting, error)); ok {
		return returnFunc(ctx, filter)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *repo.BackupGcSettingFilter) []*entity.BackupGcSetting); ok {
		r0 = returnFunc(ctx, filter)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.BackupGcSetting)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *repo.BackupGcSettingFilter) error); ok {
		r1 = returnFunc(ctx, filter)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// List is a helper method to define mock.On call
//   - ctx context.Context
//   - filter *repo.BackupGcSettingFilter
func (_e *BackupGcSettingRepo_Expecter) List(ctx interface{}, filter interface{}) *BackupGcSettingRepo_List_Call {
	return &BackupGcSettingRepo_List_Call{Call: _e.mock.On("List", ctx, filter)}
}

func (_c *BackupGcSettingRepo_List_Call) Run(run func(ctx context.Context, filter *repo.BackupGcSettingFilter)) *BackupGcSettingRepo_List_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *repo.BackupGcSettingFilter
		if args[1] != nil {
			arg1 = args[1].(*repo.BackupGcSettingFilter)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *BackupGcSettingRepo_List_Call) Return(backupGcSettings []*entity.BackupGcSetting, err error) *BackupGcSettingRepo_List_Call {
	_c.Call.Return(backupGcSettings, err)
	return _c
}

func (_c *BackupGcSettingRepo_List_Call) RunAndReturn(run func(ctx context.Context, filter *repo.BackupGcSettingFilter) ([]*entity.BackupGcSetting, error)) *BackupGcSettingRepo_List_Call {
	_c.Call.Return(run)
	return _c
}

// Load provides a mock function for the type BackupGcSettingRepo
func (_mock *BackupGcSettingRepo) Load(ctx context.Context, sharedPoolId string) (*entity.BackupGcSetting, error) {
	ret := _mock.Called(ctx, sharedPoolId)

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

	var r0 *entity.BackupGcSetting
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.BackupGcSetting, error)); ok {
		return returnFunc(ctx, sharedPoolId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.BackupGcSetting); ok {
		r0 = returnFunc(ctx, sharedPoolId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.BackupGcSetting)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Load is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
func (_e *BackupGcSettingRepo_Expecter) Load(ctx interface{}, sharedPoolId interface{}) *BackupGcSettingRepo_Load_Call {
	return &BackupGcSettingRepo_Load_Call{Call: _e.mock.On("Load", ctx, sharedPoolId)}
}

func (_c *BackupGcSettingRepo_Load_Call) Run(run func(ctx context.Context, sharedPoolId string)) *BackupGcSettingRepo_Load_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *BackupGcSettingRepo_Load_Call) Return(backupGcSetting *entity.BackupGcSetting, err error) *BackupGcSettingRepo_Load_Call {
	_c.Call.Return(backupGcSetting, err)
	return _c
}

func (_c *BackupGcSettingRepo_Load_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string) (*entity.BackupGcSetting, error)) *BackupGcSettingRepo_Load_Call {
	_c.Call.Return(run)
	return _c
}

// Save provides a mock function for the type BackupGcSettingRepo
func (_mock *BackupGcSettingRepo) Save(ctx context.Context, backupGcSetting *entity.BackupGcSetting) error {
	ret := _mock.Called(ctx, backupGcSetting)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.BackupGcSetting) error); ok {
		r0 = returnFunc(ctx, backupGcSetting)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Save is a helper method to define mock.On call
//   - ctx context.Context
//   - backupGcSetting *entity.BackupGcSetting
func (_e *BackupGcSettingRepo_Expecter) Save(ctx interface{}, backupGcSetting interface{}) *BackupGcSettingRepo_Save_Call {
	return &BackupGcSettingRepo_Save_Call{Call: _e.mock.On("Save", ctx, backupGcSetting)}
}

func (_c *BackupGcSettingRepo_Save_Call) Run(run func(ctx context.Context, backupGcSetting *entity.BackupGcSetting)) *BackupGcSettingRepo_Save_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.BackupGcSetting
		if args[1] != nil {
			arg1 = args[1].(*entity.BackupGcSetting)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *BackupGcSettingRepo_Save_Call) RunAndReturn(run func(ctx context.Context, backupGcSetting *entity.BackupGcSetting) error) *BackupGcSettingRepo_Save_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type CassandraProxyStateRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *CassandraProxyStateRepo) EXPECT() *CassandraProxyStateRepo_Expecter {
	return &CassandraProxyStateRepo_Expecter{mock: &_m.Mock}
}

// Delete provides a mock function for the type CassandraProxyStateRepo
func (_mock *CassandraProxyStateRepo) Delete(ctx context.Context, clusterID string, hostID string) error {
	ret := _mock.Called(ctx, clusterID, hostID)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, clusterID, hostID)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterID string
//   - hostID string
func (_e *CassandraProxyStateRepo_Expecter) Delete(ctx interface{}, clusterID interface{}, hostID interface{}) *CassandraProxyStateRepo_Delete_Call {
	return &CassandraProxyStateRepo_Delete_Call{Call: _e.mock.On("Delete", ctx, clusterID, hostID)}
}

func (_c *CassandraProxyStateRepo_Delete_Call) Run(run func(ctx context.Context, clusterID string, hostID string)) *CassandraProxyStateRepo_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *CassandraProxyStateRepo_Delete_Call) RunAndReturn(run func(ctx context.Context, clusterID string, hostID string) error) *CassandraProxyStateRepo_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// ListBySharedPoolID provides a mock function for the type CassandraProxyStateRepo
func (_mock *CassandraProxyStateRepo) ListBySharedPoolID(ctx context.Context, sharedPoolID string) ([]*entity.CassandraProxyState, error) {
	ret := _mock.Called(ctx, sharedPoolID)

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

	var r0 []*entity.CassandraProxyState
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*entity.CassandraProxyState, error)); ok {
		return returnFunc(ctx, sharedPoolID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*entity.CassandraProxyState); ok {
		r0 = returnFunc(ctx, sharedPoolID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.CassandraProxyState)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListBySharedPoolID is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolID string
func (_e *CassandraProxyStateRepo_Expecter) ListBySharedPoolID(ctx interface{}, sharedPoolID interface{}) *CassandraProxyStateRepo_ListBySharedPoolID_Call {
	return &CassandraProxyStateRepo_ListBySharedPoolID_Call{Call: _e.mock.On("ListBySharedPoolID", ctx, sharedPoolID)}
}

func (_c *CassandraProxyStateRepo_ListBySharedPoolID_Call) Run(run func(ctx context.Context, sharedPoolID string)) *CassandraProxyStateRepo_ListBySharedPoolID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *CassandraProxyStateRepo_ListBySharedPoolID_Call) Return(cassandraProxyStates []*entity.CassandraProxyState, err error) *CassandraProxyStateRepo_ListBySharedPoolID_Call {
	_c.Call.Return(cassandraProxyStates, err)
	return _c
}

func (_c *CassandraProxyStateRepo_ListBySharedPoolID_Call) RunAndReturn(run func(ctx context.Context, sharedPoolID string) ([]*entity.CassandraProxyState, error)) *CassandraProxyStateRepo_ListBySharedPoolID_Call {
	_c.Call.Return(run)
	return _c
}

// LoadByClusterID provides a mock function for the type CassandraProxyStateRepo
func (_mock *CassandraProxyStateRepo) LoadByClusterID(ctx context.Context, clusterID string, deleted bool) (*entity.CassandraProxyState, error) {
	ret := _mock.Called(ctx, clusterID, deleted)

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

	var r0 *entity.CassandraProxyState
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) (*entity.CassandraProxyState, error)); ok {
		return returnFunc(ctx, clusterID, deleted)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) *entity.CassandraProxyState); ok {
		r0 = returnFunc(ctx, clusterID, deleted)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.CassandraProxyState)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
		r1 = returnFunc(ctx, clusterID, deleted)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// LoadByClusterID is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterID string
//   - deleted bool
func (_e *CassandraProxyStateRepo_Expecter) LoadByClusterID(ctx interface{}, clusterID interface{}, deleted interface{}) *CassandraProxyStateRepo_LoadByClusterID_Call {
	return &CassandraProxyStateRepo_LoadByClusterID_Call{Call: _e.mock.On("LoadByClusterID", ctx, clusterID, deleted)}
}

func (_c *CassandraProxyStateRepo_LoadByClusterID_Call) Run(run func(ctx context.Context, clusterID string, deleted bool)) *CassandraProxyStateRepo_LoadByClusterID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *CassandraProxyStateRepo_LoadByClusterID_Call) Return(cassandraProxyState *entity.CassandraProxyState, err error) *CassandraProxyStateRepo_LoadByClusterID_Call {
	_c.Call.Return(cassandraProxyState, err)
	return _c
}

func (_c *CassandraProxyStateRepo_LoadByClusterID_Call) RunAndReturn(run func(ctx context.Context, clusterID string, deleted bool) (*entity.CassandraProxyState, error)) *CassandraProxyStateRepo_LoadByClusterID_Call {
	_c.Call.Return(run)
	return _c
}

// Save provides a mock function for the type CassandraProxyStateRepo
func (_mock *CassandraProxyStateRepo) Save(ctx context.Context, state *entity.CassandraProxyState) error {
	ret := _mock.Called(ctx, state)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.CassandraProxyState) error); ok {
		r0 = returnFunc(ctx, state)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Save is a helper method to define mock.On call
//   - ctx context.Context
//   - state *entity.CassandraProxyState
func (_e *CassandraProxyStateRepo_Expecter) Save(ctx interface{}, state interface{}) *CassandraProxyStateRepo_Save_Call {
	return &CassandraProxyStateRepo_Save_Call{Call: _e.mock.On("Save", ctx, state)}
}

func (_c *CassandraProxyStateRepo_Save_Call) Run(run func(ctx context.Context, state *entity.CassandraProxyState)) *CassandraProxyStateRepo_Save_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.CassandraProxyState
		if args[1] != nil {
			arg1 = args[1].(*entity.CassandraProxyState)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *CassandraProxyStateRepo_Save_Call) RunAndReturn(run func(ctx context.Context, state *entity.CassandraProxyState) error) *CassandraProxyStateRepo_Save_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePhase provides a mock function for the type CassandraProxyStateRepo
func (_mock *CassandraProxyStateRepo) UpdatePhase(ctx context.Context, clusterID string, hostID string, phase entity.ComponentPhase) error {
	ret := _mock.Called(ctx, clusterID, hostID, phase)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, entity.ComponentPhase) error); ok {
		r0 = returnFunc(ctx, clusterID, hostID, phase)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// UpdatePhase is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterID string
//   - hostID string
//   - phase entity.ComponentPhase
func (_e *CassandraProxyStateRepo_Expecter) UpdatePhase(ctx interface{}, clusterID interface{}, hostID interface{}, phase interface{}) *CassandraProxyStateRepo_UpdatePhase_Call {
	return &CassandraProxyStateRepo_UpdatePhase_Call{Call: _e.mock.On("UpdatePhase", ctx, clusterID, hostID, phase)}
}

func (_c *CassandraProxyStateRepo_UpdatePhase_Call) Run(run func(ctx context.Context, clusterID string, hostID string, phase entity.ComponentPhase)) *CassandraProxyStateRepo_UpdatePhase_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 entity.ComponentPhase
		if args[3] != nil {
			arg3 = args[3].(entity.ComponentPhase)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *CassandraProxyStateRepo_UpdatePhase_Call) RunAndReturn(run func(ctx context.Context, clusterID string, hostID string, phase entity.ComponentPhase) error) *CassandraProxyStateRepo_UpdatePhase_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePhaseIfCurrent provides a mock function for the type CassandraProxyStateRepo
func (_mock *CassandraProxyStateRepo) UpdatePhaseIfCurrent(ctx context.Context, clusterID string, hostID string, currentPhases []entity.ComponentPhase, nextPhase entity.ComponentPhase) (*entity.CassandraProxyState, bool, error) {
	ret := _mock.Called(ctx, clusterID, hostID, currentPhases, nextPhase)

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

	var r0 *entity.CassandraProxyState
	var r1 bool
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []entity.ComponentPhase, entity.ComponentPhase) (*entity.CassandraProxyState, bool, error)); ok {
		return returnFunc(ctx, clusterID, hostID, currentPhases, nextPhase)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []entity.ComponentPhase, entity.ComponentPhase) *entity.CassandraProxyState); ok {
		r0 = returnFunc(ctx, clusterID, hostID, currentPhases, nextPhase)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.CassandraProxyState)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, []entity.ComponentPhase, entity.ComponentPhase) bool); ok {
		r1 = returnFunc(ctx, clusterID, hostID, currentPhases, nextPhase)
	} else {
		r1 = ret.Get(1).(bool)
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, string, string, []entity.ComponentPhase, entity.ComponentPhase) error); ok {
		r2 = returnFunc(ctx, clusterID, hostID, currentPhases, nextPhase)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// UpdatePhaseIfCurrent is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterID string
//   - hostID string
//   - currentPhases []entity.ComponentPhase
//   - nextPhase entity.ComponentPhase
func (_e *CassandraProxyStateRepo_Expecter) UpdatePhaseIfCurrent(ctx interface{}, clusterID interface{}, hostID interface{}, currentPhases interface{}, nextPhase interface{}) *CassandraProxyStateRepo_UpdatePhaseIfCurrent_Call {
	return &CassandraProxyStateRepo_UpdatePhaseIfCurrent_Call{Call: _e.mock.On("UpdatePhaseIfCurrent", ctx, clusterID, hostID, currentPhases, nextPhase)}
}

func (_c *CassandraProxyStateRepo_UpdatePhaseIfCurrent_Call) Run(run func(ctx context.Context, clusterID string, hostID string, currentPhases []entity.ComponentPhase, nextPhase entity.ComponentPhase)) *CassandraProxyStateRepo_UpdatePhaseIfCurrent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 []entity.ComponentPhase
		if args[3] != nil {
			arg3 = args[3].([]entity.ComponentPhase)
		}
		var arg4 entity.ComponentPhase
		if args[4] != nil {
			arg4 = args[4].(entity.ComponentPhase)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *CassandraProxyStateRepo_UpdatePhaseIfCurrent_Call) Return(cassandraProxyState *entity.CassandraProxyState, b bool, err error) *CassandraProxyStateRepo_UpdatePhaseIfCurrent_Call {
	_c.Call.Return(cassandraProxyState, b, err)
	return _c
}

func (_c *CassandraProxyStateRepo_UpdatePhaseIfCurrent_Call) RunAndReturn(run func(ctx context.Context, clusterID string, hostID string, currentPhases []entity.ComponentPhase, nextPhase entity.ComponentPhase) (*entity.CassandraProxyState, bool, error)) *CassandraProxyStateRepo_UpdatePhaseIfCurrent_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type ClassicRestoreRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *ClassicRestoreRepo) EXPECT() *ClassicRestoreRepo_Expecter {
	return &ClassicRestoreRepo_Expecter{mock: &_m.Mock}
}

// AddExecutedAction provides a mock function for the type ClassicRestoreRepo
func (_mock *ClassicRestoreRepo) AddExecutedAction(ctx context.Context, restoreID string, action string) (bool, error) {
	ret := _mock.Called(ctx, restoreID, action)

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

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (bool, error)); ok {
		return returnFunc(ctx, restoreID, action)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) bool); ok {
		r0 = returnFunc(ctx, restoreID, action)
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, restoreID, action)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddExecutedAction is a helper method to define mock.On call
//   - ctx context.Context
//   - restoreID string
//   - action string
func (_e *ClassicRestoreRepo_Expecter) AddExecutedAction(ctx interface{}, restoreID interface{}, action interface{}) *ClassicRestoreRepo_AddExecutedAction_Call {
	return &ClassicRestoreRepo_AddExecutedAction_Call{Call: _e.mock.On("AddExecutedAction", ctx, restoreID, action)}
}

func (_c *ClassicRestoreRepo_AddExecutedAction_Call) Run(run func(ctx context.Context, restoreID string, action string)) *ClassicRestoreRepo_AddExecutedAction_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *ClassicRestoreRepo_AddExecutedAction_Call) Return(added bool, err error) *ClassicRestoreRepo_AddExecutedAction_Call {
	_c.Call.Return(added, err)
	return _c
}

func (_c *ClassicRestoreRepo_AddExecutedAction_Call) RunAndReturn(run func(ctx context.Context, restoreID string, action string) (bool, error)) *ClassicRestoreRepo_AddExecutedAction_Call {
	_c.Call.Return(run)
	return _c
}

// Create provides a mock function for the type ClassicRestoreRepo
func (_mock *ClassicRestoreRepo) Create(ctx context.Context, restore *entity.ClassicRestore) error {
	ret := _mock.Called(ctx, restore)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.ClassicRestore) error); ok {
		r0 = returnFunc(ctx, restore)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - restore *entity.ClassicRestore
func (_e *ClassicRestoreRepo_Expecter) Create(ctx interface{}, restore interface{}) *ClassicRestoreRepo_Create_Call {
	return &ClassicRestoreRepo_Create_Call{Call: _e.mock.On("Create", ctx, restore)}
}

func (_c *ClassicRestoreRepo_Create_Call) Run(run func(ctx context.Context, restore *entity.ClassicRestore)) *ClassicRestoreRepo_Create_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.ClassicRestore
		if args[1] != nil {
			arg1 = args[1].(*entity.ClassicRestore)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *ClassicRestoreRepo_Create_Call) RunAndReturn(run func(ctx context.Context, restore *entity.ClassicRestore) error) *ClassicRestoreRepo_Create_Call {
	_c.Call.Return(run)
	return _c
}

// Delete provides a mock function for the type ClassicRestoreRepo
func (_mock *ClassicRestoreRepo) Delete(ctx context.Context, id string) error {
	ret := _mock.Called(ctx, id)

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

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

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *ClassicRestoreRepo_Expecter) Delete(ctx interface{}, id interface{}) *ClassicRestoreRepo_Delete_Call {
	return &ClassicRestoreRepo_Delete_Call{Call: _e.mock.On("Delete", ctx, id)}
}

func (_c *ClassicRestoreRepo_Delete_Call) Run(run func(ctx context.Context, id string)) *ClassicRestoreRepo_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *ClassicRestoreRepo_Delete_Call) RunAndReturn(run func(ctx context.Context, id string) error) *ClassicRestoreRepo_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// Load provides a mock function for the type ClassicRestoreRepo
func (_mock *ClassicRestoreRepo) Load(ctx context.Context, id string, includeDeleted bool) (*entity.ClassicRestore, error) {
	ret := _mock.Called(ctx, id, includeDeleted)

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

	var r0 *entity.ClassicRestore
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) (*entity.ClassicRestore, error)); ok {
		return returnFunc(ctx, id, includeDeleted)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) *entity.ClassicRestore); ok {
		r0 = returnFunc(ctx, id, includeDeleted)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.ClassicRestore)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
		r1 = returnFunc(ctx, id, includeDeleted)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Load is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - includeDeleted bool
func (_e *ClassicRestoreRepo_Expecter) Load(ctx interface{}, id interface{}, includeDeleted interface{}) *ClassicRestoreRepo_Load_Call {
	return &ClassicRestoreRepo_Load_Call{Call: _e.mock.On("Load", ctx, id, includeDeleted)}
}

func (_c *ClassicRestoreRepo_Load_Call) Run(run func(ctx context.Context, id string, includeDeleted bool)) *ClassicRestoreRepo_Load_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *ClassicRestoreRepo_Load_Call) Return(classicRestore *entity.ClassicRestore, err error) *ClassicRestoreRepo_Load_Call {
	_c.Call.Return(classicRestore, err)
	return _c
}

func (_c *ClassicRestoreRepo_Load_Call) RunAndReturn(run func(ctx context.Context, id string, includeDeleted bool) (*entity.ClassicRestore, error)) *ClassicRestoreRepo_Load_Call {
	_c.Call.Return(run)
	return _c
}

// Save provides a mock function for the type ClassicRestoreRepo
func (_mock *ClassicRestoreRepo) Save(ctx context.Context, restore *entity.ClassicRestore) error {
	ret := _mock.Called(ctx, restore)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.ClassicRestore) error); ok {
		r0 = returnFunc(ctx, restore)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Save is a helper method to define mock.On call
//   - ctx context.Context
//   - restore *entity.ClassicRestore
func (_e *ClassicRestoreRepo_Expecter) Save(ctx interface{}, restore interface{}) *ClassicRestoreRepo_Save_Call {
	return &ClassicRestoreRepo_Save_Call{Call: _e.mock.On("Save", ctx, restore)}
}

func (_c *ClassicRestoreRepo_Save_Call) Run(run func(ctx context.Context, restore *entity.ClassicRestore)) *ClassicRestoreRepo_Save_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.ClassicRestore
		if args[1] != nil {
			arg1 = args[1].(*entity.ClassicRestore)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *ClassicRestoreRepo_Save_Call) RunAndReturn(run func(ctx context.Context, restore *entity.ClassicRestore) error) *ClassicRestoreRepo_Save_Call {
	_c.Call.Return(run)
	return _c
}

// SetStatus provides a mock function for the type ClassicRestoreRepo
func (_mock *ClassicRestoreRepo) SetStatus(ctx context.Context, restoreID string, status string) error {
	ret := _mock.Called(ctx, restoreID, status)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, restoreID, status)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - restoreID string
//   - status string
func (_e *ClassicRestoreRepo_Expecter) SetStatus(ctx interface{}, restoreID interface{}, status interface{}) *ClassicRestoreRepo_SetStatus_Call {
	return &ClassicRestoreRepo_SetStatus_Call{Call: _e.mock.On("SetStatus", ctx, restoreID, status)}
}

func (_c *ClassicRestoreRepo_SetStatus_Call) Run(run func(ctx context.Context, restoreID string, status string)) *ClassicRestoreRepo_SetStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *ClassicRestoreRepo_SetStatus_Call) RunAndReturn(run func(ctx context.Context, restoreID string, status string) error) *ClassicRestoreRepo_SetStatus_Call {
	_c.Call.Return(run)
	return _c
}

// SetStatusWithFailure provides a mock function for the type ClassicRestoreRepo
func (_mock *ClassicRestoreRepo) SetStatusWithFailure(ctx context.Context, restoreID string, status string, failure *entity.RestoreFailure) error {
	ret := _mock.Called(ctx, restoreID, status, failure)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *entity.RestoreFailure) error); ok {
		r0 = returnFunc(ctx, restoreID, status, failure)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetStatusWithFailure is a helper method to define mock.On call
//   - ctx context.Context
//   - restoreID string
//   - status string
//   - failure *entity.RestoreFailure
func (_e *ClassicRestoreRepo_Expecter) SetStatusWithFailure(ctx interface{}, restoreID interface{}, status interface{}, failure interface{}) *ClassicRestoreRepo_SetStatusWithFailure_Call {
	return &ClassicRestoreRepo_SetStatusWithFailure_Call{Call: _e.mock.On("SetStatusWithFailure", ctx, restoreID, status, failure)}
}

func (_c *ClassicRestoreRepo_SetStatusWithFailure_Call) Run(run func(ctx context.Context, restoreID string, status string, failure *entity.RestoreFailure)) *ClassicRestoreRepo_SetStatusWithFailure_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 *entity.RestoreFailure
		if args[3] != nil {
			arg3 = args[3].(*entity.RestoreFailure)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *ClassicRestoreRepo_SetStatusWithFailure_Call) RunAndReturn(run func(ctx context.Context, restoreID string, status string, failure *entity.RestoreFailure) error) *ClassicRestoreRepo_SetStatusWithFailure_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type TiDBClusterRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *TiDBClusterRepo) EXPECT() *TiDBClusterRepo_Expecter {
	return &TiDBClusterRepo_Expecter{mock: &_m.Mock}
}

// Delete provides a mock function for the type TiDBClusterRepo
func (_mock *TiDBClusterRepo) Delete(ctx context.Context, id string) error {
	ret := _mock.Called(ctx, id)

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

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

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *TiDBClusterRepo_Expecter) Delete(ctx interface{}, id interface{}) *TiDBClusterRepo_Delete_Call {
	return &TiDBClusterRepo_Delete_Call{Call: _e.mock.On("Delete", ctx, id)}
}

func (_c *TiDBClusterRepo_Delete_Call) Run(run func(ctx context.Context, id string)) *TiDBClusterRepo_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *TiDBClusterRepo_Delete_Call) RunAndReturn(run func(ctx context.Context, id string) error) *TiDBClusterRepo_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// List provides a mock function for the type TiDBClusterRepo
func (_mock *TiDBClusterRepo) List(ctx context.Context, filter *repo.TiDBClusterListFilter) ([]*entity.TiDBCluster, error) {
	ret := _mock.Called(ctx, filter)

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

	var r0 []*entity.TiDBCluster
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *repo.TiDBClusterListFilter) ([]*entity.TiDBCluster, error)); ok {
		return returnFunc(ctx, filter)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *repo.TiDBClusterListFilter) []*entity.TiDBCluster); ok {
		r0 = returnFunc(ctx, filter)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.TiDBCluster)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *repo.TiDBClusterListFilter) error); ok {
		r1 = returnFunc(ctx, filter)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// List is a helper method to define mock.On call
//   - ctx context.Context
//   - filter *repo.TiDBClusterListFilter
func (_e *TiDBClusterRepo_Expecter) List(ctx interface{}, filter interface{}) *TiDBClusterRepo_List_Call {
	return &TiDBClusterRepo_List_Call{Call: _e.mock.On("List", ctx, filter)}
}

func (_c *TiDBClusterRepo_List_Call) Run(run func(ctx context.Context, filter *repo.TiDBClusterListFilter)) *TiDBClusterRepo_List_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *repo.TiDBClusterListFilter
		if args[1] != nil {
			arg1 = args[1].(*repo.TiDBClusterListFilter)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *TiDBClusterRepo_List_Call) Return(vs []*entity.TiDBCluster, err error) *TiDBClusterRepo_List_Call {
	_c.Call.Return(vs, err)
	return _c
}

func (_c *TiDBClusterRepo_List_Call) RunAndReturn(run func(ctx context.Context, filter *repo.TiDBClusterListFilter) ([]*entity.TiDBCluster, error)) *TiDBClusterRepo_List_Call {
	_c.Call.Return(run)
	return _c
}

// Load provides a mock function for the type TiDBClusterRepo
func (_mock *TiDBClusterRepo) Load(ctx context.Context, id string, deleted bool) (*entity.TiDBCluster, error) {
	ret := _mock.Called(ctx, id, deleted)

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

	var r0 *entity.TiDBCluster
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) (*entity.TiDBCluster, error)); ok {
		return returnFunc(ctx, id, deleted)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) *entity.TiDBCluster); ok {
		r0 = returnFunc(ctx, id, deleted)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.TiDBCluster)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
		r1 = returnFunc(ctx, id, deleted)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Load is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - deleted bool
func (_e *TiDBClusterRepo_Expecter) Load(ctx interface{}, id interface{}, deleted interface{}) *TiDBClusterRepo_Load_Call {
	return &TiDBClusterRepo_Load_Call{Call: _e.mock.On("Load", ctx, id, deleted)}
}

func (_c *TiDBClusterRepo_Load_Call) Run(run func(ctx context.Context, id string, deleted bool)) *TiDBClusterRepo_Load_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *TiDBClusterRepo_Load_Call) Return(v *entity.TiDBCluster, err error) *TiDBClusterRepo_Load_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *TiDBClusterRepo_Load_Call) RunAndReturn(run func(ctx context.Context, id string, deleted bool) (*entity.TiDBCluster, error)) *TiDBClusterRepo_Load_Call {
	_c.Call.Return(run)
	return _c
}

// Save provides a mock function for the type TiDBClusterRepo
func (_mock *TiDBClusterRepo) Save(ctx context.Context, cluster *entity.TiDBCluster) error {
	ret := _mock.Called(ctx, cluster)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.TiDBCluster) error); ok {
		r0 = returnFunc(ctx, cluster)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Save is a helper method to define mock.On call
//   - ctx context.Context
//   - cluster *entity.TiDBCluster
func (_e *TiDBClusterRepo_Expecter) Save(ctx interface{}, cluster interface{}) *TiDBClusterRepo_Save_Call {
	return &TiDBClusterRepo_Save_Call{Call: _e.mock.On("Save", ctx, cluster)}
}

func (_c *TiDBClusterRepo_Save_Call) Run(run func(ctx context.Context, cluster *entity.TiDBCluster)) *TiDBClusterRepo_Save_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.TiDBCluster
		if args[1] != nil {
			arg1 = args[1].(*entity.TiDBCluster)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *TiDBClusterRepo_Save_Call) RunAndReturn(run func(ctx context.Context, cluster *entity.TiDBCluster) error) *TiDBClusterRepo_Save_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type DMClusterRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *DMClusterRepo) EXPECT() *DMClusterRepo_Expecter {
	return &DMClusterRepo_Expecter{mock: &_m.Mock}
}

// Delete provides a mock function for the type DMClusterRepo
func (_mock *DMClusterRepo) Delete(ctx context.Context, id string) error {
	ret := _mock.Called(ctx, id)

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

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

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *DMClusterRepo_Expecter) Delete(ctx interface{}, id interface{}) *DMClusterRepo_Delete_Call {
	return &DMClusterRepo_Delete_Call{Call: _e.mock.On("Delete", ctx, id)}
}

func (_c *DMClusterRepo_Delete_Call) Run(run func(ctx context.Context, id string)) *DMClusterRepo_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *DMClusterRepo_Delete_Call) RunAndReturn(run func(ctx context.Context, id string) error) *DMClusterRepo_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// GetBackend provides a mock function for the type DMClusterRepo
func (_mock *DMClusterRepo) GetBackend(ctx context.Context, id string, deleted bool) (string, error) {
	ret := _mock.Called(ctx, id, deleted)

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

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) (string, error)); ok {
		return returnFunc(ctx, id, deleted)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) string); ok {
		r0 = returnFunc(ctx, id, deleted)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
		r1 = returnFunc(ctx, id, deleted)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetBackend is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - deleted bool
func (_e *DMClusterRepo_Expecter) GetBackend(ctx interface{}, id interface{}, deleted interface{}) *DMClusterRepo_GetBackend_Call {
	return &DMClusterRepo_GetBackend_Call{Call: _e.mock.On("GetBackend", ctx, id, deleted)}
}

func (_c *DMClusterRepo_GetBackend_Call) Run(run func(ctx context.Context, id string, deleted bool)) *DMClusterRepo_GetBackend_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *DMClusterRepo_GetBackend_Call) Return(s string, err error) *DMClusterRepo_GetBackend_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *DMClusterRepo_GetBackend_Call) RunAndReturn(run func(ctx context.Context, id string, deleted bool) (string, error)) *DMClusterRepo_GetBackend_Call {
	_c.Call.Return(run)
	return _c
}

// List provides a mock function for the type DMClusterRepo
func (_mock *DMClusterRepo) List(ctx context.Context, filter *repo.DMClusterListFilter) ([]*entity.DMCluster, error) {
	ret := _mock.Called(ctx, filter)

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

	var r0 []*entity.DMCluster
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *repo.DMClusterListFilter) ([]*entity.DMCluster, error)); ok {
		return returnFunc(ctx, filter)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *repo.DMClusterListFilter) []*entity.DMCluster); ok {
		r0 = returnFunc(ctx, filter)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.DMCluster)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *repo.DMClusterListFilter) error); ok {
		r1 = returnFunc(ctx, filter)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// List is a helper method to define mock.On call
//   - ctx context.Context
//   - filter *repo.DMClusterListFilter
func (_e *DMClusterRepo_Expecter) List(ctx interface{}, filter interface{}) *DMClusterRepo_List_Call {
	return &DMClusterRepo_List_Call{Call: _e.mock.On("List", ctx, filter)}
}

func (_c *DMClusterRepo_List_Call) Run(run func(ctx context.Context, filter *repo.DMClusterListFilter)) *DMClusterRepo_List_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *repo.DMClusterListFilter
		if args[1] != nil {
			arg1 = args[1].(*repo.DMClusterListFilter)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *DMClusterRepo_List_Call) Return(vs []*entity.DMCluster, err error) *DMClusterRepo_List_Call {
	_c.Call.Return(vs, err)
	return _c
}

func (_c *DMClusterRepo_List_Call) RunAndReturn(run func(ctx context.Context, filter *repo.DMClusterListFilter) ([]*entity.DMCluster, error)) *DMClusterRepo_List_Call {
	_c.Call.Return(run)
	return _c
}

// Load provides a mock function for the type DMClusterRepo
func (_mock *DMClusterRepo) Load(ctx context.Context, id string, deleted bool) (*entity.DMCluster, error) {
	ret := _mock.Called(ctx, id, deleted)

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

	var r0 *entity.DMCluster
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) (*entity.DMCluster, error)); ok {
		return returnFunc(ctx, id, deleted)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) *entity.DMCluster); ok {
		r0 = returnFunc(ctx, id, deleted)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.DMCluster)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
		r1 = returnFunc(ctx, id, deleted)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Load is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - deleted bool
func (_e *DMClusterRepo_Expecter) Load(ctx interface{}, id interface{}, deleted interface{}) *DMClusterRepo_Load_Call {
	return &DMClusterRepo_Load_Call{Call: _e.mock.On("Load", ctx, id, deleted)}
}

func (_c *DMClusterRepo_Load_Call) Run(run func(ctx context.Context, id string, deleted bool)) *DMClusterRepo_Load_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *DMClusterRepo_Load_Call) Return(v *entity.DMCluster, err error) *DMClusterRepo_Load_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *DMClusterRepo_Load_Call) RunAndReturn(run func(ctx context.Context, id string, deleted bool) (*entity.DMCluster, error)) *DMClusterRepo_Load_Call {
	_c.Call.Return(run)
	return _c
}

// Save provides a mock function for the type DMClusterRepo
func (_mock *DMClusterRepo) Save(ctx context.Context, cluster *entity.DMCluster) error {
	ret := _mock.Called(ctx, cluster)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.DMCluster) error); ok {
		r0 = returnFunc(ctx, cluster)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Save is a helper method to define mock.On call
//   - ctx context.Context
//   - cluster *entity.DMCluster
func (_e *DMClusterRepo_Expecter) Save(ctx interface{}, cluster interface{}) *DMClusterRepo_Save_Call {
	return &DMClusterRepo_Save_Call{Call: _e.mock.On("Save", ctx, cluster)}
}

func (_c *DMClusterRepo_Save_Call) Run(run func(ctx context.Context, cluster *entity.DMCluster)) *DMClusterRepo_Save_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.DMCluster
		if args[1] != nil {
			arg1 = args[1].(*entity.DMCluster)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *DMClusterRepo_Save_Call) RunAndReturn(run func(ctx context.Context, cluster *entity.DMCluster) error) *DMClusterRepo_Save_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type ExportRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *ExportRepo) EXPECT() *ExportRepo_Expecter {
	return &ExportRepo_Expecter{mock: &_m.Mock}
}

// Create provides a mock function for the type ExportRepo
func (_mock *ExportRepo) Create(ctx context.Context, export *entity.Export) error {
	ret := _mock.Called(ctx, export)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.Export) error); ok {
		r0 = returnFunc(ctx, export)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - export *entity.Export
func (_e *ExportRepo_Expecter) Create(ctx interface{}, export interface{}) *ExportRepo_Create_Call {
	return &ExportRepo_Create_Call{Call: _e.mock.On("Create", ctx, export)}
}

func (_c *ExportRepo_Create_Call) Run(run func(ctx context.Context, export *entity.Export)) *ExportRepo_Create_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.Export
		if args[1] != nil {
			arg1 = args[1].(*entity.Export)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *ExportRepo_Create_Call) RunAndReturn(run func(ctx context.Context, export *entity.Export) error) *ExportRepo_Create_Call {
	_c.Call.Return(run)
	return _c
}

// List provides a mock function for the type ExportRepo
func (_mock *ExportRepo) List(ctx context.Context, filter *repo.ExportListFilter) ([]*entity.Export, error) {
	ret := _mock.Called(ctx, filter)

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

	var r0 []*entity.Export
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *repo.ExportListFilter) ([]*entity.Export, error)); ok {
		return returnFunc(ctx, filter)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *repo.ExportListFilter) []*entity.Export); ok {
		r0 = returnFunc(ctx, filter)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.Export)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *repo.ExportListFilter) error); ok {
		r1 = returnFunc(ctx, filter)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// List is a helper method to define mock.On call
//   - ctx context.Context
//   - filter *repo.ExportListFilter
func (_e *ExportRepo_Expecter) List(ctx interface{}, filter interface{}) *ExportRepo_List_Call {
	return &ExportRepo_List_Call{Call: _e.mock.On("List", ctx, filter)}
}

func (_c *ExportRepo_List_Call) Run(run func(ctx context.Context, filter *repo.ExportListFilter)) *ExportRepo_List_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *repo.ExportListFilter
		if args[1] != nil {
			arg1 = args[1].(*repo.ExportListFilter)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ExportRepo_List_Call) Return(vs []*entity.Export, err error) *ExportRepo_List_Call {
	_c.Call.Return(vs, err)
	return _c
}

func (_c *ExportRepo_List_Call) RunAndReturn(run func(ctx context.Context, filter *repo.ExportListFilter) ([]*entity.Export, error)) *ExportRepo_List_Call {
	_c.Call.Return(run)
	return _c
}

// Load provides a mock function for the type ExportRepo
func (_mock *ExportRepo) Load(ctx context.Context, exportID string, includeDeleted bool) (*entity.Export, error) {
	ret := _mock.Called(ctx, exportID, includeDeleted)

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

	var r0 *entity.Export
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) (*entity.Export, error)); ok {
		return returnFunc(ctx, exportID, includeDeleted)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) *entity.Export); ok {
		r0 = returnFunc(ctx, exportID, includeDeleted)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.Export)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
		r1 = returnFunc(ctx, exportID, includeDeleted)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Load is a helper method to define mock.On call
//   - ctx context.Context
//   - exportID string
//   - includeDeleted bool
func (_e *ExportRepo_Expecter) Load(ctx interface{}, exportID interface{}, includeDeleted interface{}) *ExportRepo_Load_Call {
	return &ExportRepo_Load_Call{Call: _e.mock.On("Load", ctx, exportID, includeDeleted)}
}

func (_c *ExportRepo_Load_Call) Run(run func(ctx context.Context, exportID string, includeDeleted bool)) *ExportRepo_Load_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *ExportRepo_Load_Call) Return(v *entity.Export, err error) *ExportRepo_Load_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *ExportRepo_Load_Call) RunAndReturn(run func(ctx context.Context, exportID string, includeDeleted bool) (*entity.Export, error)) *ExportRepo_Load_Call {
	_c.Call.Return(run)
	return _c
}

// Save provides a mock function for the type ExportRepo
func (_mock *ExportRepo) Save(ctx context.Context, export *entity.Export) error {
	ret := _mock.Called(ctx, export)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.Export) error); ok {
		r0 = returnFunc(ctx, export)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Save is a helper method to define mock.On call
//   - ctx context.Context
//   - export *entity.Export
func (_e *ExportRepo_Expecter) Save(ctx interface{}, export interface{}) *ExportRepo_Save_Call {
	return &ExportRepo_Save_Call{Call: _e.mock.On("Save", ctx, export)}
}

func (_c *ExportRepo_Save_Call) Run(run func(ctx context.Context, export *entity.Export)) *ExportRepo_Save_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.Export
		if args[1] != nil {
			arg1 = args[1].(*entity.Export)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *ExportRepo_Save_Call) RunAndReturn(run func(ctx context.Context, export *entity.Export) error) *ExportRepo_Save_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type LockRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *LockRepo) EXPECT() *LockRepo_Expecter {
	return &LockRepo_Expecter{mock: &_m.Mock}
}

// IsFree provides a mock function for the type LockRepo
func (_mock *LockRepo) IsFree(ctx context.Context, lock *entity.Lock) (bool, error) {
	ret := _mock.Called(ctx, lock)

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

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.Lock) (bool, error)); ok {
		return returnFunc(ctx, lock)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.Lock) bool); ok {
		r0 = returnFunc(ctx, lock)
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *entity.Lock) error); ok {
		r1 = returnFunc(ctx, lock)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// IsFree is a helper method to define mock.On call
//   - ctx context.Context
//   - lock *entity.Lock
func (_e *LockRepo_Expecter) IsFree(ctx interface{}, lock interface{}) *LockRepo_IsFree_Call {
	return &LockRepo_IsFree_Call{Call: _e.mock.On("IsFree", ctx, lock)}
}

func (_c *LockRepo_IsFree_Call) Run(run func(ctx context.Context, lock *entity.Lock)) *LockRepo_IsFree_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.Lock
		if args[1] != nil {
			arg1 = args[1].(*entity.Lock)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *LockRepo_IsFree_Call) Return(b bool, err error) *LockRepo_IsFree_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *LockRepo_IsFree_Call) RunAndReturn(run func(ctx context.Context, lock *entity.Lock) (bool, error)) *LockRepo_IsFree_Call {
	_c.Call.Return(run)
	return _c
}

// IsUsed provides a mock function for the type LockRepo
func (_mock *LockRepo) IsUsed(ctx context.Context, lock *entity.Lock) (bool, error) {
	ret := _mock.Called(ctx, lock)

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

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.Lock) (bool, error)); ok {
		return returnFunc(ctx, lock)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.Lock) bool); ok {
		r0 = returnFunc(ctx, lock)
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *entity.Lock) error); ok {
		r1 = returnFunc(ctx, lock)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// IsUsed is a helper method to define mock.On call
//   - ctx context.Context
//   - lock *entity.Lock
func (_e *LockRepo_Expecter) IsUsed(ctx interface{}, lock interface{}) *LockRepo_IsUsed_Call {
	return &LockRepo_IsUsed_Call{Call: _e.mock.On("IsUsed", ctx, lock)}
}

func (_c *LockRepo_IsUsed_Call) Run(run func(ctx context.Context, lock *entity.Lock)) *LockRepo_IsUsed_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.Lock
		if args[1] != nil {
			arg1 = args[1].(*entity.Lock)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *LockRepo_IsUsed_Call) Return(b bool, err error) *LockRepo_IsUsed_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *LockRepo_IsUsed_Call) RunAndReturn(run func(ctx context.Context, lock *entity.Lock) (bool, error)) *LockRepo_IsUsed_Call {
	_c.Call.Return(run)
	return _c
}

// Lock provides a mock function for the type LockRepo
func (_mock *LockRepo) Lock(ctx context.Context, lock *entity.Lock) (func() error, error) {
	ret := _mock.Called(ctx, lock)

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

	var r0 func() error
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.Lock) (func() error, error)); ok {
		return returnFunc(ctx, lock)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.Lock) func() error); ok {
		r0 = returnFunc(ctx, lock)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(func() error)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *entity.Lock) error); ok {
		r1 = returnFunc(ctx, lock)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Lock is a helper method to define mock.On call
//   - ctx context.Context
//   - lock *entity.Lock
func (_e *LockRepo_Expecter) Lock(ctx interface{}, lock interface{}) *LockRepo_Lock_Call {
	return &LockRepo_Lock_Call{Call: _e.mock.On("Lock", ctx, lock)}
}

func (_c *LockRepo_Lock_Call) Run(run func(ctx context.Context, lock *entity.Lock)) *LockRepo_Lock_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.Lock
		if args[1] != nil {
			arg1 = args[1].(*entity.Lock)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *LockRepo_Lock_Call) Return(fn func() error, err error) *LockRepo_Lock_Call {
	_c.Call.Return(fn, err)
	return _c
}

func (_c *LockRepo_Lock_Call) RunAndReturn(run func(ctx context.Context, lock *entity.Lock) (func() error, error)) *LockRepo_Lock_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type LightweightRestoreRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *LightweightRestoreRepo) EXPECT() *LightweightRestoreRepo_Expecter {
	return &LightweightRestoreRepo_Expecter{mock: &_m.Mock}
}

// AddExecutedAction provides a mock function for the type LightweightRestoreRepo
func (_mock *LightweightRestoreRepo) AddExecutedAction(ctx context.Context, restoreID string, action string) (bool, error) {
	ret := _mock.Called(ctx, restoreID, action)

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

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (bool, error)); ok {
		return returnFunc(ctx, restoreID, action)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) bool); ok {
		r0 = returnFunc(ctx, restoreID, action)
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, restoreID, action)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddExecutedAction is a helper method to define mock.On call
//   - ctx context.Context
//   - restoreID string
//   - action string
func (_e *LightweightRestoreRepo_Expecter) AddExecutedAction(ctx interface{}, restoreID interface{}, action interface{}) *LightweightRestoreRepo_AddExecutedAction_Call {
	return &LightweightRestoreRepo_AddExecutedAction_Call{Call: _e.mock.On("AddExecutedAction", ctx, restoreID, action)}
}

func (_c *LightweightRestoreRepo_AddExecutedAction_Call) Run(run func(ctx context.Context, restoreID string, action string)) *LightweightRestoreRepo_AddExecutedAction_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *LightweightRestoreRepo_AddExecutedAction_Call) Return(added bool, err error) *LightweightRestoreRepo_AddExecutedAction_Call {
	_c.Call.Return(added, err)
	return _c
}

func (_c *LightweightRestoreRepo_AddExecutedAction_Call) RunAndReturn(run func(ctx context.Context, restoreID string, action string) (bool, error)) *LightweightRestoreRepo_AddExecutedAction_Call {
	_c.Call.Return(run)
	return _c
}

// Create provides a mock function for the type LightweightRestoreRepo
func (_mock *LightweightRestoreRepo) Create(ctx context.Context, restore *entity.LightweightRestore) error {
	ret := _mock.Called(ctx, restore)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.LightweightRestore) error); ok {
		r0 = returnFunc(ctx, restore)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - restore *entity.LightweightRestore
func (_e *LightweightRestoreRepo_Expecter) Create(ctx interface{}, restore interface{}) *LightweightRestoreRepo_Create_Call {
	return &LightweightRestoreRepo_Create_Call{Call: _e.mock.On("Create", ctx, restore)}
}

func (_c *LightweightRestoreRepo_Create_Call) Run(run func(ctx context.Context, restore *entity.LightweightRestore)) *LightweightRestoreRepo_Create_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.LightweightRestore
		if args[1] != nil {
			arg1 = args[1].(*entity.LightweightRestore)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *LightweightRestoreRepo_Create_Call) RunAndReturn(run func(ctx context.Context, restore *entity.LightweightRestore) error) *LightweightRestoreRepo_Create_Call {
	_c.Call.Return(run)
	return _c
}

// Delete provides a mock function for the type LightweightRestoreRepo
func (_mock *LightweightRestoreRepo) Delete(ctx context.Context, id string) error {
	ret := _mock.Called(ctx, id)

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

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

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *LightweightRestoreRepo_Expecter) Delete(ctx interface{}, id interface{}) *LightweightRestoreRepo_Delete_Call {
	return &LightweightRestoreRepo_Delete_Call{Call: _e.mock.On("Delete", ctx, id)}
}

func (_c *LightweightRestoreRepo_Delete_Call) Run(run func(ctx context.Context, id string)) *LightweightRestoreRepo_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *LightweightRestoreRepo_Delete_Call) RunAndReturn(run func(ctx context.Context, id string) error) *LightweightRestoreRepo_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// List provides a mock function for the type LightweightRestoreRepo
func (_mock *LightweightRestoreRepo) List(ctx context.Context, filter *repo.LightweightRestoreFilter) ([]*entity.LightweightRestore, error) {
	ret := _mock.Called(ctx, filter)

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

	var r0 []*entity.LightweightRestore
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *repo.LightweightRestoreFilter) ([]*entity.LightweightRestore, error)); ok {
		return returnFunc(ctx, filter)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *repo.LightweightRestoreFilter) []*entity.LightweightRestore); ok {
		r0 = returnFunc(ctx, filter)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.LightweightRestore)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *repo.LightweightRestoreFilter) error); ok {
		r1 = returnFunc(ctx, filter)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// List is a helper method to define mock.On call
//   - ctx context.Context
//   - filter *repo.LightweightRestoreFilter
func (_e *LightweightRestoreRepo_Expecter) List(ctx interface{}, filter interface{}) *LightweightRestoreRepo_List_Call {
	return &LightweightRestoreRepo_List_Call{Call: _e.mock.On("List", ctx, filter)}
}

func (_c *LightweightRestoreRepo_List_Call) Run(run func(ctx context.Context, filter *repo.LightweightRestoreFilter)) *LightweightRestoreRepo_List_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *repo.LightweightRestoreFilter
		if args[1] != nil {
			arg1 = args[1].(*repo.LightweightRestoreFilter)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *LightweightRestoreRepo_List_Call) Return(lightweightRestores []*entity.LightweightRestore, err error) *LightweightRestoreRepo_List_Call {
	_c.Call.Return(lightweightRestores, err)
	return _c
}

func (_c *LightweightRestoreRepo_List_Call) RunAndReturn(run func(ctx context.Context, filter *repo.LightweightRestoreFilter) ([]*entity.LightweightRestore, error)) *LightweightRestoreRepo_List_Call {
	_c.Call.Return(run)
	return _c
}

// Load provides a mock function for the type LightweightRestoreRepo
func (_mock *LightweightRestoreRepo) Load(ctx context.Context, id string, includeDeleted bool) (*entity.LightweightRestore, error) {
	ret := _mock.Called(ctx, id, includeDeleted)

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

	var r0 *entity.LightweightRestore
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) (*entity.LightweightRestore, error)); ok {
		return returnFunc(ctx, id, includeDeleted)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) *entity.LightweightRestore); ok {
		r0 = returnFunc(ctx, id, includeDeleted)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.LightweightRestore)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
		r1 = returnFunc(ctx, id, includeDeleted)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Load is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - includeDeleted bool
func (_e *LightweightRestoreRepo_Expecter) Load(ctx interface{}, id interface{}, includeDeleted interface{}) *LightweightRestoreRepo_Load_Call {
	return &LightweightRestoreRepo_Load_Call{Call: _e.mock.On("Load", ctx, id, includeDeleted)}
}

func (_c *LightweightRestoreRepo_Load_Call) Run(run func(ctx context.Context, id string, includeDeleted bool)) *LightweightRestoreRepo_Load_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *LightweightRestoreRepo_Load_Call) Return(lightweightRestore *entity.LightweightRestore, err error) *LightweightRestoreRepo_Load_Call {
	_c.Call.Return(lightweightRestore, err)
	return _c
}

func (_c *LightweightRestoreRepo_Load_Call) RunAndReturn(run func(ctx context.Context, id string, includeDeleted bool) (*entity.LightweightRestore, error)) *LightweightRestoreRepo_Load_Call {
	_c.Call.Return(run)
	return _c
}

// Save provides a mock function for the type LightweightRestoreRepo
func (_mock *LightweightRestoreRepo) Save(ctx context.Context, restore *entity.LightweightRestore) error {
	ret := _mock.Called(ctx, restore)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.LightweightRestore) error); ok {
		r0 = returnFunc(ctx, restore)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Save is a helper method to define mock.On call
//   - ctx context.Context
//   - restore *entity.LightweightRestore
func (_e *LightweightRestoreRepo_Expecter) Save(ctx interface{}, restore interface{}) *LightweightRestoreRepo_Save_Call {
	return &LightweightRestoreRepo_Save_Call{Call: _e.mock.On("Save", ctx, restore)}
}

func (_c *LightweightRestoreRepo_Save_Call) Run(run func(ctx context.Context, restore *entity.LightweightRestore)) *LightweightRestoreRepo_Save_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.LightweightRestore
		if args[1] != nil {
			arg1 = args[1].(*entity.LightweightRestore)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *LightweightRestoreRepo_Save_Call) RunAndReturn(run func(ctx context.Context, restore *entity.LightweightRestore) error) *LightweightRestoreRepo_Save_Call {
	_c.Call.Return(run)
	return _c
}

// SetStatus provides a mock function for the type LightweightRestoreRepo
func (_mock *LightweightRestoreRepo) SetStatus(ctx context.Context, restoreID string, status string) error {
	ret := _mock.Called(ctx, restoreID, status)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, restoreID, status)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - restoreID string
//   - status string
func (_e *LightweightRestoreRepo_Expecter) SetStatus(ctx interface{}, restoreID interface{}, status interface{}) *LightweightRestoreRepo_SetStatus_Call {
	return &LightweightRestoreRepo_SetStatus_Call{Call: _e.mock.On("SetStatus", ctx, restoreID, status)}
}

func (_c *LightweightRestoreRepo_SetStatus_Call) Run(run func(ctx context.Context, restoreID string, status string)) *LightweightRestoreRepo_SetStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *LightweightRestoreRepo_SetStatus_Call) RunAndReturn(run func(ctx context.Context, restoreID string, status string) error) *LightweightRestoreRepo_SetStatus_Call {
	_c.Call.Return(run)
	return _c
}

// SetStatusWithFailure provides a mock function for the type LightweightRestoreRepo
func (_mock *LightweightRestoreRepo) SetStatusWithFailure(ctx context.Context, restoreID string, status string, failure *entity.RestoreFailure) error {
	ret := _mock.Called(ctx, restoreID, status, failure)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *entity.RestoreFailure) error); ok {
		r0 = returnFunc(ctx, restoreID, status, failure)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetStatusWithFailure is a helper method to define mock.On call
//   - ctx context.Context
//   - restoreID string
//   - status string
//   - failure *entity.RestoreFailure
func (_e *LightweightRestoreRepo_Expecter) SetStatusWithFailure(ctx interface{}, restoreID interface{}, status interface{}, failure interface{}) *LightweightRestoreRepo_SetStatusWithFailure_Call {
	return &LightweightRestoreRepo_SetStatusWithFailure_Call{Call: _e.mock.On("SetStatusWithFailure", ctx, restoreID, status, failure)}
}

func (_c *LightweightRestoreRepo_SetStatusWithFailure_Call) Run(run func(ctx context.Context, restoreID string, status string, failure *entity.RestoreFailure)) *LightweightRestoreRepo_SetStatusWithFailure_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 *entity.RestoreFailure
		if args[3] != nil {
			arg3 = args[3].(*entity.RestoreFailure)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *LightweightRestoreRepo_SetStatusWithFailure_Call) RunAndReturn(run func(ctx context.Context, restoreID string, status string, failure *entity.RestoreFailure) error) *LightweightRestoreRepo_SetStatusWithFailure_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type ManualBackupRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *ManualBackupRepo) EXPECT() *ManualBackupRepo_Expecter {
	return &ManualBackupRepo_Expecter{mock: &_m.Mock}
}

// AddExecutedAction provides a mock function for the type ManualBackupRepo
func (_mock *ManualBackupRepo) AddExecutedAction(ctx context.Context, clusterID string, backupID string, action string) (bool, error) {
	ret := _mock.Called(ctx, clusterID, backupID, action)

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

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (bool, error)); ok {
		return returnFunc(ctx, clusterID, backupID, action)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) bool); ok {
		r0 = returnFunc(ctx, clusterID, backupID, action)
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, clusterID, backupID, action)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddExecutedAction is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterID string
//   - backupID string
//   - action string
func (_e *ManualBackupRepo_Expecter) AddExecutedAction(ctx interface{}, clusterID interface{}, backupID interface{}, action interface{}) *ManualBackupRepo_AddExecutedAction_Call {
	return &ManualBackupRepo_AddExecutedAction_Call{Call: _e.mock.On("AddExecutedAction", ctx, clusterID, backupID, action)}
}

func (_c *ManualBackupRepo_AddExecutedAction_Call) Run(run func(ctx context.Context, clusterID string, backupID string, action string)) *ManualBackupRepo_AddExecutedAction_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *ManualBackupRepo_AddExecutedAction_Call) Return(added bool, err error) *ManualBackupRepo_AddExecutedAction_Call {
	_c.Call.Return(added, err)
	return _c
}

func (_c *ManualBackupRepo_AddExecutedAction_Call) RunAndReturn(run func(ctx context.Context, clusterID string, backupID string, action string) (bool, error)) *ManualBackupRepo_AddExecutedAction_Call {
	_c.Call.Return(run)
	return _c
}

// Create provides a mock function for the type ManualBackupRepo
func (_mock *ManualBackupRepo) Create(ctx context.Context, backup *entity.ManualBackup) error {
	ret := _mock.Called(ctx, backup)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.ManualBackup) error); ok {
		r0 = returnFunc(ctx, backup)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - backup *entity.ManualBackup
func (_e *ManualBackupRepo_Expecter) Create(ctx interface{}, backup interface{}) *ManualBackupRepo_Create_Call {
	return &ManualBackupRepo_Create_Call{Call: _e.mock.On("Create", ctx, backup)}
}

func (_c *ManualBackupRepo_Create_Call) Run(run func(ctx context.Context, backup *entity.ManualBackup)) *ManualBackupRepo_Create_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.ManualBackup
		if args[1] != nil {
			arg1 = args[1].(*entity.ManualBackup)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *ManualBackupRepo_Create_Call) RunAndReturn(run func(ctx context.Context, backup *entity.ManualBackup) error) *ManualBackupRepo_Create_Call {
	_c.Call.Return(run)
	return _c
}

// Delete provides a mock function for the type ManualBackupRepo
func (_mock *ManualBackupRepo) Delete(ctx context.Context, clusterID string, backupID string) error {
	ret := _mock.Called(ctx, clusterID, backupID)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, clusterID, backupID)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterID string
//   - backupID string
func (_e *ManualBackupRepo_Expecter) Delete(ctx interface{}, clusterID interface{}, backupID interface{}) *ManualBackupRepo_Delete_Call {
	return &ManualBackupRepo_Delete_Call{Call: _e.mock.On("Delete", ctx, clusterID, backupID)}
}

func (_c *ManualBackupRepo_Delete_Call) Run(run func(ctx context.Context, clusterID string, backupID string)) *ManualBackupRepo_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *ManualBackupRepo_Delete_Call) RunAndReturn(run func(ctx context.Context, clusterID string, backupID string) error) *ManualBackupRepo_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// ExistsUndeletedBySharedPool provides a mock function for the type ManualBackupRepo
func (_mock *ManualBackupRepo) ExistsUndeletedBySharedPool(ctx context.Context, sharedPoolID string) (bool, error) {
	ret := _mock.Called(ctx, sharedPoolID)

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

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (bool, error)); ok {
		return returnFunc(ctx, sharedPoolID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) bool); ok {
		r0 = returnFunc(ctx, sharedPoolID)
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ExistsUndeletedBySharedPool is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolID string
func (_e *ManualBackupRepo_Expecter) ExistsUndeletedBySharedPool(ctx interface{}, sharedPoolID interface{}) *ManualBackupRepo_ExistsUndeletedBySharedPool_Call {
	return &ManualBackupRepo_ExistsUndeletedBySharedPool_Call{Call: _e.mock.On("ExistsUndeletedBySharedPool", ctx, sharedPoolID)}
}

func (_c *ManualBackupRepo_ExistsUndeletedBySharedPool_Call) Run(run func(ctx context.Context, sharedPoolID string)) *ManualBackupRepo_ExistsUndeletedBySharedPool_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ManualBackupRepo_ExistsUndeletedBySharedPool_Call) Return(b bool, err error) *ManualBackupRepo_ExistsUndeletedBySharedPool_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *ManualBackupRepo_ExistsUndeletedBySharedPool_Call) RunAndReturn(run func(ctx context.Context, sharedPoolID string) (bool, error)) *ManualBackupRepo_ExistsUndeletedBySharedPool_Call {
	_c.Call.Return(run)
	return _c
}

// ListPendingLifecycleRuleRecycles provides a mock function for the type ManualBackupRepo
func (_mock *ManualBackupRepo) ListPendingLifecycleRuleRecycles(ctx context.Context, olderThan time.Duration) ([]*entity.ManualBackup, error) {
	ret := _mock.Called(ctx, olderThan)

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

	var r0 []*entity.ManualBackup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Duration) ([]*entity.ManualBackup, error)); ok {
		return returnFunc(ctx, olderThan)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Duration) []*entity.ManualBackup); ok {
		r0 = returnFunc(ctx, olderThan)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.ManualBackup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, time.Duration) error); ok {
		r1 = returnFunc(ctx, olderThan)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListPendingLifecycleRuleRecycles is a helper method to define mock.On call
//   - ctx context.Context
//   - olderThan time.Duration
func (_e *ManualBackupRepo_Expecter) ListPendingLifecycleRuleRecycles(ctx interface{}, olderThan interface{}) *ManualBackupRepo_ListPendingLifecycleRuleRecycles_Call {
	return &ManualBackupRepo_ListPendingLifecycleRuleRecycles_Call{Call: _e.mock.On("ListPendingLifecycleRuleRecycles", ctx, olderThan)}
}

func (_c *ManualBackupRepo_ListPendingLifecycleRuleRecycles_Call) Run(run func(ctx context.Context, olderThan time.Duration)) *ManualBackupRepo_ListPendingLifecycleRuleRecycles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 time.Duration
		if args[1] != nil {
			arg1 = args[1].(time.Duration)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ManualBackupRepo_ListPendingLifecycleRuleRecycles_Call) Return(manualBackups []*entity.ManualBackup, err error) *ManualBackupRepo_ListPendingLifecycleRuleRecycles_Call {
	_c.Call.Return(manualBackups, err)
	return _c
}

func (_c *ManualBackupRepo_ListPendingLifecycleRuleRecycles_Call) RunAndReturn(run func(ctx context.Context, olderThan time.Duration) ([]*entity.ManualBackup, error)) *ManualBackupRepo_ListPendingLifecycleRuleRecycles_Call {
	_c.Call.Return(run)
	return _c
}

// ListUndeletedSucceeded provides a mock function for the type ManualBackupRepo
func (_mock *ManualBackupRepo) ListUndeletedSucceeded(ctx context.Context) ([]*entity.ManualBackup, error) {
	ret := _mock.Called(ctx)

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

	var r0 []*entity.ManualBackup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.ManualBackup, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.ManualBackup); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.ManualBackup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListUndeletedSucceeded is a helper method to define mock.On call
//   - ctx context.Context
func (_e *ManualBackupRepo_Expecter) ListUndeletedSucceeded(ctx interface{}) *ManualBackupRepo_ListUndeletedSucceeded_Call {
	return &ManualBackupRepo_ListUndeletedSucceeded_Call{Call: _e.mock.On("ListUndeletedSucceeded", ctx)}
}

func (_c *ManualBackupRepo_ListUndeletedSucceeded_Call) Run(run func(ctx context.Context)) *ManualBackupRepo_ListUndeletedSucceeded_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *ManualBackupRepo_ListUndeletedSucceeded_Call) Return(manualBackups []*entity.ManualBackup, err error) *ManualBackupRepo_ListUndeletedSucceeded_Call {
	_c.Call.Return(manualBackups, err)
	return _c
}

func (_c *ManualBackupRepo_ListUndeletedSucceeded_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.ManualBackup, error)) *ManualBackupRepo_ListUndeletedSucceeded_Call {
	_c.Call.Return(run)
	return _c
}

// Load provides a mock function for the type ManualBackupRepo
func (_mock *ManualBackupRepo) Load(ctx context.Context, clusterID string, backupID string, includeDeleted bool) (*entity.ManualBackup, error) {
	ret := _mock.Called(ctx, clusterID, backupID, includeDeleted)

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

	var r0 *entity.ManualBackup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, bool) (*entity.ManualBackup, error)); ok {
		return returnFunc(ctx, clusterID, backupID, includeDeleted)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, bool) *entity.ManualBackup); ok {
		r0 = returnFunc(ctx, clusterID, backupID, includeDeleted)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.ManualBackup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, bool) error); ok {
		r1 = returnFunc(ctx, clusterID, backupID, includeDeleted)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Load is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterID string
//   - backupID string
//   - includeDeleted bool
func (_e *ManualBackupRepo_Expecter) Load(ctx interface{}, clusterID interface{}, backupID interface{}, includeDeleted interface{}) *ManualBackupRepo_Load_Call {
	return &ManualBackupRepo_Load_Call{Call: _e.mock.On("Load", ctx, clusterID, backupID, includeDeleted)}
}

func (_c *ManualBackupRepo_Load_Call) Run(run func(ctx context.Context, clusterID string, backupID string, includeDeleted bool)) *ManualBackupRepo_Load_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 bool
		if args[3] != nil {
			arg3 = args[3].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *ManualBackupRepo_Load_Call) Return(manualBackup *entity.ManualBackup, err error) *ManualBackupRepo_Load_Call {
	_c.Call.Return(manualBackup, err)
	return _c
}

func (_c *ManualBackupRepo_Load_Call) RunAndReturn(run func(ctx context.Context, clusterID string, backupID string, includeDeleted bool) (*entity.ManualBackup, error)) *ManualBackupRepo_Load_Call {
	_c.Call.Return(run)
	return _c
}

// Save provides a mock function for the type ManualBackupRepo
func (_mock *ManualBackupRepo) Save(ctx context.Context, backup *entity.ManualBackup) error {
	ret := _mock.Called(ctx, backup)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.ManualBackup) error); ok {
		r0 = returnFunc(ctx, backup)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Save is a helper method to define mock.On call
//   - ctx context.Context
//   - backup *entity.ManualBackup
func (_e *ManualBackupRepo_Expecter) Save(ctx interface{}, backup interface{}) *ManualBackupRepo_Save_Call {
	return &ManualBackupRepo_Save_Call{Call: _e.mock.On("Save", ctx, backup)}
}

func (_c *ManualBackupRepo_Save_Call) Run(run func(ctx context.Context, backup *entity.ManualBackup)) *ManualBackupRepo_Save_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.ManualBackup
		if args[1] != nil {
			arg1 = args[1].(*entity.ManualBackup)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *ManualBackupRepo_Save_Call) RunAndReturn(run func(ctx context.Context, backup *entity.ManualBackup) error) *ManualBackupRepo_Save_Call {
	_c.Call.Return(run)
	return _c
}

// SetStatus provides a mock function for the type ManualBackupRepo
func (_mock *ManualBackupRepo) SetStatus(ctx context.Context, clusterID string, backupID string, status string) error {
	ret := _mock.Called(ctx, clusterID, backupID, status)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, clusterID, backupID, status)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - clusterID string
//   - backupID string
//   - status string
func (_e *ManualBackupRepo_Expecter) SetStatus(ctx interface{}, clusterID interface{}, backupID interface{}, status interface{}) *ManualBackupRepo_SetStatus_Call {
	return &ManualBackupRepo_SetStatus_Call{Call: _e.mock.On("SetStatus", ctx, clusterID, backupID, status)}
}

func (_c *ManualBackupRepo_SetStatus_Call) Run(run func(ctx context.Context, clusterID string, backupID string, status string)) *ManualBackupRepo_SetStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *ManualBackupRepo_SetStatus_Call) RunAndReturn(run func(ctx context.Context, clusterID string, backupID string, status string) error) *ManualBackupRepo_SetStatus_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type ManualBackupRestoreRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *ManualBackupRestoreRepo) EXPECT() *ManualBackupRestoreRepo_Expecter {
	return &ManualBackupRestoreRepo_Expecter{mock: &_m.Mock}
}

// AddExecutedAction provides a mock function for the type ManualBackupRestoreRepo
func (_mock *ManualBackupRestoreRepo) AddExecutedAction(ctx context.Context, restoreID string, action string) (bool, error) {
	ret := _mock.Called(ctx, restoreID, action)

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

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (bool, error)); ok {
		return returnFunc(ctx, restoreID, action)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) bool); ok {
		r0 = returnFunc(ctx, restoreID, action)
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, restoreID, action)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddExecutedAction is a helper method to define mock.On call
//   - ctx context.Context
//   - restoreID string
//   - action string
func (_e *ManualBackupRestoreRepo_Expecter) AddExecutedAction(ctx interface{}, restoreID interface{}, action interface{}) *ManualBackupRestoreRepo_AddExecutedAction_Call {
	return &ManualBackupRestoreRepo_AddExecutedAction_Call{Call: _e.mock.On("AddExecutedAction", ctx, restoreID, action)}
}

func (_c *ManualBackupRestoreRepo_AddExecutedAction_Call) Run(run func(ctx context.Context, restoreID string, action string)) *ManualBackupRestoreRepo_AddExecutedAction_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *ManualBackupRestoreRepo_AddExecutedAction_Call) Return(added bool, err error) *ManualBackupRestoreRepo_AddExecutedAction_Call {
	_c.Call.Return(added, err)
	return _c
}

func (_c *ManualBackupRestoreRepo_AddExecutedAction_Call) RunAndReturn(run func(ctx context.Context, restoreID string, action string) (bool, error)) *ManualBackupRestoreRepo_AddExecutedAction_Call {
	_c.Call.Return(run)
	return _c
}

// Create provides a mock function for the type ManualBackupRestoreRepo
func (_mock *ManualBackupRestoreRepo) Create(ctx context.Context, restore *entity.ManualBackupRestore) error {
	ret := _mock.Called(ctx, restore)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.ManualBackupRestore) error); ok {
		r0 = returnFunc(ctx, restore)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - restore *entity.ManualBackupRestore
func (_e *ManualBackupRestoreRepo_Expecter) Create(ctx interface{}, restore interface{}) *ManualBackupRestoreRepo_Create_Call {
	return &ManualBackupRestoreRepo_Create_Call{Call: _e.mock.On("Create", ctx, restore)}
}

func (_c *ManualBackupRestoreRepo_Create_Call) Run(run func(ctx context.Context, restore *entity.ManualBackupRestore)) *ManualBackupRestoreRepo_Create_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.ManualBackupRestore
		if args[1] != nil {
			arg1 = args[1].(*entity.ManualBackupRestore)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *ManualBackupRestoreRepo_Create_Call) RunAndReturn(run func(ctx context.Context, restore *entity.ManualBackupRestore) error) *ManualBackupRestoreRepo_Create_Call {
	_c.Call.Return(run)
	return _c
}

// Delete provides a mock function for the type ManualBackupRestoreRepo
func (_mock *ManualBackupRestoreRepo) Delete(ctx context.Context, restoreID string) error {
	ret := _mock.Called(ctx, restoreID)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(ctx, restoreID)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - restoreID string
func (_e *ManualBackupRestoreRepo_Expecter) Delete(ctx interface{}, restoreID interface{}) *ManualBackupRestoreRepo_Delete_Call {
	return &ManualBackupRestoreRepo_Delete_Call{Call: _e.mock.On("Delete", ctx, restoreID)}
}

func (_c *ManualBackupRestoreRepo_Delete_Call) Run(run func(ctx context.Context, restoreID string)) *ManualBackupRestoreRepo_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *ManualBackupRestoreRepo_Delete_Call) RunAndReturn(run func(ctx context.Context, restoreID string) error) *ManualBackupRestoreRepo_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// List provides a mock function for the type ManualBackupRestoreRepo
func (_mock *ManualBackupRestoreRepo) List(ctx context.Context, filter *repo.ManualBackupRestoreFilter) ([]*entity.ManualBackupRestore, error) {
	ret := _mock.Called(ctx, filter)

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

	var r0 []*entity.ManualBackupRestore
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *repo.ManualBackupRestoreFilter) ([]*entity.ManualBackupRestore, error)); ok {
		return returnFunc(ctx, filter)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *repo.ManualBackupRestoreFilter) []*entity.ManualBackupRestore); ok {
		r0 = returnFunc(ctx, filter)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.ManualBackupRestore)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *repo.ManualBackupRestoreFilter) error); ok {
		r1 = returnFunc(ctx, filter)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// List is a helper method to define mock.On call
//   - ctx context.Context
//   - filter *repo.ManualBackupRestoreFilter
func (_e *ManualBackupRestoreRepo_Expecter) List(ctx interface{}, filter interface{}) *ManualBackupRestoreRepo_List_Call {
	return &ManualBackupRestoreRepo_List_Call{Call: _e.mock.On("List", ctx, filter)}
}

func (_c *ManualBackupRestoreRepo_List_Call) Run(run func(ctx context.Context, filter *repo.ManualBackupRestoreFilter)) *ManualBackupRestoreRepo_List_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *repo.ManualBackupRestoreFilter
		if args[1] != nil {
			arg1 = args[1].(*repo.ManualBackupRestoreFilter)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ManualBackupRestoreRepo_List_Call) Return(manualBackupRestores []*entity.ManualBackupRestore, err error) *ManualBackupRestoreRepo_List_Call {
	_c.Call.Return(manualBackupRestores, err)
	return _c
}

func (_c *ManualBackupRestoreRepo_List_Call) RunAndReturn(run func(ctx context.Context, filter *repo.ManualBackupRestoreFilter) ([]*entity.ManualBackupRestore, error)) *ManualBackupRestoreRepo_List_Call {
	_c.Call.Return(run)
	return _c
}

// Load provides a mock function for the type ManualBackupRestoreRepo
func (_mock *ManualBackupRestoreRepo) Load(ctx context.Context, restoreID string, includeDeleted bool) (*entity.ManualBackupRestore, error) {
	ret := _mock.Called(ctx, restoreID, includeDeleted)

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

	var r0 *entity.ManualBackupRestore
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) (*entity.ManualBackupRestore, error)); ok {
		return returnFunc(ctx, restoreID, includeDeleted)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) *entity.ManualBackupRestore); ok {
		r0 = returnFunc(ctx, restoreID, includeDeleted)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.ManualBackupRestore)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
		r1 = returnFunc(ctx, restoreID, includeDeleted)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Load is a helper method to define mock.On call
//   - ctx context.Context
//   - restoreID string
//   - includeDeleted bool
func (_e *ManualBackupRestoreRepo_Expecter) Load(ctx interface{}, restoreID interface{}, includeDeleted interface{}) *ManualBackupRestoreRepo_Load_Call {
	return &ManualBackupRestoreRepo_Load_Call{Call: _e.mock.On("Load", ctx, restoreID, includeDeleted)}
}

func (_c *ManualBackupRestoreRepo_Load_Call) Run(run func(ctx context.Context, restoreID string, includeDeleted bool)) *ManualBackupRestoreRepo_Load_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *ManualBackupRestoreRepo_Load_Call) Return(manualBackupRestore *entity.ManualBackupRestore, err error) *ManualBackupRestoreRepo_Load_Call {
	_c.Call.Return(manualBackupRestore, err)
	return _c
}

func (_c *ManualBackupRestoreRepo_Load_Call) RunAndReturn(run func(ctx context.Context, restoreID string, includeDeleted bool) (*entity.ManualBackupRestore, error)) *ManualBackupRestoreRepo_Load_Call {
	_c.Call.Return(run)
	return _c
}

// Save provides a mock function for the type ManualBackupRestoreRepo
func (_mock *ManualBackupRestoreRepo) Save(ctx context.Context, restore *entity.ManualBackupRestore) error {
	ret := _mock.Called(ctx, restore)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.ManualBackupRestore) error); ok {
		r0 = returnFunc(ctx, restore)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Save is a helper method to define mock.On call
//   - ctx context.Context
//   - restore *entity.ManualBackupRestore
func (_e *ManualBackupRestoreRepo_Expecter) Save(ctx interface{}, restore interface{}) *ManualBackupRestoreRepo_Save_Call {
	return &ManualBackupRestoreRepo_Save_Call{Call: _e.mock.On("Save", ctx, restore)}
}

func (_c *ManualBackupRestoreRepo_Save_Call) Run(run func(ctx context.Context, restore *entity.ManualBackupRestore)) *ManualBackupRestoreRepo_Save_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.ManualBackupRestore
		if args[1] != nil {
			arg1 = args[1].(*entity.ManualBackupRestore)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *ManualBackupRestoreRepo_Save_Call) RunAndReturn(run func(ctx context.Context, restore *entity.ManualBackupRestore) error) *ManualBackupRestoreRepo_Save_Call {
	_c.Call.Return(run)
	return _c
}

// SetStatus provides a mock function for the type ManualBackupRestoreRepo
func (_mock *ManualBackupRestoreRepo) SetStatus(ctx context.Context, restoreID string, status string) error {
	ret := _mock.Called(ctx, restoreID, status)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, restoreID, status)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - restoreID string
//   - status string
func (_e *ManualBackupRestoreRepo_Expecter) SetStatus(ctx interface{}, restoreID interface{}, status interface{}) *ManualBackupRestoreRepo_SetStatus_Call {
	return &ManualBackupRestoreRepo_SetStatus_Call{Call: _e.mock.On("SetStatus", ctx, restoreID, status)}
}

func (_c *ManualBackupRestoreRepo_SetStatus_Call) Run(run func(ctx context.Context, restoreID string, status string)) *ManualBackupRestoreRepo_SetStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *ManualBackupRestoreRepo_SetStatus_Call) RunAndReturn(run func(ctx context.Context, restoreID string, status string) error) *ManualBackupRestoreRepo_SetStatus_Call {
	_c.Call.Return(run)
	return _c
}

// SetStatusWithFailure provides a mock function for the type ManualBackupRestoreRepo
func (_mock *ManualBackupRestoreRepo) SetStatusWithFailure(ctx context.Context, restoreID string, status string, failure *entity.RestoreFailure) error {
	ret := _mock.Called(ctx, restoreID, status, failure)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *entity.RestoreFailure) error); ok {
		r0 = returnFunc(ctx, restoreID, status, failure)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetStatusWithFailure is a helper method to define mock.On call
//   - ctx context.Context
//   - restoreID string
//   - status string
//   - failure *entity.RestoreFailure
func (_e *ManualBackupRestoreRepo_Expecter) SetStatusWithFailure(ctx interface{}, restoreID interface{}, status interface{}, failure interface{}) *ManualBackupRestoreRepo_SetStatusWithFailure_Call {
	return &ManualBackupRestoreRepo_SetStatusWithFailure_Call{Call: _e.mock.On("SetStatusWithFailure", ctx, restoreID, status, failure)}
}

func (_c *ManualBackupRestoreRepo_SetStatusWithFailure_Call) Run(run func(ctx context.Context, restoreID string, status string, failure *entity.RestoreFailure)) *ManualBackupRestoreRepo_SetStatusWithFailure_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 *entity.RestoreFailure
		if args[3] != nil {
			arg3 = args[3].(*entity.RestoreFailure)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *ManualBackupRestoreRepo_SetStatusWithFailure_Call) RunAndReturn(run func(ctx context.Context, restoreID string, status string, failure *entity.RestoreFailure) error) *ManualBackupRestoreRepo_SetStatusWithFailure_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type NodeInstanceGroupRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *NodeInstanceGroupRepo) EXPECT() *NodeInstanceGroupRepo_Expecter {
	return &NodeInstanceGroupRepo_Expecter{mock: &_m.Mock}
}

// Delete provides a mock function for the type NodeInstanceGroupRepo
func (_mock *NodeInstanceGroupRepo) Delete(ctx context.Context, nodeSpec string, primaryInstance string) error {
	ret := _mock.Called(ctx, nodeSpec, primaryInstance)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, nodeSpec, primaryInstance)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - nodeSpec string
//   - primaryInstance string
func (_e *NodeInstanceGroupRepo_Expecter) Delete(ctx interface{}, nodeSpec interface{}, primaryInstance interface{}) *NodeInstanceGroupRepo_Delete_Call {
	return &NodeInstanceGroupRepo_Delete_Call{Call: _e.mock.On("Delete", ctx, nodeSpec, primaryInstance)}
}

func (_c *NodeInstanceGroupRepo_Delete_Call) Run(run func(ctx context.Context, nodeSpec string, primaryInstance string)) *NodeInstanceGroupRepo_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *NodeInstanceGroupRepo_Delete_Call) RunAndReturn(run func(ctx context.Context, nodeSpec string, primaryInstance string) error) *NodeInstanceGroupRepo_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// ListAll provides a mock function for the type NodeInstanceGroupRepo
func (_mock *NodeInstanceGroupRepo) ListAll(ctx context.Context) ([]*entity.NodeInstanceGroup, error) {
	ret := _mock.Called(ctx)

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

	var r0 []*entity.NodeInstanceGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.NodeInstanceGroup, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.NodeInstanceGroup); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.NodeInstanceGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListAll is a helper method to define mock.On call
//   - ctx context.Context
func (_e *NodeInstanceGroupRepo_Expecter) ListAll(ctx interface{}) *NodeInstanceGroupRepo_ListAll_Call {
	return &NodeInstanceGroupRepo_ListAll_Call{Call: _e.mock.On("ListAll", ctx)}
}

func (_c *NodeInstanceGroupRepo_ListAll_Call) Run(run func(ctx context.Context)) *NodeInstanceGroupRepo_ListAll_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *NodeInstanceGroupRepo_ListAll_Call) Return(vs []*entity.NodeInstanceGroup, err error) *NodeInstanceGroupRepo_ListAll_Call {
	_c.Call.Return(vs, err)
	return _c
}

func (_c *NodeInstanceGroupRepo_ListAll_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.NodeInstanceGroup, error)) *NodeInstanceGroupRepo_ListAll_Call {
	_c.Call.Return(run)
	return _c
}

// ListBySpec provides a mock function for the type NodeInstanceGroupRepo
func (_mock *NodeInstanceGroupRepo) ListBySpec(ctx context.Context, nodeSpec string) ([]*entity.NodeInstanceGroup, error) {
	ret := _mock.Called(ctx, nodeSpec)

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

	var r0 []*entity.NodeInstanceGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*entity.NodeInstanceGroup, error)); ok {
		return returnFunc(ctx, nodeSpec)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*entity.NodeInstanceGroup); ok {
		r0 = returnFunc(ctx, nodeSpec)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.NodeInstanceGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, nodeSpec)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListBySpec is a helper method to define mock.On call
//   - ctx context.Context
//   - nodeSpec string
func (_e *NodeInstanceGroupRepo_Expecter) ListBySpec(ctx interface{}, nodeSpec interface{}) *NodeInstanceGroupRepo_ListBySpec_Call {
	return &NodeInstanceGroupRepo_ListBySpec_Call{Call: _e.mock.On("ListBySpec", ctx, nodeSpec)}
}

func (_c *NodeInstanceGroupRepo_ListBySpec_Call) Run(run func(ctx context.Context, nodeSpec string)) *NodeInstanceGroupRepo_ListBySpec_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *NodeInstanceGroupRepo_ListBySpec_Call) Return(vs []*entity.NodeInstanceGroup, err error) *NodeInstanceGroupRepo_ListBySpec_Call {
	_c.Call.Return(vs, err)
	return _c
}

func (_c *NodeInstanceGroupRepo_ListBySpec_Call) RunAndReturn(run func(ctx context.Context, nodeSpec string) ([]*entity.NodeInstanceGroup, error)) *NodeInstanceGroupRepo_ListBySpec_Call {
	_c.Call.Return(run)
	return _c
}

// ListByStatus provides a mock function for the type NodeInstanceGroupRepo
func (_mock *NodeInstanceGroupRepo) ListByStatus(ctx context.Context, status string) ([]*entity.NodeInstanceGroup, error) {
	ret := _mock.Called(ctx, status)

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

	var r0 []*entity.NodeInstanceGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*entity.NodeInstanceGroup, error)); ok {
		return returnFunc(ctx, status)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*entity.NodeInstanceGroup); ok {
		r0 = returnFunc(ctx, status)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.NodeInstanceGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, status)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListByStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - status string
func (_e *NodeInstanceGroupRepo_Expecter) ListByStatus(ctx interface{}, status interface{}) *NodeInstanceGroupRepo_ListByStatus_Call {
	return &NodeInstanceGroupRepo_ListByStatus_Call{Call: _e.mock.On("ListByStatus", ctx, status)}
}

func (_c *NodeInstanceGroupRepo_ListByStatus_Call) Run(run func(ctx context.Context, status string)) *NodeInstanceGroupRepo_ListByStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *NodeInstanceGroupRepo_ListByStatus_Call) Return(vs []*entity.NodeInstanceGroup, err error) *NodeInstanceGroupRepo_ListByStatus_Call {
	_c.Call.Return(vs, err)
	return _c
}

func (_c *NodeInstanceGroupRepo_ListByStatus_Call) RunAndReturn(run func(ctx context.Context, status string) ([]*entity.NodeInstanceGroup, error)) *NodeInstanceGroupRepo_ListByStatus_Call {
	_c.Call.Return(run)
	return _c
}

// Load provides a mock function for the type NodeInstanceGroupRepo
func (_mock *NodeInstanceGroupRepo) Load(ctx context.Context, id string) (*entity.NodeInstanceGroup, error) {
	ret := _mock.Called(ctx, id)

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

	var r0 *entity.NodeInstanceGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.NodeInstanceGroup, error)); ok {
		return returnFunc(ctx, id)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.NodeInstanceGroup); ok {
		r0 = returnFunc(ctx, id)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.NodeInstanceGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, id)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Load is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *NodeInstanceGroupRepo_Expecter) Load(ctx interface{}, id interface{}) *NodeInstanceGroupRepo_Load_Call {
	return &NodeInstanceGroupRepo_Load_Call{Call: _e.mock.On("Load", ctx, id)}
}

func (_c *NodeInstanceGroupRepo_Load_Call) Run(run func(ctx context.Context, id string)) *NodeInstanceGroupRepo_Load_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *NodeInstanceGroupRepo_Load_Call) Return(v *entity.NodeInstanceGroup, err error) *NodeInstanceGroupRepo_Load_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *NodeInstanceGroupRepo_Load_Call) RunAndReturn(run func(ctx context.Context, id string) (*entity.NodeInstanceGroup, error)) *NodeInstanceGroupRepo_Load_Call {
	_c.Call.Return(run)
	return _c
}

// LoadActiveBySpec provides a mock function for the type NodeInstanceGroupRepo
func (_mock *NodeInstanceGroupRepo) LoadActiveBySpec(ctx context.Context, nodeSpec string) (*entity.NodeInstanceGroup, error) {
	ret := _mock.Called(ctx, nodeSpec)

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

	var r0 *entity.NodeInstanceGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.NodeInstanceGroup, error)); ok {
		return returnFunc(ctx, nodeSpec)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.NodeInstanceGroup); ok {
		r0 = returnFunc(ctx, nodeSpec)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.NodeInstanceGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, nodeSpec)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// LoadActiveBySpec is a helper method to define mock.On call
//   - ctx context.Context
//   - nodeSpec string
func (_e *NodeInstanceGroupRepo_Expecter) LoadActiveBySpec(ctx interface{}, nodeSpec interface{}) *NodeInstanceGroupRepo_LoadActiveBySpec_Call {
	return &NodeInstanceGroupRepo_LoadActiveBySpec_Call{Call: _e.mock.On("LoadActiveBySpec", ctx, nodeSpec)}
}

func (_c *NodeInstanceGroupRepo_LoadActiveBySpec_Call) Run(run func(ctx context.Context, nodeSpec string)) *NodeInstanceGroupRepo_LoadActiveBySpec_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *NodeInstanceGroupRepo_LoadActiveBySpec_Call) Return(v *entity.NodeInstanceGroup, err error) *NodeInstanceGroupRepo_LoadActiveBySpec_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *NodeInstanceGroupRepo_LoadActiveBySpec_Call) RunAndReturn(run func(ctx context.Context, nodeSpec string) (*entity.NodeInstanceGroup, error)) *NodeInstanceGroupRepo_LoadActiveBySpec_Call {
	_c.Call.Return(run)
	return _c
}

// LoadActiveBySpecAndPrimary provides a mock function for the type NodeInstanceGroupRepo
func (_mock *NodeInstanceGroupRepo) LoadActiveBySpecAndPrimary(ctx context.Context, nodeSpec string, primaryInstance string) (*entity.NodeInstanceGroup, error) {
	ret := _mock.Called(ctx, nodeSpec, primaryInstance)

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

	var r0 *entity.NodeInstanceGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*entity.NodeInstanceGroup, error)); ok {
		return returnFunc(ctx, nodeSpec, primaryInstance)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *entity.NodeInstanceGroup); ok {
		r0 = returnFunc(ctx, nodeSpec, primaryInstance)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.NodeInstanceGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, nodeSpec, primaryInstance)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// LoadActiveBySpecAndPrimary is a helper method to define mock.On call
//   - ctx context.Context
//   - nodeSpec string
//   - primaryInstance string
func (_e *NodeInstanceGroupRepo_Expecter) LoadActiveBySpecAndPrimary(ctx interface{}, nodeSpec interface{}, primaryInstance interface{}) *NodeInstanceGroupRepo_LoadActiveBySpecAndPrimary_Call {
	return &NodeInstanceGroupRepo_LoadActiveBySpecAndPrimary_Call{Call: _e.mock.On("LoadActiveBySpecAndPrimary", ctx, nodeSpec, primaryInstance)}
}

func (_c *NodeInstanceGroupRepo_LoadActiveBySpecAndPrimary_Call) Run(run func(ctx context.Context, nodeSpec string, primaryInstance string)) *NodeInstanceGroupRepo_LoadActiveBySpecAndPrimary_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *NodeInstanceGroupRepo_LoadActiveBySpecAndPrimary_Call) Return(v *entity.NodeInstanceGroup, err error) *NodeInstanceGroupRepo_LoadActiveBySpecAndPrimary_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *NodeInstanceGroupRepo_LoadActiveBySpecAndPrimary_Call) RunAndReturn(run func(ctx context.Context, nodeSpec string, primaryInstance string) (*entity.NodeInstanceGroup, error)) *NodeInstanceGroupRepo_LoadActiveBySpecAndPrimary_Call {
	_c.Call.Return(run)
	return _c
}

// LoadBySpec provides a mock function for the type NodeInstanceGroupRepo
func (_mock *NodeInstanceGroupRepo) LoadBySpec(ctx context.Context, nodeSpec string) (*entity.NodeInstanceGroup, error) {
	ret := _mock.Called(ctx, nodeSpec)

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

	var r0 *entity.NodeInstanceGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.NodeInstanceGroup, error)); ok {
		return returnFunc(ctx, nodeSpec)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.NodeInstanceGroup); ok {
		r0 = returnFunc(ctx, nodeSpec)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.NodeInstanceGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, nodeSpec)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// LoadBySpec is a helper method to define mock.On call
//   - ctx context.Context
//   - nodeSpec string
func (_e *NodeInstanceGroupRepo_Expecter) LoadBySpec(ctx interface{}, nodeSpec interface{}) *NodeInstanceGroupRepo_LoadBySpec_Call {
	return &NodeInstanceGroupRepo_LoadBySpec_Call{Call: _e.mock.On("LoadBySpec", ctx, nodeSpec)}
}

func (_c *NodeInstanceGroupRepo_LoadBySpec_Call) Run(run func(ctx context.Context, nodeSpec string)) *NodeInstanceGroupRepo_LoadBySpec_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *NodeInstanceGroupRepo_LoadBySpec_Call) Return(v *entity.NodeInstanceGroup, err error) *NodeInstanceGroupRepo_LoadBySpec_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *NodeInstanceGroupRepo_LoadBySpec_Call) RunAndReturn(run func(ctx context.Context, nodeSpec string) (*entity.NodeInstanceGroup, error)) *NodeInstanceGroupRepo_LoadBySpec_Call {
	_c.Call.Return(run)
	return _c
}

// LoadBySpecAndPrimary provides a mock function for the type NodeInstanceGroupRepo
func (_mock *NodeInstanceGroupRepo) LoadBySpecAndPrimary(ctx context.Context, nodeSpec string, primaryInstance string) (*entity.NodeInstanceGroup, error) {
	ret := _mock.Called(ctx, nodeSpec, primaryInstance)

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

	var r0 *entity.NodeInstanceGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*entity.NodeInstanceGroup, error)); ok {
		return returnFunc(ctx, nodeSpec, primaryInstance)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *entity.NodeInstanceGroup); ok {
		r0 = returnFunc(ctx, nodeSpec, primaryInstance)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.NodeInstanceGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, nodeSpec, primaryInstance)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// LoadBySpecAndPrimary is a helper method to define mock.On call
//   - ctx context.Context
//   - nodeSpec string
//   - primaryInstance string
func (_e *NodeInstanceGroupRepo_Expecter) LoadBySpecAndPrimary(ctx interface{}, nodeSpec interface{}, primaryInstance interface{}) *NodeInstanceGroupRepo_LoadBySpecAndPrimary_Call {
	return &NodeInstanceGroupRepo_LoadBySpecAndPrimary_Call{Call: _e.mock.On("LoadBySpecAndPrimary", ctx, nodeSpec, primaryInstance)}
}

func (_c *NodeInstanceGroupRepo_LoadBySpecAndPrimary_Call) Run(run func(ctx context.Context, nodeSpec string, primaryInstance string)) *NodeInstanceGroupRepo_LoadBySpecAndPrimary_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *NodeInstanceGroupRepo_LoadBySpecAndPrimary_Call) Return(v *entity.NodeInstanceGroup, err error) *NodeInstanceGroupRepo_LoadBySpecAndPrimary_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *NodeInstanceGroupRepo_LoadBySpecAndPrimary_Call) RunAndReturn(run func(ctx context.Context, nodeSpec string, primaryInstance string) (*entity.NodeInstanceGroup, error)) *NodeInstanceGroupRepo_LoadBySpecAndPrimary_Call {
	_c.Call.Return(run)
	return _c
}

// Save provides a mock function for the type NodeInstanceGroupRepo
func (_mock *NodeInstanceGroupRepo) Save(ctx context.Context, group *entity.NodeInstanceGroup) error {
	ret := _mock.Called(ctx, group)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.NodeInstanceGroup) error); ok {
		r0 = returnFunc(ctx, group)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Save is a helper method to define mock.On call
//   - ctx context.Context
//   - group *entity.NodeInstanceGroup
func (_e *NodeInstanceGroupRepo_Expecter) Save(ctx interface{}, group interface{}) *NodeInstanceGroupRepo_Save_Call {
	return &NodeInstanceGroupRepo_Save_Call{Call: _e.mock.On("Save", ctx, group)}
}

func (_c *NodeInstanceGroupRepo_Save_Call) Run(run func(ctx context.Context, group *entity.NodeInstanceGroup)) *NodeInstanceGroupRepo_Save_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.NodeInstanceGroup
		if args[1] != nil {
			arg1 = args[1].(*entity.NodeInstanceGroup)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *NodeInstanceGroupRepo_Save_Call) RunAndReturn(run func(ctx context.Context, group *entity.NodeInstanceGroup) error) *NodeInstanceGroupRepo_Save_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type DataplaneNodeInstanceGroupStateRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *DataplaneNodeInstanceGroupStateRepo) EXPECT() *DataplaneNodeInstanceGroupStateRepo_Expecter {
	return &DataplaneNodeInstanceGroupStateRepo_Expecter{mock: &_m.Mock}
}

// ClearCooldown provides a mock function for the type DataplaneNodeInstanceGroupStateRepo
func (_mock *DataplaneNodeInstanceGroupStateRepo) ClearCooldown(ctx context.Context, id string) error {
	ret := _mock.Called(ctx, id)

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

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

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

// ClearCooldown is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *DataplaneNodeInstanceGroupStateRepo_Expecter) ClearCooldown(ctx interface{}, id interface{}) *DataplaneNodeInstanceGroupStateRepo_ClearCooldown_Call {
	return &DataplaneNodeInstanceGroupStateRepo_ClearCooldown_Call{Call: _e.mock.On("ClearCooldown", ctx, id)}
}

func (_c *DataplaneNodeInstanceGroupStateRepo_ClearCooldown_Call) Run(run func(ctx context.Context, id string)) *DataplaneNodeInstanceGroupStateRepo_ClearCooldown_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *DataplaneNodeInstanceGroupStateRepo_ClearCooldown_Call) RunAndReturn(run func(ctx context.Context, id string) error) *DataplaneNodeInstanceGroupStateRepo_ClearCooldown_Call {
	_c.Call.Return(run)
	return _c
}

// Delete provides a mock function for the type DataplaneNodeInstanceGroupStateRepo
func (_mock *DataplaneNodeInstanceGroupStateRepo) Delete(ctx context.Context, id string) error {
	ret := _mock.Called(ctx, id)

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

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

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *DataplaneNodeInstanceGroupStateRepo_Expecter) Delete(ctx interface{}, id interface{}) *DataplaneNodeInstanceGroupStateRepo_Delete_Call {
	return &DataplaneNodeInstanceGroupStateRepo_Delete_Call{Call: _e.mock.On("Delete", ctx, id)}
}

func (_c *DataplaneNodeInstanceGroupStateRepo_Delete_Call) Run(run func(ctx context.Context, id string)) *DataplaneNodeInstanceGroupStateRepo_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *DataplaneNodeInstanceGroupStateRepo_Delete_Call) RunAndReturn(run func(ctx context.Context, id string) error) *DataplaneNodeInstanceGroupStateRepo_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteByDataplaneAndSpec provides a mock function for the type DataplaneNodeInstanceGroupStateRepo
func (_mock *DataplaneNodeInstanceGroupStateRepo) DeleteByDataplaneAndSpec(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string) error {
	ret := _mock.Called(ctx, dataplaneName, nodeSpec, primaryInstance)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// DeleteByDataplaneAndSpec is a helper method to define mock.On call
//   - ctx context.Context
//   - dataplaneName string
//   - nodeSpec string
//   - primaryInstance string
func (_e *DataplaneNodeInstanceGroupStateRepo_Expecter) DeleteByDataplaneAndSpec(ctx interface{}, dataplaneName interface{}, nodeSpec interface{}, primaryInstance interface{}) *DataplaneNodeInstanceGroupStateRepo_DeleteByDataplaneAndSpec_Call {
	return &DataplaneNodeInstanceGroupStateRepo_DeleteByDataplaneAndSpec_Call{Call: _e.mock.On("DeleteByDataplaneAndSpec", ctx, dataplaneName, nodeSpec, primaryInstance)}
}

func (_c *DataplaneNodeInstanceGroupStateRepo_DeleteByDataplaneAndSpec_Call) Run(run func(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string)) *DataplaneNodeInstanceGroupStateRepo_DeleteByDataplaneAndSpec_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *DataplaneNodeInstanceGroupStateRepo_DeleteByDataplaneAndSpec_Call) RunAndReturn(run func(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string) error) *DataplaneNodeInstanceGroupStateRepo_DeleteByDataplaneAndSpec_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteBySpecAndPrimary provides a mock function for the type DataplaneNodeInstanceGroupStateRepo
func (_mock *DataplaneNodeInstanceGroupStateRepo) DeleteBySpecAndPrimary(ctx context.Context, nodeSpec string, primaryInstance string) error {
	ret := _mock.Called(ctx, nodeSpec, primaryInstance)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, nodeSpec, primaryInstance)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// DeleteBySpecAndPrimary is a helper method to define mock.On call
//   - ctx context.Context
//   - nodeSpec string
//   - primaryInstance string
func (_e *DataplaneNodeInstanceGroupStateRepo_Expecter) DeleteBySpecAndPrimary(ctx interface{}, nodeSpec interface{}, primaryInstance interface{}) *DataplaneNodeInstanceGroupStateRepo_DeleteBySpecAndPrimary_Call {
	return &DataplaneNodeInstanceGroupStateRepo_DeleteBySpecAndPrimary_Call{Call: _e.mock.On("DeleteBySpecAndPrimary", ctx, nodeSpec, primaryInstance)}
}

func (_c *DataplaneNodeInstanceGroupStateRepo_DeleteBySpecAndPrimary_Call) Run(run func(ctx context.Context, nodeSpec string, primaryInstance string)) *DataplaneNodeInstanceGroupStateRepo_DeleteBySpecAndPrimary_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *DataplaneNodeInstanceGroupStateRepo_DeleteBySpecAndPrimary_Call) RunAndReturn(run func(ctx context.Context, nodeSpec string, primaryInstance string) error) *DataplaneNodeInstanceGroupStateRepo_DeleteBySpecAndPrimary_Call {
	_c.Call.Return(run)
	return _c
}

// ListByDataplane provides a mock function for the type DataplaneNodeInstanceGroupStateRepo
func (_mock *DataplaneNodeInstanceGroupStateRepo) ListByDataplane(ctx context.Context, dataplaneName string) ([]*entity.DataplaneNodeInstanceGroupState, error) {
	ret := _mock.Called(ctx, dataplaneName)

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

	var r0 []*entity.DataplaneNodeInstanceGroupState
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*entity.DataplaneNodeInstanceGroupState, error)); ok {
		return returnFunc(ctx, dataplaneName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*entity.DataplaneNodeInstanceGroupState); ok {
		r0 = returnFunc(ctx, dataplaneName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.DataplaneNodeInstanceGroupState)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, dataplaneName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListByDataplane is a helper method to define mock.On call
//   - ctx context.Context
//   - dataplaneName string
func (_e *DataplaneNodeInstanceGroupStateRepo_Expecter) ListByDataplane(ctx interface{}, dataplaneName interface{}) *DataplaneNodeInstanceGroupStateRepo_ListByDataplane_Call {
	return &DataplaneNodeInstanceGroupStateRepo_ListByDataplane_Call{Call: _e.mock.On("ListByDataplane", ctx, dataplaneName)}
}

func (_c *DataplaneNodeInstanceGroupStateRepo_ListByDataplane_Call) Run(run func(ctx context.Context, dataplaneName string)) *DataplaneNodeInstanceGroupStateRepo_ListByDataplane_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *DataplaneNodeInstanceGroupStateRepo_ListByDataplane_Call) Return(dataplaneNodeInstanceGroupStates []*entity.DataplaneNodeInstanceGroupState, err error) *DataplaneNodeInstanceGroupStateRepo_ListByDataplane_Call {
	_c.Call.Return(dataplaneNodeInstanceGroupStates, err)
	return _c
}

func (_c *DataplaneNodeInstanceGroupStateRepo_ListByDataplane_Call) RunAndReturn(run func(ctx context.Context, dataplaneName string) ([]*entity.DataplaneNodeInstanceGroupState, error)) *DataplaneNodeInstanceGroupStateRepo_ListByDataplane_Call {
	_c.Call.Return(run)
	return _c
}

// ListByState provides a mock function for the type DataplaneNodeInstanceGroupStateRepo
func (_mock *DataplaneNodeInstanceGroupStateRepo) ListByState(ctx context.Context, state string) ([]*entity.DataplaneNodeInstanceGroupState, error) {
	ret := _mock.Called(ctx, state)

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

	var r0 []*entity.DataplaneNodeInstanceGroupState
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*entity.DataplaneNodeInstanceGroupState, error)); ok {
		return returnFunc(ctx, state)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*entity.DataplaneNodeInstanceGroupState); ok {
		r0 = returnFunc(ctx, state)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.DataplaneNodeInstanceGroupState)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, state)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListByState is a helper method to define mock.On call
//   - ctx context.Context
//   - state string
func (_e *DataplaneNodeInstanceGroupStateRepo_Expecter) ListByState(ctx interface{}, state interface{}) *DataplaneNodeInstanceGroupStateRepo_ListByState_Call {
	return &DataplaneNodeInstanceGroupStateRepo_ListByState_Call{Call: _e.mock.On("ListByState", ctx, state)}
}

func (_c *DataplaneNodeInstanceGroupStateRepo_ListByState_Call) Run(run func(ctx context.Context, state string)) *DataplaneNodeInstanceGroupStateRepo_ListByState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *DataplaneNodeInstanceGroupStateRepo_ListByState_Call) Return(dataplaneNodeInstanceGroupStates []*entity.DataplaneNodeInstanceGroupState, err error) *DataplaneNodeInstanceGroupStateRepo_ListByState_Call {
	_c.Call.Return(dataplaneNodeInstanceGroupStates, err)
	return _c
}

func (_c *DataplaneNodeInstanceGroupStateRepo_ListByState_Call) RunAndReturn(run func(ctx context.Context, state string) ([]*entity.DataplaneNodeInstanceGroupState, error)) *DataplaneNodeInstanceGroupStateRepo_ListByState_Call {
	_c.Call.Return(run)
	return _c
}

// Load provides a mock function for the type DataplaneNodeInstanceGroupStateRepo
func (_mock *DataplaneNodeInstanceGroupStateRepo) Load(ctx context.Context, id string) (*entity.DataplaneNodeInstanceGroupState, error) {
	ret := _mock.Called(ctx, id)

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

	var r0 *entity.DataplaneNodeInstanceGroupState
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.DataplaneNodeInstanceGroupState, error)); ok {
		return returnFunc(ctx, id)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.DataplaneNodeInstanceGroupState); ok {
		r0 = returnFunc(ctx, id)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.DataplaneNodeInstanceGroupState)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, id)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Load is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *DataplaneNodeInstanceGroupStateRepo_Expecter) Load(ctx interface{}, id interface{}) *DataplaneNodeInstanceGroupStateRepo_Load_Call {
	return &DataplaneNodeInstanceGroupStateRepo_Load_Call{Call: _e.mock.On("Load", ctx, id)}
}

func (_c *DataplaneNodeInstanceGroupStateRepo_Load_Call) Run(run func(ctx context.Context, id string)) *DataplaneNodeInstanceGroupStateRepo_Load_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *DataplaneNodeInstanceGroupStateRepo_Load_Call) Return(dataplaneNodeInstanceGroupState *entity.DataplaneNodeInstanceGroupState, err error) *DataplaneNodeInstanceGroupStateRepo_Load_Call {
	_c.Call.Return(dataplaneNodeInstanceGroupState, err)
	return _c
}

func (_c *DataplaneNodeInstanceGroupStateRepo_Load_Call) RunAndReturn(run func(ctx context.Context, id string) (*entity.DataplaneNodeInstanceGroupState, error)) *DataplaneNodeInstanceGroupStateRepo_Load_Call {
	_c.Call.Return(run)
	return _c
}

// LoadByDataplaneAndSpec provides a mock function for the type DataplaneNodeInstanceGroupStateRepo
func (_mock *DataplaneNodeInstanceGroupStateRepo) LoadByDataplaneAndSpec(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string) (*entity.DataplaneNodeInstanceGroupState, error) {
	ret := _mock.Called(ctx, dataplaneName, nodeSpec, primaryInstance)

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

	var r0 *entity.DataplaneNodeInstanceGroupState
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*entity.DataplaneNodeInstanceGroupState, error)); ok {
		return returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *entity.DataplaneNodeInstanceGroupState); ok {
		r0 = returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.DataplaneNodeInstanceGroupState)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// LoadByDataplaneAndSpec is a helper method to define mock.On call
//   - ctx context.Context
//   - dataplaneName string
//   - nodeSpec string
//   - primaryInstance string
func (_e *DataplaneNodeInstanceGroupStateRepo_Expecter) LoadByDataplaneAndSpec(ctx interface{}, dataplaneName interface{}, nodeSpec interface{}, primaryInstance interface{}) *DataplaneNodeInstanceGroupStateRepo_LoadByDataplaneAndSpec_Call {
	return &DataplaneNodeInstanceGroupStateRepo_LoadByDataplaneAndSpec_Call{Call: _e.mock.On("LoadByDataplaneAndSpec", ctx, dataplaneName, nodeSpec, primaryInstance)}
}

func (_c *DataplaneNodeInstanceGroupStateRepo_LoadByDataplaneAndSpec_Call) Run(run func(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string)) *DataplaneNodeInstanceGroupStateRepo_LoadByDataplaneAndSpec_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *DataplaneNodeInstanceGroupStateRepo_LoadByDataplaneAndSpec_Call) Return(dataplaneNodeInstanceGroupState *entity.DataplaneNodeInstanceGroupState, err error) *DataplaneNodeInstanceGroupStateRepo_LoadByDataplaneAndSpec_Call {
	_c.Call.Return(dataplaneNodeInstanceGroupState, err)
	return _c
}

func (_c *DataplaneNodeInstanceGroupStateRepo_LoadByDataplaneAndSpec_Call) RunAndReturn(run func(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string) (*entity.DataplaneNodeInstanceGroupState, error)) *DataplaneNodeInstanceGroupStateRepo_LoadByDataplaneAndSpec_Call {
	_c.Call.Return(run)
	return _c
}

// LoadOrCreate provides a mock function for the type DataplaneNodeInstanceGroupStateRepo
func (_mock *DataplaneNodeInstanceGroupStateRepo) LoadOrCreate(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string) (*entity.DataplaneNodeInstanceGroupState, error) {
	ret := _mock.Called(ctx, dataplaneName, nodeSpec, primaryInstance)

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

	var r0 *entity.DataplaneNodeInstanceGroupState
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*entity.DataplaneNodeInstanceGroupState, error)); ok {
		return returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *entity.DataplaneNodeInstanceGroupState); ok {
		r0 = returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.DataplaneNodeInstanceGroupState)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// LoadOrCreate is a helper method to define mock.On call
//   - ctx context.Context
//   - dataplaneName string
//   - nodeSpec string
//   - primaryInstance string
func (_e *DataplaneNodeInstanceGroupStateRepo_Expecter) LoadOrCreate(ctx interface{}, dataplaneName interface{}, nodeSpec interface{}, primaryInstance interface{}) *DataplaneNodeInstanceGroupStateRepo_LoadOrCreate_Call {
	return &DataplaneNodeInstanceGroupStateRepo_LoadOrCreate_Call{Call: _e.mock.On("LoadOrCreate", ctx, dataplaneName, nodeSpec, primaryInstance)}
}

func (_c *DataplaneNodeInstanceGroupStateRepo_LoadOrCreate_Call) Run(run func(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string)) *DataplaneNodeInstanceGroupStateRepo_LoadOrCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *DataplaneNodeInstanceGroupStateRepo_LoadOrCreate_Call) Return(dataplaneNodeInstanceGroupState *entity.DataplaneNodeInstanceGroupState, err error) *DataplaneNodeInstanceGroupStateRepo_LoadOrCreate_Call {
	_c.Call.Return(dataplaneNodeInstanceGroupState, err)
	return _c
}

func (_c *DataplaneNodeInstanceGroupStateRepo_LoadOrCreate_Call) RunAndReturn(run func(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string) (*entity.DataplaneNodeInstanceGroupState, error)) *DataplaneNodeInstanceGroupStateRepo_LoadOrCreate_Call {
	_c.Call.Return(run)
	return _c
}

// Save provides a mock function for the type DataplaneNodeInstanceGroupStateRepo
func (_mock *DataplaneNodeInstanceGroupStateRepo) Save(ctx context.Context, state *entity.DataplaneNodeInstanceGroupState) error {
	ret := _mock.Called(ctx, state)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.DataplaneNodeInstanceGroupState) error); ok {
		r0 = returnFunc(ctx, state)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Save is a helper method to define mock.On call
//   - ctx context.Context
//   - state *entity.DataplaneNodeInstanceGroupState
func (_e *DataplaneNodeInstanceGroupStateRepo_Expecter) Save(ctx interface{}, state interface{}) *DataplaneNodeInstanceGroupStateRepo_Save_Call {
	return &DataplaneNodeInstanceGroupStateRepo_Save_Call{Call: _e.mock.On("Save", ctx, state)}
}

func (_c *DataplaneNodeInstanceGroupStateRepo_Save_Call) Run(run func(ctx context.Context, state *entity.DataplaneNodeInstanceGroupState)) *DataplaneNodeInstanceGroupStateRepo_Save_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.DataplaneNodeInstanceGroupState
		if args[1] != nil {
			arg1 = args[1].(*entity.DataplaneNodeInstanceGroupState)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *DataplaneNodeInstanceGroupStateRepo_Save_Call) RunAndReturn(run func(ctx context.Context, state *entity.DataplaneNodeInstanceGroupState) error) *DataplaneNodeInstanceGroupStateRepo_Save_Call {
	_c.Call.Return(run)
	return _c
}

// SetCooldown provides a mock function for the type DataplaneNodeInstanceGroupStateRepo
func (_mock *DataplaneNodeInstanceGroupStateRepo) SetCooldown(ctx context.Context, id string, until time.Time) error {
	ret := _mock.Called(ctx, id, until)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, time.Time) error); ok {
		r0 = returnFunc(ctx, id, until)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetCooldown is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - until time.Time
func (_e *DataplaneNodeInstanceGroupStateRepo_Expecter) SetCooldown(ctx interface{}, id interface{}, until interface{}) *DataplaneNodeInstanceGroupStateRepo_SetCooldown_Call {
	return &DataplaneNodeInstanceGroupStateRepo_SetCooldown_Call{Call: _e.mock.On("SetCooldown", ctx, id, until)}
}

func (_c *DataplaneNodeInstanceGroupStateRepo_SetCooldown_Call) Run(run func(ctx context.Context, id string, until time.Time)) *DataplaneNodeInstanceGroupStateRepo_SetCooldown_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 time.Time
		if args[2] != nil {
			arg2 = args[2].(time.Time)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *DataplaneNodeInstanceGroupStateRepo_SetCooldown_Call) RunAndReturn(run func(ctx context.Context, id string, until time.Time) error) *DataplaneNodeInstanceGroupStateRepo_SetCooldown_Call {
	_c.Call.Return(run)
	return _c
}

// TransitionState provides a mock function for the type DataplaneNodeInstanceGroupStateRepo
func (_mock *DataplaneNodeInstanceGroupStateRepo) TransitionState(ctx context.Context, id string, expectedState string, newState string) error {
	ret := _mock.Called(ctx, id, expectedState, newState)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, id, expectedState, newState)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// TransitionState is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - expectedState string
//   - newState string
func (_e *DataplaneNodeInstanceGroupStateRepo_Expecter) TransitionState(ctx interface{}, id interface{}, expectedState interface{}, newState interface{}) *DataplaneNodeInstanceGroupStateRepo_TransitionState_Call {
	return &DataplaneNodeInstanceGroupStateRepo_TransitionState_Call{Call: _e.mock.On("TransitionState", ctx, id, expectedState, newState)}
}

func (_c *DataplaneNodeInstanceGroupStateRepo_TransitionState_Call) Run(run func(ctx context.Context, id string, expectedState string, newState string)) *DataplaneNodeInstanceGroupStateRepo_TransitionState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *DataplaneNodeInstanceGroupStateRepo_TransitionState_Call) RunAndReturn(run func(ctx context.Context, id string, expectedState string, newState string) error) *DataplaneNodeInstanceGroupStateRepo_TransitionState_Call {
	_c.Call.Return(run)
	return _c
}

// TransitionStateWithCooldown provides a mock function for the type DataplaneNodeInstanceGroupStateRepo
func (_mock *DataplaneNodeInstanceGroupStateRepo) TransitionStateWithCooldown(ctx context.Context, id string, expectedState string, newState string, cooldownUntil *time.Time) error {
	ret := _mock.Called(ctx, id, expectedState, newState, cooldownUntil)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *time.Time) error); ok {
		r0 = returnFunc(ctx, id, expectedState, newState, cooldownUntil)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// TransitionStateWithCooldown is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - expectedState string
//   - newState string
//   - cooldownUntil *time.Time
func (_e *DataplaneNodeInstanceGroupStateRepo_Expecter) TransitionStateWithCooldown(ctx interface{}, id interface{}, expectedState interface{}, newState interface{}, cooldownUntil interface{}) *DataplaneNodeInstanceGroupStateRepo_TransitionStateWithCooldown_Call {
	return &DataplaneNodeInstanceGroupStateRepo_TransitionStateWithCooldown_Call{Call: _e.mock.On("TransitionStateWithCooldown", ctx, id, expectedState, newState, cooldownUntil)}
}

func (_c *DataplaneNodeInstanceGroupStateRepo_TransitionStateWithCooldown_Call) Run(run func(ctx context.Context, id string, expectedState string, newState string, cooldownUntil *time.Time)) *DataplaneNodeInstanceGroupStateRepo_TransitionStateWithCooldown_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 *time.Time
		if args[4] != nil {
			arg4 = args[4].(*time.Time)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *DataplaneNodeInstanceGroupStateRepo_TransitionStateWithCooldown_Call) RunAndReturn(run func(ctx context.Context, id string, expectedState string, newState string, cooldownUntil *time.Time) error) *DataplaneNodeInstanceGroupStateRepo_TransitionStateWithCooldown_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type DataplaneNodeInstanceGroupLockRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *DataplaneNodeInstanceGroupLockRepo) EXPECT() *DataplaneNodeInstanceGroupLockRepo_Expecter {
	return &DataplaneNodeInstanceGroupLockRepo_Expecter{mock: &_m.Mock}
}

// ForceRelease provides a mock function for the type DataplaneNodeInstanceGroupLockRepo
func (_mock *DataplaneNodeInstanceGroupLockRepo) ForceRelease(ctx context.Context, dataplaneName string) error {
	ret := _mock.Called(ctx, dataplaneName)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(ctx, dataplaneName)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ForceRelease is a helper method to define mock.On call
//   - ctx context.Context
//   - dataplaneName string
func (_e *DataplaneNodeInstanceGroupLockRepo_Expecter) ForceRelease(ctx interface{}, dataplaneName interface{}) *DataplaneNodeInstanceGroupLockRepo_ForceRelease_Call {
	return &DataplaneNodeInstanceGroupLockRepo_ForceRelease_Call{Call: _e.mock.On("ForceRelease", ctx, dataplaneName)}
}

func (_c *DataplaneNodeInstanceGroupLockRepo_ForceRelease_Call) Run(run func(ctx context.Context, dataplaneName string)) *DataplaneNodeInstanceGroupLockRepo_ForceRelease_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *DataplaneNodeInstanceGroupLockRepo_ForceRelease_Call) RunAndReturn(run func(ctx context.Context, dataplaneName string) error) *DataplaneNodeInstanceGroupLockRepo_ForceRelease_Call {
	_c.Call.Return(run)
	return _c
}

// IsLockValid provides a mock function for the type DataplaneNodeInstanceGroupLockRepo
func (_mock *DataplaneNodeInstanceGroupLockRepo) IsLockValid(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string, fencingToken int64) (bool, error) {
	ret := _mock.Called(ctx, dataplaneName, nodeSpec, primaryInstance, fencingToken)

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

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, int64) (bool, error)); ok {
		return returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance, fencingToken)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, int64) bool); ok {
		r0 = returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance, fencingToken)
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, int64) error); ok {
		r1 = returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance, fencingToken)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// IsLockValid is a helper method to define mock.On call
//   - ctx context.Context
//   - dataplaneName string
//   - nodeSpec string
//   - primaryInstance string
//   - fencingToken int64
func (_e *DataplaneNodeInstanceGroupLockRepo_Expecter) IsLockValid(ctx interface{}, dataplaneName interface{}, nodeSpec interface{}, primaryInstance interface{}, fencingToken interface{}) *DataplaneNodeInstanceGroupLockRepo_IsLockValid_Call {
	return &DataplaneNodeInstanceGroupLockRepo_IsLockValid_Call{Call: _e.mock.On("IsLockValid", ctx, dataplaneName, nodeSpec, primaryInstance, fencingToken)}
}

func (_c *DataplaneNodeInstanceGroupLockRepo_IsLockValid_Call) Run(run func(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string, fencingToken int64)) *DataplaneNodeInstanceGroupLockRepo_IsLockValid_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 int64
		if args[4] != nil {
			arg4 = args[4].(int64)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *DataplaneNodeInstanceGroupLockRepo_IsLockValid_Call) Return(b bool, err error) *DataplaneNodeInstanceGroupLockRepo_IsLockValid_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *DataplaneNodeInstanceGroupLockRepo_IsLockValid_Call) RunAndReturn(run func(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string, fencingToken int64) (bool, error)) *DataplaneNodeInstanceGroupLockRepo_IsLockValid_Call {
	_c.Call.Return(run)
	return _c
}

// Load provides a mock function for the type DataplaneNodeInstanceGroupLockRepo
func (_mock *DataplaneNodeInstanceGroupLockRepo) Load(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string) (*entity.DataplaneNodeInstanceGroupLock, error) {
	ret := _mock.Called(ctx, dataplaneName, nodeSpec, primaryInstance)

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

	var r0 *entity.DataplaneNodeInstanceGroupLock
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*entity.DataplaneNodeInstanceGroupLock, error)); ok {
		return returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *entity.DataplaneNodeInstanceGroupLock); ok {
		r0 = returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.DataplaneNodeInstanceGroupLock)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Load is a helper method to define mock.On call
//   - ctx context.Context
//   - dataplaneName string
//   - nodeSpec string
//   - primaryInstance string
func (_e *DataplaneNodeInstanceGroupLockRepo_Expecter) Load(ctx interface{}, dataplaneName interface{}, nodeSpec interface{}, primaryInstance interface{}) *DataplaneNodeInstanceGroupLockRepo_Load_Call {
	return &DataplaneNodeInstanceGroupLockRepo_Load_Call{Call: _e.mock.On("Load", ctx, dataplaneName, nodeSpec, primaryInstance)}
}

func (_c *DataplaneNodeInstanceGroupLockRepo_Load_Call) Run(run func(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string)) *DataplaneNodeInstanceGroupLockRepo_Load_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *DataplaneNodeInstanceGroupLockRepo_Load_Call) Return(dataplaneNodeInstanceGroupLock *entity.DataplaneNodeInstanceGroupLock, err error) *DataplaneNodeInstanceGroupLockRepo_Load_Call {
	_c.Call.Return(dataplaneNodeInstanceGroupLock, err)
	return _c
}

func (_c *DataplaneNodeInstanceGroupLockRepo_Load_Call) RunAndReturn(run func(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string) (*entity.DataplaneNodeInstanceGroupLock, error)) *DataplaneNodeInstanceGroupLockRepo_Load_Call {
	_c.Call.Return(run)
	return _c
}

// Release provides a mock function for the type DataplaneNodeInstanceGroupLockRepo
func (_mock *DataplaneNodeInstanceGroupLockRepo) Release(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string, ownerID string) error {
	ret := _mock.Called(ctx, dataplaneName, nodeSpec, primaryInstance, ownerID)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) error); ok {
		r0 = returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance, ownerID)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Release is a helper method to define mock.On call
//   - ctx context.Context
//   - dataplaneName string
//   - nodeSpec string
//   - primaryInstance string
//   - ownerID string
func (_e *DataplaneNodeInstanceGroupLockRepo_Expecter) Release(ctx interface{}, dataplaneName interface{}, nodeSpec interface{}, primaryInstance interface{}, ownerID interface{}) *DataplaneNodeInstanceGroupLockRepo_Release_Call {
	return &DataplaneNodeInstanceGroupLockRepo_Release_Call{Call: _e.mock.On("Release", ctx, dataplaneName, nodeSpec, primaryInstance, ownerID)}
}

func (_c *DataplaneNodeInstanceGroupLockRepo_Release_Call) Run(run func(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string, ownerID string)) *DataplaneNodeInstanceGroupLockRepo_Release_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *DataplaneNodeInstanceGroupLockRepo_Release_Call) RunAndReturn(run func(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string, ownerID string) error) *DataplaneNodeInstanceGroupLockRepo_Release_Call {
	_c.Call.Return(run)
	return _c
}

// TryAcquire provides a mock function for the type DataplaneNodeInstanceGroupLockRepo
func (_mock *DataplaneNodeInstanceGroupLockRepo) TryAcquire(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string, ownerID string, leaseDuration time.Duration) (*entity.DataplaneNodeInstanceGroupLock, error) {
	ret := _mock.Called(ctx, dataplaneName, nodeSpec, primaryInstance, ownerID, leaseDuration)

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

	var r0 *entity.DataplaneNodeInstanceGroupLock
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string, time.Duration) (*entity.DataplaneNodeInstanceGroupLock, error)); ok {
		return returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance, ownerID, leaseDuration)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string, time.Duration) *entity.DataplaneNodeInstanceGroupLock); ok {
		r0 = returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance, ownerID, leaseDuration)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.DataplaneNodeInstanceGroupLock)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string, time.Duration) error); ok {
		r1 = returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance, ownerID, leaseDuration)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// TryAcquire is a helper method to define mock.On call
//   - ctx context.Context
//   - dataplaneName string
//   - nodeSpec string
//   - primaryInstance string
//   - ownerID string
//   - leaseDuration time.Duration
func (_e *DataplaneNodeInstanceGroupLockRepo_Expecter) TryAcquire(ctx interface{}, dataplaneName interface{}, nodeSpec interface{}, primaryInstance interface{}, ownerID interface{}, leaseDuration interface{}) *DataplaneNodeInstanceGroupLockRepo_TryAcquire_Call {
	return &DataplaneNodeInstanceGroupLockRepo_TryAcquire_Call{Call: _e.mock.On("TryAcquire", ctx, dataplaneName, nodeSpec, primaryInstance, ownerID, leaseDuration)}
}

func (_c *DataplaneNodeInstanceGroupLockRepo_TryAcquire_Call) Run(run func(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string, ownerID string, leaseDuration time.Duration)) *DataplaneNodeInstanceGroupLockRepo_TryAcquire_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		var arg5 time.Duration
		if args[5] != nil {
			arg5 = args[5].(time.Duration)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *DataplaneNodeInstanceGroupLockRepo_TryAcquire_Call) Return(dataplaneNodeInstanceGroupLock *entity.DataplaneNodeInstanceGroupLock, err error) *DataplaneNodeInstanceGroupLockRepo_TryAcquire_Call {
	_c.Call.Return(dataplaneNodeInstanceGroupLock, err)
	return _c
}

func (_c *DataplaneNodeInstanceGroupLockRepo_TryAcquire_Call) RunAndReturn(run func(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string, ownerID string, leaseDuration time.Duration) (*entity.DataplaneNodeInstanceGroupLock, error)) *DataplaneNodeInstanceGroupLockRepo_TryAcquire_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type DataplaneNodeInstanceGroupRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *DataplaneNodeInstanceGroupRepo) EXPECT() *DataplaneNodeInstanceGroupRepo_Expecter {
	return &DataplaneNodeInstanceGroupRepo_Expecter{mock: &_m.Mock}
}

// Delete provides a mock function for the type DataplaneNodeInstanceGroupRepo
func (_mock *DataplaneNodeInstanceGroupRepo) Delete(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string) error {
	ret := _mock.Called(ctx, dataplaneName, nodeSpec, primaryInstance)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - dataplaneName string
//   - nodeSpec string
//   - primaryInstance string
func (_e *DataplaneNodeInstanceGroupRepo_Expecter) Delete(ctx interface{}, dataplaneName interface{}, nodeSpec interface{}, primaryInstance interface{}) *DataplaneNodeInstanceGroupRepo_Delete_Call {
	return &DataplaneNodeInstanceGroupRepo_Delete_Call{Call: _e.mock.On("Delete", ctx, dataplaneName, nodeSpec, primaryInstance)}
}

func (_c *DataplaneNodeInstanceGroupRepo_Delete_Call) Run(run func(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string)) *DataplaneNodeInstanceGroupRepo_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *DataplaneNodeInstanceGroupRepo_Delete_Call) RunAndReturn(run func(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string) error) *DataplaneNodeInstanceGroupRepo_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteByDataplane provides a mock function for the type DataplaneNodeInstanceGroupRepo
func (_mock *DataplaneNodeInstanceGroupRepo) DeleteByDataplane(ctx context.Context, dataplaneName string) error {
	ret := _mock.Called(ctx, dataplaneName)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(ctx, dataplaneName)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// DeleteByDataplane is a helper method to define mock.On call
//   - ctx context.Context
//   - dataplaneName string
func (_e *DataplaneNodeInstanceGroupRepo_Expecter) DeleteByDataplane(ctx interface{}, dataplaneName interface{}) *DataplaneNodeInstanceGroupRepo_DeleteByDataplane_Call {
	return &DataplaneNodeInstanceGroupRepo_DeleteByDataplane_Call{Call: _e.mock.On("DeleteByDataplane", ctx, dataplaneName)}
}

func (_c *DataplaneNodeInstanceGroupRepo_DeleteByDataplane_Call) Run(run func(ctx context.Context, dataplaneName string)) *DataplaneNodeInstanceGroupRepo_DeleteByDataplane_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *DataplaneNodeInstanceGroupRepo_DeleteByDataplane_Call) RunAndReturn(run func(ctx context.Context, dataplaneName string) error) *DataplaneNodeInstanceGroupRepo_DeleteByDataplane_Call {
	_c.Call.Return(run)
	return _c
}

// ListByDataplane provides a mock function for the type DataplaneNodeInstanceGroupRepo
func (_mock *DataplaneNodeInstanceGroupRepo) ListByDataplane(ctx context.Context, dataplaneName string) ([]*entity.DataplaneNodeInstanceGroup, error) {
	ret := _mock.Called(ctx, dataplaneName)

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

	var r0 []*entity.DataplaneNodeInstanceGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*entity.DataplaneNodeInstanceGroup, error)); ok {
		return returnFunc(ctx, dataplaneName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*entity.DataplaneNodeInstanceGroup); ok {
		r0 = returnFunc(ctx, dataplaneName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.DataplaneNodeInstanceGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, dataplaneName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListByDataplane is a helper method to define mock.On call
//   - ctx context.Context
//   - dataplaneName string
func (_e *DataplaneNodeInstanceGroupRepo_Expecter) ListByDataplane(ctx interface{}, dataplaneName interface{}) *DataplaneNodeInstanceGroupRepo_ListByDataplane_Call {
	return &DataplaneNodeInstanceGroupRepo_ListByDataplane_Call{Call: _e.mock.On("ListByDataplane", ctx, dataplaneName)}
}

func (_c *DataplaneNodeInstanceGroupRepo_ListByDataplane_Call) Run(run func(ctx context.Context, dataplaneName string)) *DataplaneNodeInstanceGroupRepo_ListByDataplane_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *DataplaneNodeInstanceGroupRepo_ListByDataplane_Call) Return(vs []*entity.DataplaneNodeInstanceGroup, err error) *DataplaneNodeInstanceGroupRepo_ListByDataplane_Call {
	_c.Call.Return(vs, err)
	return _c
}

func (_c *DataplaneNodeInstanceGroupRepo_ListByDataplane_Call) RunAndReturn(run func(ctx context.Context, dataplaneName string) ([]*entity.DataplaneNodeInstanceGroup, error)) *DataplaneNodeInstanceGroupRepo_ListByDataplane_Call {
	_c.Call.Return(run)
	return _c
}

// ListBySpec provides a mock function for the type DataplaneNodeInstanceGroupRepo
func (_mock *DataplaneNodeInstanceGroupRepo) ListBySpec(ctx context.Context, nodeSpec string) ([]*entity.DataplaneNodeInstanceGroup, error) {
	ret := _mock.Called(ctx, nodeSpec)

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

	var r0 []*entity.DataplaneNodeInstanceGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*entity.DataplaneNodeInstanceGroup, error)); ok {
		return returnFunc(ctx, nodeSpec)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*entity.DataplaneNodeInstanceGroup); ok {
		r0 = returnFunc(ctx, nodeSpec)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.DataplaneNodeInstanceGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, nodeSpec)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListBySpec is a helper method to define mock.On call
//   - ctx context.Context
//   - nodeSpec string
func (_e *DataplaneNodeInstanceGroupRepo_Expecter) ListBySpec(ctx interface{}, nodeSpec interface{}) *DataplaneNodeInstanceGroupRepo_ListBySpec_Call {
	return &DataplaneNodeInstanceGroupRepo_ListBySpec_Call{Call: _e.mock.On("ListBySpec", ctx, nodeSpec)}
}

func (_c *DataplaneNodeInstanceGroupRepo_ListBySpec_Call) Run(run func(ctx context.Context, nodeSpec string)) *DataplaneNodeInstanceGroupRepo_ListBySpec_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *DataplaneNodeInstanceGroupRepo_ListBySpec_Call) Return(vs []*entity.DataplaneNodeInstanceGroup, err error) *DataplaneNodeInstanceGroupRepo_ListBySpec_Call {
	_c.Call.Return(vs, err)
	return _c
}

func (_c *DataplaneNodeInstanceGroupRepo_ListBySpec_Call) RunAndReturn(run func(ctx context.Context, nodeSpec string) ([]*entity.DataplaneNodeInstanceGroup, error)) *DataplaneNodeInstanceGroupRepo_ListBySpec_Call {
	_c.Call.Return(run)
	return _c
}

// LoadByDataplaneAndSpec provides a mock function for the type DataplaneNodeInstanceGroupRepo
func (_mock *DataplaneNodeInstanceGroupRepo) LoadByDataplaneAndSpec(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string) (*entity.DataplaneNodeInstanceGroup, error) {
	ret := _mock.Called(ctx, dataplaneName, nodeSpec, primaryInstance)

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

	var r0 *entity.DataplaneNodeInstanceGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*entity.DataplaneNodeInstanceGroup, error)); ok {
		return returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *entity.DataplaneNodeInstanceGroup); ok {
		r0 = returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.DataplaneNodeInstanceGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, dataplaneName, nodeSpec, primaryInstance)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// LoadByDataplaneAndSpec is a helper method to define mock.On call
//   - ctx context.Context
//   - dataplaneName string
//   - nodeSpec string
//   - primaryInstance string
func (_e *DataplaneNodeInstanceGroupRepo_Expecter) LoadByDataplaneAndSpec(ctx interface{}, dataplaneName interface{}, nodeSpec interface{}, primaryInstance interface{}) *DataplaneNodeInstanceGroupRepo_LoadByDataplaneAndSpec_Call {
	return &DataplaneNodeInstanceGroupRepo_LoadByDataplaneAndSpec_Call{Call: _e.mock.On("LoadByDataplaneAndSpec", ctx, dataplaneName, nodeSpec, primaryInstance)}
}

func (_c *DataplaneNodeInstanceGroupRepo_LoadByDataplaneAndSpec_Call) Run(run func(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string)) *DataplaneNodeInstanceGroupRepo_LoadByDataplaneAndSpec_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *DataplaneNodeInstanceGroupRepo_LoadByDataplaneAndSpec_Call) Return(v *entity.DataplaneNodeInstanceGroup, err error) *DataplaneNodeInstanceGroupRepo_LoadByDataplaneAndSpec_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *DataplaneNodeInstanceGroupRepo_LoadByDataplaneAndSpec_Call) RunAndReturn(run func(ctx context.Context, dataplaneName string, nodeSpec string, primaryInstance string) (*entity.DataplaneNodeInstanceGroup, error)) *DataplaneNodeInstanceGroupRepo_LoadByDataplaneAndSpec_Call {
	_c.Call.Return(run)
	return _c
}

// Save provides a mock function for the type DataplaneNodeInstanceGroupRepo
func (_mock *DataplaneNodeInstanceGroupRepo) Save(ctx context.Context, override *entity.DataplaneNodeInstanceGroup) error {
	ret := _mock.Called(ctx, override)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.DataplaneNodeInstanceGroup) error); ok {
		r0 = returnFunc(ctx, override)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Save is a helper method to define mock.On call
//   - ctx context.Context
//   - override *entity.DataplaneNodeInstanceGroup
func (_e *DataplaneNodeInstanceGroupRepo_Expecter) Save(ctx interface{}, override interface{}) *DataplaneNodeInstanceGroupRepo_Save_Call {
	return &DataplaneNodeInstanceGroupRepo_Save_Call{Call: _e.mock.On("Save", ctx, override)}
}

func (_c *DataplaneNodeInstanceGroupRepo_Save_Call) Run(run func(ctx context.Context, override *entity.DataplaneNodeInstanceGroup)) *DataplaneNodeInstanceGroupRepo_Save_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.DataplaneNodeInstanceGroup
		if args[1] != nil {
			arg1 = args[1].(*entity.DataplaneNodeInstanceGroup)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *DataplaneNodeInstanceGroupRepo_Save_Call) RunAndReturn(run func(ctx context.Context, override *entity.DataplaneNodeInstanceGroup) error) *DataplaneNodeInstanceGroupRepo_Save_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type ReservedNodeMeteringCheckpointRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *ReservedNodeMeteringCheckpointRepo) EXPECT() *ReservedNodeMeteringCheckpointRepo_Expecter {
	return &ReservedNodeMeteringCheckpointRepo_Expecter{mock: &_m.Mock}
}

// LoadLastSuccessfulMinute provides a mock function for the type ReservedNodeMeteringCheckpointRepo
func (_mock *ReservedNodeMeteringCheckpointRepo) LoadLastSuccessfulMinute(ctx context.Context, region string, cloudProvider string, dataplane string) (int64, error) {
	ret := _mock.Called(ctx, region, cloudProvider, dataplane)

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

	var r0 int64
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (int64, error)); ok {
		return returnFunc(ctx, region, cloudProvider, dataplane)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) int64); ok {
		r0 = returnFunc(ctx, region, cloudProvider, dataplane)
	} else {
		r0 = ret.Get(0).(int64)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, region, cloudProvider, dataplane)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// LoadLastSuccessfulMinute is a helper method to define mock.On call
//   - ctx context.Context
//   - region string
//   - cloudProvider string
//   - dataplane string
func (_e *ReservedNodeMeteringCheckpointRepo_Expecter) LoadLastSuccessfulMinute(ctx interface{}, region interface{}, cloudProvider interface{}, dataplane interface{}) *ReservedNodeMeteringCheckpointRepo_LoadLastSuccessfulMinute_Call {
	return &ReservedNodeMeteringCheckpointRepo_LoadLastSuccessfulMinute_Call{Call: _e.mock.On("LoadLastSuccessfulMinute", ctx, region, cloudProvider, dataplane)}
}

func (_c *ReservedNodeMeteringCheckpointRepo_LoadLastSuccessfulMinute_Call) Run(run func(ctx context.Context, region string, cloudProvider string, dataplane string)) *ReservedNodeMeteringCheckpointRepo_LoadLastSuccessfulMinute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *ReservedNodeMeteringCheckpointRepo_LoadLastSuccessfulMinute_Call) Return(n int64, err error) *ReservedNodeMeteringCheckpointRepo_LoadLastSuccessfulMinute_Call {
	_c.Call.Return(n, err)
	return _c
}

func (_c *ReservedNodeMeteringCheckpointRepo_LoadLastSuccessfulMinute_Call) RunAndReturn(run func(ctx context.Context, region string, cloudProvider string, dataplane string) (int64, error)) *ReservedNodeMeteringCheckpointRepo_LoadLastSuccessfulMinute_Call {
	_c.Call.Return(run)
	return _c
}

// SaveLastSuccessfulMinute provides a mock function for the type ReservedNodeMeteringCheckpointRepo
func (_mock *ReservedNodeMeteringCheckpointRepo) SaveLastSuccessfulMinute(ctx context.Context, region string, cloudProvider string, dataplane string, minuteTs int64) error {
	ret := _mock.Called(ctx, region, cloudProvider, dataplane, minuteTs)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, int64) error); ok {
		r0 = returnFunc(ctx, region, cloudProvider, dataplane, minuteTs)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SaveLastSuccessfulMinute is a helper method to define mock.On call
//   - ctx context.Context
//   - region string
//   - cloudProvider string
//   - dataplane string
//   - minuteTs int64
func (_e *ReservedNodeMeteringCheckpointRepo_Expecter) SaveLastSuccessfulMinute(ctx interface{}, region interface{}, cloudProvider interface{}, dataplane interface{}, minuteTs interface{}) *ReservedNodeMeteringCheckpointRepo_SaveLastSuccessfulMinute_Call {
	return &ReservedNodeMeteringCheckpointRepo_SaveLastSuccessfulMinute_Call{Call: _e.mock.On("SaveLastSuccessfulMinute", ctx, region, cloudProvider, dataplane, minuteTs)}
}

func (_c *ReservedNodeMeteringCheckpointRepo_SaveLastSuccessfulMinute_Call) Run(run func(ctx context.Context, region string, cloudProvider string, dataplane string, minuteTs int64)) *ReservedNodeMeteringCheckpointRepo_SaveLastSuccessfulMinute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 int64
		if args[4] != nil {
			arg4 = args[4].(int64)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *ReservedNodeMeteringCheckpointRepo_SaveLastSuccessfulMinute_Call) RunAndReturn(run func(ctx context.Context, region string, cloudProvider string, dataplane string, minuteTs int64) error) *ReservedNodeMeteringCheckpointRepo_SaveLastSuccessfulMinute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type RuConfigRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *RuConfigRepo) EXPECT() *RuConfigRepo_Expecter {
	return &RuConfigRepo_Expecter{mock: &_m.Mock}
}

// DeleteRuConfig provides a mock function for the type RuConfigRepo
func (_mock *RuConfigRepo) DeleteRuConfig(ctx context.Context, id string, scope entity.RuConfigScope) error {
	ret := _mock.Called(ctx, id, scope)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.RuConfigScope) error); ok {
		r0 = returnFunc(ctx, id, scope)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// DeleteRuConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - scope entity.RuConfigScope
func (_e *RuConfigRepo_Expecter) DeleteRuConfig(ctx interface{}, id interface{}, scope interface{}) *RuConfigRepo_DeleteRuConfig_Call {
	return &RuConfigRepo_DeleteRuConfig_Call{Call: _e.mock.On("DeleteRuConfig", ctx, id, scope)}
}

func (_c *RuConfigRepo_DeleteRuConfig_Call) Run(run func(ctx context.Context, id string, scope entity.RuConfigScope)) *RuConfigRepo_DeleteRuConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 entity.RuConfigScope
		if args[2] != nil {
			arg2 = args[2].(entity.RuConfigScope)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *RuConfigRepo_DeleteRuConfig_Call) RunAndReturn(run func(ctx context.Context, id string, scope entity.RuConfigScope) error) *RuConfigRepo_DeleteRuConfig_Call {
	_c.Call.Return(run)
	return _c
}

// GetFeatureFlags provides a mock function for the type RuConfigRepo
func (_mock *RuConfigRepo) GetFeatureFlags(ctx context.Context, id string, scope entity.RuConfigScope) (*entity.RuConfigFeatureFlags, error) {
	ret := _mock.Called(ctx, id, scope)

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

	var r0 *entity.RuConfigFeatureFlags
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.RuConfigScope) (*entity.RuConfigFeatureFlags, error)); ok {
		return returnFunc(ctx, id, scope)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.RuConfigScope) *entity.RuConfigFeatureFlags); ok {
		r0 = returnFunc(ctx, id, scope)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.RuConfigFeatureFlags)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, entity.RuConfigScope) error); ok {
		r1 = returnFunc(ctx, id, scope)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetFeatureFlags is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - scope entity.RuConfigScope
func (_e *RuConfigRepo_Expecter) GetFeatureFlags(ctx interface{}, id interface{}, scope interface{}) *RuConfigRepo_GetFeatureFlags_Call {
	return &RuConfigRepo_GetFeatureFlags_Call{Call: _e.mock.On("GetFeatureFlags", ctx, id, scope)}
}

func (_c *RuConfigRepo_GetFeatureFlags_Call) Run(run func(ctx context.Context, id string, scope entity.RuConfigScope)) *RuConfigRepo_GetFeatureFlags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 entity.RuConfigScope
		if args[2] != nil {
			arg2 = args[2].(entity.RuConfigScope)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *RuConfigRepo_GetFeatureFlags_Call) Return(v *entity.RuConfigFeatureFlags, err error) *RuConfigRepo_GetFeatureFlags_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *RuConfigRepo_GetFeatureFlags_Call) RunAndReturn(run func(ctx context.Context, id string, scope entity.RuConfigScope) (*entity.RuConfigFeatureFlags, error)) *RuConfigRepo_GetFeatureFlags_Call {
	_c.Call.Return(run)
	return _c
}

// GetRuConfig provides a mock function for the type RuConfigRepo
func (_mock *RuConfigRepo) GetRuConfig(ctx context.Context, id string, scope entity.RuConfigScope) (*entity.RuConfig, error) {
	ret := _mock.Called(ctx, id, scope)

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

	var r0 *entity.RuConfig
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.RuConfigScope) (*entity.RuConfig, error)); ok {
		return returnFunc(ctx, id, scope)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.RuConfigScope) *entity.RuConfig); ok {
		r0 = returnFunc(ctx, id, scope)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.RuConfig)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, entity.RuConfigScope) error); ok {
		r1 = returnFunc(ctx, id, scope)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetRuConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - scope entity.RuConfigScope
func (_e *RuConfigRepo_Expecter) GetRuConfig(ctx interface{}, id interface{}, scope interface{}) *RuConfigRepo_GetRuConfig_Call {
	return &RuConfigRepo_GetRuConfig_Call{Call: _e.mock.On("GetRuConfig", ctx, id, scope)}
}

func (_c *RuConfigRepo_GetRuConfig_Call) Run(run func(ctx context.Context, id string, scope entity.RuConfigScope)) *RuConfigRepo_GetRuConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 entity.RuConfigScope
		if args[2] != nil {
			arg2 = args[2].(entity.RuConfigScope)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *RuConfigRepo_GetRuConfig_Call) Return(ruConfig *entity.RuConfig, err error) *RuConfigRepo_GetRuConfig_Call {
	_c.Call.Return(ruConfig, err)
	return _c
}

func (_c *RuConfigRepo_GetRuConfig_Call) RunAndReturn(run func(ctx context.Context, id string, scope entity.RuConfigScope) (*entity.RuConfig, error)) *RuConfigRepo_GetRuConfig_Call {
	_c.Call.Return(run)
	return _c
}

// GetRuConfigWithFound provides a mock function for the type RuConfigRepo
func (_mock *RuConfigRepo) GetRuConfigWithFound(ctx context.Context, id string, scope entity.RuConfigScope) (*entity.RuConfig, bool, error) {
	hasWithFoundExpectation := false
	hasLegacyExpectation := false
	for _, call := range _mock.ExpectedCalls {
		switch call.Method {
		case "GetRuConfigWithFound":
			hasWithFoundExpectation = true
		case "GetRuConfig":
			hasLegacyExpectation = true
		}
	}
	if !hasWithFoundExpectation && hasLegacyExpectation {
		ruConfig, err := _mock.GetRuConfig(ctx, id, scope)
		return ruConfig, err == nil, err
	}

	ret := _mock.Called(ctx, id, scope)

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

	var r0 *entity.RuConfig
	var r1 bool
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.RuConfigScope) (*entity.RuConfig, bool, error)); ok {
		return returnFunc(ctx, id, scope)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.RuConfigScope) *entity.RuConfig); ok {
		r0 = returnFunc(ctx, id, scope)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.RuConfig)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, entity.RuConfigScope) bool); ok {
		r1 = returnFunc(ctx, id, scope)
	} else {
		r1 = ret.Get(1).(bool)
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, string, entity.RuConfigScope) error); ok {
		r2 = returnFunc(ctx, id, scope)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// GetRuConfigWithFound is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - scope entity.RuConfigScope
func (_e *RuConfigRepo_Expecter) GetRuConfigWithFound(ctx interface{}, id interface{}, scope interface{}) *RuConfigRepo_GetRuConfigWithFound_Call {
	return &RuConfigRepo_GetRuConfigWithFound_Call{Call: _e.mock.On("GetRuConfigWithFound", ctx, id, scope)}
}

func (_c *RuConfigRepo_GetRuConfigWithFound_Call) Run(run func(ctx context.Context, id string, scope entity.RuConfigScope)) *RuConfigRepo_GetRuConfigWithFound_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 entity.RuConfigScope
		if args[2] != nil {
			arg2 = args[2].(entity.RuConfigScope)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *RuConfigRepo_GetRuConfigWithFound_Call) Return(ruConfig *entity.RuConfig, found bool, err error) *RuConfigRepo_GetRuConfigWithFound_Call {
	_c.Call.Return(ruConfig, found, err)
	return _c
}

func (_c *RuConfigRepo_GetRuConfigWithFound_Call) RunAndReturn(run func(ctx context.Context, id string, scope entity.RuConfigScope) (*entity.RuConfig, bool, error)) *RuConfigRepo_GetRuConfigWithFound_Call {
	_c.Call.Return(run)
	return _c
}

// GetServerDefaultRuConfig provides a mock function for the type RuConfigRepo
func (_mock *RuConfigRepo) GetServerDefaultRuConfig(ctx context.Context) (*entity.RuConfig, error) {
	ret := _mock.Called(ctx)

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

	var r0 *entity.RuConfig
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (*entity.RuConfig, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) *entity.RuConfig); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.RuConfig)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetServerDefaultRuConfig is a helper method to define mock.On call
//   - ctx context.Context
func (_e *RuConfigRepo_Expecter) GetServerDefaultRuConfig(ctx interface{}) *RuConfigRepo_GetServerDefaultRuConfig_Call {
	return &RuConfigRepo_GetServerDefaultRuConfig_Call{Call: _e.mock.On("GetServerDefaultRuConfig", ctx)}
}

func (_c *RuConfigRepo_GetServerDefaultRuConfig_Call) Run(run func(ctx context.Context)) *RuConfigRepo_GetServerDefaultRuConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *RuConfigRepo_GetServerDefaultRuConfig_Call) Return(ruConfig *entity.RuConfig, err error) *RuConfigRepo_GetServerDefaultRuConfig_Call {
	_c.Call.Return(ruConfig, err)
	return _c
}

func (_c *RuConfigRepo_GetServerDefaultRuConfig_Call) RunAndReturn(run func(ctx context.Context) (*entity.RuConfig, error)) *RuConfigRepo_GetServerDefaultRuConfig_Call {
	_c.Call.Return(run)
	return _c
}

// PatchFeatureFlags provides a mock function for the type RuConfigRepo
func (_mock *RuConfigRepo) PatchFeatureFlags(ctx context.Context, id string, scope entity.RuConfigScope, patch repo.FeatureFlagsPatch) error {
	ret := _mock.Called(ctx, id, scope, patch)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.RuConfigScope, repo.FeatureFlagsPatch) error); ok {
		r0 = returnFunc(ctx, id, scope, patch)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// PatchFeatureFlags is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - scope entity.RuConfigScope
//   - patch repo.FeatureFlagsPatch
func (_e *RuConfigRepo_Expecter) PatchFeatureFlags(ctx interface{}, id interface{}, scope interface{}, patch interface{}) *RuConfigRepo_PatchFeatureFlags_Call {
	return &RuConfigRepo_PatchFeatureFlags_Call{Call: _e.mock.On("PatchFeatureFlags", ctx, id, scope, patch)}
}

func (_c *RuConfigRepo_PatchFeatureFlags_Call) Run(run func(ctx context.Context, id string, scope entity.RuConfigScope, patch repo.FeatureFlagsPatch)) *RuConfigRepo_PatchFeatureFlags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 entity.RuConfigScope
		if args[2] != nil {
			arg2 = args[2].(entity.RuConfigScope)
		}
		var arg3 repo.FeatureFlagsPatch
		if args[3] != nil {
			arg3 = args[3].(repo.FeatureFlagsPatch)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *RuConfigRepo_PatchFeatureFlags_Call) RunAndReturn(run func(ctx context.Context, id string, scope entity.RuConfigScope, patch repo.FeatureFlagsPatch) error) *RuConfigRepo_PatchFeatureFlags_Call {
	_c.Call.Return(run)
	return _c
}

// ReplaceFeatureFlags provides a mock function for the type RuConfigRepo
func (_mock *RuConfigRepo) ReplaceFeatureFlags(ctx context.Context, id string, scope entity.RuConfigScope, flags *entity.RuConfigFeatureFlags) error {
	ret := _mock.Called(ctx, id, scope, flags)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.RuConfigScope, *entity.RuConfigFeatureFlags) error); ok {
		r0 = returnFunc(ctx, id, scope, flags)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ReplaceFeatureFlags is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - scope entity.RuConfigScope
//   - flags *entity.RuConfigFeatureFlags
func (_e *RuConfigRepo_Expecter) ReplaceFeatureFlags(ctx interface{}, id interface{}, scope interface{}, flags interface{}) *RuConfigRepo_ReplaceFeatureFlags_Call {
	return &RuConfigRepo_ReplaceFeatureFlags_Call{Call: _e.mock.On("ReplaceFeatureFlags", ctx, id, scope, flags)}
}

func (_c *RuConfigRepo_ReplaceFeatureFlags_Call) Run(run func(ctx context.Context, id string, scope entity.RuConfigScope, flags *entity.RuConfigFeatureFlags)) *RuConfigRepo_ReplaceFeatureFlags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 entity.RuConfigScope
		if args[2] != nil {
			arg2 = args[2].(entity.RuConfigScope)
		}
		var arg3 *entity.RuConfigFeatureFlags
		if args[3] != nil {
			arg3 = args[3].(*entity.RuConfigFeatureFlags)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *RuConfigRepo_ReplaceFeatureFlags_Call) RunAndReturn(run func(ctx context.Context, id string, scope entity.RuConfigScope, flags *entity.RuConfigFeatureFlags) error) *RuConfigRepo_ReplaceFeatureFlags_Call {
	_c.Call.Return(run)
	return _c
}

// SetRuConfig provides a mock function for the type RuConfigRepo
func (_mock *RuConfigRepo) SetRuConfig(ctx context.Context, id string, scope entity.RuConfigScope, ruConfig *entity.RuConfig) error {
	ret := _mock.Called(ctx, id, scope, ruConfig)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.RuConfigScope, *entity.RuConfig) error); ok {
		r0 = returnFunc(ctx, id, scope, ruConfig)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetRuConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - scope entity.RuConfigScope
//   - ruConfig *entity.RuConfig
func (_e *RuConfigRepo_Expecter) SetRuConfig(ctx interface{}, id interface{}, scope interface{}, ruConfig interface{}) *RuConfigRepo_SetRuConfig_Call {
	return &RuConfigRepo_SetRuConfig_Call{Call: _e.mock.On("SetRuConfig", ctx, id, scope, ruConfig)}
}

func (_c *RuConfigRepo_SetRuConfig_Call) Run(run func(ctx context.Context, id string, scope entity.RuConfigScope, ruConfig *entity.RuConfig)) *RuConfigRepo_SetRuConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 entity.RuConfigScope
		if args[2] != nil {
			arg2 = args[2].(entity.RuConfigScope)
		}
		var arg3 *entity.RuConfig
		if args[3] != nil {
			arg3 = args[3].(*entity.RuConfig)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *RuConfigRepo_SetRuConfig_Call) RunAndReturn(run func(ctx context.Context, id string, scope entity.RuConfigScope, ruConfig *entity.RuConfig) error) *RuConfigRepo_SetRuConfig_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type ScaleOperationRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *ScaleOperationRepo) EXPECT() *ScaleOperationRepo_Expecter {
	return &ScaleOperationRepo_Expecter{mock: &_m.Mock}
}

// Create provides a mock function for the type ScaleOperationRepo
func (_mock *ScaleOperationRepo) Create(ctx context.Context, operation *entity.ScaleOperation) error {
	ret := _mock.Called(ctx, operation)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.ScaleOperation) error); ok {
		r0 = returnFunc(ctx, operation)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - operation *entity.ScaleOperation
func (_e *ScaleOperationRepo_Expecter) Create(ctx interface{}, operation interface{}) *ScaleOperationRepo_Create_Call {
	return &ScaleOperationRepo_Create_Call{Call: _e.mock.On("Create", ctx, operation)}
}

func (_c *ScaleOperationRepo_Create_Call) Run(run func(ctx context.Context, operation *entity.ScaleOperation)) *ScaleOperationRepo_Create_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.ScaleOperation
		if args[1] != nil {
			arg1 = args[1].(*entity.ScaleOperation)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *ScaleOperationRepo_Create_Call) RunAndReturn(run func(ctx context.Context, operation *entity.ScaleOperation) error) *ScaleOperationRepo_Create_Call {
	_c.Call.Return(run)
	return _c
}

// FindActiveByComponent provides a mock function for the type ScaleOperationRepo
func (_mock *ScaleOperationRepo) FindActiveByComponent(ctx context.Context, sharedPoolID string, componentID string) ([]*entity.ScaleOperation, error) {
	ret := _mock.Called(ctx, sharedPoolID, componentID)

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

	var r0 []*entity.ScaleOperation
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]*entity.ScaleOperation, error)); ok {
		return returnFunc(ctx, sharedPoolID, componentID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []*entity.ScaleOperation); ok {
		r0 = returnFunc(ctx, sharedPoolID, componentID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.ScaleOperation)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolID, componentID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// FindActiveByComponent is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolID string
//   - componentID string
func (_e *ScaleOperationRepo_Expecter) FindActiveByComponent(ctx interface{}, sharedPoolID interface{}, componentID interface{}) *ScaleOperationRepo_FindActiveByComponent_Call {
	return &ScaleOperationRepo_FindActiveByComponent_Call{Call: _e.mock.On("FindActiveByComponent", ctx, sharedPoolID, componentID)}
}

func (_c *ScaleOperationRepo_FindActiveByComponent_Call) Run(run func(ctx context.Context, sharedPoolID string, componentID string)) *ScaleOperationRepo_FindActiveByComponent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *ScaleOperationRepo_FindActiveByComponent_Call) Return(scaleOperations []*entity.ScaleOperation, err error) *ScaleOperationRepo_FindActiveByComponent_Call {
	_c.Call.Return(scaleOperations, err)
	return _c
}

func (_c *ScaleOperationRepo_FindActiveByComponent_Call) RunAndReturn(run func(ctx context.Context, sharedPoolID string, componentID string) ([]*entity.ScaleOperation, error)) *ScaleOperationRepo_FindActiveByComponent_Call {
	_c.Call.Return(run)
	return _c
}

// ListNonTerminal provides a mock function for the type ScaleOperationRepo
func (_mock *ScaleOperationRepo) ListNonTerminal(ctx context.Context, limit int) ([]*entity.ScaleOperation, error) {
	ret := _mock.Called(ctx, limit)

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

	var r0 []*entity.ScaleOperation
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]*entity.ScaleOperation, error)); ok {
		return returnFunc(ctx, limit)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, int) []*entity.ScaleOperation); ok {
		r0 = returnFunc(ctx, limit)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.ScaleOperation)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
		r1 = returnFunc(ctx, limit)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListNonTerminal is a helper method to define mock.On call
//   - ctx context.Context
//   - limit int
func (_e *ScaleOperationRepo_Expecter) ListNonTerminal(ctx interface{}, limit interface{}) *ScaleOperationRepo_ListNonTerminal_Call {
	return &ScaleOperationRepo_ListNonTerminal_Call{Call: _e.mock.On("ListNonTerminal", ctx, limit)}
}

func (_c *ScaleOperationRepo_ListNonTerminal_Call) Run(run func(ctx context.Context, limit int)) *ScaleOperationRepo_ListNonTerminal_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ScaleOperationRepo_ListNonTerminal_Call) Return(scaleOperations []*entity.ScaleOperation, err error) *ScaleOperationRepo_ListNonTerminal_Call {
	_c.Call.Return(scaleOperations, err)
	return _c
}

func (_c *ScaleOperationRepo_ListNonTerminal_Call) RunAndReturn(run func(ctx context.Context, limit int) ([]*entity.ScaleOperation, error)) *ScaleOperationRepo_ListNonTerminal_Call {
	_c.Call.Return(run)
	return _c
}

// LoadByID provides a mock function for the type ScaleOperationRepo
func (_mock *ScaleOperationRepo) LoadByID(ctx context.Context, sharedPoolID string, scaleOperationID string, includeDeleted bool) (*entity.ScaleOperation, error) {
	ret := _mock.Called(ctx, sharedPoolID, scaleOperationID, includeDeleted)

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

	var r0 *entity.ScaleOperation
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, bool) (*entity.ScaleOperation, error)); ok {
		return returnFunc(ctx, sharedPoolID, scaleOperationID, includeDeleted)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, bool) *entity.ScaleOperation); ok {
		r0 = returnFunc(ctx, sharedPoolID, scaleOperationID, includeDeleted)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.ScaleOperation)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, bool) error); ok {
		r1 = returnFunc(ctx, sharedPoolID, scaleOperationID, includeDeleted)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// LoadByID is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolID string
//   - scaleOperationID string
//   - includeDeleted bool
func (_e *ScaleOperationRepo_Expecter) LoadByID(ctx interface{}, sharedPoolID interface{}, scaleOperationID interface{}, includeDeleted interface{}) *ScaleOperationRepo_LoadByID_Call {
	return &ScaleOperationRepo_LoadByID_Call{Call: _e.mock.On("LoadByID", ctx, sharedPoolID, scaleOperationID, includeDeleted)}
}

func (_c *ScaleOperationRepo_LoadByID_Call) Run(run func(ctx context.Context, sharedPoolID string, scaleOperationID string, includeDeleted bool)) *ScaleOperationRepo_LoadByID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 bool
		if args[3] != nil {
			arg3 = args[3].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *ScaleOperationRepo_LoadByID_Call) Return(scaleOperation *entity.ScaleOperation, err error) *ScaleOperationRepo_LoadByID_Call {
	_c.Call.Return(scaleOperation, err)
	return _c
}

func (_c *ScaleOperationRepo_LoadByID_Call) RunAndReturn(run func(ctx context.Context, sharedPoolID string, scaleOperationID string, includeDeleted bool) (*entity.ScaleOperation, error)) *ScaleOperationRepo_LoadByID_Call {
	_c.Call.Return(run)
	return _c
}

// Save provides a mock function for the type ScaleOperationRepo
func (_mock *ScaleOperationRepo) Save(ctx context.Context, operation *entity.ScaleOperation) error {
	ret := _mock.Called(ctx, operation)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.ScaleOperation) error); ok {
		r0 = returnFunc(ctx, operation)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Save is a helper method to define mock.On call
//   - ctx context.Context
//   - operation *entity.ScaleOperation
func (_e *ScaleOperationRepo_Expecter) Save(ctx interface{}, operation interface{}) *ScaleOperationRepo_Save_Call {
	return &ScaleOperationRepo_Save_Call{Call: _e.mock.On("Save", ctx, operation)}
}

func (_c *ScaleOperationRepo_Save_Call) Run(run func(ctx context.Context, operation *entity.ScaleOperation)) *ScaleOperationRepo_Save_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.ScaleOperation
		if args[1] != nil {
			arg1 = args[1].(*entity.ScaleOperation)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *ScaleOperationRepo_Save_Call) RunAndReturn(run func(ctx context.Context, operation *entity.ScaleOperation) error) *ScaleOperationRepo_Save_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type ScaleTikvDecisionRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *ScaleTikvDecisionRepo) EXPECT() *ScaleTikvDecisionRepo_Expecter {
	return &ScaleTikvDecisionRepo_Expecter{mock: &_m.Mock}
}

// Create provides a mock function for the type ScaleTikvDecisionRepo
func (_mock *ScaleTikvDecisionRepo) Create(ctx context.Context, scaleTikvDecision *schema.ScaleTikvDecision) error {
	ret := _mock.Called(ctx, scaleTikvDecision)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *schema.ScaleTikvDecision) error); ok {
		r0 = returnFunc(ctx, scaleTikvDecision)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - scaleTikvDecision *schema.ScaleTikvDecision
func (_e *ScaleTikvDecisionRepo_Expecter) Create(ctx interface{}, scaleTikvDecision interface{}) *ScaleTikvDecisionRepo_Create_Call {
	return &ScaleTikvDecisionRepo_Create_Call{Call: _e.mock.On("Create", ctx, scaleTikvDecision)}
}

func (_c *ScaleTikvDecisionRepo_Create_Call) Run(run func(ctx context.Context, scaleTikvDecision *schema.ScaleTikvDecision)) *ScaleTikvDecisionRepo_Create_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *schema.ScaleTikvDecision
		if args[1] != nil {
			arg1 = args[1].(*schema.ScaleTikvDecision)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *ScaleTikvDecisionRepo_Create_Call) RunAndReturn(run func(ctx context.Context, scaleTikvDecision *schema.ScaleTikvDecision) error) *ScaleTikvDecisionRepo_Create_Call {
	_c.Call.Return(run)
	return _c
}

// Delete provides a mock function for the type ScaleTikvDecisionRepo
func (_mock *ScaleTikvDecisionRepo) Delete(ctx context.Context, id uint) error {
	ret := _mock.Called(ctx, id)

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

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

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - id uint
func (_e *ScaleTikvDecisionRepo_Expecter) Delete(ctx interface{}, id interface{}) *ScaleTikvDecisionRepo_Delete_Call {
	return &ScaleTikvDecisionRepo_Delete_Call{Call: _e.mock.On("Delete", ctx, id)}
}

func (_c *ScaleTikvDecisionRepo_Delete_Call) Run(run func(ctx context.Context, id uint)) *ScaleTikvDecisionRepo_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint
		if args[1] != nil {
			arg1 = args[1].(uint)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *ScaleTikvDecisionRepo_Delete_Call) RunAndReturn(run func(ctx context.Context, id uint) error) *ScaleTikvDecisionRepo_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// List provides a mock function for the type ScaleTikvDecisionRepo
func (_mock *ScaleTikvDecisionRepo) List(ctx context.Context, filter *repo.ScaleTikvDecisionFilter) ([]*schema.ScaleTikvDecision, error) {
	ret := _mock.Called(ctx, filter)

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

	var r0 []*schema.ScaleTikvDecision
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *repo.ScaleTikvDecisionFilter) ([]*schema.ScaleTikvDecision, error)); ok {
		return returnFunc(ctx, filter)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *repo.ScaleTikvDecisionFilter) []*schema.ScaleTikvDecision); ok {
		r0 = returnFunc(ctx, filter)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*schema.ScaleTikvDecision)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *repo.ScaleTikvDecisionFilter) error); ok {
		r1 = returnFunc(ctx, filter)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// List is a helper method to define mock.On call
//   - ctx context.Context
//   - filter *repo.ScaleTikvDecisionFilter
func (_e *ScaleTikvDecisionRepo_Expecter) List(ctx interface{}, filter interface{}) *ScaleTikvDecisionRepo_List_Call {
	return &ScaleTikvDecisionRepo_List_Call{Call: _e.mock.On("List", ctx, filter)}
}

func (_c *ScaleTikvDecisionRepo_List_Call) Run(run func(ctx context.Context, filter *repo.ScaleTikvDecisionFilter)) *ScaleTikvDecisionRepo_List_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *repo.ScaleTikvDecisionFilter
		if args[1] != nil {
			arg1 = args[1].(*repo.ScaleTikvDecisionFilter)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ScaleTikvDecisionRepo_List_Call) Return(scaleTikvDecisions []*schema.ScaleTikvDecision, err error) *ScaleTikvDecisionRepo_List_Call {
	_c.Call.Return(scaleTikvDecisions, err)
	return _c
}

func (_c *ScaleTikvDecisionRepo_List_Call) RunAndReturn(run func(ctx context.Context, filter *repo.ScaleTikvDecisionFilter) ([]*schema.ScaleTikvDecision, error)) *ScaleTikvDecisionRepo_List_Call {
	_c.Call.Return(run)
	return _c
}

// Load provides a mock function for the type ScaleTikvDecisionRepo
func (_mock *ScaleTikvDecisionRepo) Load(ctx context.Context, id uint, includeDeleted bool) (*schema.ScaleTikvDecision, error) {
	ret := _mock.Called(ctx, id, includeDeleted)

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

	var r0 *schema.ScaleTikvDecision
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint, bool) (*schema.ScaleTikvDecision, error)); ok {
		return returnFunc(ctx, id, includeDeleted)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint, bool) *schema.ScaleTikvDecision); ok {
		r0 = returnFunc(ctx, id, includeDeleted)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*schema.ScaleTikvDecision)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, uint, bool) error); ok {
		r1 = returnFunc(ctx, id, includeDeleted)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Load is a helper method to define mock.On call
//   - ctx context.Context
//   - id uint
//   - includeDeleted bool
func (_e *ScaleTikvDecisionRepo_Expecter) Load(ctx interface{}, id interface{}, includeDeleted interface{}) *ScaleTikvDecisionRepo_Load_Call {
	return &ScaleTikvDecisionRepo_Load_Call{Call: _e.mock.On("Load", ctx, id, includeDeleted)}
}

func (_c *ScaleTikvDecisionRepo_Load_Call) Run(run func(ctx context.Context, id uint, includeDeleted bool)) *ScaleTikvDecisionRepo_Load_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint
		if args[1] != nil {
			arg1 = args[1].(uint)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *ScaleTikvDecisionRepo_Load_Call) Return(scaleTikvDecision *schema.ScaleTikvDecision, err error) *ScaleTikvDecisionRepo_Load_Call {
	_c.Call.Return(scaleTikvDecision, err)
	return _c
}

func (_c *ScaleTikvDecisionRepo_Load_Call) RunAndReturn(run func(ctx context.Context, id uint, includeDeleted bool) (*schema.ScaleTikvDecision, error)) *ScaleTikvDecisionRepo_Load_Call {
	_c.Call.Return(run)
	return _c
}

// Save provides a mock function for the type ScaleTikvDecisionRepo
func (_mock *ScaleTikvDecisionRepo) Save(ctx context.Context, scaleTikvDecision *schema.ScaleTikvDecision) error {
	ret := _mock.Called(ctx, scaleTikvDecision)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *schema.ScaleTikvDecision) error); ok {
		r0 = returnFunc(ctx, scaleTikvDecision)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Save is a helper method to define mock.On call
//   - ctx context.Context
//   - scaleTikvDecision *schema.ScaleTikvDecision
func (_e *ScaleTikvDecisionRepo_Expecter) Save(ctx interface{}, scaleTikvDecision interface{}) *ScaleTikvDecisionRepo_Save_Call {
	return &ScaleTikvDecisionRepo_Save_Call{Call: _e.mock.On("Save", ctx, scaleTikvDecision)}
}

func (_c *ScaleTikvDecisionRepo_Save_Call) Run(run func(ctx context.Context, scaleTikvDecision *schema.ScaleTikvDecision)) *ScaleTikvDecisionRepo_Save_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *schema.ScaleTikvDecision
		if args[1] != nil {
			arg1 = args[1].(*schema.ScaleTikvDecision)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *ScaleTikvDecisionRepo_Save_Call) RunAndReturn(run func(ctx context.Context, scaleTikvDecision *schema.ScaleTikvDecision) error) *ScaleTikvDecisionRepo_Save_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type SharedPoolRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *SharedPoolRepo) EXPECT() *SharedPoolRepo_Expecter {
	return &SharedPoolRepo_Expecter{mock: &_m.Mock}
}

// Delete provides a mock function for the type SharedPoolRepo
func (_mock *SharedPoolRepo) Delete(ctx context.Context, id string) error {
	ret := _mock.Called(ctx, id)

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

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

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *SharedPoolRepo_Expecter) Delete(ctx interface{}, id interface{}) *SharedPoolRepo_Delete_Call {
	return &SharedPoolRepo_Delete_Call{Call: _e.mock.On("Delete", ctx, id)}
}

func (_c *SharedPoolRepo_Delete_Call) Run(run func(ctx context.Context, id string)) *SharedPoolRepo_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *SharedPoolRepo_Delete_Call) RunAndReturn(run func(ctx context.Context, id string) error) *SharedPoolRepo_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// List provides a mock function for the type SharedPoolRepo
func (_mock *SharedPoolRepo) List(ctx context.Context, filter *repo.SharedPoolFilter) ([]*entity.SharedPool, error) {
	ret := _mock.Called(ctx, filter)

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

	var r0 []*entity.SharedPool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *repo.SharedPoolFilter) ([]*entity.SharedPool, error)); ok {
		return returnFunc(ctx, filter)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *repo.SharedPoolFilter) []*entity.SharedPool); ok {
		r0 = returnFunc(ctx, filter)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.SharedPool)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *repo.SharedPoolFilter) error); ok {
		r1 = returnFunc(ctx, filter)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// List is a helper method to define mock.On call
//   - ctx context.Context
//   - filter *repo.SharedPoolFilter
func (_e *SharedPoolRepo_Expecter) List(ctx interface{}, filter interface{}) *SharedPoolRepo_List_Call {
	return &SharedPoolRepo_List_Call{Call: _e.mock.On("List", ctx, filter)}
}

func (_c *SharedPoolRepo_List_Call) Run(run func(ctx context.Context, filter *repo.SharedPoolFilter)) *SharedPoolRepo_List_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *repo.SharedPoolFilter
		if args[1] != nil {
			arg1 = args[1].(*repo.SharedPoolFilter)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *SharedPoolRepo_List_Call) Return(sharedPools []*entity.SharedPool, err error) *SharedPoolRepo_List_Call {
	_c.Call.Return(sharedPools, err)
	return _c
}

func (_c *SharedPoolRepo_List_Call) RunAndReturn(run func(ctx context.Context, filter *repo.SharedPoolFilter) ([]*entity.SharedPool, error)) *SharedPoolRepo_List_Call {
	_c.Call.Return(run)
	return _c
}

// Load provides a mock function for the type SharedPoolRepo
func (_mock *SharedPoolRepo) Load(ctx context.Context, id string, deleted bool) (*entity.SharedPool, error) {
	ret := _mock.Called(ctx, id, deleted)

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

	var r0 *entity.SharedPool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) (*entity.SharedPool, error)); ok {
		return returnFunc(ctx, id, deleted)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) *entity.SharedPool); ok {
		r0 = returnFunc(ctx, id, deleted)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.SharedPool)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
		r1 = returnFunc(ctx, id, deleted)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Load is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - deleted bool
func (_e *SharedPoolRepo_Expecter) Load(ctx interface{}, id interface{}, deleted interface{}) *SharedPoolRepo_Load_Call {
	return &SharedPoolRepo_Load_Call{Call: _e.mock.On("Load", ctx, id, deleted)}
}

func (_c *SharedPoolRepo_Load_Call) Run(run func(ctx context.Context, id string, deleted bool)) *SharedPoolRepo_Load_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SharedPoolRepo_Load_Call) Return(sharedPool *entity.SharedPool, err error) *SharedPoolRepo_Load_Call {
	_c.Call.Return(sharedPool, err)
	return _c
}

func (_c *SharedPoolRepo_Load_Call) RunAndReturn(run func(ctx context.Context, id string, deleted bool) (*entity.SharedPool, error)) *SharedPoolRepo_Load_Call {
	_c.Call.Return(run)
	return _c
}

// LoadDataplaneName provides a mock function for the type SharedPoolRepo
func (_mock *SharedPoolRepo) LoadDataplaneName(ctx context.Context, id string, deleted bool) (string, error) {
	ret := _mock.Called(ctx, id, deleted)

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

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) (string, error)); ok {
		return returnFunc(ctx, id, deleted)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) string); ok {
		r0 = returnFunc(ctx, id, deleted)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
		r1 = returnFunc(ctx, id, deleted)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// LoadDataplaneName is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - deleted bool
func (_e *SharedPoolRepo_Expecter) LoadDataplaneName(ctx interface{}, id interface{}, deleted interface{}) *SharedPoolRepo_LoadDataplaneName_Call {
	return &SharedPoolRepo_LoadDataplaneName_Call{Call: _e.mock.On("LoadDataplaneName", ctx, id, deleted)}
}

func (_c *SharedPoolRepo_LoadDataplaneName_Call) Run(run func(ctx context.Context, id string, deleted bool)) *SharedPoolRepo_LoadDataplaneName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SharedPoolRepo_LoadDataplaneName_Call) Return(s string, err error) *SharedPoolRepo_LoadDataplaneName_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *SharedPoolRepo_LoadDataplaneName_Call) RunAndReturn(run func(ctx context.Context, id string, deleted bool) (string, error)) *SharedPoolRepo_LoadDataplaneName_Call {
	_c.Call.Return(run)
	return _c
}

// Save provides a mock function for the type SharedPoolRepo
func (_mock *SharedPoolRepo) Save(ctx context.Context, sharedPool *entity.SharedPool) error {
	ret := _mock.Called(ctx, sharedPool)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.SharedPool) error); ok {
		r0 = returnFunc(ctx, sharedPool)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Save is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPool *entity.SharedPool
func (_e *SharedPoolRepo_Expecter) Save(ctx interface{}, sharedPool interface{}) *SharedPoolRepo_Save_Call {
	return &SharedPoolRepo_Save_Call{Call: _e.mock.On("Save", ctx, sharedPool)}
}

func (_c *SharedPoolRepo_Save_Call) Run(run func(ctx context.Context, sharedPool *entity.SharedPool)) *SharedPoolRepo_Save_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.SharedPool
		if args[1] != nil {
			arg1 = args[1].(*entity.SharedPool)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *SharedPoolRepo_Save_Call) RunAndReturn(run func(ctx context.Context, sharedPool *entity.SharedPool) error) *SharedPoolRepo_Save_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePauseResumeState provides a mock function for the type SharedPoolRepo
func (_mock *SharedPoolRepo) UpdatePauseResumeState(ctx context.Context, id string, state entity.PauseResumeState, suspendComputeDesired bool) error {
	ret := _mock.Called(ctx, id, state, suspendComputeDesired)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.PauseResumeState, bool) error); ok {
		r0 = returnFunc(ctx, id, state, suspendComputeDesired)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// UpdatePauseResumeState is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - state entity.PauseResumeState
//   - suspendComputeDesired bool
func (_e *SharedPoolRepo_Expecter) UpdatePauseResumeState(ctx interface{}, id interface{}, state interface{}, suspendComputeDesired interface{}) *SharedPoolRepo_UpdatePauseResumeState_Call {
	return &SharedPoolRepo_UpdatePauseResumeState_Call{Call: _e.mock.On("UpdatePauseResumeState", ctx, id, state, suspendComputeDesired)}
}

func (_c *SharedPoolRepo_UpdatePauseResumeState_Call) Run(run func(ctx context.Context, id string, state entity.PauseResumeState, suspendComputeDesired bool)) *SharedPoolRepo_UpdatePauseResumeState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 entity.PauseResumeState
		if args[2] != nil {
			arg2 = args[2].(entity.PauseResumeState)
		}
		var arg3 bool
		if args[3] != nil {
			arg3 = args[3].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *SharedPoolRepo_UpdatePauseResumeState_Call) RunAndReturn(run func(ctx context.Context, id string, state entity.PauseResumeState, suspendComputeDesired bool) error) *SharedPoolRepo_UpdatePauseResumeState_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type PauseResumeOperationRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *PauseResumeOperationRepo) EXPECT() *PauseResumeOperationRepo_Expecter {
	return &PauseResumeOperationRepo_Expecter{mock: &_m.Mock}
}

// CancelIfRunning provides a mock function for the type PauseResumeOperationRepo
func (_mock *PauseResumeOperationRepo) CancelIfRunning(ctx context.Context, sharedPoolID string, operationID string, reason string, completedAt time.Time) (bool, error) {
	ret := _mock.Called(ctx, sharedPoolID, operationID, reason, completedAt)

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

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, time.Time) (bool, error)); ok {
		return returnFunc(ctx, sharedPoolID, operationID, reason, completedAt)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, time.Time) bool); ok {
		r0 = returnFunc(ctx, sharedPoolID, operationID, reason, completedAt)
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, time.Time) error); ok {
		r1 = returnFunc(ctx, sharedPoolID, operationID, reason, completedAt)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CancelIfRunning is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolID string
//   - operationID string
//   - reason string
//   - completedAt time.Time
func (_e *PauseResumeOperationRepo_Expecter) CancelIfRunning(ctx interface{}, sharedPoolID interface{}, operationID interface{}, reason interface{}, completedAt interface{}) *PauseResumeOperationRepo_CancelIfRunning_Call {
	return &PauseResumeOperationRepo_CancelIfRunning_Call{Call: _e.mock.On("CancelIfRunning", ctx, sharedPoolID, operationID, reason, completedAt)}
}

func (_c *PauseResumeOperationRepo_CancelIfRunning_Call) Run(run func(ctx context.Context, sharedPoolID string, operationID string, reason string, completedAt time.Time)) *PauseResumeOperationRepo_CancelIfRunning_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 time.Time
		if args[4] != nil {
			arg4 = args[4].(time.Time)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *PauseResumeOperationRepo_CancelIfRunning_Call) Return(b bool, err error) *PauseResumeOperationRepo_CancelIfRunning_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *PauseResumeOperationRepo_CancelIfRunning_Call) RunAndReturn(run func(ctx context.Context, sharedPoolID string, operationID string, reason string, completedAt time.Time) (bool, error)) *PauseResumeOperationRepo_CancelIfRunning_Call {
	_c.Call.Return(run)
	return _c
}

// Create provides a mock function for the type PauseResumeOperationRepo
func (_mock *PauseResumeOperationRepo) Create(ctx context.Context, operation *entity.PauseResumeOperation) error {
	ret := _mock.Called(ctx, operation)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.PauseResumeOperation) error); ok {
		r0 = returnFunc(ctx, operation)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - operation *entity.PauseResumeOperation
func (_e *PauseResumeOperationRepo_Expecter) Create(ctx interface{}, operation interface{}) *PauseResumeOperationRepo_Create_Call {
	return &PauseResumeOperationRepo_Create_Call{Call: _e.mock.On("Create", ctx, operation)}
}

func (_c *PauseResumeOperationRepo_Create_Call) Run(run func(ctx context.Context, operation *entity.PauseResumeOperation)) *PauseResumeOperationRepo_Create_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.PauseResumeOperation
		if args[1] != nil {
			arg1 = args[1].(*entity.PauseResumeOperation)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *PauseResumeOperationRepo_Create_Call) RunAndReturn(run func(ctx context.Context, operation *entity.PauseResumeOperation) error) *PauseResumeOperationRepo_Create_Call {
	_c.Call.Return(run)
	return _c
}

// LoadByID provides a mock function for the type PauseResumeOperationRepo
func (_mock *PauseResumeOperationRepo) LoadByID(ctx context.Context, sharedPoolID string, operationID string) (*entity.PauseResumeOperation, error) {
	ret := _mock.Called(ctx, sharedPoolID, operationID)

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

	var r0 *entity.PauseResumeOperation
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*entity.PauseResumeOperation, error)); ok {
		return returnFunc(ctx, sharedPoolID, operationID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *entity.PauseResumeOperation); ok {
		r0 = returnFunc(ctx, sharedPoolID, operationID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.PauseResumeOperation)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolID, operationID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// LoadByID is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolID string
//   - operationID string
func (_e *PauseResumeOperationRepo_Expecter) LoadByID(ctx interface{}, sharedPoolID interface{}, operationID interface{}) *PauseResumeOperationRepo_LoadByID_Call {
	return &PauseResumeOperationRepo_LoadByID_Call{Call: _e.mock.On("LoadByID", ctx, sharedPoolID, operationID)}
}

func (_c *PauseResumeOperationRepo_LoadByID_Call) Run(run func(ctx context.Context, sharedPoolID string, operationID string)) *PauseResumeOperationRepo_LoadByID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *PauseResumeOperationRepo_LoadByID_Call) Return(v *entity.PauseResumeOperation, err error) *PauseResumeOperationRepo_LoadByID_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *PauseResumeOperationRepo_LoadByID_Call) RunAndReturn(run func(ctx context.Context, sharedPoolID string, operationID string) (*entity.PauseResumeOperation, error)) *PauseResumeOperationRepo_LoadByID_Call {
	_c.Call.Return(run)
	return _c
}

// LoadLatestBySharedPoolID provides a mock function for the type PauseResumeOperationRepo
func (_mock *PauseResumeOperationRepo) LoadLatestBySharedPoolID(ctx context.Context, sharedPoolID string) (*entity.PauseResumeOperation, error) {
	ret := _mock.Called(ctx, sharedPoolID)

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

	var r0 *entity.PauseResumeOperation
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.PauseResumeOperation, error)); ok {
		return returnFunc(ctx, sharedPoolID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.PauseResumeOperation); ok {
		r0 = returnFunc(ctx, sharedPoolID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.PauseResumeOperation)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, sharedPoolID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// LoadLatestBySharedPoolID is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolID string
func (_e *PauseResumeOperationRepo_Expecter) LoadLatestBySharedPoolID(ctx interface{}, sharedPoolID interface{}) *PauseResumeOperationRepo_LoadLatestBySharedPoolID_Call {
	return &PauseResumeOperationRepo_LoadLatestBySharedPoolID_Call{Call: _e.mock.On("LoadLatestBySharedPoolID", ctx, sharedPoolID)}
}

func (_c *PauseResumeOperationRepo_LoadLatestBySharedPoolID_Call) Run(run func(ctx context.Context, sharedPoolID string)) *PauseResumeOperationRepo_LoadLatestBySharedPoolID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *PauseResumeOperationRepo_LoadLatestBySharedPoolID_Call) Return(v *entity.PauseResumeOperation, err error) *PauseResumeOperationRepo_LoadLatestBySharedPoolID_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *PauseResumeOperationRepo_LoadLatestBySharedPoolID_Call) RunAndReturn(run func(ctx context.Context, sharedPoolID string) (*entity.PauseResumeOperation, error)) *PauseResumeOperationRepo_LoadLatestBySharedPoolID_Call {
	_c.Call.Return(run)
	return _c
}

// MarkFailedIfRunning provides a mock function for the type PauseResumeOperationRepo
func (_mock *PauseResumeOperationRepo) MarkFailedIfRunning(ctx context.Context, sharedPoolID string, operationID string, summary string, completedAt time.Time) (bool, error) {
	ret := _mock.Called(ctx, sharedPoolID, operationID, summary, completedAt)

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

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, time.Time) (bool, error)); ok {
		return returnFunc(ctx, sharedPoolID, operationID, summary, completedAt)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, time.Time) bool); ok {
		r0 = returnFunc(ctx, sharedPoolID, operationID, summary, completedAt)
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, time.Time) error); ok {
		r1 = returnFunc(ctx, sharedPoolID, operationID, summary, completedAt)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// MarkFailedIfRunning is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolID string
//   - operationID string
//   - summary string
//   - completedAt time.Time
func (_e *PauseResumeOperationRepo_Expecter) MarkFailedIfRunning(ctx interface{}, sharedPoolID interface{}, operationID interface{}, summary interface{}, completedAt interface{}) *PauseResumeOperationRepo_MarkFailedIfRunning_Call {
	return &PauseResumeOperationRepo_MarkFailedIfRunning_Call{Call: _e.mock.On("MarkFailedIfRunning", ctx, sharedPoolID, operationID, summary, completedAt)}
}

func (_c *PauseResumeOperationRepo_MarkFailedIfRunning_Call) Run(run func(ctx context.Context, sharedPoolID string, operationID string, summary string, completedAt time.Time)) *PauseResumeOperationRepo_MarkFailedIfRunning_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 time.Time
		if args[4] != nil {
			arg4 = args[4].(time.Time)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *PauseResumeOperationRepo_MarkFailedIfRunning_Call) Return(b bool, err error) *PauseResumeOperationRepo_MarkFailedIfRunning_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *PauseResumeOperationRepo_MarkFailedIfRunning_Call) RunAndReturn(run func(ctx context.Context, sharedPoolID string, operationID string, summary string, completedAt time.Time) (bool, error)) *PauseResumeOperationRepo_MarkFailedIfRunning_Call {
	_c.Call.Return(run)
	return _c
}

// MarkSucceededIfRunning provides a mock function for the type PauseResumeOperationRepo
func (_mock *PauseResumeOperationRepo) MarkSucceededIfRunning(ctx context.Context, sharedPoolID string, operationID string, summary string, completedAt time.Time) (bool, error) {
	ret := _mock.Called(ctx, sharedPoolID, operationID, summary, completedAt)

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

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, time.Time) (bool, error)); ok {
		return returnFunc(ctx, sharedPoolID, operationID, summary, completedAt)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, time.Time) bool); ok {
		r0 = returnFunc(ctx, sharedPoolID, operationID, summary, completedAt)
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, time.Time) error); ok {
		r1 = returnFunc(ctx, sharedPoolID, operationID, summary, completedAt)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// MarkSucceededIfRunning is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolID string
//   - operationID string
//   - summary string
//   - completedAt time.Time
func (_e *PauseResumeOperationRepo_Expecter) MarkSucceededIfRunning(ctx interface{}, sharedPoolID interface{}, operationID interface{}, summary interface{}, completedAt interface{}) *PauseResumeOperationRepo_MarkSucceededIfRunning_Call {
	return &PauseResumeOperationRepo_MarkSucceededIfRunning_Call{Call: _e.mock.On("MarkSucceededIfRunning", ctx, sharedPoolID, operationID, summary, completedAt)}
}

func (_c *PauseResumeOperationRepo_MarkSucceededIfRunning_Call) Run(run func(ctx context.Context, sharedPoolID string, operationID string, summary string, completedAt time.Time)) *PauseResumeOperationRepo_MarkSucceededIfRunning_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 time.Time
		if args[4] != nil {
			arg4 = args[4].(time.Time)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *PauseResumeOperationRepo_MarkSucceededIfRunning_Call) Return(b bool, err error) *PauseResumeOperationRepo_MarkSucceededIfRunning_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *PauseResumeOperationRepo_MarkSucceededIfRunning_Call) RunAndReturn(run func(ctx context.Context, sharedPoolID string, operationID string, summary string, completedAt time.Time) (bool, error)) *PauseResumeOperationRepo_MarkSucceededIfRunning_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateStageIfRunning provides a mock function for the type PauseResumeOperationRepo
func (_mock *PauseResumeOperationRepo) UpdateStageIfRunning(ctx context.Context, sharedPoolID string, operationID string, stage entity.PauseResumeOperationStage) (bool, error) {
	ret := _mock.Called(ctx, sharedPoolID, operationID, stage)

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

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, entity.PauseResumeOperationStage) (bool, error)); ok {
		return returnFunc(ctx, sharedPoolID, operationID, stage)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, entity.PauseResumeOperationStage) bool); ok {
		r0 = returnFunc(ctx, sharedPoolID, operationID, stage)
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, entity.PauseResumeOperationStage) error); ok {
		r1 = returnFunc(ctx, sharedPoolID, operationID, stage)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateStageIfRunning is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolID string
//   - operationID string
//   - stage entity.PauseResumeOperationStage
func (_e *PauseResumeOperationRepo_Expecter) UpdateStageIfRunning(ctx interface{}, sharedPoolID interface{}, operationID interface{}, stage interface{}) *PauseResumeOperationRepo_UpdateStageIfRunning_Call {
	return &PauseResumeOperationRepo_UpdateStageIfRunning_Call{Call: _e.mock.On("UpdateStageIfRunning", ctx, sharedPoolID, operationID, stage)}
}

func (_c *PauseResumeOperationRepo_UpdateStageIfRunning_Call) Run(run func(ctx context.Context, sharedPoolID string, operationID string, stage entity.PauseResumeOperationStage)) *PauseResumeOperationRepo_UpdateStageIfRunning_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 entity.PauseResumeOperationStage
		if args[3] != nil {
			arg3 = args[3].(entity.PauseResumeOperationStage)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *PauseResumeOperationRepo_UpdateStageIfRunning_Call) Return(b bool, err error) *PauseResumeOperationRepo_UpdateStageIfRunning_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *PauseResumeOperationRepo_UpdateStageIfRunning_Call) RunAndReturn(run func(ctx context.Context, sharedPoolID string, operationID string, stage entity.PauseResumeOperationStage) (bool, error)) *PauseResumeOperationRepo_UpdateStageIfRunning_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type DataplaneRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *DataplaneRepo) EXPECT() *DataplaneRepo_Expecter {
	return &DataplaneRepo_Expecter{mock: &_m.Mock}
}

// LoadByName provides a mock function for the type DataplaneRepo
func (_mock *DataplaneRepo) LoadByName(ctx context.Context, name string) (*entity.DataPlaneProvider, error) {
	ret := _mock.Called(ctx, name)

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

	var r0 *entity.DataPlaneProvider
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.DataPlaneProvider, error)); ok {
		return returnFunc(ctx, name)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.DataPlaneProvider); ok {
		r0 = returnFunc(ctx, name)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.DataPlaneProvider)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, name)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

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

func (_c *DataplaneRepo_LoadByName_Call) Run(run func(ctx context.Context, name string)) *DataplaneRepo_LoadByName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *DataplaneRepo_LoadByName_Call) Return(v *entity.DataPlaneProvider, err error) *DataplaneRepo_LoadByName_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *DataplaneRepo_LoadByName_Call) RunAndReturn(run func(ctx context.Context, name string) (*entity.DataPlaneProvider, error)) *DataplaneRepo_LoadByName_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type SharedPoolObjectStoreRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *SharedPoolObjectStoreRepo) EXPECT() *SharedPoolObjectStoreRepo_Expecter {
	return &SharedPoolObjectStoreRepo_Expecter{mock: &_m.Mock}
}

// Delete provides a mock function for the type SharedPoolObjectStoreRepo
func (_mock *SharedPoolObjectStoreRepo) Delete(ctx context.Context, sharedPoolId string, storeType string) error {
	ret := _mock.Called(ctx, sharedPoolId, storeType)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, sharedPoolId, storeType)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - storeType string
func (_e *SharedPoolObjectStoreRepo_Expecter) Delete(ctx interface{}, sharedPoolId interface{}, storeType interface{}) *SharedPoolObjectStoreRepo_Delete_Call {
	return &SharedPoolObjectStoreRepo_Delete_Call{Call: _e.mock.On("Delete", ctx, sharedPoolId, storeType)}
}

func (_c *SharedPoolObjectStoreRepo_Delete_Call) Run(run func(ctx context.Context, sharedPoolId string, storeType string)) *SharedPoolObjectStoreRepo_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *SharedPoolObjectStoreRepo_Delete_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, storeType string) error) *SharedPoolObjectStoreRepo_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// ListWithDeletedSharedPool provides a mock function for the type SharedPoolObjectStoreRepo
func (_mock *SharedPoolObjectStoreRepo) ListWithDeletedSharedPool(ctx context.Context, sharedPoolIds []string, storeTypes []string) ([]*entity.SharedPoolObjectStore, error) {
	ret := _mock.Called(ctx, sharedPoolIds, storeTypes)

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

	var r0 []*entity.SharedPoolObjectStore
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []string, []string) ([]*entity.SharedPoolObjectStore, error)); ok {
		return returnFunc(ctx, sharedPoolIds, storeTypes)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []string, []string) []*entity.SharedPoolObjectStore); ok {
		r0 = returnFunc(ctx, sharedPoolIds, storeTypes)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.SharedPoolObjectStore)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []string, []string) error); ok {
		r1 = returnFunc(ctx, sharedPoolIds, storeTypes)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListWithDeletedSharedPool is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolIds []string
//   - storeTypes []string
func (_e *SharedPoolObjectStoreRepo_Expecter) ListWithDeletedSharedPool(ctx interface{}, sharedPoolIds interface{}, storeTypes interface{}) *SharedPoolObjectStoreRepo_ListWithDeletedSharedPool_Call {
	return &SharedPoolObjectStoreRepo_ListWithDeletedSharedPool_Call{Call: _e.mock.On("ListWithDeletedSharedPool", ctx, sharedPoolIds, storeTypes)}
}

func (_c *SharedPoolObjectStoreRepo_ListWithDeletedSharedPool_Call) Run(run func(ctx context.Context, sharedPoolIds []string, storeTypes []string)) *SharedPoolObjectStoreRepo_ListWithDeletedSharedPool_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []string
		if args[1] != nil {
			arg1 = args[1].([]string)
		}
		var arg2 []string
		if args[2] != nil {
			arg2 = args[2].([]string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SharedPoolObjectStoreRepo_ListWithDeletedSharedPool_Call) Return(sharedPoolObjectStores []*entity.SharedPoolObjectStore, err error) *SharedPoolObjectStoreRepo_ListWithDeletedSharedPool_Call {
	_c.Call.Return(sharedPoolObjectStores, err)
	return _c
}

func (_c *SharedPoolObjectStoreRepo_ListWithDeletedSharedPool_Call) RunAndReturn(run func(ctx context.Context, sharedPoolIds []string, storeTypes []string) ([]*entity.SharedPoolObjectStore, error)) *SharedPoolObjectStoreRepo_ListWithDeletedSharedPool_Call {
	_c.Call.Return(run)
	return _c
}

// Load provides a mock function for the type SharedPoolObjectStoreRepo
func (_mock *SharedPoolObjectStoreRepo) Load(ctx context.Context, sharedPoolId string, storeType string, deleted bool) (*entity.SharedPoolObjectStore, error) {
	ret := _mock.Called(ctx, sharedPoolId, storeType, deleted)

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

	var r0 *entity.SharedPoolObjectStore
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, bool) (*entity.SharedPoolObjectStore, error)); ok {
		return returnFunc(ctx, sharedPoolId, storeType, deleted)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, bool) *entity.SharedPoolObjectStore); ok {
		r0 = returnFunc(ctx, sharedPoolId, storeType, deleted)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.SharedPoolObjectStore)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, bool) error); ok {
		r1 = returnFunc(ctx, sharedPoolId, storeType, deleted)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Load is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolId string
//   - storeType string
//   - deleted bool
func (_e *SharedPoolObjectStoreRepo_Expecter) Load(ctx interface{}, sharedPoolId interface{}, storeType interface{}, deleted interface{}) *SharedPoolObjectStoreRepo_Load_Call {
	return &SharedPoolObjectStoreRepo_Load_Call{Call: _e.mock.On("Load", ctx, sharedPoolId, storeType, deleted)}
}

func (_c *SharedPoolObjectStoreRepo_Load_Call) Run(run func(ctx context.Context, sharedPoolId string, storeType string, deleted bool)) *SharedPoolObjectStoreRepo_Load_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 bool
		if args[3] != nil {
			arg3 = args[3].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SharedPoolObjectStoreRepo_Load_Call) Return(sharedPoolObjectStore *entity.SharedPoolObjectStore, err error) *SharedPoolObjectStoreRepo_Load_Call {
	_c.Call.Return(sharedPoolObjectStore, err)
	return _c
}

func (_c *SharedPoolObjectStoreRepo_Load_Call) RunAndReturn(run func(ctx context.Context, sharedPoolId string, storeType string, deleted bool) (*entity.SharedPoolObjectStore, error)) *SharedPoolObjectStoreRepo_Load_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type TemplateRegistryRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *TemplateRegistryRepo) EXPECT() *TemplateRegistryRepo_Expecter {
	return &TemplateRegistryRepo_Expecter{mock: &_m.Mock}
}

// ListByTemplateName provides a mock function for the type TemplateRegistryRepo
func (_mock *TemplateRegistryRepo) ListByTemplateName(ctx context.Context, templateName string) ([]*entity.TemplateRegistry, error) {
	ret := _mock.Called(ctx, templateName)

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

	var r0 []*entity.TemplateRegistry
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*entity.TemplateRegistry, error)); ok {
		return returnFunc(ctx, templateName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*entity.TemplateRegistry); ok {
		r0 = returnFunc(ctx, templateName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.TemplateRegistry)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, templateName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListByTemplateName is a helper method to define mock.On call
//   - ctx context.Context
//   - templateName string
func (_e *TemplateRegistryRepo_Expecter) ListByTemplateName(ctx interface{}, templateName interface{}) *TemplateRegistryRepo_ListByTemplateName_Call {
	return &TemplateRegistryRepo_ListByTemplateName_Call{Call: _e.mock.On("ListByTemplateName", ctx, templateName)}
}

func (_c *TemplateRegistryRepo_ListByTemplateName_Call) Run(run func(ctx context.Context, templateName string)) *TemplateRegistryRepo_ListByTemplateName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *TemplateRegistryRepo_ListByTemplateName_Call) Return(templateRegistrys []*entity.TemplateRegistry, err error) *TemplateRegistryRepo_ListByTemplateName_Call {
	_c.Call.Return(templateRegistrys, err)
	return _c
}

func (_c *TemplateRegistryRepo_ListByTemplateName_Call) RunAndReturn(run func(ctx context.Context, templateName string) ([]*entity.TemplateRegistry, error)) *TemplateRegistryRepo_ListByTemplateName_Call {
	_c.Call.Return(run)
	return _c
}

// ListByTemplateNameForUpdate provides a mock function for the type TemplateRegistryRepo
func (_mock *TemplateRegistryRepo) ListByTemplateNameForUpdate(ctx context.Context, templateName string) ([]*entity.TemplateRegistry, error) {
	ret := _mock.Called(ctx, templateName)

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

	var r0 []*entity.TemplateRegistry
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*entity.TemplateRegistry, error)); ok {
		return returnFunc(ctx, templateName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*entity.TemplateRegistry); ok {
		r0 = returnFunc(ctx, templateName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.TemplateRegistry)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, templateName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListByTemplateNameForUpdate is a helper method to define mock.On call
//   - ctx context.Context
//   - templateName string
func (_e *TemplateRegistryRepo_Expecter) ListByTemplateNameForUpdate(ctx interface{}, templateName interface{}) *TemplateRegistryRepo_ListByTemplateNameForUpdate_Call {
	return &TemplateRegistryRepo_ListByTemplateNameForUpdate_Call{Call: _e.mock.On("ListByTemplateNameForUpdate", ctx, templateName)}
}

func (_c *TemplateRegistryRepo_ListByTemplateNameForUpdate_Call) Run(run func(ctx context.Context, templateName string)) *TemplateRegistryRepo_ListByTemplateNameForUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *TemplateRegistryRepo_ListByTemplateNameForUpdate_Call) Return(templateRegistrys []*entity.TemplateRegistry, err error) *TemplateRegistryRepo_ListByTemplateNameForUpdate_Call {
	_c.Call.Return(templateRegistrys, err)
	return _c
}

func (_c *TemplateRegistryRepo_ListByTemplateNameForUpdate_Call) RunAndReturn(run func(ctx context.Context, templateName string) ([]*entity.TemplateRegistry, error)) *TemplateRegistryRepo_ListByTemplateNameForUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// ListTemplateSummaries provides a mock function for the type TemplateRegistryRepo
func (_mock *TemplateRegistryRepo) ListTemplateSummaries(ctx context.Context) ([]*repo.TemplateSummary, error) {
	ret := _mock.Called(ctx)

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

	var r0 []*repo.TemplateSummary
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*repo.TemplateSummary, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) []*repo.TemplateSummary); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*repo.TemplateSummary)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListTemplateSummaries is a helper method to define mock.On call
//   - ctx context.Context
func (_e *TemplateRegistryRepo_Expecter) ListTemplateSummaries(ctx interface{}) *TemplateRegistryRepo_ListTemplateSummaries_Call {
	return &TemplateRegistryRepo_ListTemplateSummaries_Call{Call: _e.mock.On("ListTemplateSummaries", ctx)}
}

func (_c *TemplateRegistryRepo_ListTemplateSummaries_Call) Run(run func(ctx context.Context)) *TemplateRegistryRepo_ListTemplateSummaries_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *TemplateRegistryRepo_ListTemplateSummaries_Call) Return(templateSummarys []*repo.TemplateSummary, err error) *TemplateRegistryRepo_ListTemplateSummaries_Call {
	_c.Call.Return(templateSummarys, err)
	return _c
}

func (_c *TemplateRegistryRepo_ListTemplateSummaries_Call) RunAndReturn(run func(ctx context.Context) ([]*repo.TemplateSummary, error)) *TemplateRegistryRepo_ListTemplateSummaries_Call {
	_c.Call.Return(run)
	return _c
}

// Load provides a mock function for the type TemplateRegistryRepo
func (_mock *TemplateRegistryRepo) Load(ctx context.Context, templateName string, version string) (*entity.TemplateRegistry, error) {
	ret := _mock.Called(ctx, templateName, version)

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

	var r0 *entity.TemplateRegistry
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*entity.TemplateRegistry, error)); ok {
		return returnFunc(ctx, templateName, version)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *entity.TemplateRegistry); ok {
		r0 = returnFunc(ctx, templateName, version)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.TemplateRegistry)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, templateName, version)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Load is a helper method to define mock.On call
//   - ctx context.Context
//   - templateName string
//   - version string
func (_e *TemplateRegistryRepo_Expecter) Load(ctx interface{}, templateName interface{}, version interface{}) *TemplateRegistryRepo_Load_Call {
	return &TemplateRegistryRepo_Load_Call{Call: _e.mock.On("Load", ctx, templateName, version)}
}

func (_c *TemplateRegistryRepo_Load_Call) Run(run func(ctx context.Context, templateName string, version string)) *TemplateRegistryRepo_Load_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *TemplateRegistryRepo_Load_Call) Return(templateRegistry *entity.TemplateRegistry, err error) *TemplateRegistryRepo_Load_Call {
	_c.Call.Return(templateRegistry, err)
	return _c
}

func (_c *TemplateRegistryRepo_Load_Call) RunAndReturn(run func(ctx context.Context, templateName string, version string) (*entity.TemplateRegistry, error)) *TemplateRegistryRepo_Load_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateStatus provides a mock function for the type TemplateRegistryRepo
func (_mock *TemplateRegistryRepo) UpdateStatus(ctx context.Context, templateName string, version string, status entity.TemplateVersionStatus) error {
	ret := _mock.Called(ctx, templateName, version, status)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, entity.TemplateVersionStatus) error); ok {
		r0 = returnFunc(ctx, templateName, version, status)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// UpdateStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - templateName string
//   - version string
//   - status entity.TemplateVersionStatus
func (_e *TemplateRegistryRepo_Expecter) UpdateStatus(ctx interface{}, templateName interface{}, version interface{}, status interface{}) *TemplateRegistryRepo_UpdateStatus_Call {
	return &TemplateRegistryRepo_UpdateStatus_Call{Call: _e.mock.On("UpdateStatus", ctx, templateName, version, status)}
}

func (_c *TemplateRegistryRepo_UpdateStatus_Call) Run(run func(ctx context.Context, templateName string, version string, status entity.TemplateVersionStatus)) *TemplateRegistryRepo_UpdateStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 entity.TemplateVersionStatus
		if args[3] != nil {
			arg3 = args[3].(entity.TemplateVersionStatus)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *TemplateRegistryRepo_UpdateStatus_Call) RunAndReturn(run func(ctx context.Context, templateName string, version string, status entity.TemplateVersionStatus) error) *TemplateRegistryRepo_UpdateStatus_Call {
	_c.Call.Return(run)
	return _c
}

// Upsert provides a mock function for the type TemplateRegistryRepo
func (_mock *TemplateRegistryRepo) Upsert(ctx context.Context, item *entity.TemplateRegistry) error {
	ret := _mock.Called(ctx, item)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.TemplateRegistry) error); ok {
		r0 = returnFunc(ctx, item)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Upsert is a helper method to define mock.On call
//   - ctx context.Context
//   - item *entity.TemplateRegistry
func (_e *TemplateRegistryRepo_Expecter) Upsert(ctx interface{}, item interface{}) *TemplateRegistryRepo_Upsert_Call {
	return &TemplateRegistryRepo_Upsert_Call{Call: _e.mock.On("Upsert", ctx, item)}
}

func (_c *TemplateRegistryRepo_Upsert_Call) Run(run func(ctx context.Context, item *entity.TemplateRegistry)) *TemplateRegistryRepo_Upsert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.TemplateRegistry
		if args[1] != nil {
			arg1 = args[1].(*entity.TemplateRegistry)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *TemplateRegistryRepo_Upsert_Call) RunAndReturn(run func(ctx context.Context, item *entity.TemplateRegistry) error) *TemplateRegistryRepo_Upsert_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type TiDBGroupRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *TiDBGroupRepo) EXPECT() *TiDBGroupRepo_Expecter {
	return &TiDBGroupRepo_Expecter{mock: &_m.Mock}
}

// Delete provides a mock function for the type TiDBGroupRepo
func (_mock *TiDBGroupRepo) Delete(ctx context.Context, id string) error {
	ret := _mock.Called(ctx, id)

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

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

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *TiDBGroupRepo_Expecter) Delete(ctx interface{}, id interface{}) *TiDBGroupRepo_Delete_Call {
	return &TiDBGroupRepo_Delete_Call{Call: _e.mock.On("Delete", ctx, id)}
}

func (_c *TiDBGroupRepo_Delete_Call) Run(run func(ctx context.Context, id string)) *TiDBGroupRepo_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *TiDBGroupRepo_Delete_Call) RunAndReturn(run func(ctx context.Context, id string) error) *TiDBGroupRepo_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// List provides a mock function for the type TiDBGroupRepo
func (_mock *TiDBGroupRepo) List(ctx context.Context, sharedPoolIds []string, tenantIds []string, clusterIds []string, keyspaces []string, deleted bool) ([]*entity.TiDBGroup, error) {
	ret := _mock.Called(ctx, sharedPoolIds, tenantIds, clusterIds, keyspaces, deleted)

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

	var r0 []*entity.TiDBGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []string, []string, []string, []string, bool) ([]*entity.TiDBGroup, error)); ok {
		return returnFunc(ctx, sharedPoolIds, tenantIds, clusterIds, keyspaces, deleted)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []string, []string, []string, []string, bool) []*entity.TiDBGroup); ok {
		r0 = returnFunc(ctx, sharedPoolIds, tenantIds, clusterIds, keyspaces, deleted)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*entity.TiDBGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []string, []string, []string, []string, bool) error); ok {
		r1 = returnFunc(ctx, sharedPoolIds, tenantIds, clusterIds, keyspaces, deleted)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// List is a helper method to define mock.On call
//   - ctx context.Context
//   - sharedPoolIds []string
//   - tenantIds []string
//   - clusterIds []string
//   - keyspaces []string
//   - deleted bool
func (_e *TiDBGroupRepo_Expecter) List(ctx interface{}, sharedPoolIds interface{}, tenantIds interface{}, clusterIds interface{}, keyspaces interface{}, deleted interface{}) *TiDBGroupRepo_List_Call {
	return &TiDBGroupRepo_List_Call{Call: _e.mock.On("List", ctx, sharedPoolIds, tenantIds, clusterIds, keyspaces, deleted)}
}

func (_c *TiDBGroupRepo_List_Call) Run(run func(ctx context.Context, sharedPoolIds []string, tenantIds []string, clusterIds []string, keyspaces []string, deleted bool)) *TiDBGroupRepo_List_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []string
		if args[1] != nil {
			arg1 = args[1].([]string)
		}
		var arg2 []string
		if args[2] != nil {
			arg2 = args[2].([]string)
		}
		var arg3 []string
		if args[3] != nil {
			arg3 = args[3].([]string)
		}
		var arg4 []string
		if args[4] != nil {
			arg4 = args[4].([]string)
		}
		var arg5 bool
		if args[5] != nil {
			arg5 = args[5].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *TiDBGroupRepo_List_Call) Return(tiDBGroups []*entity.TiDBGroup, err error) *TiDBGroupRepo_List_Call {
	_c.Call.Return(tiDBGroups, err)
	return _c
}

func (_c *TiDBGroupRepo_List_Call) RunAndReturn(run func(ctx context.Context, sharedPoolIds []string, tenantIds []string, clusterIds []string, keyspaces []string, deleted bool) ([]*entity.TiDBGroup, error)) *TiDBGroupRepo_List_Call {
	_c.Call.Return(run)
	return _c
}

// Load provides a mock function for the type TiDBGroupRepo
func (_mock *TiDBGroupRepo) Load(ctx context.Context, id string, deleted bool) (*entity.TiDBGroup, error) {
	ret := _mock.Called(ctx, id, deleted)

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

	var r0 *entity.TiDBGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) (*entity.TiDBGroup, error)); ok {
		return returnFunc(ctx, id, deleted)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) *entity.TiDBGroup); ok {
		r0 = returnFunc(ctx, id, deleted)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*entity.TiDBGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
		r1 = returnFunc(ctx, id, deleted)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Load is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - deleted bool
func (_e *TiDBGroupRepo_Expecter) Load(ctx interface{}, id interface{}, deleted interface{}) *TiDBGroupRepo_Load_Call {
	return &TiDBGroupRepo_Load_Call{Call: _e.mock.On("Load", ctx, id, deleted)}
}

func (_c *TiDBGroupRepo_Load_Call) Run(run func(ctx context.Context, id string, deleted bool)) *TiDBGroupRepo_Load_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *TiDBGroupRepo_Load_Call) Return(tiDBGroup *entity.TiDBGroup, err error) *TiDBGroupRepo_Load_Call {
	_c.Call.Return(tiDBGroup, err)
	return _c
}

func (_c *TiDBGroupRepo_Load_Call) RunAndReturn(run func(ctx context.Context, id string, deleted bool) (*entity.TiDBGroup, error)) *TiDBGroupRepo_Load_Call {
	_c.Call.Return(run)
	return _c
}

// Save provides a mock function for the type TiDBGroupRepo
func (_mock *TiDBGroupRepo) Save(ctx context.Context, tidbGroup *entity.TiDBGroup) error {
	ret := _mock.Called(ctx, tidbGroup)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.TiDBGroup) error); ok {
		r0 = returnFunc(ctx, tidbGroup)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Save is a helper method to define mock.On call
//   - ctx context.Context
//   - tidbGroup *entity.TiDBGroup
func (_e *TiDBGroupRepo_Expecter) Save(ctx interface{}, tidbGroup interface{}) *TiDBGroupRepo_Save_Call {
	return &TiDBGroupRepo_Save_Call{Call: _e.mock.On("Save", ctx, tidbGroup)}
}

func (_c *TiDBGroupRepo_Save_Call) Run(run func(ctx context.Context, tidbGroup *entity.TiDBGroup)) *TiDBGroupRepo_Save_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *entity.TiDBGroup
		if args[1] != nil {
			arg1 = args[1].(*entity.TiDBGroup)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *TiDBGroupRepo_Save_Call) RunAndReturn(run func(ctx context.Context, tidbGroup *entity.TiDBGroup) error) *TiDBGroupRepo_Save_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type WorkerNodeMeteringCheckpointRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *WorkerNodeMeteringCheckpointRepo) EXPECT() *WorkerNodeMeteringCheckpointRepo_Expecter {
	return &WorkerNodeMeteringCheckpointRepo_Expecter{mock: &_m.Mock}
}

// LoadLastSuccessfulMinute provides a mock function for the type WorkerNodeMeteringCheckpointRepo
func (_mock *WorkerNodeMeteringCheckpointRepo) LoadLastSuccessfulMinute(ctx context.Context, region string, cloudProvider string, dataplane string) (int64, error) {
	ret := _mock.Called(ctx, region, cloudProvider, dataplane)

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

	var r0 int64
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (int64, error)); ok {
		return returnFunc(ctx, region, cloudProvider, dataplane)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) int64); ok {
		r0 = returnFunc(ctx, region, cloudProvider, dataplane)
	} else {
		r0 = ret.Get(0).(int64)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, region, cloudProvider, dataplane)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// LoadLastSuccessfulMinute is a helper method to define mock.On call
//   - ctx context.Context
//   - region string
//   - cloudProvider string
//   - dataplane string
func (_e *WorkerNodeMeteringCheckpointRepo_Expecter) LoadLastSuccessfulMinute(ctx interface{}, region interface{}, cloudProvider interface{}, dataplane interface{}) *WorkerNodeMeteringCheckpointRepo_LoadLastSuccessfulMinute_Call {
	return &WorkerNodeMeteringCheckpointRepo_LoadLastSuccessfulMinute_Call{Call: _e.mock.On("LoadLastSuccessfulMinute", ctx, region, cloudProvider, dataplane)}
}

func (_c *WorkerNodeMeteringCheckpointRepo_LoadLastSuccessfulMinute_Call) Run(run func(ctx context.Context, region string, cloudProvider string, dataplane string)) *WorkerNodeMeteringCheckpointRepo_LoadLastSuccessfulMinute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *WorkerNodeMeteringCheckpointRepo_LoadLastSuccessfulMinute_Call) Return(n int64, err error) *WorkerNodeMeteringCheckpointRepo_LoadLastSuccessfulMinute_Call {
	_c.Call.Return(n, err)
	return _c
}

func (_c *WorkerNodeMeteringCheckpointRepo_LoadLastSuccessfulMinute_Call) RunAndReturn(run func(ctx context.Context, region string, cloudProvider string, dataplane string) (int64, error)) *WorkerNodeMeteringCheckpointRepo_LoadLastSuccessfulMinute_Call {
	_c.Call.Return(run)
	return _c
}

// SaveLastSuccessfulMinute provides a mock function for the type WorkerNodeMeteringCheckpointRepo
func (_mock *WorkerNodeMeteringCheckpointRepo) SaveLastSuccessfulMinute(ctx context.Context, region string, cloudProvider string, dataplane string, minuteTs int64) error {
	ret := _mock.Called(ctx, region, cloudProvider, dataplane, minuteTs)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, int64) error); ok {
		r0 = returnFunc(ctx, region, cloudProvider, dataplane, minuteTs)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SaveLastSuccessfulMinute is a helper method to define mock.On call
//   - ctx context.Context
//   - region string
//   - cloudProvider string
//   - dataplane string
//   - minuteTs int64
func (_e *WorkerNodeMeteringCheckpointRepo_Expecter) SaveLastSuccessfulMinute(ctx interface{}, region interface{}, cloudProvider interface{}, dataplane interface{}, minuteTs interface{}) *WorkerNodeMeteringCheckpointRepo_SaveLastSuccessfulMinute_Call {
	return &WorkerNodeMeteringCheckpointRepo_SaveLastSuccessfulMinute_Call{Call: _e.mock.On("SaveLastSuccessfulMinute", ctx, region, cloudProvider, dataplane, minuteTs)}
}

func (_c *WorkerNodeMeteringCheckpointRepo_SaveLastSuccessfulMinute_Call) Run(run func(ctx context.Context, region string, cloudProvider string, dataplane string, minuteTs int64)) *WorkerNodeMeteringCheckpointRepo_SaveLastSuccessfulMinute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 int64
		if args[4] != nil {
			arg4 = args[4].(int64)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *WorkerNodeMeteringCheckpointRepo_SaveLastSuccessfulMinute_Call) RunAndReturn(run func(ctx context.Context, region string, cloudProvider string, dataplane string, minuteTs int64) error) *WorkerNodeMeteringCheckpointRepo_SaveLastSuccessfulMinute_Call {
	_c.Call.Return(run)
	return _c
}