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

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

import (
	context "context"
	reflect "reflect"

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

// MockDMTaskRepo is a mock of DMTaskRepo interface.
type MockDMTaskRepo struct {
	ctrl     *gomock.Controller
	recorder *MockDMTaskRepoMockRecorder
}

// MockDMTaskRepoMockRecorder is the mock recorder for MockDMTaskRepo.
type MockDMTaskRepoMockRecorder struct {
	mock *MockDMTaskRepo
}

// NewMockDMTaskRepo creates a new mock instance.
func NewMockDMTaskRepo(ctrl *gomock.Controller) *MockDMTaskRepo {
	mock := &MockDMTaskRepo{ctrl: ctrl}
	mock.recorder = &MockDMTaskRepoMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetTask mocks base method.
func (m *MockDMTaskRepo) GetTask(ctx context.Context, clusterID, taskID string, stages []constant.DMTaskStage) (*entity.DMTask, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTask", ctx, clusterID, taskID, stages)
	ret0, _ := ret[0].(*entity.DMTask)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetTask indicates an expected call of GetTask.
func (mr *MockDMTaskRepoMockRecorder) GetTask(ctx, clusterID, taskID, stages any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTask", reflect.TypeOf((*MockDMTaskRepo)(nil).GetTask), ctx, clusterID, taskID, stages)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// UpdateTask mocks base method.
func (m *MockDMTaskRepo) UpdateTask(ctx context.Context, id string, stages []constant.DMTaskStage, updates map[string]any) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTask", ctx, id, stages, updates)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// UpdateTask indicates an expected call of UpdateTask.
func (mr *MockDMTaskRepoMockRecorder) UpdateTask(ctx, id, stages, updates any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTask", reflect.TypeOf((*MockDMTaskRepo)(nil).UpdateTask), ctx, id, stages, updates)
}

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

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