// Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/domain/repo/cluster.go
//
// Generated by this command:
//
//	mockgen -source=./internal/domain/repo/cluster.go -destination ./internal/domain/repo/mock_repo/mock_cluster.go -package mock_repo
//

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

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

	bizerr "github.com/tidbcloud/pkgv2/bizerr"
	constant "github.com/tidbcloud/serverless-service/internal/domain/constant"
	entity "github.com/tidbcloud/serverless-service/internal/domain/entity"
	repo "github.com/tidbcloud/serverless-service/internal/domain/repo"
	gomock "go.uber.org/mock/gomock"
)

// MockClusterRepo is a mock of ClusterRepo interface.
type MockClusterRepo struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRepoMockRecorder
}

// MockClusterRepoMockRecorder is the mock recorder for MockClusterRepo.
type MockClusterRepoMockRecorder struct {
	mock *MockClusterRepo
}

// NewMockClusterRepo creates a new mock instance.
func NewMockClusterRepo(ctrl *gomock.Controller) *MockClusterRepo {
	mock := &MockClusterRepo{ctrl: ctrl}
	mock.recorder = &MockClusterRepoMockRecorder{mock}
	return mock
}

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

// CountClusters mocks base method.
func (m *MockClusterRepo) CountClusters(ctx context.Context, filter *repo.ClusterFilter) (int64, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountClusters", ctx, filter)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

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

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

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

// ListClustersInPage mocks base method.
func (m *MockClusterRepo) ListClustersInPage(ctx context.Context, filter *repo.ClusterFilter, page, size uint32) ([]*entity.Cluster, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClustersInPage", ctx, filter, page, size)
	ret0, _ := ret[0].([]*entity.Cluster)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ListClustersInPage indicates an expected call of ListClustersInPage.
func (mr *MockClusterRepoMockRecorder) ListClustersInPage(ctx, filter, page, size any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClustersInPage", reflect.TypeOf((*MockClusterRepo)(nil).ListClustersInPage), ctx, filter, page, size)
}

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

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

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

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

// UpdateRUMode mocks base method.
func (m *MockClusterRepo) UpdateRUMode(ctx context.Context, clusterID uint64, mode constant.ClusterRUMode) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRUMode", ctx, clusterID, mode)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// UpdateRUMode indicates an expected call of UpdateRUMode.
func (mr *MockClusterRepoMockRecorder) UpdateRUMode(ctx, clusterID, mode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRUMode", reflect.TypeOf((*MockClusterRepo)(nil).UpdateRUMode), ctx, clusterID, mode)
}

// MockClusterTidbPoolRepo is a mock of ClusterTidbPoolRepo interface.
type MockClusterTidbPoolRepo struct {
	ctrl     *gomock.Controller
	recorder *MockClusterTidbPoolRepoMockRecorder
}

// MockClusterTidbPoolRepoMockRecorder is the mock recorder for MockClusterTidbPoolRepo.
type MockClusterTidbPoolRepoMockRecorder struct {
	mock *MockClusterTidbPoolRepo
}

// NewMockClusterTidbPoolRepo creates a new mock instance.
func NewMockClusterTidbPoolRepo(ctrl *gomock.Controller) *MockClusterTidbPoolRepo {
	mock := &MockClusterTidbPoolRepo{ctrl: ctrl}
	mock.recorder = &MockClusterTidbPoolRepoMockRecorder{mock}
	return mock
}

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

// CleanUp mocks base method.
func (m *MockClusterTidbPoolRepo) CleanUp(ctx context.Context, before time.Time, limit int) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CleanUp", ctx, before, limit)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// CleanUp indicates an expected call of CleanUp.
func (mr *MockClusterTidbPoolRepoMockRecorder) CleanUp(ctx, before, limit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CleanUp", reflect.TypeOf((*MockClusterTidbPoolRepo)(nil).CleanUp), ctx, before, limit)
}

// ListSpendLimitEvents mocks base method.
func (m *MockClusterTidbPoolRepo) ListSpendLimitEvents(ctx context.Context, clusterID uint64, start, end time.Time) ([]*entity.ClusterTidbPool, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSpendLimitEvents", ctx, clusterID, start, end)
	ret0, _ := ret[0].([]*entity.ClusterTidbPool)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ListSpendLimitEvents indicates an expected call of ListSpendLimitEvents.
func (mr *MockClusterTidbPoolRepoMockRecorder) ListSpendLimitEvents(ctx, clusterID, start, end any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSpendLimitEvents", reflect.TypeOf((*MockClusterTidbPoolRepo)(nil).ListSpendLimitEvents), ctx, clusterID, start, end)
}

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

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

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

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

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

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

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

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

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

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

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

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

// MockDowntimeRepo is a mock of DowntimeRepo interface.
type MockDowntimeRepo struct {
	ctrl     *gomock.Controller
	recorder *MockDowntimeRepoMockRecorder
}

// MockDowntimeRepoMockRecorder is the mock recorder for MockDowntimeRepo.
type MockDowntimeRepoMockRecorder struct {
	mock *MockDowntimeRepo
}

// NewMockDowntimeRepo creates a new mock instance.
func NewMockDowntimeRepo(ctrl *gomock.Controller) *MockDowntimeRepo {
	mock := &MockDowntimeRepo{ctrl: ctrl}
	mock.recorder = &MockDowntimeRepoMockRecorder{mock}
	return mock
}

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

// ListByFilter mocks base method.
func (m *MockDowntimeRepo) ListByFilter(ctx context.Context, filter *repo.DowntimeFilter) ([]*entity.Downtime, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListByFilter", ctx, filter)
	ret0, _ := ret[0].([]*entity.Downtime)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

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

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

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

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

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

// MockCanaryRepo is a mock of CanaryRepo interface.
type MockCanaryRepo struct {
	ctrl     *gomock.Controller
	recorder *MockCanaryRepoMockRecorder
}

// MockCanaryRepoMockRecorder is the mock recorder for MockCanaryRepo.
type MockCanaryRepoMockRecorder struct {
	mock *MockCanaryRepo
}

// NewMockCanaryRepo creates a new mock instance.
func NewMockCanaryRepo(ctrl *gomock.Controller) *MockCanaryRepo {
	mock := &MockCanaryRepo{ctrl: ctrl}
	mock.recorder = &MockCanaryRepoMockRecorder{mock}
	return mock
}

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

// AddClusters mocks base method.
func (m *MockCanaryRepo) AddClusters(ctx context.Context, canaries []*repo.CanaryCluster) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddClusters", ctx, canaries)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

// RemoveClusters mocks base method.
func (m *MockCanaryRepo) RemoveClusters(ctx context.Context, canaries []*repo.CanaryCluster) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveClusters", ctx, canaries)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

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

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

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