// Code generated by MockGen. DO NOT EDIT.
// Source: internal/domain/repo/backup.go
//
// Generated by this command:
//
//	mockgen -source=internal/domain/repo/backup.go -destination=internal/domain/repo/mock_repo/mock_backup.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"
	entity "github.com/tidbcloud/serverless-service/internal/domain/entity"
	gomock "go.uber.org/mock/gomock"
)

// MockBackupJobRepo is a mock of BackupJobRepo interface.
type MockBackupJobRepo struct {
	ctrl     *gomock.Controller
	recorder *MockBackupJobRepoMockRecorder
	isgomock struct{}
}

// MockBackupJobRepoMockRecorder is the mock recorder for MockBackupJobRepo.
type MockBackupJobRepoMockRecorder struct {
	mock *MockBackupJobRepo
}

// NewMockBackupJobRepo creates a new mock instance.
func NewMockBackupJobRepo(ctrl *gomock.Controller) *MockBackupJobRepo {
	mock := &MockBackupJobRepo{ctrl: ctrl}
	mock.recorder = &MockBackupJobRepoMockRecorder{mock}
	return mock
}

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

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

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

// MockBackupScheduleRepo is a mock of BackupScheduleRepo interface.
type MockBackupScheduleRepo struct {
	ctrl     *gomock.Controller
	recorder *MockBackupScheduleRepoMockRecorder
	isgomock struct{}
}

// MockBackupScheduleRepoMockRecorder is the mock recorder for MockBackupScheduleRepo.
type MockBackupScheduleRepoMockRecorder struct {
	mock *MockBackupScheduleRepo
}

// NewMockBackupScheduleRepo creates a new mock instance.
func NewMockBackupScheduleRepo(ctrl *gomock.Controller) *MockBackupScheduleRepo {
	mock := &MockBackupScheduleRepo{ctrl: ctrl}
	mock.recorder = &MockBackupScheduleRepoMockRecorder{mock}
	return mock
}

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

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

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

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

// CleanDeletedWithoutBackup indicates an expected call of CleanDeletedWithoutBackup.
func (mr *MockBackupScheduleRepoMockRecorder) CleanDeletedWithoutBackup(ctx, expireTimeGte, limit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CleanDeletedWithoutBackup", reflect.TypeOf((*MockBackupScheduleRepo)(nil).CleanDeletedWithoutBackup), ctx, expireTimeGte, limit)
}

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

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

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

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

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

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

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

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

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

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

// UpdateKubernetesByClusterID mocks base method.
func (m *MockBackupScheduleRepo) UpdateKubernetesByClusterID(ctx context.Context, clusterId, kubernetes string) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateKubernetesByClusterID", ctx, clusterId, kubernetes)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// UpdateKubernetesByClusterID indicates an expected call of UpdateKubernetesByClusterID.
func (mr *MockBackupScheduleRepoMockRecorder) UpdateKubernetesByClusterID(ctx, clusterId, kubernetes any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateKubernetesByClusterID", reflect.TypeOf((*MockBackupScheduleRepo)(nil).UpdateKubernetesByClusterID), ctx, clusterId, kubernetes)
}

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

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

// MockBackupScheduleHistoryRepo is a mock of BackupScheduleHistoryRepo interface.
type MockBackupScheduleHistoryRepo struct {
	ctrl     *gomock.Controller
	recorder *MockBackupScheduleHistoryRepoMockRecorder
	isgomock struct{}
}

// MockBackupScheduleHistoryRepoMockRecorder is the mock recorder for MockBackupScheduleHistoryRepo.
type MockBackupScheduleHistoryRepoMockRecorder struct {
	mock *MockBackupScheduleHistoryRepo
}

// NewMockBackupScheduleHistoryRepo creates a new mock instance.
func NewMockBackupScheduleHistoryRepo(ctrl *gomock.Controller) *MockBackupScheduleHistoryRepo {
	mock := &MockBackupScheduleHistoryRepo{ctrl: ctrl}
	mock.recorder = &MockBackupScheduleHistoryRepoMockRecorder{mock}
	return mock
}

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

// ArchiveCurrentSchedule mocks base method.
func (m *MockBackupScheduleHistoryRepo) ArchiveCurrentSchedule(ctx context.Context, schedule *entity.BackupSchedule, validTo time.Time, deletedAt *time.Time) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ArchiveCurrentSchedule", ctx, schedule, validTo, deletedAt)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// ArchiveCurrentSchedule indicates an expected call of ArchiveCurrentSchedule.
func (mr *MockBackupScheduleHistoryRepoMockRecorder) ArchiveCurrentSchedule(ctx, schedule, validTo, deletedAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ArchiveCurrentSchedule", reflect.TypeOf((*MockBackupScheduleHistoryRepo)(nil).ArchiveCurrentSchedule), ctx, schedule, validTo, deletedAt)
}

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

// DeleteExpired indicates an expected call of DeleteExpired.
func (mr *MockBackupScheduleHistoryRepoMockRecorder) DeleteExpired(ctx, now, limit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteExpired", reflect.TypeOf((*MockBackupScheduleHistoryRepo)(nil).DeleteExpired), ctx, now, limit)
}

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

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

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

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

// MarkDeleted mocks base method.
func (m *MockBackupScheduleHistoryRepo) MarkDeleted(ctx context.Context, clusterID string, deletedAt time.Time) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarkDeleted", ctx, clusterID, deletedAt)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

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

// MockUserBackupRepo is a mock of UserBackupRepo interface.
type MockUserBackupRepo struct {
	ctrl     *gomock.Controller
	recorder *MockUserBackupRepoMockRecorder
	isgomock struct{}
}

// MockUserBackupRepoMockRecorder is the mock recorder for MockUserBackupRepo.
type MockUserBackupRepoMockRecorder struct {
	mock *MockUserBackupRepo
}

// NewMockUserBackupRepo creates a new mock instance.
func NewMockUserBackupRepo(ctrl *gomock.Controller) *MockUserBackupRepo {
	mock := &MockUserBackupRepo{ctrl: ctrl}
	mock.recorder = &MockUserBackupRepoMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

// GetByClusterIdAndBackupId indicates an expected call of GetByClusterIdAndBackupId.
func (mr *MockUserBackupRepoMockRecorder) GetByClusterIdAndBackupId(ctx, clusterId, backupId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByClusterIdAndBackupId", reflect.TypeOf((*MockUserBackupRepo)(nil).GetByClusterIdAndBackupId), ctx, clusterId, backupId)
}

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

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

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

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

// MockBackupTombstoneRepo is a mock of BackupTombstoneRepo interface.
type MockBackupTombstoneRepo struct {
	ctrl     *gomock.Controller
	recorder *MockBackupTombstoneRepoMockRecorder
	isgomock struct{}
}

// MockBackupTombstoneRepoMockRecorder is the mock recorder for MockBackupTombstoneRepo.
type MockBackupTombstoneRepoMockRecorder struct {
	mock *MockBackupTombstoneRepo
}

// NewMockBackupTombstoneRepo creates a new mock instance.
func NewMockBackupTombstoneRepo(ctrl *gomock.Controller) *MockBackupTombstoneRepo {
	mock := &MockBackupTombstoneRepo{ctrl: ctrl}
	mock.recorder = &MockBackupTombstoneRepoMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Exists mocks base method.
func (m *MockBackupTombstoneRepo) Exists(ctx context.Context, clusterID string, scheduleTime time.Time) (bool, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Exists", ctx, clusterID, scheduleTime)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

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

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

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

// MockPhysicalBackupSlotRepo is a mock of PhysicalBackupSlotRepo interface.
type MockPhysicalBackupSlotRepo struct {
	ctrl     *gomock.Controller
	recorder *MockPhysicalBackupSlotRepoMockRecorder
	isgomock struct{}
}

// MockPhysicalBackupSlotRepoMockRecorder is the mock recorder for MockPhysicalBackupSlotRepo.
type MockPhysicalBackupSlotRepoMockRecorder struct {
	mock *MockPhysicalBackupSlotRepo
}

// NewMockPhysicalBackupSlotRepo creates a new mock instance.
func NewMockPhysicalBackupSlotRepo(ctrl *gomock.Controller) *MockPhysicalBackupSlotRepo {
	mock := &MockPhysicalBackupSlotRepo{ctrl: ctrl}
	mock.recorder = &MockPhysicalBackupSlotRepoMockRecorder{mock}
	return mock
}

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

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

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

// Get mocks base method.
func (m *MockPhysicalBackupSlotRepo) Get(ctx context.Context, provider, region, kubernetes string, slotTime time.Time) (*entity.PhysicalBackupSlot, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, provider, region, kubernetes, slotTime)
	ret0, _ := ret[0].(*entity.PhysicalBackupSlot)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockPhysicalBackupSlotRepoMockRecorder) Get(ctx, provider, region, kubernetes, slotTime any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockPhysicalBackupSlotRepo)(nil).Get), ctx, provider, region, kubernetes, slotTime)
}

// GetLatest mocks base method.
func (m *MockPhysicalBackupSlotRepo) GetLatest(ctx context.Context, provider, region, kubernetes string) (*entity.PhysicalBackupSlot, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatest", ctx, provider, region, kubernetes)
	ret0, _ := ret[0].(*entity.PhysicalBackupSlot)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetLatest indicates an expected call of GetLatest.
func (mr *MockPhysicalBackupSlotRepoMockRecorder) GetLatest(ctx, provider, region, kubernetes any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatest", reflect.TypeOf((*MockPhysicalBackupSlotRepo)(nil).GetLatest), ctx, provider, region, kubernetes)
}

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

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

// ListByBackupTime mocks base method.
func (m *MockPhysicalBackupSlotRepo) ListByBackupTime(ctx context.Context, scopes []entity.PhysicalBackupSlotScope, backupTimeGte time.Time) ([]*entity.PhysicalBackupSlot, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListByBackupTime", ctx, scopes, backupTimeGte)
	ret0, _ := ret[0].([]*entity.PhysicalBackupSlot)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ListByBackupTime indicates an expected call of ListByBackupTime.
func (mr *MockPhysicalBackupSlotRepoMockRecorder) ListByBackupTime(ctx, scopes, backupTimeGte any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListByBackupTime", reflect.TypeOf((*MockPhysicalBackupSlotRepo)(nil).ListByBackupTime), ctx, scopes, backupTimeGte)
}

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

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

// MockRestoreJobRepo is a mock of RestoreJobRepo interface.
type MockRestoreJobRepo struct {
	ctrl     *gomock.Controller
	recorder *MockRestoreJobRepoMockRecorder
	isgomock struct{}
}

// MockRestoreJobRepoMockRecorder is the mock recorder for MockRestoreJobRepo.
type MockRestoreJobRepoMockRecorder struct {
	mock *MockRestoreJobRepo
}

// NewMockRestoreJobRepo creates a new mock instance.
func NewMockRestoreJobRepo(ctrl *gomock.Controller) *MockRestoreJobRepo {
	mock := &MockRestoreJobRepo{ctrl: ctrl}
	mock.recorder = &MockRestoreJobRepoMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

// MockBackupScheduleCheckJobRepo is a mock of BackupScheduleCheckJobRepo interface.
type MockBackupScheduleCheckJobRepo struct {
	ctrl     *gomock.Controller
	recorder *MockBackupScheduleCheckJobRepoMockRecorder
	isgomock struct{}
}

// MockBackupScheduleCheckJobRepoMockRecorder is the mock recorder for MockBackupScheduleCheckJobRepo.
type MockBackupScheduleCheckJobRepoMockRecorder struct {
	mock *MockBackupScheduleCheckJobRepo
}

// NewMockBackupScheduleCheckJobRepo creates a new mock instance.
func NewMockBackupScheduleCheckJobRepo(ctrl *gomock.Controller) *MockBackupScheduleCheckJobRepo {
	mock := &MockBackupScheduleCheckJobRepo{ctrl: ctrl}
	mock.recorder = &MockBackupScheduleCheckJobRepoMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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