// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/tidbcloud/serverless-service/idl/pbgen/proto/rpc (interfaces: RegionalK8SOperationServiceClient,ClusterCROperationServiceClient,ChangefeedOpsServiceClient)
//
// Generated by this command:
//
//	mockgen -destination client_mock.go -package=serverlesscli github.com/tidbcloud/serverless-service/idl/pbgen/proto/rpc RegionalK8SOperationServiceClient,ClusterCROperationServiceClient,ChangefeedOpsServiceClient
//

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

import (
	context "context"
	reflect "reflect"

	rpc "github.com/tidbcloud/serverless-service/idl/pbgen/proto/rpc"
	gomock "go.uber.org/mock/gomock"
	grpc "google.golang.org/grpc"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// MockRegionalK8SOperationServiceClient is a mock of RegionalK8SOperationServiceClient interface.
type MockRegionalK8SOperationServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockRegionalK8SOperationServiceClientMockRecorder
	isgomock struct{}
}

// MockRegionalK8SOperationServiceClientMockRecorder is the mock recorder for MockRegionalK8SOperationServiceClient.
type MockRegionalK8SOperationServiceClientMockRecorder struct {
	mock *MockRegionalK8SOperationServiceClient
}

// NewMockRegionalK8SOperationServiceClient creates a new mock instance.
func NewMockRegionalK8SOperationServiceClient(ctrl *gomock.Controller) *MockRegionalK8SOperationServiceClient {
	mock := &MockRegionalK8SOperationServiceClient{ctrl: ctrl}
	mock.recorder = &MockRegionalK8SOperationServiceClientMockRecorder{mock}
	return mock
}

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

// ExecuteCommand mocks base method.
func (m *MockRegionalK8SOperationServiceClient) ExecuteCommand(ctx context.Context, in *rpc.OpsExecuteCommandRequest, opts ...grpc.CallOption) (*rpc.OpsExecuteCommandResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ExecuteCommand", varargs...)
	ret0, _ := ret[0].(*rpc.OpsExecuteCommandResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExecuteCommand indicates an expected call of ExecuteCommand.
func (mr *MockRegionalK8SOperationServiceClientMockRecorder) ExecuteCommand(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteCommand", reflect.TypeOf((*MockRegionalK8SOperationServiceClient)(nil).ExecuteCommand), varargs...)
}

// ListGatewayHPAInfos mocks base method.
func (m *MockRegionalK8SOperationServiceClient) ListGatewayHPAInfos(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*rpc.ListGatewayHPAInfosResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGatewayHPAInfos", varargs...)
	ret0, _ := ret[0].(*rpc.ListGatewayHPAInfosResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListGatewayHPAInfos indicates an expected call of ListGatewayHPAInfos.
func (mr *MockRegionalK8SOperationServiceClientMockRecorder) ListGatewayHPAInfos(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGatewayHPAInfos", reflect.TypeOf((*MockRegionalK8SOperationServiceClient)(nil).ListGatewayHPAInfos), varargs...)
}

// ListTiDBAutoscalingInfos mocks base method.
func (m *MockRegionalK8SOperationServiceClient) ListTiDBAutoscalingInfos(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*rpc.ListTiDBAutoscalingInfosResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTiDBAutoscalingInfos", varargs...)
	ret0, _ := ret[0].(*rpc.ListTiDBAutoscalingInfosResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTiDBAutoscalingInfos indicates an expected call of ListTiDBAutoscalingInfos.
func (mr *MockRegionalK8SOperationServiceClientMockRecorder) ListTiDBAutoscalingInfos(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTiDBAutoscalingInfos", reflect.TypeOf((*MockRegionalK8SOperationServiceClient)(nil).ListTiDBAutoscalingInfos), varargs...)
}

// RestartTiDBPodsByCluster mocks base method.
func (m *MockRegionalK8SOperationServiceClient) RestartTiDBPodsByCluster(ctx context.Context, in *rpc.OpsRestartByClusterRequest, opts ...grpc.CallOption) (*rpc.OpsRestartByClusterResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RestartTiDBPodsByCluster", varargs...)
	ret0, _ := ret[0].(*rpc.OpsRestartByClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RestartTiDBPodsByCluster indicates an expected call of RestartTiDBPodsByCluster.
func (mr *MockRegionalK8SOperationServiceClientMockRecorder) RestartTiDBPodsByCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestartTiDBPodsByCluster", reflect.TypeOf((*MockRegionalK8SOperationServiceClient)(nil).RestartTiDBPodsByCluster), varargs...)
}

// RestartTiDBPodsByNamespace mocks base method.
func (m *MockRegionalK8SOperationServiceClient) RestartTiDBPodsByNamespace(ctx context.Context, in *rpc.OpsRestartByNamespaceRequest, opts ...grpc.CallOption) (*rpc.OpsRestartByNamespaceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RestartTiDBPodsByNamespace", varargs...)
	ret0, _ := ret[0].(*rpc.OpsRestartByNamespaceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RestartTiDBPodsByNamespace indicates an expected call of RestartTiDBPodsByNamespace.
func (mr *MockRegionalK8SOperationServiceClientMockRecorder) RestartTiDBPodsByNamespace(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestartTiDBPodsByNamespace", reflect.TypeOf((*MockRegionalK8SOperationServiceClient)(nil).RestartTiDBPodsByNamespace), varargs...)
}

// UpdateGatewayHPAMinReplicas mocks base method.
func (m *MockRegionalK8SOperationServiceClient) UpdateGatewayHPAMinReplicas(ctx context.Context, in *rpc.UpdateGatewayHPAMinReplicasRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateGatewayHPAMinReplicas", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateGatewayHPAMinReplicas indicates an expected call of UpdateGatewayHPAMinReplicas.
func (mr *MockRegionalK8SOperationServiceClientMockRecorder) UpdateGatewayHPAMinReplicas(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGatewayHPAMinReplicas", reflect.TypeOf((*MockRegionalK8SOperationServiceClient)(nil).UpdateGatewayHPAMinReplicas), varargs...)
}

// UpdateTiDBAutoscalingThreshold mocks base method.
func (m *MockRegionalK8SOperationServiceClient) UpdateTiDBAutoscalingThreshold(ctx context.Context, in *rpc.UpdateTiDBAutoscalingThresholdRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateTiDBAutoscalingThreshold", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTiDBAutoscalingThreshold indicates an expected call of UpdateTiDBAutoscalingThreshold.
func (mr *MockRegionalK8SOperationServiceClientMockRecorder) UpdateTiDBAutoscalingThreshold(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTiDBAutoscalingThreshold", reflect.TypeOf((*MockRegionalK8SOperationServiceClient)(nil).UpdateTiDBAutoscalingThreshold), varargs...)
}

// MockClusterCROperationServiceClient is a mock of ClusterCROperationServiceClient interface.
type MockClusterCROperationServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockClusterCROperationServiceClientMockRecorder
	isgomock struct{}
}

// MockClusterCROperationServiceClientMockRecorder is the mock recorder for MockClusterCROperationServiceClient.
type MockClusterCROperationServiceClientMockRecorder struct {
	mock *MockClusterCROperationServiceClient
}

// NewMockClusterCROperationServiceClient creates a new mock instance.
func NewMockClusterCROperationServiceClient(ctrl *gomock.Controller) *MockClusterCROperationServiceClient {
	mock := &MockClusterCROperationServiceClient{ctrl: ctrl}
	mock.recorder = &MockClusterCROperationServiceClientMockRecorder{mock}
	return mock
}

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

// GetCluster mocks base method.
func (m *MockClusterCROperationServiceClient) GetCluster(ctx context.Context, in *rpc.GetClusterRequest, opts ...grpc.CallOption) (*rpc.ClusterDetails, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCluster", varargs...)
	ret0, _ := ret[0].(*rpc.ClusterDetails)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCluster indicates an expected call of GetCluster.
func (mr *MockClusterCROperationServiceClientMockRecorder) GetCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCluster", reflect.TypeOf((*MockClusterCROperationServiceClient)(nil).GetCluster), varargs...)
}

// UpdateCluster mocks base method.
func (m *MockClusterCROperationServiceClient) UpdateCluster(ctx context.Context, in *rpc.UpdateClusterRequest, opts ...grpc.CallOption) (*rpc.ClusterDetails, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateCluster", varargs...)
	ret0, _ := ret[0].(*rpc.ClusterDetails)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateCluster indicates an expected call of UpdateCluster.
func (mr *MockClusterCROperationServiceClientMockRecorder) UpdateCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCluster", reflect.TypeOf((*MockClusterCROperationServiceClient)(nil).UpdateCluster), varargs...)
}

// MockChangefeedOpsServiceClient is a mock of ChangefeedOpsServiceClient interface.
type MockChangefeedOpsServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockChangefeedOpsServiceClientMockRecorder
	isgomock struct{}
}

// MockChangefeedOpsServiceClientMockRecorder is the mock recorder for MockChangefeedOpsServiceClient.
type MockChangefeedOpsServiceClientMockRecorder struct {
	mock *MockChangefeedOpsServiceClient
}

// NewMockChangefeedOpsServiceClient creates a new mock instance.
func NewMockChangefeedOpsServiceClient(ctrl *gomock.Controller) *MockChangefeedOpsServiceClient {
	mock := &MockChangefeedOpsServiceClient{ctrl: ctrl}
	mock.recorder = &MockChangefeedOpsServiceClientMockRecorder{mock}
	return mock
}

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

// ApplyConfigChanges mocks base method.
func (m *MockChangefeedOpsServiceClient) ApplyConfigChanges(ctx context.Context, in *rpc.ApplyConfigChangesRequest, opts ...grpc.CallOption) (*rpc.ApplyConfigChangesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ApplyConfigChanges", varargs...)
	ret0, _ := ret[0].(*rpc.ApplyConfigChangesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ApplyConfigChanges indicates an expected call of ApplyConfigChanges.
func (mr *MockChangefeedOpsServiceClientMockRecorder) ApplyConfigChanges(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyConfigChanges", reflect.TypeOf((*MockChangefeedOpsServiceClient)(nil).ApplyConfigChanges), varargs...)
}

// CompareChangefeeds mocks base method.
func (m *MockChangefeedOpsServiceClient) CompareChangefeeds(ctx context.Context, in *rpc.CompareChangefeedsRequest, opts ...grpc.CallOption) (*rpc.CompareChangefeedsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CompareChangefeeds", varargs...)
	ret0, _ := ret[0].(*rpc.CompareChangefeedsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CompareChangefeeds indicates an expected call of CompareChangefeeds.
func (mr *MockChangefeedOpsServiceClientMockRecorder) CompareChangefeeds(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompareChangefeeds", reflect.TypeOf((*MockChangefeedOpsServiceClient)(nil).CompareChangefeeds), varargs...)
}

// DeleteChangefeed mocks base method.
func (m *MockChangefeedOpsServiceClient) DeleteChangefeed(ctx context.Context, in *rpc.DeleteChangefeedRequest, opts ...grpc.CallOption) (*rpc.ChangefeedInfo, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteChangefeed", varargs...)
	ret0, _ := ret[0].(*rpc.ChangefeedInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteChangefeed indicates an expected call of DeleteChangefeed.
func (mr *MockChangefeedOpsServiceClientMockRecorder) DeleteChangefeed(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChangefeed", reflect.TypeOf((*MockChangefeedOpsServiceClient)(nil).DeleteChangefeed), varargs...)
}

// DeleteClusterCDCJob mocks base method.
func (m *MockChangefeedOpsServiceClient) DeleteClusterCDCJob(ctx context.Context, in *rpc.DeleteClusterCDCJobRequest, opts ...grpc.CallOption) (*rpc.DeleteClusterCDCJobResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteClusterCDCJob", varargs...)
	ret0, _ := ret[0].(*rpc.DeleteClusterCDCJobResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteClusterCDCJob indicates an expected call of DeleteClusterCDCJob.
func (mr *MockChangefeedOpsServiceClientMockRecorder) DeleteClusterCDCJob(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClusterCDCJob", reflect.TypeOf((*MockChangefeedOpsServiceClient)(nil).DeleteClusterCDCJob), varargs...)
}

// GetChangefeed mocks base method.
func (m *MockChangefeedOpsServiceClient) GetChangefeed(ctx context.Context, in *rpc.GetChangefeedRequest, opts ...grpc.CallOption) (*rpc.ChangefeedInfo, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetChangefeed", varargs...)
	ret0, _ := ret[0].(*rpc.ChangefeedInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChangefeed indicates an expected call of GetChangefeed.
func (mr *MockChangefeedOpsServiceClientMockRecorder) GetChangefeed(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChangefeed", reflect.TypeOf((*MockChangefeedOpsServiceClient)(nil).GetChangefeed), varargs...)
}

// GetTiCDCCluster mocks base method.
func (m *MockChangefeedOpsServiceClient) GetTiCDCCluster(ctx context.Context, in *rpc.GetTiCDCClusterRequest, opts ...grpc.CallOption) (*rpc.TiCDCClusterInfo, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTiCDCCluster", varargs...)
	ret0, _ := ret[0].(*rpc.TiCDCClusterInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTiCDCCluster indicates an expected call of GetTiCDCCluster.
func (mr *MockChangefeedOpsServiceClientMockRecorder) GetTiCDCCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTiCDCCluster", reflect.TypeOf((*MockChangefeedOpsServiceClient)(nil).GetTiCDCCluster), varargs...)
}

// ListClusterCDCJobs mocks base method.
func (m *MockChangefeedOpsServiceClient) ListClusterCDCJobs(ctx context.Context, in *rpc.ListClusterCDCJobsRequest, opts ...grpc.CallOption) (*rpc.ListClusterCDCJobsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListClusterCDCJobs", varargs...)
	ret0, _ := ret[0].(*rpc.ListClusterCDCJobsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClusterCDCJobs indicates an expected call of ListClusterCDCJobs.
func (mr *MockChangefeedOpsServiceClientMockRecorder) ListClusterCDCJobs(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusterCDCJobs", reflect.TypeOf((*MockChangefeedOpsServiceClient)(nil).ListClusterCDCJobs), varargs...)
}

// ListClusterChangefeeds mocks base method.
func (m *MockChangefeedOpsServiceClient) ListClusterChangefeeds(ctx context.Context, in *rpc.ListClusterChangefeedsRequest, opts ...grpc.CallOption) (*rpc.ListClusterChangefeedsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListClusterChangefeeds", varargs...)
	ret0, _ := ret[0].(*rpc.ListClusterChangefeedsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClusterChangefeeds indicates an expected call of ListClusterChangefeeds.
func (mr *MockChangefeedOpsServiceClientMockRecorder) ListClusterChangefeeds(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusterChangefeeds", reflect.TypeOf((*MockChangefeedOpsServiceClient)(nil).ListClusterChangefeeds), varargs...)
}

// ListTiCDCClusters mocks base method.
func (m *MockChangefeedOpsServiceClient) ListTiCDCClusters(ctx context.Context, in *rpc.ListTiCDCClustersRequest, opts ...grpc.CallOption) (*rpc.ListTiCDCClustersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTiCDCClusters", varargs...)
	ret0, _ := ret[0].(*rpc.ListTiCDCClustersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTiCDCClusters indicates an expected call of ListTiCDCClusters.
func (mr *MockChangefeedOpsServiceClientMockRecorder) ListTiCDCClusters(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTiCDCClusters", reflect.TypeOf((*MockChangefeedOpsServiceClient)(nil).ListTiCDCClusters), varargs...)
}

// MigrateChangefeed mocks base method.
func (m *MockChangefeedOpsServiceClient) MigrateChangefeed(ctx context.Context, in *rpc.MigrateChangefeedRequest, opts ...grpc.CallOption) (*rpc.MigrateChangefeedResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MigrateChangefeed", varargs...)
	ret0, _ := ret[0].(*rpc.MigrateChangefeedResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MigrateChangefeed indicates an expected call of MigrateChangefeed.
func (mr *MockChangefeedOpsServiceClientMockRecorder) MigrateChangefeed(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MigrateChangefeed", reflect.TypeOf((*MockChangefeedOpsServiceClient)(nil).MigrateChangefeed), varargs...)
}

// PauseChangefeed mocks base method.
func (m *MockChangefeedOpsServiceClient) PauseChangefeed(ctx context.Context, in *rpc.PauseChangefeedRequest, opts ...grpc.CallOption) (*rpc.ChangefeedInfo, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PauseChangefeed", varargs...)
	ret0, _ := ret[0].(*rpc.ChangefeedInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PauseChangefeed indicates an expected call of PauseChangefeed.
func (mr *MockChangefeedOpsServiceClientMockRecorder) PauseChangefeed(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PauseChangefeed", reflect.TypeOf((*MockChangefeedOpsServiceClient)(nil).PauseChangefeed), varargs...)
}

// PrecheckMigrateChangefeed mocks base method.
func (m *MockChangefeedOpsServiceClient) PrecheckMigrateChangefeed(ctx context.Context, in *rpc.PrecheckMigrateChangefeedRequest, opts ...grpc.CallOption) (*rpc.PrecheckMigrateChangefeedResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PrecheckMigrateChangefeed", varargs...)
	ret0, _ := ret[0].(*rpc.PrecheckMigrateChangefeedResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PrecheckMigrateChangefeed indicates an expected call of PrecheckMigrateChangefeed.
func (mr *MockChangefeedOpsServiceClientMockRecorder) PrecheckMigrateChangefeed(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrecheckMigrateChangefeed", reflect.TypeOf((*MockChangefeedOpsServiceClient)(nil).PrecheckMigrateChangefeed), varargs...)
}

// RestartChangefeed mocks base method.
func (m *MockChangefeedOpsServiceClient) RestartChangefeed(ctx context.Context, in *rpc.RestartChangefeedRequest, opts ...grpc.CallOption) (*rpc.ChangefeedInfo, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RestartChangefeed", varargs...)
	ret0, _ := ret[0].(*rpc.ChangefeedInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RestartChangefeed indicates an expected call of RestartChangefeed.
func (mr *MockChangefeedOpsServiceClientMockRecorder) RestartChangefeed(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestartChangefeed", reflect.TypeOf((*MockChangefeedOpsServiceClient)(nil).RestartChangefeed), varargs...)
}

// ResumeChangefeed mocks base method.
func (m *MockChangefeedOpsServiceClient) ResumeChangefeed(ctx context.Context, in *rpc.ResumeChangefeedRequest, opts ...grpc.CallOption) (*rpc.ChangefeedInfo, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResumeChangefeed", varargs...)
	ret0, _ := ret[0].(*rpc.ChangefeedInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResumeChangefeed indicates an expected call of ResumeChangefeed.
func (mr *MockChangefeedOpsServiceClientMockRecorder) ResumeChangefeed(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeChangefeed", reflect.TypeOf((*MockChangefeedOpsServiceClient)(nil).ResumeChangefeed), varargs...)
}

// ScaleChangefeed mocks base method.
func (m *MockChangefeedOpsServiceClient) ScaleChangefeed(ctx context.Context, in *rpc.ScaleChangefeedRequest, opts ...grpc.CallOption) (*rpc.ChangefeedInfo, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ScaleChangefeed", varargs...)
	ret0, _ := ret[0].(*rpc.ChangefeedInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ScaleChangefeed indicates an expected call of ScaleChangefeed.
func (mr *MockChangefeedOpsServiceClientMockRecorder) ScaleChangefeed(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScaleChangefeed", reflect.TypeOf((*MockChangefeedOpsServiceClient)(nil).ScaleChangefeed), varargs...)
}

// UpgradeTiCDCCluster mocks base method.
func (m *MockChangefeedOpsServiceClient) UpgradeTiCDCCluster(ctx context.Context, in *rpc.UpgradeTiCDCClusterRequest, opts ...grpc.CallOption) (*rpc.TiCDCClusterInfo, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpgradeTiCDCCluster", varargs...)
	ret0, _ := ret[0].(*rpc.TiCDCClusterInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpgradeTiCDCCluster indicates an expected call of UpgradeTiCDCCluster.
func (mr *MockChangefeedOpsServiceClientMockRecorder) UpgradeTiCDCCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpgradeTiCDCCluster", reflect.TypeOf((*MockChangefeedOpsServiceClient)(nil).UpgradeTiCDCCluster), varargs...)
}