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

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

import (
	context "context"
	reflect "reflect"

	v1 "github.com/tidbcloud/infra-api/api/v1"
	bizerr "github.com/tidbcloud/pkgv2/bizerr"
	clusterproxy "github.com/tidbcloud/pkgv2/clusterproxy"
	serverless "github.com/tidbcloud/pkgv2/clusterproxy/serverless"
	dm "github.com/tidbcloud/pkgv2/clusterproxy/serverless/dm"
	facade "github.com/tidbcloud/serverless-service/internal/domain/facade"
	tidb_mgmt_servicev1 "github.com/tidbcloud/tidb-management-service/api/spec/tidb_mgmt_service/v1"
	gomock "go.uber.org/mock/gomock"
)

// MockClusterProxyProviderFacade is a mock of ClusterProxyProviderFacade interface.
type MockClusterProxyProviderFacade struct {
	ctrl     *gomock.Controller
	recorder *MockClusterProxyProviderFacadeMockRecorder
}

// MockClusterProxyProviderFacadeMockRecorder is the mock recorder for MockClusterProxyProviderFacade.
type MockClusterProxyProviderFacadeMockRecorder struct {
	mock *MockClusterProxyProviderFacade
}

// NewMockClusterProxyProviderFacade creates a new mock instance.
func NewMockClusterProxyProviderFacade(ctrl *gomock.Controller) *MockClusterProxyProviderFacade {
	mock := &MockClusterProxyProviderFacade{ctrl: ctrl}
	mock.recorder = &MockClusterProxyProviderFacadeMockRecorder{mock}
	return mock
}

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

// GetBranchProxy mocks base method.
func (m *MockClusterProxyProviderFacade) GetBranchProxy(ctx context.Context, branchCr *v1.Branch, operator *clusterproxy.ClusterOperator) (facade.ClusterProxyFacade, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBranchProxy", ctx, branchCr, operator)
	ret0, _ := ret[0].(facade.ClusterProxyFacade)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

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

// GetClusterProxy mocks base method.
func (m *MockClusterProxyProviderFacade) GetClusterProxy(ctx context.Context, cluster *tidb_mgmt_servicev1.Cluster, operator *clusterproxy.ClusterOperator) (facade.ClusterProxyFacade, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterProxy", ctx, cluster, operator)
	ret0, _ := ret[0].(facade.ClusterProxyFacade)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

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

// GetClusterProxyWithTimeout mocks base method.
func (m *MockClusterProxyProviderFacade) GetClusterProxyWithTimeout(ctx context.Context, cluster *tidb_mgmt_servicev1.Cluster, operator *clusterproxy.ClusterOperator, timeoutSec int) (facade.ClusterProxyFacade, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterProxyWithTimeout", ctx, cluster, operator, timeoutSec)
	ret0, _ := ret[0].(facade.ClusterProxyFacade)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetClusterProxyWithTimeout indicates an expected call of GetClusterProxyWithTimeout.
func (mr *MockClusterProxyProviderFacadeMockRecorder) GetClusterProxyWithTimeout(ctx, cluster, operator, timeoutSec any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterProxyWithTimeout", reflect.TypeOf((*MockClusterProxyProviderFacade)(nil).GetClusterProxyWithTimeout), ctx, cluster, operator, timeoutSec)
}

// GetServerlessHTTPProxy mocks base method.
func (m *MockClusterProxyProviderFacade) GetServerlessHTTPProxy(ctx context.Context, clusterProxyURL string, namespace, service *string) (facade.ServerlessClusterProxyFacade, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServerlessHTTPProxy", ctx, clusterProxyURL, namespace, service)
	ret0, _ := ret[0].(facade.ServerlessClusterProxyFacade)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetServerlessHTTPProxy indicates an expected call of GetServerlessHTTPProxy.
func (mr *MockClusterProxyProviderFacadeMockRecorder) GetServerlessHTTPProxy(ctx, clusterProxyURL, namespace, service any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServerlessHTTPProxy", reflect.TypeOf((*MockClusterProxyProviderFacade)(nil).GetServerlessHTTPProxy), ctx, clusterProxyURL, namespace, service)
}

// GetServerlessProxy mocks base method.
func (m *MockClusterProxyProviderFacade) GetServerlessProxy(ctx context.Context, baseURL string) (facade.ServerlessClusterProxyFacade, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServerlessProxy", ctx, baseURL)
	ret0, _ := ret[0].(facade.ServerlessClusterProxyFacade)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

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

// MockClusterProxyFacade is a mock of ClusterProxyFacade interface.
type MockClusterProxyFacade struct {
	ctrl     *gomock.Controller
	recorder *MockClusterProxyFacadeMockRecorder
}

// MockClusterProxyFacadeMockRecorder is the mock recorder for MockClusterProxyFacade.
type MockClusterProxyFacadeMockRecorder struct {
	mock *MockClusterProxyFacade
}

// NewMockClusterProxyFacade creates a new mock instance.
func NewMockClusterProxyFacade(ctrl *gomock.Controller) *MockClusterProxyFacade {
	mock := &MockClusterProxyFacade{ctrl: ctrl}
	mock.recorder = &MockClusterProxyFacadeMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetOperator mocks base method.
func (m *MockClusterProxyFacade) SetOperator(operator *clusterproxy.ClusterOperator) facade.ClusterProxyFacade {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetOperator", operator)
	ret0, _ := ret[0].(facade.ClusterProxyFacade)
	return ret0
}

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

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

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

// MockServerlessClusterProxyFacade is a mock of ServerlessClusterProxyFacade interface.
type MockServerlessClusterProxyFacade struct {
	ctrl     *gomock.Controller
	recorder *MockServerlessClusterProxyFacadeMockRecorder
}

// MockServerlessClusterProxyFacadeMockRecorder is the mock recorder for MockServerlessClusterProxyFacade.
type MockServerlessClusterProxyFacadeMockRecorder struct {
	mock *MockServerlessClusterProxyFacade
}

// NewMockServerlessClusterProxyFacade creates a new mock instance.
func NewMockServerlessClusterProxyFacade(ctrl *gomock.Controller) *MockServerlessClusterProxyFacade {
	mock := &MockServerlessClusterProxyFacade{ctrl: ctrl}
	mock.recorder = &MockServerlessClusterProxyFacadeMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// CreateServerlessDMSource mocks base method.
func (m *MockServerlessClusterProxyFacade) 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 *MockServerlessClusterProxyFacadeMockRecorder) CreateServerlessDMSource(ctx, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateServerlessDMSource", reflect.TypeOf((*MockServerlessClusterProxyFacade)(nil).CreateServerlessDMSource), ctx, req)
}

// CreateServerlessDMTask mocks base method.
func (m *MockServerlessClusterProxyFacade) 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 *MockServerlessClusterProxyFacadeMockRecorder) CreateServerlessDMTask(ctx, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateServerlessDMTask", reflect.TypeOf((*MockServerlessClusterProxyFacade)(nil).CreateServerlessDMTask), ctx, req)
}

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

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

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

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

// DeleteServerlessDMSource mocks base method.
func (m *MockServerlessClusterProxyFacade) 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 *MockServerlessClusterProxyFacadeMockRecorder) DeleteServerlessDMSource(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServerlessDMSource", reflect.TypeOf((*MockServerlessClusterProxyFacade)(nil).DeleteServerlessDMSource), ctx, name)
}

// DeleteServerlessDMTask mocks base method.
func (m *MockServerlessClusterProxyFacade) 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 *MockServerlessClusterProxyFacadeMockRecorder) DeleteServerlessDMTask(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServerlessDMTask", reflect.TypeOf((*MockServerlessClusterProxyFacade)(nil).DeleteServerlessDMTask), ctx, name)
}

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

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

// GetServerlessDMSource mocks base method.
func (m *MockServerlessClusterProxyFacade) 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 *MockServerlessClusterProxyFacadeMockRecorder) GetServerlessDMSource(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServerlessDMSource", reflect.TypeOf((*MockServerlessClusterProxyFacade)(nil).GetServerlessDMSource), ctx, name)
}

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

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

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

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

// GetSourceTables mocks base method.
func (m *MockServerlessClusterProxyFacade) 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 *MockServerlessClusterProxyFacadeMockRecorder) GetSourceTables(ctx, model any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSourceTables", reflect.TypeOf((*MockServerlessClusterProxyFacade)(nil).GetSourceTables), ctx, model)
}

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

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

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

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

// ListServerlessDMWorkers mocks base method.
func (m *MockServerlessClusterProxyFacade) 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 *MockServerlessClusterProxyFacadeMockRecorder) ListServerlessDMWorkers(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServerlessDMWorkers", reflect.TypeOf((*MockServerlessClusterProxyFacade)(nil).ListServerlessDMWorkers), ctx)
}

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

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

// QueryServerlessDMTaskStatus mocks base method.
func (m *MockServerlessClusterProxyFacade) 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 *MockServerlessClusterProxyFacadeMockRecorder) QueryServerlessDMTaskStatus(ctx, name, sourceNameList any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryServerlessDMTaskStatus", reflect.TypeOf((*MockServerlessClusterProxyFacade)(nil).QueryServerlessDMTaskStatus), ctx, name, sourceNameList)
}

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

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

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

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

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

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

// StopServerlessDMTask mocks base method.
func (m *MockServerlessClusterProxyFacade) 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 *MockServerlessClusterProxyFacadeMockRecorder) StopServerlessDMTask(ctx, name, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopServerlessDMTask", reflect.TypeOf((*MockServerlessClusterProxyFacade)(nil).StopServerlessDMTask), ctx, name, req)
}

// TestConnection mocks base method.
func (m *MockServerlessClusterProxyFacade) 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 *MockServerlessClusterProxyFacadeMockRecorder) TestConnection(ctx, model any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestConnection", reflect.TypeOf((*MockServerlessClusterProxyFacade)(nil).TestConnection), ctx, model)
}

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

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