// Code generated by MockGen. DO NOT EDIT.
// Source: resourcepool.go
//
// Generated by this command:
//
//	mockgen -source=resourcepool.go -package=mock_resourcepool -destination=./mock_resourcepool/mock_resourcepool.go
//

// Package mock_resourcepool is a generated GoMock package.
package mock_resourcepool

import (
	context "context"
	reflect "reflect"
	time "time"

	nextgenv1 "github.com/tidbcloud/tidb-management-service/api/spec/global/nextgen/v1"
	entity "github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/entity"
	resourcepool "github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/repository/resourcepool"
	bizerr "github.com/tidbcloud/tidb-management-service/utilities/bizerr"
	gomock "go.uber.org/mock/gomock"
)

// MockRepo is a mock of Repo interface.
type MockRepo struct {
	ctrl     *gomock.Controller
	recorder *MockRepoMockRecorder
	isgomock struct{}
}

// MockRepoMockRecorder is the mock recorder for MockRepo.
type MockRepoMockRecorder struct {
	mock *MockRepo
}

// NewMockRepo creates a new mock instance.
func NewMockRepo(ctrl *gomock.Controller) *MockRepo {
	mock := &MockRepo{ctrl: ctrl}
	mock.recorder = &MockRepoMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRepo) EXPECT() *MockRepoMockRecorder {
	return m.recorder
}

// BackfillMetadata mocks base method.
func (m *MockRepo) BackfillMetadata(ctx context.Context, patch *resourcepool.MetadataBackfillPatch) (resourcepool.MetadataBackfillResult, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BackfillMetadata", ctx, patch)
	ret0, _ := ret[0].(resourcepool.MetadataBackfillResult)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// BackfillMetadata indicates an expected call of BackfillMetadata.
func (mr *MockRepoMockRecorder) BackfillMetadata(ctx, patch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BackfillMetadata", reflect.TypeOf((*MockRepo)(nil).BackfillMetadata), ctx, patch)
}

// CompareAndSetLifecycle mocks base method.
func (m *MockRepo) CompareAndSetLifecycle(ctx context.Context, id uint64, expectedState nextgenv1.ResourcePool_LifecycleState, expectedMessageCode string, expectedUpdatedAt time.Time, state nextgenv1.ResourcePool_LifecycleState, messageCode string) (bool, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompareAndSetLifecycle", ctx, id, expectedState, expectedMessageCode, expectedUpdatedAt, state, messageCode)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// CompareAndSetLifecycle indicates an expected call of CompareAndSetLifecycle.
func (mr *MockRepoMockRecorder) CompareAndSetLifecycle(ctx, id, expectedState, expectedMessageCode, expectedUpdatedAt, state, messageCode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompareAndSetLifecycle", reflect.TypeOf((*MockRepo)(nil).CompareAndSetLifecycle), ctx, id, expectedState, expectedMessageCode, expectedUpdatedAt, state, messageCode)
}

// CompletePauseResumeLifecycle mocks base method.
func (m *MockRepo) CompletePauseResumeLifecycle(ctx context.Context, id uint64, expectedState, targetState nextgenv1.ResourcePool_LifecycleState) (bool, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompletePauseResumeLifecycle", ctx, id, expectedState, targetState)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// CompletePauseResumeLifecycle indicates an expected call of CompletePauseResumeLifecycle.
func (mr *MockRepoMockRecorder) CompletePauseResumeLifecycle(ctx, id, expectedState, targetState any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompletePauseResumeLifecycle", reflect.TypeOf((*MockRepo)(nil).CompletePauseResumeLifecycle), ctx, id, expectedState, targetState)
}

// Create mocks base method.
func (m *MockRepo) Create(ctx context.Context, resourcePool *entity.ResourcePool) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, resourcePool)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// Create indicates an expected call of Create.
func (mr *MockRepoMockRecorder) Create(ctx, resourcePool any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockRepo)(nil).Create), ctx, resourcePool)
}

// Delete mocks base method.
func (m *MockRepo) Delete(ctx context.Context, id uint64) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, id)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockRepoMockRecorder) Delete(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRepo)(nil).Delete), ctx, id)
}

// HasLiveCIDROverlap mocks base method.
func (m *MockRepo) HasLiveCIDROverlap(ctx context.Context, organizationID uint64, cloudProvider entity.CloudProviderName, region entity.RegionName, cidrStart, cidrEnd []byte, excludeResourcePoolID uint64) (bool, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasLiveCIDROverlap", ctx, organizationID, cloudProvider, region, cidrStart, cidrEnd, excludeResourcePoolID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// HasLiveCIDROverlap indicates an expected call of HasLiveCIDROverlap.
func (mr *MockRepoMockRecorder) HasLiveCIDROverlap(ctx, organizationID, cloudProvider, region, cidrStart, cidrEnd, excludeResourcePoolID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasLiveCIDROverlap", reflect.TypeOf((*MockRepo)(nil).HasLiveCIDROverlap), ctx, organizationID, cloudProvider, region, cidrStart, cidrEnd, excludeResourcePoolID)
}

// HasLiveNormalizedName mocks base method.
func (m *MockRepo) HasLiveNormalizedName(ctx context.Context, organizationID uint64, normalizedName string, excludeResourcePoolID uint64) (bool, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasLiveNormalizedName", ctx, organizationID, normalizedName, excludeResourcePoolID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// HasLiveNormalizedName indicates an expected call of HasLiveNormalizedName.
func (mr *MockRepoMockRecorder) HasLiveNormalizedName(ctx, organizationID, normalizedName, excludeResourcePoolID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasLiveNormalizedName", reflect.TypeOf((*MockRepo)(nil).HasLiveNormalizedName), ctx, organizationID, normalizedName, excludeResourcePoolID)
}

// InspectLiveCIDROverlapForBackfill mocks base method.
func (m *MockRepo) InspectLiveCIDROverlapForBackfill(ctx context.Context, organizationID uint64, cloudProvider entity.CloudProviderName, region entity.RegionName, cidrStart, cidrEnd []byte, excludeResourcePoolID uint64) (bool, []uint64, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InspectLiveCIDROverlapForBackfill", ctx, organizationID, cloudProvider, region, cidrStart, cidrEnd, excludeResourcePoolID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].([]uint64)
	ret2, _ := ret[2].(bizerr.BizError)
	return ret0, ret1, ret2
}

// InspectLiveCIDROverlapForBackfill indicates an expected call of InspectLiveCIDROverlapForBackfill.
func (mr *MockRepoMockRecorder) InspectLiveCIDROverlapForBackfill(ctx, organizationID, cloudProvider, region, cidrStart, cidrEnd, excludeResourcePoolID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectLiveCIDROverlapForBackfill", reflect.TypeOf((*MockRepo)(nil).InspectLiveCIDROverlapForBackfill), ctx, organizationID, cloudProvider, region, cidrStart, cidrEnd, excludeResourcePoolID)
}

// ListDueAutomaticResume mocks base method.
func (m *MockRepo) ListDueAutomaticResume(ctx context.Context) ([]uint64, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDueAutomaticResume", ctx)
	ret0, _ := ret[0].([]uint64)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ListDueAutomaticResume indicates an expected call of ListDueAutomaticResume.
func (mr *MockRepoMockRecorder) ListDueAutomaticResume(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDueAutomaticResume", reflect.TypeOf((*MockRepo)(nil).ListDueAutomaticResume), ctx)
}

// ListIdle mocks base method.
func (m *MockRepo) ListIdle(ctx context.Context) ([]*resourcepool.IdleInfo, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIdle", ctx)
	ret0, _ := ret[0].([]*resourcepool.IdleInfo)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ListIdle indicates an expected call of ListIdle.
func (mr *MockRepoMockRecorder) ListIdle(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIdle", reflect.TypeOf((*MockRepo)(nil).ListIdle), ctx)
}

// ListLiveBYOCOrganizationResourcePoolsInRegion mocks base method.
func (m *MockRepo) ListLiveBYOCOrganizationResourcePoolsInRegion(ctx context.Context, organizationID uint64, cloudProvider entity.CloudProviderName, region entity.RegionName) ([]*entity.ResourcePool, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLiveBYOCOrganizationResourcePoolsInRegion", ctx, organizationID, cloudProvider, region)
	ret0, _ := ret[0].([]*entity.ResourcePool)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ListLiveBYOCOrganizationResourcePoolsInRegion indicates an expected call of ListLiveBYOCOrganizationResourcePoolsInRegion.
func (mr *MockRepoMockRecorder) ListLiveBYOCOrganizationResourcePoolsInRegion(ctx, organizationID, cloudProvider, region any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLiveBYOCOrganizationResourcePoolsInRegion", reflect.TypeOf((*MockRepo)(nil).ListLiveBYOCOrganizationResourcePoolsInRegion), ctx, organizationID, cloudProvider, region)
}

// Load mocks base method.
func (m *MockRepo) Load(ctx context.Context, id uint64, showDeleted bool) (*entity.ResourcePool, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Load", ctx, id, showDeleted)
	ret0, _ := ret[0].(*entity.ResourcePool)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// Load indicates an expected call of Load.
func (mr *MockRepoMockRecorder) Load(ctx, id, showDeleted any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Load", reflect.TypeOf((*MockRepo)(nil).Load), ctx, id, showDeleted)
}

// LoadForUpdate mocks base method.
func (m *MockRepo) LoadForUpdate(ctx context.Context, id uint64, showDeleted bool) (*entity.ResourcePool, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadForUpdate", ctx, id, showDeleted)
	ret0, _ := ret[0].(*entity.ResourcePool)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// LoadForUpdate indicates an expected call of LoadForUpdate.
func (mr *MockRepoMockRecorder) LoadForUpdate(ctx, id, showDeleted any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadForUpdate", reflect.TypeOf((*MockRepo)(nil).LoadForUpdate), ctx, id, showDeleted)
}

// LoadLifecycleForUpdate mocks base method.
func (m *MockRepo) LoadLifecycleForUpdate(ctx context.Context, id uint64, showDeleted bool) (*resourcepool.Lifecycle, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadLifecycleForUpdate", ctx, id, showDeleted)
	ret0, _ := ret[0].(*resourcepool.Lifecycle)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// LoadLifecycleForUpdate indicates an expected call of LoadLifecycleForUpdate.
func (mr *MockRepoMockRecorder) LoadLifecycleForUpdate(ctx, id, showDeleted any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadLifecycleForUpdate", reflect.TypeOf((*MockRepo)(nil).LoadLifecycleForUpdate), ctx, id, showDeleted)
}

// LockOrganizationNamespace mocks base method.
func (m *MockRepo) LockOrganizationNamespace(ctx context.Context, organizationID uint64) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LockOrganizationNamespace", ctx, organizationID)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// LockOrganizationNamespace indicates an expected call of LockOrganizationNamespace.
func (mr *MockRepoMockRecorder) LockOrganizationNamespace(ctx, organizationID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LockOrganizationNamespace", reflect.TypeOf((*MockRepo)(nil).LockOrganizationNamespace), ctx, organizationID)
}

// Query mocks base method.
func (m *MockRepo) Query(ctx context.Context, filter *resourcepool.Filter) ([]*entity.ResourcePool, int64, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Query", ctx, filter)
	ret0, _ := ret[0].([]*entity.ResourcePool)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(bizerr.BizError)
	return ret0, ret1, ret2
}

// Query indicates an expected call of Query.
func (mr *MockRepoMockRecorder) Query(ctx, filter any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockRepo)(nil).Query), ctx, filter)
}

// Save mocks base method.
func (m *MockRepo) Save(ctx context.Context, resourcePool *entity.ResourcePool) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Save", ctx, resourcePool)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// Save indicates an expected call of Save.
func (mr *MockRepoMockRecorder) Save(ctx, resourcePool any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockRepo)(nil).Save), ctx, resourcePool)
}

// UpdateCloudResourceTags mocks base method.
func (m *MockRepo) UpdateCloudResourceTags(ctx context.Context, id uint64, tags map[string]string) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCloudResourceTags", ctx, id, tags)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// UpdateCloudResourceTags indicates an expected call of UpdateCloudResourceTags.
func (mr *MockRepoMockRecorder) UpdateCloudResourceTags(ctx, id, tags any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCloudResourceTags", reflect.TypeOf((*MockRepo)(nil).UpdateCloudResourceTags), ctx, id, tags)
}

// UpdateDataplaneId mocks base method.
func (m *MockRepo) UpdateDataplaneId(ctx context.Context, id uint64, dataplaneId string) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDataplaneId", ctx, id, dataplaneId)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// UpdateDataplaneId indicates an expected call of UpdateDataplaneId.
func (mr *MockRepoMockRecorder) UpdateDataplaneId(ctx, id, dataplaneId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDataplaneId", reflect.TypeOf((*MockRepo)(nil).UpdateDataplaneId), ctx, id, dataplaneId)
}

// UpdateInstanceLimit mocks base method.
func (m *MockRepo) UpdateInstanceLimit(ctx context.Context, id, limit uint64) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateInstanceLimit", ctx, id, limit)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// UpdateInstanceLimit indicates an expected call of UpdateInstanceLimit.
func (mr *MockRepoMockRecorder) UpdateInstanceLimit(ctx, id, limit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateInstanceLimit", reflect.TypeOf((*MockRepo)(nil).UpdateInstanceLimit), ctx, id, limit)
}

// UpdateLifecycle mocks base method.
func (m *MockRepo) UpdateLifecycle(ctx context.Context, id uint64, state nextgenv1.ResourcePool_LifecycleState, messageCode string) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateLifecycle", ctx, id, state, messageCode)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// UpdateLifecycle indicates an expected call of UpdateLifecycle.
func (mr *MockRepoMockRecorder) UpdateLifecycle(ctx, id, state, messageCode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLifecycle", reflect.TypeOf((*MockRepo)(nil).UpdateLifecycle), ctx, id, state, messageCode)
}

// UpdateVcpuPolicy mocks base method.
func (m *MockRepo) UpdateVcpuPolicy(ctx context.Context, id uint64, mode nextgenv1.ResourcePool_VcpuLimitMode, limit uint64) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateVcpuPolicy", ctx, id, mode, limit)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// UpdateVcpuPolicy indicates an expected call of UpdateVcpuPolicy.
func (mr *MockRepoMockRecorder) UpdateVcpuPolicy(ctx, id, mode, limit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateVcpuPolicy", reflect.TypeOf((*MockRepo)(nil).UpdateVcpuPolicy), ctx, id, mode, limit)
}

// MockStrategyRepo is a mock of StrategyRepo interface.
type MockStrategyRepo struct {
	ctrl     *gomock.Controller
	recorder *MockStrategyRepoMockRecorder
	isgomock struct{}
}

// MockStrategyRepoMockRecorder is the mock recorder for MockStrategyRepo.
type MockStrategyRepoMockRecorder struct {
	mock *MockStrategyRepo
}

// NewMockStrategyRepo creates a new mock instance.
func NewMockStrategyRepo(ctrl *gomock.Controller) *MockStrategyRepo {
	mock := &MockStrategyRepo{ctrl: ctrl}
	mock.recorder = &MockStrategyRepoMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockStrategyRepo) EXPECT() *MockStrategyRepoMockRecorder {
	return m.recorder
}

// Create mocks base method.
func (m *MockStrategyRepo) Create(ctx context.Context, strategy *entity.ResourcePoolStrategy) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, strategy)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// Create indicates an expected call of Create.
func (mr *MockStrategyRepoMockRecorder) Create(ctx, strategy any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockStrategyRepo)(nil).Create), ctx, strategy)
}

// Delete mocks base method.
func (m *MockStrategyRepo) Delete(ctx context.Context, id uint64) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, id)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockStrategyRepoMockRecorder) Delete(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockStrategyRepo)(nil).Delete), ctx, id)
}

// GetByOrgProviderRegion mocks base method.
func (m *MockStrategyRepo) GetByOrgProviderRegion(ctx context.Context, orgId uint64, provider entity.CloudProviderName, region entity.RegionName, servicePlan entity.ServicePlan) (*entity.ResourcePoolStrategy, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByOrgProviderRegion", ctx, orgId, provider, region, servicePlan)
	ret0, _ := ret[0].(*entity.ResourcePoolStrategy)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetByOrgProviderRegion indicates an expected call of GetByOrgProviderRegion.
func (mr *MockStrategyRepoMockRecorder) GetByOrgProviderRegion(ctx, orgId, provider, region, servicePlan any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByOrgProviderRegion", reflect.TypeOf((*MockStrategyRepo)(nil).GetByOrgProviderRegion), ctx, orgId, provider, region, servicePlan)
}

// Load mocks base method.
func (m *MockStrategyRepo) Load(ctx context.Context, id uint64) (*entity.ResourcePoolStrategy, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Load", ctx, id)
	ret0, _ := ret[0].(*entity.ResourcePoolStrategy)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// Load indicates an expected call of Load.
func (mr *MockStrategyRepoMockRecorder) Load(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Load", reflect.TypeOf((*MockStrategyRepo)(nil).Load), ctx, id)
}

// Query mocks base method.
func (m *MockStrategyRepo) Query(ctx context.Context, filter *resourcepool.StrategyFilter) ([]*entity.ResourcePoolStrategy, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Query", ctx, filter)
	ret0, _ := ret[0].([]*entity.ResourcePoolStrategy)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// Query indicates an expected call of Query.
func (mr *MockStrategyRepoMockRecorder) Query(ctx, filter any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockStrategyRepo)(nil).Query), ctx, filter)
}

// Save mocks base method.
func (m *MockStrategyRepo) Save(ctx context.Context, strategy *entity.ResourcePoolStrategy) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Save", ctx, strategy)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// Save indicates an expected call of Save.
func (mr *MockStrategyRepoMockRecorder) Save(ctx, strategy any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockStrategyRepo)(nil).Save), ctx, strategy)
}

// SwitchDefaultResourcePool mocks base method.
func (m *MockStrategyRepo) SwitchDefaultResourcePool(ctx context.Context, strategyId, oldPoolId, newPoolId uint64) (bool, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SwitchDefaultResourcePool", ctx, strategyId, oldPoolId, newPoolId)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// SwitchDefaultResourcePool indicates an expected call of SwitchDefaultResourcePool.
func (mr *MockStrategyRepoMockRecorder) SwitchDefaultResourcePool(ctx, strategyId, oldPoolId, newPoolId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwitchDefaultResourcePool", reflect.TypeOf((*MockStrategyRepo)(nil).SwitchDefaultResourcePool), ctx, strategyId, oldPoolId, newPoolId)
}