// Code generated by MockGen. DO NOT EDIT.
// Source: ./thirdparty/infra/infra.go

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

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	entity "github.com/tidbcloud/account/internel/dao/entity"
	core "github.com/tidbcloud/core-svc/idl/pbgen/proto/core"
	clusterproxy "github.com/tidbcloud/pkgv2/clusterproxy"
)

// MockInfraHandler is a mock of InfraHandler interface.
type MockInfraHandler struct {
	ctrl     *gomock.Controller
	recorder *MockInfraHandlerMockRecorder
}

// MockInfraHandlerMockRecorder is the mock recorder for MockInfraHandler.
type MockInfraHandlerMockRecorder struct {
	mock *MockInfraHandler
}

// NewMockInfraHandler creates a new mock instance.
func NewMockInfraHandler(ctrl *gomock.Controller) *MockInfraHandler {
	mock := &MockInfraHandler{ctrl: ctrl}
	mock.recorder = &MockInfraHandlerMockRecorder{mock}
	return mock
}

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

// CleanClusters mocks base method.
func (m *MockInfraHandler) CleanClusters(ctx context.Context, tenantID uint64, disableFinalBackup bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CleanClusters", ctx, tenantID, disableFinalBackup)
	ret0, _ := ret[0].(error)
	return ret0
}

// CleanClusters indicates an expected call of CleanClusters.
func (mr *MockInfraHandlerMockRecorder) CleanClusters(ctx, tenantID, disableFinalBackup interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CleanClusters", reflect.TypeOf((*MockInfraHandler)(nil).CleanClusters), ctx, tenantID, disableFinalBackup)
}

// CleanFreeClusters mocks base method.
func (m *MockInfraHandler) CleanFreeClusters(ctx context.Context, tenantID uint64, disableFinalBackup bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CleanFreeClusters", ctx, tenantID, disableFinalBackup)
	ret0, _ := ret[0].(error)
	return ret0
}

// CleanFreeClusters indicates an expected call of CleanFreeClusters.
func (mr *MockInfraHandlerMockRecorder) CleanFreeClusters(ctx, tenantID, disableFinalBackup interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CleanFreeClusters", reflect.TypeOf((*MockInfraHandler)(nil).CleanFreeClusters), ctx, tenantID, disableFinalBackup)
}

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

// CleanProjectResource indicates an expected call of CleanProjectResource.
func (mr *MockInfraHandlerMockRecorder) CleanProjectResource(ctx, projectID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CleanProjectResource", reflect.TypeOf((*MockInfraHandler)(nil).CleanProjectResource), ctx, projectID)
}

// CleanTenantResource mocks base method.
func (m *MockInfraHandler) CleanTenantResource(ctx context.Context, tenantID uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CleanTenantResource", ctx, tenantID)
	ret0, _ := ret[0].(error)
	return ret0
}

// CleanTenantResource indicates an expected call of CleanTenantResource.
func (mr *MockInfraHandlerMockRecorder) CleanTenantResource(ctx, tenantID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CleanTenantResource", reflect.TypeOf((*MockInfraHandler)(nil).CleanTenantResource), ctx, tenantID)
}

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

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

// CountClustersByOrg mocks base method.
func (m *MockInfraHandler) CountClustersByOrg(ctx context.Context, projectIds []uint64) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountClustersByOrg", ctx, projectIds)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountClustersByOrg indicates an expected call of CountClustersByOrg.
func (mr *MockInfraHandlerMockRecorder) CountClustersByOrg(ctx, projectIds interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountClustersByOrg", reflect.TypeOf((*MockInfraHandler)(nil).CountClustersByOrg), ctx, projectIds)
}

// CountClustersByProject mocks base method.
func (m *MockInfraHandler) CountClustersByProject(ctx context.Context, projectIds []uint64) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountClustersByProject", ctx, projectIds)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountClustersByProject indicates an expected call of CountClustersByProject.
func (mr *MockInfraHandlerMockRecorder) CountClustersByProject(ctx, projectIds interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountClustersByProject", reflect.TypeOf((*MockInfraHandler)(nil).CountClustersByProject), ctx, projectIds)
}

// CountNetworkPeers mocks base method.
func (m *MockInfraHandler) CountNetworkPeers(ctx context.Context, filter *core.NetworkPeerFilter) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountNetworkPeers", ctx, filter)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountNetworkPeers indicates an expected call of CountNetworkPeers.
func (mr *MockInfraHandlerMockRecorder) CountNetworkPeers(ctx, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountNetworkPeers", reflect.TypeOf((*MockInfraHandler)(nil).CountNetworkPeers), ctx, filter)
}

// CreateCluster mocks base method.
func (m *MockInfraHandler) CreateCluster(ctx context.Context, req *core.CreateClusterReq) (*uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCluster", ctx, req)
	ret0, _ := ret[0].(*uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCluster indicates an expected call of CreateCluster.
func (mr *MockInfraHandlerMockRecorder) CreateCluster(ctx, req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCluster", reflect.TypeOf((*MockInfraHandler)(nil).CreateCluster), ctx, req)
}

// CreateDBUser mocks base method.
func (m *MockInfraHandler) CreateDBUser(ctx context.Context, clusterId uint64, OperatorUserName string, operatorAuthMethod clusterproxy.AuthMethod, jwtToken, userEmail, dbUser string, ignoreExists bool, command *entity.CommandDBUserCluster, dbRole string) entity.CommandStatus {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDBUser", ctx, clusterId, OperatorUserName, operatorAuthMethod, jwtToken, userEmail, dbUser, ignoreExists, command, dbRole)
	ret0, _ := ret[0].(entity.CommandStatus)
	return ret0
}

// CreateDBUser indicates an expected call of CreateDBUser.
func (mr *MockInfraHandlerMockRecorder) CreateDBUser(ctx, clusterId, OperatorUserName, operatorAuthMethod, jwtToken, userEmail, dbUser, ignoreExists, command, dbRole interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBUser", reflect.TypeOf((*MockInfraHandler)(nil).CreateDBUser), ctx, clusterId, OperatorUserName, operatorAuthMethod, jwtToken, userEmail, dbUser, ignoreExists, command, dbRole)
}

// CreateGeneralDBUser mocks base method.
func (m *MockInfraHandler) CreateGeneralDBUser(ctx context.Context, req *core.CreateDBUserReq, checkCloudBuiltinRole string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGeneralDBUser", ctx, req, checkCloudBuiltinRole)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateGeneralDBUser indicates an expected call of CreateGeneralDBUser.
func (mr *MockInfraHandlerMockRecorder) CreateGeneralDBUser(ctx, req, checkCloudBuiltinRole interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGeneralDBUser", reflect.TypeOf((*MockInfraHandler)(nil).CreateGeneralDBUser), ctx, req, checkCloudBuiltinRole)
}

// DBUserISExisting mocks base method.
func (m *MockInfraHandler) DBUserISExisting(ctx context.Context, clusterId uint64, OperatorUserName, jwtToken, dbUser string) (bool, entity.CommandStatus) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DBUserISExisting", ctx, clusterId, OperatorUserName, jwtToken, dbUser)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(entity.CommandStatus)
	return ret0, ret1
}

// DBUserISExisting indicates an expected call of DBUserISExisting.
func (mr *MockInfraHandlerMockRecorder) DBUserISExisting(ctx, clusterId, OperatorUserName, jwtToken, dbUser interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DBUserISExisting", reflect.TypeOf((*MockInfraHandler)(nil).DBUserISExisting), ctx, clusterId, OperatorUserName, jwtToken, dbUser)
}

// DeleteDBUser mocks base method.
func (m *MockInfraHandler) DeleteDBUser(ctx context.Context, clusterId uint64, OperatorUserName, jwtToken, username string, command *entity.CommandDBUserCluster) entity.CommandStatus {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDBUser", ctx, clusterId, OperatorUserName, jwtToken, username, command)
	ret0, _ := ret[0].(entity.CommandStatus)
	return ret0
}

// DeleteDBUser indicates an expected call of DeleteDBUser.
func (mr *MockInfraHandlerMockRecorder) DeleteDBUser(ctx, clusterId, OperatorUserName, jwtToken, username, command interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBUser", reflect.TypeOf((*MockInfraHandler)(nil).DeleteDBUser), ctx, clusterId, OperatorUserName, jwtToken, username, command)
}

// DeleteSqlUser mocks base method.
func (m *MockInfraHandler) DeleteSqlUser(ctx context.Context, operator *core.DBUserOperator, dbUser string, clusterId uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSqlUser", ctx, operator, dbUser, clusterId)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteSqlUser indicates an expected call of DeleteSqlUser.
func (mr *MockInfraHandlerMockRecorder) DeleteSqlUser(ctx, operator, dbUser, clusterId interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSqlUser", reflect.TypeOf((*MockInfraHandler)(nil).DeleteSqlUser), ctx, operator, dbUser, clusterId)
}

// GetClusterById mocks base method.
func (m *MockInfraHandler) GetClusterById(ctx context.Context, clusterId uint64, useCache bool, status ...core.ClusterStatus) (*core.Cluster, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, clusterId, useCache}
	for _, a := range status {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClusterById", varargs...)
	ret0, _ := ret[0].(*core.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterById indicates an expected call of GetClusterById.
func (mr *MockInfraHandlerMockRecorder) GetClusterById(ctx, clusterId, useCache interface{}, status ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, clusterId, useCache}, status...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterById", reflect.TypeOf((*MockInfraHandler)(nil).GetClusterById), varargs...)
}

// GetClusterConfidentialInfo mocks base method.
func (m *MockInfraHandler) GetClusterConfidentialInfo(ctx context.Context, req *core.GetClusterConfidentialInfoReq) (*core.GetClusterConfidentialInfoResp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterConfidentialInfo", ctx, req)
	ret0, _ := ret[0].(*core.GetClusterConfidentialInfoResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterConfidentialInfo indicates an expected call of GetClusterConfidentialInfo.
func (mr *MockInfraHandlerMockRecorder) GetClusterConfidentialInfo(ctx, req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterConfidentialInfo", reflect.TypeOf((*MockInfraHandler)(nil).GetClusterConfidentialInfo), ctx, req)
}

// GetNormalStatusClusters mocks base method.
func (m *MockInfraHandler) GetNormalStatusClusters(ctx context.Context, orgID uint64, projectIds []uint64) ([]*core.Cluster, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNormalStatusClusters", ctx, orgID, projectIds)
	ret0, _ := ret[0].([]*core.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNormalStatusClusters indicates an expected call of GetNormalStatusClusters.
func (mr *MockInfraHandlerMockRecorder) GetNormalStatusClusters(ctx, orgID, projectIds interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNormalStatusClusters", reflect.TypeOf((*MockInfraHandler)(nil).GetNormalStatusClusters), ctx, orgID, projectIds)
}

// GetOrgClusterSupportDbUser mocks base method.
func (m *MockInfraHandler) GetOrgClusterSupportDbUser(ctx context.Context, orgID uint64) ([]*core.Cluster, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrgClusterSupportDbUser", ctx, orgID)
	ret0, _ := ret[0].([]*core.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrgClusterSupportDbUser indicates an expected call of GetOrgClusterSupportDbUser.
func (mr *MockInfraHandlerMockRecorder) GetOrgClusterSupportDbUser(ctx, orgID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrgClusterSupportDbUser", reflect.TypeOf((*MockInfraHandler)(nil).GetOrgClusterSupportDbUser), ctx, orgID)
}

// GetProjectClusterSupportDbUser mocks base method.
func (m *MockInfraHandler) GetProjectClusterSupportDbUser(ctx context.Context, projectIds []uint64) ([]*core.Cluster, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProjectClusterSupportDbUser", ctx, projectIds)
	ret0, _ := ret[0].([]*core.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProjectClusterSupportDbUser indicates an expected call of GetProjectClusterSupportDbUser.
func (mr *MockInfraHandlerMockRecorder) GetProjectClusterSupportDbUser(ctx, projectIds interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectClusterSupportDbUser", reflect.TypeOf((*MockInfraHandler)(nil).GetProjectClusterSupportDbUser), ctx, projectIds)
}

// GetProjectClustersInStatus mocks base method.
func (m *MockInfraHandler) GetProjectClustersInStatus(ctx context.Context, projectID uint64, status ...core.ClusterStatus) ([]*core.Cluster, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, projectID}
	for _, a := range status {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetProjectClustersInStatus", varargs...)
	ret0, _ := ret[0].([]*core.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProjectClustersInStatus indicates an expected call of GetProjectClustersInStatus.
func (mr *MockInfraHandlerMockRecorder) GetProjectClustersInStatus(ctx, projectID interface{}, status ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, projectID}, status...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectClustersInStatus", reflect.TypeOf((*MockInfraHandler)(nil).GetProjectClustersInStatus), varargs...)
}

// GetProjectClustersNotInStatus mocks base method.
func (m *MockInfraHandler) GetProjectClustersNotInStatus(ctx context.Context, projectID uint64, status ...core.ClusterStatus) ([]*core.Cluster, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, projectID}
	for _, a := range status {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetProjectClustersNotInStatus", varargs...)
	ret0, _ := ret[0].([]*core.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProjectClustersNotInStatus indicates an expected call of GetProjectClustersNotInStatus.
func (mr *MockInfraHandlerMockRecorder) GetProjectClustersNotInStatus(ctx, projectID interface{}, status ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, projectID}, status...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectClustersNotInStatus", reflect.TypeOf((*MockInfraHandler)(nil).GetProjectClustersNotInStatus), varargs...)
}

// GetServerlessDefaultRegion mocks base method.
func (m *MockInfraHandler) GetServerlessDefaultRegion(ctx context.Context, provider string, orgId, projectId uint64, clientIP string) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServerlessDefaultRegion", ctx, provider, orgId, projectId, clientIP)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetServerlessDefaultRegion indicates an expected call of GetServerlessDefaultRegion.
func (mr *MockInfraHandlerMockRecorder) GetServerlessDefaultRegion(ctx, provider, orgId, projectId, clientIP interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServerlessDefaultRegion", reflect.TypeOf((*MockInfraHandler)(nil).GetServerlessDefaultRegion), ctx, provider, orgId, projectId, clientIP)
}

// IsDedicatedCluster mocks base method.
func (m *MockInfraHandler) IsDedicatedCluster(ctx context.Context, clusterId uint64) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsDedicatedCluster", ctx, clusterId)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsDedicatedCluster indicates an expected call of IsDedicatedCluster.
func (mr *MockInfraHandlerMockRecorder) IsDedicatedCluster(ctx, clusterId interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsDedicatedCluster", reflect.TypeOf((*MockInfraHandler)(nil).IsDedicatedCluster), ctx, clusterId)
}

// ListSqlUser mocks base method.
func (m *MockInfraHandler) ListSqlUser(ctx context.Context, req *core.ListDBUsersReq) (*core.ListDBUsersResp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSqlUser", ctx, req)
	ret0, _ := ret[0].(*core.ListDBUsersResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSqlUser indicates an expected call of ListSqlUser.
func (mr *MockInfraHandlerMockRecorder) ListSqlUser(ctx, req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSqlUser", reflect.TypeOf((*MockInfraHandler)(nil).ListSqlUser), ctx, req)
}

// SetClusterAuthPubKey mocks base method.
func (m *MockInfraHandler) SetClusterAuthPubKey(ctx context.Context, clusterId uint64, keys string) entity.CommandStatus {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetClusterAuthPubKey", ctx, clusterId, keys)
	ret0, _ := ret[0].(entity.CommandStatus)
	return ret0
}

// SetClusterAuthPubKey indicates an expected call of SetClusterAuthPubKey.
func (mr *MockInfraHandlerMockRecorder) SetClusterAuthPubKey(ctx, clusterId, keys interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetClusterAuthPubKey", reflect.TypeOf((*MockInfraHandler)(nil).SetClusterAuthPubKey), ctx, clusterId, keys)
}

// UpdateSqlUser mocks base method.
func (m *MockInfraHandler) UpdateSqlUser(ctx context.Context, req *core.UpdateDBUserReq, cloudBuiltinRole string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSqlUser", ctx, req, cloudBuiltinRole)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateSqlUser indicates an expected call of UpdateSqlUser.
func (mr *MockInfraHandlerMockRecorder) UpdateSqlUser(ctx, req, cloudBuiltinRole interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSqlUser", reflect.TypeOf((*MockInfraHandler)(nil).UpdateSqlUser), ctx, req, cloudBuiltinRole)
}