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

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

import (
	context "context"
	reflect "reflect"

	v1 "github.com/jetstack/cert-manager/pkg/apis/certmanager/v1"
	v1alpha2 "github.com/jetstack/cert-manager/pkg/apis/certmanager/v1alpha2"
	v1alpha1 "github.com/pingcap/tidb-operator/pkg/apis/pingcap/v1alpha1"
	clusterproxy "github.com/tidbcloud/pkgv2/clusterproxy"
	serverless "github.com/tidbcloud/pkgv2/clusterproxy/serverless"
	dm "github.com/tidbcloud/pkgv2/clusterproxy/serverless/dm"
	encrypt "github.com/tidbcloud/pkgv2/secret/encrypt"
	gomock "go.uber.org/mock/gomock"
	v10 "k8s.io/api/core/v1"
)

// MockClusterProxy is a mock of ClusterProxy interface.
type MockClusterProxy struct {
	ctrl     *gomock.Controller
	recorder *MockClusterProxyMockRecorder
}

// MockClusterProxyMockRecorder is the mock recorder for MockClusterProxy.
type MockClusterProxyMockRecorder struct {
	mock *MockClusterProxy
}

// NewMockClusterProxy creates a new mock instance.
func NewMockClusterProxy(ctrl *gomock.Controller) *MockClusterProxy {
	mock := &MockClusterProxy{ctrl: ctrl}
	mock.recorder = &MockClusterProxyMockRecorder{mock}
	return mock
}

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

// ChangePassword mocks base method.
func (m *MockClusterProxy) ChangePassword(ctx context.Context, pwd encrypt.Secret, newPwd string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangePassword", ctx, pwd, newPwd)
	ret0, _ := ret[0].(error)
	return ret0
}

// ChangePassword indicates an expected call of ChangePassword.
func (mr *MockClusterProxyMockRecorder) ChangePassword(ctx, pwd, newPwd any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangePassword", reflect.TypeOf((*MockClusterProxy)(nil).ChangePassword), ctx, pwd, newPwd)
}

// ChangePasswordV2 mocks base method.
func (m *MockClusterProxy) ChangePasswordV2(ctx context.Context, operator *clusterproxy.ClusterOperator, username, newPwd string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangePasswordV2", ctx, operator, username, newPwd)
	ret0, _ := ret[0].(error)
	return ret0
}

// ChangePasswordV2 indicates an expected call of ChangePasswordV2.
func (mr *MockClusterProxyMockRecorder) ChangePasswordV2(ctx, operator, username, newPwd any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangePasswordV2", reflect.TypeOf((*MockClusterProxy)(nil).ChangePasswordV2), ctx, operator, username, newPwd)
}

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

// CleanServerlessRestoreTask indicates an expected call of CleanServerlessRestoreTask.
func (mr *MockClusterProxyMockRecorder) CleanServerlessRestoreTask(ctx, token, restoreId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CleanServerlessRestoreTask", reflect.TypeOf((*MockClusterProxy)(nil).CleanServerlessRestoreTask), ctx, token, restoreId)
}

// CreateCDCTask mocks base method.
func (m *MockClusterProxy) CreateCDCTask(ctx context.Context, model clusterproxy.CdcCreateModel) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCDCTask", ctx, model)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// CreateChangefeed mocks base method.
func (m *MockClusterProxy) CreateChangefeed(ctx context.Context, crName string, model clusterproxy.CdcCreateModel) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateChangefeed", ctx, crName, model)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateChangefeed indicates an expected call of CreateChangefeed.
func (mr *MockClusterProxyMockRecorder) CreateChangefeed(ctx, crName, model any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateChangefeed", reflect.TypeOf((*MockClusterProxy)(nil).CreateChangefeed), ctx, crName, model)
}

// CreateChangefeedV2 mocks base method.
func (m *MockClusterProxy) CreateChangefeedV2(ctx context.Context, model clusterproxy.ChangefeedConfig) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateChangefeedV2", ctx, model)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// CreateChangefeed_v2 mocks base method.
func (m *MockClusterProxy) CreateChangefeed_v2(ctx context.Context, crName string, model clusterproxy.ChangefeedConfig) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateChangefeed_v2", ctx, crName, model)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateChangefeed_v2 indicates an expected call of CreateChangefeed_v2.
func (mr *MockClusterProxyMockRecorder) CreateChangefeed_v2(ctx, crName, model any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateChangefeed_v2", reflect.TypeOf((*MockClusterProxy)(nil).CreateChangefeed_v2), ctx, crName, model)
}

// CreateCloudAdmin mocks base method.
func (m *MockClusterProxy) CreateCloudAdmin(ctx context.Context, pwd encrypt.Secret) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCloudAdmin", ctx, pwd)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// CreateServerlessCDC mocks base method.
func (m *MockClusterProxy) CreateServerlessCDC(ctx context.Context, keyspaceId uint32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateServerlessCDC", ctx, keyspaceId)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// CreateServerlessChangefeed mocks base method.
func (m *MockClusterProxy) CreateServerlessChangefeed(ctx context.Context, keyspaceId uint32, req *serverless.ChangefeedConfig) (*serverless.Changefeed, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateServerlessChangefeed", ctx, keyspaceId, req)
	ret0, _ := ret[0].(*serverless.Changefeed)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateServerlessChangefeed indicates an expected call of CreateServerlessChangefeed.
func (mr *MockClusterProxyMockRecorder) CreateServerlessChangefeed(ctx, keyspaceId, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateServerlessChangefeed", reflect.TypeOf((*MockClusterProxy)(nil).CreateServerlessChangefeed), ctx, keyspaceId, req)
}

// CreateServerlessDMSource mocks base method.
func (m *MockClusterProxy) CreateServerlessDMSource(ctx context.Context, req *dm.CreateSourceRequest) (*dm.Source, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateServerlessDMSource", ctx, req)
	ret0, _ := ret[0].(*dm.Source)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateServerlessDMTask mocks base method.
func (m *MockClusterProxy) CreateServerlessDMTask(ctx context.Context, req *dm.CreateTaskRequest) (*dm.OperateTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateServerlessDMTask", ctx, req)
	ret0, _ := ret[0].(*dm.OperateTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTiCDCCR mocks base method.
func (m *MockClusterProxy) CreateTiCDCCR(ctx context.Context, cr *v1alpha1.TidbCluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTiCDCCR", ctx, cr)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// CreateTiCDCCertV1 mocks base method.
func (m *MockClusterProxy) CreateTiCDCCertV1(ctx context.Context, cert *v1.Certificate) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTiCDCCertV1", ctx, cert)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// CreateTiCDCCertV1alpha2 mocks base method.
func (m *MockClusterProxy) CreateTiCDCCertV1alpha2(ctx context.Context, cert *v1alpha2.Certificate) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTiCDCCertV1alpha2", ctx, cert)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteCDCTask mocks base method.
func (m *MockClusterProxy) DeleteCDCTask(ctx context.Context, taskID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCDCTask", ctx, taskID)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteChangefeed mocks base method.
func (m *MockClusterProxy) DeleteChangefeed(ctx context.Context, crName, changefeedID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteChangefeed", ctx, crName, changefeedID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteChangefeed indicates an expected call of DeleteChangefeed.
func (mr *MockClusterProxyMockRecorder) DeleteChangefeed(ctx, crName, changefeedID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChangefeed", reflect.TypeOf((*MockClusterProxy)(nil).DeleteChangefeed), ctx, crName, changefeedID)
}

// DeleteChangefeedV2 mocks base method.
func (m *MockClusterProxy) DeleteChangefeedV2(ctx context.Context, taskID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteChangefeedV2", ctx, taskID)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteChangefeed_v2 mocks base method.
func (m *MockClusterProxy) DeleteChangefeed_v2(ctx context.Context, crName, changefeedID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteChangefeed_v2", ctx, crName, changefeedID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteChangefeed_v2 indicates an expected call of DeleteChangefeed_v2.
func (mr *MockClusterProxyMockRecorder) DeleteChangefeed_v2(ctx, crName, changefeedID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChangefeed_v2", reflect.TypeOf((*MockClusterProxy)(nil).DeleteChangefeed_v2), ctx, crName, changefeedID)
}

// DeleteServerlessCDC mocks base method.
func (m *MockClusterProxy) DeleteServerlessCDC(ctx context.Context, keyspaceId uint32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteServerlessCDC", ctx, keyspaceId)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteServerlessChangefeed mocks base method.
func (m *MockClusterProxy) DeleteServerlessChangefeed(ctx context.Context, keyspaceId uint32, changefeedId string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteServerlessChangefeed", ctx, keyspaceId, changefeedId)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteServerlessChangefeed indicates an expected call of DeleteServerlessChangefeed.
func (mr *MockClusterProxyMockRecorder) DeleteServerlessChangefeed(ctx, keyspaceId, changefeedId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServerlessChangefeed", reflect.TypeOf((*MockClusterProxy)(nil).DeleteServerlessChangefeed), ctx, keyspaceId, changefeedId)
}

// DeleteServerlessDMSource mocks base method.
func (m *MockClusterProxy) DeleteServerlessDMSource(ctx context.Context, name string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteServerlessDMSource", ctx, name)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteServerlessDMTask mocks base method.
func (m *MockClusterProxy) DeleteServerlessDMTask(ctx context.Context, name string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteServerlessDMTask", ctx, name)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteTiCDCCR mocks base method.
func (m *MockClusterProxy) DeleteTiCDCCR(ctx context.Context, name, namespace string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTiCDCCR", ctx, name, namespace)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTiCDCCR indicates an expected call of DeleteTiCDCCR.
func (mr *MockClusterProxyMockRecorder) DeleteTiCDCCR(ctx, name, namespace any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTiCDCCR", reflect.TypeOf((*MockClusterProxy)(nil).DeleteTiCDCCR), ctx, name, namespace)
}

// DeleteTiCDCCertV1 mocks base method.
func (m *MockClusterProxy) DeleteTiCDCCertV1(ctx context.Context, name, namespace string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTiCDCCertV1", ctx, name, namespace)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTiCDCCertV1 indicates an expected call of DeleteTiCDCCertV1.
func (mr *MockClusterProxyMockRecorder) DeleteTiCDCCertV1(ctx, name, namespace any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTiCDCCertV1", reflect.TypeOf((*MockClusterProxy)(nil).DeleteTiCDCCertV1), ctx, name, namespace)
}

// DeleteTiCDCCertV1alpha2 mocks base method.
func (m *MockClusterProxy) DeleteTiCDCCertV1alpha2(ctx context.Context, name, namespace string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTiCDCCertV1alpha2", ctx, name, namespace)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTiCDCCertV1alpha2 indicates an expected call of DeleteTiCDCCertV1alpha2.
func (mr *MockClusterProxyMockRecorder) DeleteTiCDCCertV1alpha2(ctx, name, namespace any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTiCDCCertV1alpha2", reflect.TypeOf((*MockClusterProxy)(nil).DeleteTiCDCCertV1alpha2), ctx, name, namespace)
}

// DeleteTiCDCPvc mocks base method.
func (m *MockClusterProxy) DeleteTiCDCPvc(ctx context.Context, name, namespace string, label map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTiCDCPvc", ctx, name, namespace, label)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTiCDCPvc indicates an expected call of DeleteTiCDCPvc.
func (mr *MockClusterProxyMockRecorder) DeleteTiCDCPvc(ctx, name, namespace, label any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTiCDCPvc", reflect.TypeOf((*MockClusterProxy)(nil).DeleteTiCDCPvc), ctx, name, namespace, label)
}

// ExecuteMultiSQL mocks base method.
func (m *MockClusterProxy) ExecuteMultiSQL(ctx context.Context, pwd encrypt.Secret, sqls []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecuteMultiSQL", ctx, pwd, sqls)
	ret0, _ := ret[0].(error)
	return ret0
}

// ExecuteMultiSQL indicates an expected call of ExecuteMultiSQL.
func (mr *MockClusterProxyMockRecorder) ExecuteMultiSQL(ctx, pwd, sqls any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteMultiSQL", reflect.TypeOf((*MockClusterProxy)(nil).ExecuteMultiSQL), ctx, pwd, sqls)
}

// ExecuteMultiSQLV2 mocks base method.
func (m *MockClusterProxy) ExecuteMultiSQLV2(ctx context.Context, operator *clusterproxy.ClusterOperator, sqls []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecuteMultiSQLV2", ctx, operator, sqls)
	ret0, _ := ret[0].(error)
	return ret0
}

// ExecuteMultiSQLV2 indicates an expected call of ExecuteMultiSQLV2.
func (mr *MockClusterProxyMockRecorder) ExecuteMultiSQLV2(ctx, operator, sqls any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteMultiSQLV2", reflect.TypeOf((*MockClusterProxy)(nil).ExecuteMultiSQLV2), ctx, operator, sqls)
}

// ExecuteMultiSQLWithSqlError mocks base method.
func (m *MockClusterProxy) ExecuteMultiSQLWithSqlError(ctx context.Context, operator *clusterproxy.ClusterOperator, sqls []string) (*clusterproxy.ExecuteResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecuteMultiSQLWithSqlError", ctx, operator, sqls)
	ret0, _ := ret[0].(*clusterproxy.ExecuteResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExecuteMultiSQLWithSqlError indicates an expected call of ExecuteMultiSQLWithSqlError.
func (mr *MockClusterProxyMockRecorder) ExecuteMultiSQLWithSqlError(ctx, operator, sqls any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteMultiSQLWithSqlError", reflect.TypeOf((*MockClusterProxy)(nil).ExecuteMultiSQLWithSqlError), ctx, operator, sqls)
}

// ExecuteSQL mocks base method.
func (m *MockClusterProxy) ExecuteSQL(ctx context.Context, pwd encrypt.Secret, sql string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecuteSQL", ctx, pwd, sql)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ExecuteSQLEachTiDB mocks base method.
func (m *MockClusterProxy) ExecuteSQLEachTiDB(ctx context.Context, pwd encrypt.Secret, sql string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecuteSQLEachTiDB", ctx, pwd, sql)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ExecuteSQLV2 mocks base method.
func (m *MockClusterProxy) ExecuteSQLV2(ctx context.Context, operator *clusterproxy.ClusterOperator, sql string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecuteSQLV2", ctx, operator, sql)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ExecuteSQLWithSqlError mocks base method.
func (m *MockClusterProxy) ExecuteSQLWithSqlError(ctx context.Context, operator *clusterproxy.ClusterOperator, sql string) (*clusterproxy.ExecuteResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecuteSQLWithSqlError", ctx, operator, sql)
	ret0, _ := ret[0].(*clusterproxy.ExecuteResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCDCTaskInfo mocks base method.
func (m *MockClusterProxy) GetCDCTaskInfo(ctx context.Context) ([]clusterproxy.CdcInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCDCTaskInfo", ctx)
	ret0, _ := ret[0].([]clusterproxy.CdcInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChangefeedList mocks base method.
func (m *MockClusterProxy) GetChangefeedList(ctx context.Context, crName string) ([]clusterproxy.CdcInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChangefeedList", ctx, crName)
	ret0, _ := ret[0].([]clusterproxy.CdcInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChangefeedListV2 mocks base method.
func (m *MockClusterProxy) GetChangefeedListV2(ctx context.Context) ([]clusterproxy.ChangefeedCommonInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChangefeedListV2", ctx)
	ret0, _ := ret[0].([]clusterproxy.ChangefeedCommonInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChangefeedList_v2 mocks base method.
func (m *MockClusterProxy) GetChangefeedList_v2(ctx context.Context, crName string) ([]clusterproxy.ChangefeedCommonInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChangefeedList_v2", ctx, crName)
	ret0, _ := ret[0].([]clusterproxy.ChangefeedCommonInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChangefeedV2 mocks base method.
func (m *MockClusterProxy) GetChangefeedV2(ctx context.Context, taskID string) (*clusterproxy.ChangeFeedInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChangefeedV2", ctx, taskID)
	ret0, _ := ret[0].(*clusterproxy.ChangeFeedInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChangefeed_v2 mocks base method.
func (m *MockClusterProxy) GetChangefeed_v2(ctx context.Context, crName, changefeedID string) (*clusterproxy.ChangeFeedInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChangefeed_v2", ctx, crName, changefeedID)
	ret0, _ := ret[0].(*clusterproxy.ChangeFeedInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChangefeed_v2 indicates an expected call of GetChangefeed_v2.
func (mr *MockClusterProxyMockRecorder) GetChangefeed_v2(ctx, crName, changefeedID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChangefeed_v2", reflect.TypeOf((*MockClusterProxy)(nil).GetChangefeed_v2), ctx, crName, changefeedID)
}

// GetPDSafepoint mocks base method.
func (m *MockClusterProxy) GetPDSafepoint(ctx context.Context) (*clusterproxy.Safepoint, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPDSafepoint", ctx)
	ret0, _ := ret[0].(*clusterproxy.Safepoint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetServerlessChangefeed mocks base method.
func (m *MockClusterProxy) GetServerlessChangefeed(ctx context.Context, keyspaceId uint32, changefeedId string) (*serverless.Changefeed, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServerlessChangefeed", ctx, keyspaceId, changefeedId)
	ret0, _ := ret[0].(*serverless.Changefeed)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetServerlessChangefeed indicates an expected call of GetServerlessChangefeed.
func (mr *MockClusterProxyMockRecorder) GetServerlessChangefeed(ctx, keyspaceId, changefeedId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServerlessChangefeed", reflect.TypeOf((*MockClusterProxy)(nil).GetServerlessChangefeed), ctx, keyspaceId, changefeedId)
}

// GetServerlessDMSource mocks base method.
func (m *MockClusterProxy) GetServerlessDMSource(ctx context.Context, name string) (*dm.Source, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServerlessDMSource", ctx, name)
	ret0, _ := ret[0].(*dm.Source)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetServerlessGCSafePoint mocks base method.
func (m *MockClusterProxy) GetServerlessGCSafePoint(ctx context.Context, keyspaceId uint32) (*serverless.GCSafePointV2, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServerlessGCSafePoint", ctx, keyspaceId)
	ret0, _ := ret[0].(*serverless.GCSafePointV2)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetServerlessRestoreProgress mocks base method.
func (m *MockClusterProxy) GetServerlessRestoreProgress(ctx context.Context, token string, restoreId uint64) (*serverless.RestoreProgressResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServerlessRestoreProgress", ctx, token, restoreId)
	ret0, _ := ret[0].(*serverless.RestoreProgressResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetServerlessRestoreProgress indicates an expected call of GetServerlessRestoreProgress.
func (mr *MockClusterProxyMockRecorder) GetServerlessRestoreProgress(ctx, token, restoreId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServerlessRestoreProgress", reflect.TypeOf((*MockClusterProxy)(nil).GetServerlessRestoreProgress), ctx, token, restoreId)
}

// GetSourceTables mocks base method.
func (m *MockClusterProxy) GetSourceTables(ctx context.Context, model *clusterproxy.ConnectionModel) ([]clusterproxy.TableInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSourceTables", ctx, model)
	ret0, _ := ret[0].([]clusterproxy.TableInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// ListServerlessBackups mocks base method.
func (m *MockClusterProxy) ListServerlessBackups(ctx context.Context, req serverless.ListBackupRequest) (*serverless.ListBackupResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListServerlessBackups", ctx, req)
	ret0, _ := ret[0].(*serverless.ListBackupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListServerlessChangefeeds mocks base method.
func (m *MockClusterProxy) ListServerlessChangefeeds(ctx context.Context, keyspaceId uint32, state *serverless.ChangefeedState) (*serverless.ListChangefeedsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListServerlessChangefeeds", ctx, keyspaceId, state)
	ret0, _ := ret[0].(*serverless.ListChangefeedsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListServerlessChangefeeds indicates an expected call of ListServerlessChangefeeds.
func (mr *MockClusterProxyMockRecorder) ListServerlessChangefeeds(ctx, keyspaceId, state any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServerlessChangefeeds", reflect.TypeOf((*MockClusterProxy)(nil).ListServerlessChangefeeds), ctx, keyspaceId, state)
}

// ListServerlessDMWorkers mocks base method.
func (m *MockClusterProxy) ListServerlessDMWorkers(ctx context.Context) (*dm.GetClusterWorkerListResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListServerlessDMWorkers", ctx)
	ret0, _ := ret[0].(*dm.GetClusterWorkerListResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTiCDCNode mocks base method.
func (m *MockClusterProxy) ListTiCDCNode(ctx context.Context, label map[string]string) (*v10.NodeList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTiCDCNode", ctx, label)
	ret0, _ := ret[0].(*v10.NodeList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTiCDCPod mocks base method.
func (m *MockClusterProxy) ListTiCDCPod(ctx context.Context, label map[string]string) (*v10.PodList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTiCDCPod", ctx, label)
	ret0, _ := ret[0].(*v10.PodList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTiCDCPvc mocks base method.
func (m *MockClusterProxy) ListTiCDCPvc(ctx context.Context, namespace string, label map[string]string) (*v10.PersistentVolumeClaimList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTiCDCPvc", ctx, namespace, label)
	ret0, _ := ret[0].(*v10.PersistentVolumeClaimList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTiCDCPvc indicates an expected call of ListTiCDCPvc.
func (mr *MockClusterProxyMockRecorder) ListTiCDCPvc(ctx, namespace, label any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTiCDCPvc", reflect.TypeOf((*MockClusterProxy)(nil).ListTiCDCPvc), ctx, namespace, label)
}

// OpenWebsocket mocks base method.
func (m *MockClusterProxy) OpenWebsocket(ctx context.Context, operator *clusterproxy.ClusterOperator) (clusterproxy.WebsocketConn, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenWebsocket", ctx, operator)
	ret0, _ := ret[0].(clusterproxy.WebsocketConn)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PauseCDCTask mocks base method.
func (m *MockClusterProxy) PauseCDCTask(ctx context.Context, taskID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PauseCDCTask", ctx, taskID)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// PauseChangefeed mocks base method.
func (m *MockClusterProxy) PauseChangefeed(ctx context.Context, crName, changefeedID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PauseChangefeed", ctx, crName, changefeedID)
	ret0, _ := ret[0].(error)
	return ret0
}

// PauseChangefeed indicates an expected call of PauseChangefeed.
func (mr *MockClusterProxyMockRecorder) PauseChangefeed(ctx, crName, changefeedID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PauseChangefeed", reflect.TypeOf((*MockClusterProxy)(nil).PauseChangefeed), ctx, crName, changefeedID)
}

// PauseChangefeedV2 mocks base method.
func (m *MockClusterProxy) PauseChangefeedV2(ctx context.Context, taskID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PauseChangefeedV2", ctx, taskID)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// PauseChangefeed_v2 mocks base method.
func (m *MockClusterProxy) PauseChangefeed_v2(ctx context.Context, crName, changefeedID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PauseChangefeed_v2", ctx, crName, changefeedID)
	ret0, _ := ret[0].(error)
	return ret0
}

// PauseChangefeed_v2 indicates an expected call of PauseChangefeed_v2.
func (mr *MockClusterProxyMockRecorder) PauseChangefeed_v2(ctx, crName, changefeedID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PauseChangefeed_v2", reflect.TypeOf((*MockClusterProxy)(nil).PauseChangefeed_v2), ctx, crName, changefeedID)
}

// PauseServerlessChangefeed mocks base method.
func (m *MockClusterProxy) PauseServerlessChangefeed(ctx context.Context, keyspaceId uint32, changefeedId string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PauseServerlessChangefeed", ctx, keyspaceId, changefeedId)
	ret0, _ := ret[0].(error)
	return ret0
}

// PauseServerlessChangefeed indicates an expected call of PauseServerlessChangefeed.
func (mr *MockClusterProxyMockRecorder) PauseServerlessChangefeed(ctx, keyspaceId, changefeedId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PauseServerlessChangefeed", reflect.TypeOf((*MockClusterProxy)(nil).PauseServerlessChangefeed), ctx, keyspaceId, changefeedId)
}

// QuerySQL mocks base method.
func (m *MockClusterProxy) QuerySQL(ctx context.Context, pwd encrypt.Secret, sql string) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QuerySQL", ctx, pwd, sql)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// QuerySQLV2 mocks base method.
func (m *MockClusterProxy) QuerySQLV2(ctx context.Context, operator *clusterproxy.ClusterOperator, sql string) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QuerySQLV2", ctx, operator, sql)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// QuerySQLWithSqlError mocks base method.
func (m *MockClusterProxy) QuerySQLWithSqlError(ctx context.Context, operator *clusterproxy.ClusterOperator, sql string) (*clusterproxy.QuerySQLResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QuerySQLWithSqlError", ctx, operator, sql)
	ret0, _ := ret[0].(*clusterproxy.QuerySQLResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// QueryServerlessDMTaskStatus mocks base method.
func (m *MockClusterProxy) QueryServerlessDMTaskStatus(ctx context.Context, name string, sourceNameList []string) (*dm.GetTaskStatusResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryServerlessDMTaskStatus", ctx, name, sourceNameList)
	ret0, _ := ret[0].(*dm.GetTaskStatusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryServerlessDMTaskStatus indicates an expected call of QueryServerlessDMTaskStatus.
func (mr *MockClusterProxyMockRecorder) QueryServerlessDMTaskStatus(ctx, name, sourceNameList any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryServerlessDMTaskStatus", reflect.TypeOf((*MockClusterProxy)(nil).QueryServerlessDMTaskStatus), ctx, name, sourceNameList)
}

// QueryTiCDCCR mocks base method.
func (m *MockClusterProxy) QueryTiCDCCR(ctx context.Context, name, namespace string) (*v1alpha1.TidbCluster, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryTiCDCCR", ctx, name, namespace)
	ret0, _ := ret[0].(*v1alpha1.TidbCluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryTiCDCCR indicates an expected call of QueryTiCDCCR.
func (mr *MockClusterProxyMockRecorder) QueryTiCDCCR(ctx, name, namespace any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTiCDCCR", reflect.TypeOf((*MockClusterProxy)(nil).QueryTiCDCCR), ctx, name, namespace)
}

// QueryTiCDCCertV1 mocks base method.
func (m *MockClusterProxy) QueryTiCDCCertV1(ctx context.Context, name, namespace string) (*v1.Certificate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryTiCDCCertV1", ctx, name, namespace)
	ret0, _ := ret[0].(*v1.Certificate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryTiCDCCertV1 indicates an expected call of QueryTiCDCCertV1.
func (mr *MockClusterProxyMockRecorder) QueryTiCDCCertV1(ctx, name, namespace any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTiCDCCertV1", reflect.TypeOf((*MockClusterProxy)(nil).QueryTiCDCCertV1), ctx, name, namespace)
}

// QueryTiCDCCertV1alpha2 mocks base method.
func (m *MockClusterProxy) QueryTiCDCCertV1alpha2(ctx context.Context, name, namespace string) (*v1alpha2.Certificate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryTiCDCCertV1alpha2", ctx, name, namespace)
	ret0, _ := ret[0].(*v1alpha2.Certificate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryTiCDCCertV1alpha2 indicates an expected call of QueryTiCDCCertV1alpha2.
func (mr *MockClusterProxyMockRecorder) QueryTiCDCCertV1alpha2(ctx, name, namespace any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTiCDCCertV1alpha2", reflect.TypeOf((*MockClusterProxy)(nil).QueryTiCDCCertV1alpha2), ctx, name, namespace)
}

// RestoreServerlessCluster mocks base method.
func (m *MockClusterProxy) RestoreServerlessCluster(ctx context.Context, req serverless.RestoreRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreServerlessCluster", ctx, req)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ResumeCDCTask mocks base method.
func (m *MockClusterProxy) ResumeCDCTask(ctx context.Context, taskID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResumeCDCTask", ctx, taskID)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ResumeChangefeed mocks base method.
func (m *MockClusterProxy) ResumeChangefeed(ctx context.Context, crName, changefeedID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResumeChangefeed", ctx, crName, changefeedID)
	ret0, _ := ret[0].(error)
	return ret0
}

// ResumeChangefeed indicates an expected call of ResumeChangefeed.
func (mr *MockClusterProxyMockRecorder) ResumeChangefeed(ctx, crName, changefeedID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeChangefeed", reflect.TypeOf((*MockClusterProxy)(nil).ResumeChangefeed), ctx, crName, changefeedID)
}

// ResumeChangefeedV2 mocks base method.
func (m *MockClusterProxy) ResumeChangefeedV2(ctx context.Context, taskID string, resumeConfig clusterproxy.ResumeChangefeedConfig) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResumeChangefeedV2", ctx, taskID, resumeConfig)
	ret0, _ := ret[0].(error)
	return ret0
}

// ResumeChangefeedV2 indicates an expected call of ResumeChangefeedV2.
func (mr *MockClusterProxyMockRecorder) ResumeChangefeedV2(ctx, taskID, resumeConfig any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeChangefeedV2", reflect.TypeOf((*MockClusterProxy)(nil).ResumeChangefeedV2), ctx, taskID, resumeConfig)
}

// ResumeChangefeed_v2 mocks base method.
func (m *MockClusterProxy) ResumeChangefeed_v2(ctx context.Context, crName, changefeedID string, resumeConfig clusterproxy.ResumeChangefeedConfig) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResumeChangefeed_v2", ctx, crName, changefeedID, resumeConfig)
	ret0, _ := ret[0].(error)
	return ret0
}

// ResumeChangefeed_v2 indicates an expected call of ResumeChangefeed_v2.
func (mr *MockClusterProxyMockRecorder) ResumeChangefeed_v2(ctx, crName, changefeedID, resumeConfig any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeChangefeed_v2", reflect.TypeOf((*MockClusterProxy)(nil).ResumeChangefeed_v2), ctx, crName, changefeedID, resumeConfig)
}

// ResumeServerlessChangefeed mocks base method.
func (m *MockClusterProxy) ResumeServerlessChangefeed(ctx context.Context, keyspaceId uint32, changefeedId string, req *serverless.ResumeChangefeedConfig) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResumeServerlessChangefeed", ctx, keyspaceId, changefeedId, req)
	ret0, _ := ret[0].(error)
	return ret0
}

// ResumeServerlessChangefeed indicates an expected call of ResumeServerlessChangefeed.
func (mr *MockClusterProxyMockRecorder) ResumeServerlessChangefeed(ctx, keyspaceId, changefeedId, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeServerlessChangefeed", reflect.TypeOf((*MockClusterProxy)(nil).ResumeServerlessChangefeed), ctx, keyspaceId, changefeedId, req)
}

// StartServerlessDMTask mocks base method.
func (m *MockClusterProxy) StartServerlessDMTask(ctx context.Context, name string, reqg *dm.StartTaskRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartServerlessDMTask", ctx, name, reqg)
	ret0, _ := ret[0].(error)
	return ret0
}

// StartServerlessDMTask indicates an expected call of StartServerlessDMTask.
func (mr *MockClusterProxyMockRecorder) StartServerlessDMTask(ctx, name, reqg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartServerlessDMTask", reflect.TypeOf((*MockClusterProxy)(nil).StartServerlessDMTask), ctx, name, reqg)
}

// StopServerlessDMTask mocks base method.
func (m *MockClusterProxy) StopServerlessDMTask(ctx context.Context, name string, req *dm.StopTaskRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopServerlessDMTask", ctx, name, req)
	ret0, _ := ret[0].(error)
	return ret0
}

// StopServerlessDMTask indicates an expected call of StopServerlessDMTask.
func (mr *MockClusterProxyMockRecorder) StopServerlessDMTask(ctx, name, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopServerlessDMTask", reflect.TypeOf((*MockClusterProxy)(nil).StopServerlessDMTask), ctx, name, req)
}

// TestAuditConnection mocks base method.
func (m *MockClusterProxy) TestAuditConnection(ctx context.Context, input clusterproxy.AuditCheckModel) (*clusterproxy.AuditCheckResp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TestAuditConnection", ctx, input)
	ret0, _ := ret[0].(*clusterproxy.AuditCheckResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// TestAuditConnectionV2 mocks base method.
func (m *MockClusterProxy) TestAuditConnectionV2(ctx context.Context, input clusterproxy.AuditCheckModelV2) (*clusterproxy.AuditCheckResp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TestAuditConnectionV2", ctx, input)
	ret0, _ := ret[0].(*clusterproxy.AuditCheckResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// TestConnection mocks base method.
func (m *MockClusterProxy) TestConnection(ctx context.Context, model *clusterproxy.ConnectionModel) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TestConnection", ctx, model)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UpdateCDCTask mocks base method.
func (m *MockClusterProxy) UpdateCDCTask(ctx context.Context, taskID string, model clusterproxy.CdcUpdateModel) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCDCTask", ctx, taskID, model)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateCDCTask indicates an expected call of UpdateCDCTask.
func (mr *MockClusterProxyMockRecorder) UpdateCDCTask(ctx, taskID, model any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCDCTask", reflect.TypeOf((*MockClusterProxy)(nil).UpdateCDCTask), ctx, taskID, model)
}

// UpdateChangefeed mocks base method.
func (m *MockClusterProxy) UpdateChangefeed(ctx context.Context, crName, taskID string, model clusterproxy.CdcUpdateModel) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChangefeed", ctx, crName, taskID, model)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateChangefeed indicates an expected call of UpdateChangefeed.
func (mr *MockClusterProxyMockRecorder) UpdateChangefeed(ctx, crName, taskID, model any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChangefeed", reflect.TypeOf((*MockClusterProxy)(nil).UpdateChangefeed), ctx, crName, taskID, model)
}

// UpdateChangefeedV2 mocks base method.
func (m *MockClusterProxy) UpdateChangefeedV2(ctx context.Context, taskID string, model clusterproxy.ChangefeedConfig) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChangefeedV2", ctx, taskID, model)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateChangefeedV2 indicates an expected call of UpdateChangefeedV2.
func (mr *MockClusterProxyMockRecorder) UpdateChangefeedV2(ctx, taskID, model any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChangefeedV2", reflect.TypeOf((*MockClusterProxy)(nil).UpdateChangefeedV2), ctx, taskID, model)
}

// UpdateChangefeed_v2 mocks base method.
func (m *MockClusterProxy) UpdateChangefeed_v2(ctx context.Context, crName, changefeedID string, model clusterproxy.ChangefeedConfig) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChangefeed_v2", ctx, crName, changefeedID, model)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateChangefeed_v2 indicates an expected call of UpdateChangefeed_v2.
func (mr *MockClusterProxyMockRecorder) UpdateChangefeed_v2(ctx, crName, changefeedID, model any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChangefeed_v2", reflect.TypeOf((*MockClusterProxy)(nil).UpdateChangefeed_v2), ctx, crName, changefeedID, model)
}

// UpdateServerlessChangefeed mocks base method.
func (m *MockClusterProxy) UpdateServerlessChangefeed(ctx context.Context, keyspaceId uint32, changefeedId string, req *serverless.ChangefeedConfig) (*serverless.Changefeed, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateServerlessChangefeed", ctx, keyspaceId, changefeedId, req)
	ret0, _ := ret[0].(*serverless.Changefeed)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateServerlessChangefeed indicates an expected call of UpdateServerlessChangefeed.
func (mr *MockClusterProxyMockRecorder) UpdateServerlessChangefeed(ctx, keyspaceId, changefeedId, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServerlessChangefeed", reflect.TypeOf((*MockClusterProxy)(nil).UpdateServerlessChangefeed), ctx, keyspaceId, changefeedId, req)
}

// UpdateTiCDCCR mocks base method.
func (m *MockClusterProxy) UpdateTiCDCCR(ctx context.Context, cr *v1alpha1.TidbCluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTiCDCCR", ctx, cr)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockTiCDCClusterInterface is a mock of TiCDCClusterInterface interface.
type MockTiCDCClusterInterface struct {
	ctrl     *gomock.Controller
	recorder *MockTiCDCClusterInterfaceMockRecorder
}

// MockTiCDCClusterInterfaceMockRecorder is the mock recorder for MockTiCDCClusterInterface.
type MockTiCDCClusterInterfaceMockRecorder struct {
	mock *MockTiCDCClusterInterface
}

// NewMockTiCDCClusterInterface creates a new mock instance.
func NewMockTiCDCClusterInterface(ctrl *gomock.Controller) *MockTiCDCClusterInterface {
	mock := &MockTiCDCClusterInterface{ctrl: ctrl}
	mock.recorder = &MockTiCDCClusterInterfaceMockRecorder{mock}
	return mock
}

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

// CreateTiCDCCR mocks base method.
func (m *MockTiCDCClusterInterface) CreateTiCDCCR(ctx context.Context, cr *v1alpha1.TidbCluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTiCDCCR", ctx, cr)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// CreateTiCDCCertV1 mocks base method.
func (m *MockTiCDCClusterInterface) CreateTiCDCCertV1(ctx context.Context, cert *v1.Certificate) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTiCDCCertV1", ctx, cert)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// CreateTiCDCCertV1alpha2 mocks base method.
func (m *MockTiCDCClusterInterface) CreateTiCDCCertV1alpha2(ctx context.Context, cert *v1alpha2.Certificate) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTiCDCCertV1alpha2", ctx, cert)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteTiCDCCR mocks base method.
func (m *MockTiCDCClusterInterface) DeleteTiCDCCR(ctx context.Context, name, namespace string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTiCDCCR", ctx, name, namespace)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTiCDCCR indicates an expected call of DeleteTiCDCCR.
func (mr *MockTiCDCClusterInterfaceMockRecorder) DeleteTiCDCCR(ctx, name, namespace any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTiCDCCR", reflect.TypeOf((*MockTiCDCClusterInterface)(nil).DeleteTiCDCCR), ctx, name, namespace)
}

// DeleteTiCDCCertV1 mocks base method.
func (m *MockTiCDCClusterInterface) DeleteTiCDCCertV1(ctx context.Context, name, namespace string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTiCDCCertV1", ctx, name, namespace)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTiCDCCertV1 indicates an expected call of DeleteTiCDCCertV1.
func (mr *MockTiCDCClusterInterfaceMockRecorder) DeleteTiCDCCertV1(ctx, name, namespace any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTiCDCCertV1", reflect.TypeOf((*MockTiCDCClusterInterface)(nil).DeleteTiCDCCertV1), ctx, name, namespace)
}

// DeleteTiCDCCertV1alpha2 mocks base method.
func (m *MockTiCDCClusterInterface) DeleteTiCDCCertV1alpha2(ctx context.Context, name, namespace string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTiCDCCertV1alpha2", ctx, name, namespace)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTiCDCCertV1alpha2 indicates an expected call of DeleteTiCDCCertV1alpha2.
func (mr *MockTiCDCClusterInterfaceMockRecorder) DeleteTiCDCCertV1alpha2(ctx, name, namespace any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTiCDCCertV1alpha2", reflect.TypeOf((*MockTiCDCClusterInterface)(nil).DeleteTiCDCCertV1alpha2), ctx, name, namespace)
}

// DeleteTiCDCPvc mocks base method.
func (m *MockTiCDCClusterInterface) DeleteTiCDCPvc(ctx context.Context, name, namespace string, label map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTiCDCPvc", ctx, name, namespace, label)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTiCDCPvc indicates an expected call of DeleteTiCDCPvc.
func (mr *MockTiCDCClusterInterfaceMockRecorder) DeleteTiCDCPvc(ctx, name, namespace, label any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTiCDCPvc", reflect.TypeOf((*MockTiCDCClusterInterface)(nil).DeleteTiCDCPvc), ctx, name, namespace, label)
}

// ListTiCDCNode mocks base method.
func (m *MockTiCDCClusterInterface) ListTiCDCNode(ctx context.Context, label map[string]string) (*v10.NodeList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTiCDCNode", ctx, label)
	ret0, _ := ret[0].(*v10.NodeList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTiCDCPod mocks base method.
func (m *MockTiCDCClusterInterface) ListTiCDCPod(ctx context.Context, label map[string]string) (*v10.PodList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTiCDCPod", ctx, label)
	ret0, _ := ret[0].(*v10.PodList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTiCDCPvc mocks base method.
func (m *MockTiCDCClusterInterface) ListTiCDCPvc(ctx context.Context, namespace string, label map[string]string) (*v10.PersistentVolumeClaimList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTiCDCPvc", ctx, namespace, label)
	ret0, _ := ret[0].(*v10.PersistentVolumeClaimList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTiCDCPvc indicates an expected call of ListTiCDCPvc.
func (mr *MockTiCDCClusterInterfaceMockRecorder) ListTiCDCPvc(ctx, namespace, label any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTiCDCPvc", reflect.TypeOf((*MockTiCDCClusterInterface)(nil).ListTiCDCPvc), ctx, namespace, label)
}

// QueryTiCDCCR mocks base method.
func (m *MockTiCDCClusterInterface) QueryTiCDCCR(ctx context.Context, name, namespace string) (*v1alpha1.TidbCluster, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryTiCDCCR", ctx, name, namespace)
	ret0, _ := ret[0].(*v1alpha1.TidbCluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryTiCDCCR indicates an expected call of QueryTiCDCCR.
func (mr *MockTiCDCClusterInterfaceMockRecorder) QueryTiCDCCR(ctx, name, namespace any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTiCDCCR", reflect.TypeOf((*MockTiCDCClusterInterface)(nil).QueryTiCDCCR), ctx, name, namespace)
}

// QueryTiCDCCertV1 mocks base method.
func (m *MockTiCDCClusterInterface) QueryTiCDCCertV1(ctx context.Context, name, namespace string) (*v1.Certificate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryTiCDCCertV1", ctx, name, namespace)
	ret0, _ := ret[0].(*v1.Certificate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryTiCDCCertV1 indicates an expected call of QueryTiCDCCertV1.
func (mr *MockTiCDCClusterInterfaceMockRecorder) QueryTiCDCCertV1(ctx, name, namespace any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTiCDCCertV1", reflect.TypeOf((*MockTiCDCClusterInterface)(nil).QueryTiCDCCertV1), ctx, name, namespace)
}

// QueryTiCDCCertV1alpha2 mocks base method.
func (m *MockTiCDCClusterInterface) QueryTiCDCCertV1alpha2(ctx context.Context, name, namespace string) (*v1alpha2.Certificate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryTiCDCCertV1alpha2", ctx, name, namespace)
	ret0, _ := ret[0].(*v1alpha2.Certificate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryTiCDCCertV1alpha2 indicates an expected call of QueryTiCDCCertV1alpha2.
func (mr *MockTiCDCClusterInterfaceMockRecorder) QueryTiCDCCertV1alpha2(ctx, name, namespace any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTiCDCCertV1alpha2", reflect.TypeOf((*MockTiCDCClusterInterface)(nil).QueryTiCDCCertV1alpha2), ctx, name, namespace)
}

// UpdateTiCDCCR mocks base method.
func (m *MockTiCDCClusterInterface) UpdateTiCDCCR(ctx context.Context, cr *v1alpha1.TidbCluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTiCDCCR", ctx, cr)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockChangefeedInterface is a mock of ChangefeedInterface interface.
type MockChangefeedInterface struct {
	ctrl     *gomock.Controller
	recorder *MockChangefeedInterfaceMockRecorder
}

// MockChangefeedInterfaceMockRecorder is the mock recorder for MockChangefeedInterface.
type MockChangefeedInterfaceMockRecorder struct {
	mock *MockChangefeedInterface
}

// NewMockChangefeedInterface creates a new mock instance.
func NewMockChangefeedInterface(ctrl *gomock.Controller) *MockChangefeedInterface {
	mock := &MockChangefeedInterface{ctrl: ctrl}
	mock.recorder = &MockChangefeedInterfaceMockRecorder{mock}
	return mock
}

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

// CreateChangefeed mocks base method.
func (m *MockChangefeedInterface) CreateChangefeed(ctx context.Context, crName string, model clusterproxy.CdcCreateModel) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateChangefeed", ctx, crName, model)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateChangefeed indicates an expected call of CreateChangefeed.
func (mr *MockChangefeedInterfaceMockRecorder) CreateChangefeed(ctx, crName, model any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateChangefeed", reflect.TypeOf((*MockChangefeedInterface)(nil).CreateChangefeed), ctx, crName, model)
}

// CreateChangefeed_v2 mocks base method.
func (m *MockChangefeedInterface) CreateChangefeed_v2(ctx context.Context, crName string, model clusterproxy.ChangefeedConfig) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateChangefeed_v2", ctx, crName, model)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateChangefeed_v2 indicates an expected call of CreateChangefeed_v2.
func (mr *MockChangefeedInterfaceMockRecorder) CreateChangefeed_v2(ctx, crName, model any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateChangefeed_v2", reflect.TypeOf((*MockChangefeedInterface)(nil).CreateChangefeed_v2), ctx, crName, model)
}

// DeleteChangefeed mocks base method.
func (m *MockChangefeedInterface) DeleteChangefeed(ctx context.Context, crName, changefeedID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteChangefeed", ctx, crName, changefeedID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteChangefeed indicates an expected call of DeleteChangefeed.
func (mr *MockChangefeedInterfaceMockRecorder) DeleteChangefeed(ctx, crName, changefeedID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChangefeed", reflect.TypeOf((*MockChangefeedInterface)(nil).DeleteChangefeed), ctx, crName, changefeedID)
}

// DeleteChangefeed_v2 mocks base method.
func (m *MockChangefeedInterface) DeleteChangefeed_v2(ctx context.Context, crName, changefeedID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteChangefeed_v2", ctx, crName, changefeedID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteChangefeed_v2 indicates an expected call of DeleteChangefeed_v2.
func (mr *MockChangefeedInterfaceMockRecorder) DeleteChangefeed_v2(ctx, crName, changefeedID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChangefeed_v2", reflect.TypeOf((*MockChangefeedInterface)(nil).DeleteChangefeed_v2), ctx, crName, changefeedID)
}

// GetChangefeedList mocks base method.
func (m *MockChangefeedInterface) GetChangefeedList(ctx context.Context, crName string) ([]clusterproxy.CdcInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChangefeedList", ctx, crName)
	ret0, _ := ret[0].([]clusterproxy.CdcInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChangefeedList_v2 mocks base method.
func (m *MockChangefeedInterface) GetChangefeedList_v2(ctx context.Context, crName string) ([]clusterproxy.ChangefeedCommonInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChangefeedList_v2", ctx, crName)
	ret0, _ := ret[0].([]clusterproxy.ChangefeedCommonInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChangefeed_v2 mocks base method.
func (m *MockChangefeedInterface) GetChangefeed_v2(ctx context.Context, crName, changefeedID string) (*clusterproxy.ChangeFeedInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChangefeed_v2", ctx, crName, changefeedID)
	ret0, _ := ret[0].(*clusterproxy.ChangeFeedInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChangefeed_v2 indicates an expected call of GetChangefeed_v2.
func (mr *MockChangefeedInterfaceMockRecorder) GetChangefeed_v2(ctx, crName, changefeedID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChangefeed_v2", reflect.TypeOf((*MockChangefeedInterface)(nil).GetChangefeed_v2), ctx, crName, changefeedID)
}

// PauseChangefeed mocks base method.
func (m *MockChangefeedInterface) PauseChangefeed(ctx context.Context, crName, changefeedID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PauseChangefeed", ctx, crName, changefeedID)
	ret0, _ := ret[0].(error)
	return ret0
}

// PauseChangefeed indicates an expected call of PauseChangefeed.
func (mr *MockChangefeedInterfaceMockRecorder) PauseChangefeed(ctx, crName, changefeedID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PauseChangefeed", reflect.TypeOf((*MockChangefeedInterface)(nil).PauseChangefeed), ctx, crName, changefeedID)
}

// PauseChangefeed_v2 mocks base method.
func (m *MockChangefeedInterface) PauseChangefeed_v2(ctx context.Context, crName, changefeedID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PauseChangefeed_v2", ctx, crName, changefeedID)
	ret0, _ := ret[0].(error)
	return ret0
}

// PauseChangefeed_v2 indicates an expected call of PauseChangefeed_v2.
func (mr *MockChangefeedInterfaceMockRecorder) PauseChangefeed_v2(ctx, crName, changefeedID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PauseChangefeed_v2", reflect.TypeOf((*MockChangefeedInterface)(nil).PauseChangefeed_v2), ctx, crName, changefeedID)
}

// ResumeChangefeed mocks base method.
func (m *MockChangefeedInterface) ResumeChangefeed(ctx context.Context, crName, changefeedID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResumeChangefeed", ctx, crName, changefeedID)
	ret0, _ := ret[0].(error)
	return ret0
}

// ResumeChangefeed indicates an expected call of ResumeChangefeed.
func (mr *MockChangefeedInterfaceMockRecorder) ResumeChangefeed(ctx, crName, changefeedID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeChangefeed", reflect.TypeOf((*MockChangefeedInterface)(nil).ResumeChangefeed), ctx, crName, changefeedID)
}

// ResumeChangefeed_v2 mocks base method.
func (m *MockChangefeedInterface) ResumeChangefeed_v2(ctx context.Context, crName, changefeedID string, resumeConfig clusterproxy.ResumeChangefeedConfig) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResumeChangefeed_v2", ctx, crName, changefeedID, resumeConfig)
	ret0, _ := ret[0].(error)
	return ret0
}

// ResumeChangefeed_v2 indicates an expected call of ResumeChangefeed_v2.
func (mr *MockChangefeedInterfaceMockRecorder) ResumeChangefeed_v2(ctx, crName, changefeedID, resumeConfig any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeChangefeed_v2", reflect.TypeOf((*MockChangefeedInterface)(nil).ResumeChangefeed_v2), ctx, crName, changefeedID, resumeConfig)
}

// UpdateChangefeed mocks base method.
func (m *MockChangefeedInterface) UpdateChangefeed(ctx context.Context, crName, taskID string, model clusterproxy.CdcUpdateModel) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChangefeed", ctx, crName, taskID, model)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateChangefeed indicates an expected call of UpdateChangefeed.
func (mr *MockChangefeedInterfaceMockRecorder) UpdateChangefeed(ctx, crName, taskID, model any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChangefeed", reflect.TypeOf((*MockChangefeedInterface)(nil).UpdateChangefeed), ctx, crName, taskID, model)
}

// UpdateChangefeed_v2 mocks base method.
func (m *MockChangefeedInterface) UpdateChangefeed_v2(ctx context.Context, crName, changefeedID string, model clusterproxy.ChangefeedConfig) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChangefeed_v2", ctx, crName, changefeedID, model)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateChangefeed_v2 indicates an expected call of UpdateChangefeed_v2.
func (mr *MockChangefeedInterfaceMockRecorder) UpdateChangefeed_v2(ctx, crName, changefeedID, model any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChangefeed_v2", reflect.TypeOf((*MockChangefeedInterface)(nil).UpdateChangefeed_v2), ctx, crName, changefeedID, model)
}

// MockWebsocketConn is a mock of WebsocketConn interface.
type MockWebsocketConn struct {
	ctrl     *gomock.Controller
	recorder *MockWebsocketConnMockRecorder
}

// MockWebsocketConnMockRecorder is the mock recorder for MockWebsocketConn.
type MockWebsocketConnMockRecorder struct {
	mock *MockWebsocketConn
}

// NewMockWebsocketConn creates a new mock instance.
func NewMockWebsocketConn(ctrl *gomock.Controller) *MockWebsocketConn {
	mock := &MockWebsocketConn{ctrl: ctrl}
	mock.recorder = &MockWebsocketConnMockRecorder{mock}
	return mock
}

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

// BatchQuery mocks base method.
func (m *MockWebsocketConn) BatchQuery(ctx context.Context, sqls []string) ([][]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchQuery", ctx, sqls)
	ret0, _ := ret[0].([][]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Close mocks base method.
func (m *MockWebsocketConn) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close.
func (mr *MockWebsocketConnMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockWebsocketConn)(nil).Close))
}

// Exec mocks base method.
func (m *MockWebsocketConn) Exec(ctx context.Context, sql string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Exec", ctx, sql)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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