// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/tidbcloud/config-center/proto/config_center (interfaces: ConfigCenterServiceClient)
//
// Generated by this command:
//
//	mockgen -destination client_mock.go -package=configcentercli github.com/tidbcloud/config-center/proto/config_center ConfigCenterServiceClient
//

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

import (
	context "context"
	reflect "reflect"

	config_center "github.com/tidbcloud/config-center/proto/config_center"
	gomock "go.uber.org/mock/gomock"
	grpc "google.golang.org/grpc"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// MockConfigCenterServiceClient is a mock of ConfigCenterServiceClient interface.
type MockConfigCenterServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockConfigCenterServiceClientMockRecorder
	isgomock struct{}
}

// MockConfigCenterServiceClientMockRecorder is the mock recorder for MockConfigCenterServiceClient.
type MockConfigCenterServiceClientMockRecorder struct {
	mock *MockConfigCenterServiceClient
}

// NewMockConfigCenterServiceClient creates a new mock instance.
func NewMockConfigCenterServiceClient(ctrl *gomock.Controller) *MockConfigCenterServiceClient {
	mock := &MockConfigCenterServiceClient{ctrl: ctrl}
	mock.recorder = &MockConfigCenterServiceClientMockRecorder{mock}
	return mock
}

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

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

// AutoUpdateClusterConfigurationFile indicates an expected call of AutoUpdateClusterConfigurationFile.
func (mr *MockConfigCenterServiceClientMockRecorder) AutoUpdateClusterConfigurationFile(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, "AutoUpdateClusterConfigurationFile", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).AutoUpdateClusterConfigurationFile), varargs...)
}

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

// AutoUpdateClusterMeta indicates an expected call of AutoUpdateClusterMeta.
func (mr *MockConfigCenterServiceClientMockRecorder) AutoUpdateClusterMeta(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, "AutoUpdateClusterMeta", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).AutoUpdateClusterMeta), varargs...)
}

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

// BatchAutoUpdateClusterConfigurationFiles indicates an expected call of BatchAutoUpdateClusterConfigurationFiles.
func (mr *MockConfigCenterServiceClientMockRecorder) BatchAutoUpdateClusterConfigurationFiles(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, "BatchAutoUpdateClusterConfigurationFiles", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).BatchAutoUpdateClusterConfigurationFiles), varargs...)
}

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

// BatchCreateClusterConfigurationFiles indicates an expected call of BatchCreateClusterConfigurationFiles.
func (mr *MockConfigCenterServiceClientMockRecorder) BatchCreateClusterConfigurationFiles(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, "BatchCreateClusterConfigurationFiles", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).BatchCreateClusterConfigurationFiles), varargs...)
}

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

// BatchCreateConfigurationDictItems indicates an expected call of BatchCreateConfigurationDictItems.
func (mr *MockConfigCenterServiceClientMockRecorder) BatchCreateConfigurationDictItems(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, "BatchCreateConfigurationDictItems", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).BatchCreateConfigurationDictItems), varargs...)
}

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

// BatchCreateConfigurationTemplates indicates an expected call of BatchCreateConfigurationTemplates.
func (mr *MockConfigCenterServiceClientMockRecorder) BatchCreateConfigurationTemplates(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, "BatchCreateConfigurationTemplates", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).BatchCreateConfigurationTemplates), varargs...)
}

// BatchDeleteClusterConfigurationFiles mocks base method.
func (m *MockConfigCenterServiceClient) BatchDeleteClusterConfigurationFiles(ctx context.Context, in *config_center.BatchDeleteClusterConfigurationFilesRequest, 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, "BatchDeleteClusterConfigurationFiles", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchDeleteClusterConfigurationFiles indicates an expected call of BatchDeleteClusterConfigurationFiles.
func (mr *MockConfigCenterServiceClientMockRecorder) BatchDeleteClusterConfigurationFiles(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, "BatchDeleteClusterConfigurationFiles", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).BatchDeleteClusterConfigurationFiles), varargs...)
}

// BatchDeleteClusterMeta mocks base method.
func (m *MockConfigCenterServiceClient) BatchDeleteClusterMeta(ctx context.Context, in *config_center.BatchDeleteClusterMetaRequest, 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, "BatchDeleteClusterMeta", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchDeleteClusterMeta indicates an expected call of BatchDeleteClusterMeta.
func (mr *MockConfigCenterServiceClientMockRecorder) BatchDeleteClusterMeta(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, "BatchDeleteClusterMeta", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).BatchDeleteClusterMeta), varargs...)
}

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

// BatchSearchDefaultConfigurationTemplate indicates an expected call of BatchSearchDefaultConfigurationTemplate.
func (mr *MockConfigCenterServiceClientMockRecorder) BatchSearchDefaultConfigurationTemplate(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, "BatchSearchDefaultConfigurationTemplate", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).BatchSearchDefaultConfigurationTemplate), varargs...)
}

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

// BatchUpdateClusterComponents indicates an expected call of BatchUpdateClusterComponents.
func (mr *MockConfigCenterServiceClientMockRecorder) BatchUpdateClusterComponents(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, "BatchUpdateClusterComponents", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).BatchUpdateClusterComponents), varargs...)
}

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

// BatchUpdateClusterConfigurationFiles indicates an expected call of BatchUpdateClusterConfigurationFiles.
func (mr *MockConfigCenterServiceClientMockRecorder) BatchUpdateClusterConfigurationFiles(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, "BatchUpdateClusterConfigurationFiles", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).BatchUpdateClusterConfigurationFiles), varargs...)
}

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

// BatchUpdateDefaultConfigurationTemplate indicates an expected call of BatchUpdateDefaultConfigurationTemplate.
func (mr *MockConfigCenterServiceClientMockRecorder) BatchUpdateDefaultConfigurationTemplate(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, "BatchUpdateDefaultConfigurationTemplate", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).BatchUpdateDefaultConfigurationTemplate), varargs...)
}

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

// BatchUpdateTenantInitialCustomParams indicates an expected call of BatchUpdateTenantInitialCustomParams.
func (mr *MockConfigCenterServiceClientMockRecorder) BatchUpdateTenantInitialCustomParams(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, "BatchUpdateTenantInitialCustomParams", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).BatchUpdateTenantInitialCustomParams), varargs...)
}

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

// BatchUpsertClusterCustomParams indicates an expected call of BatchUpsertClusterCustomParams.
func (mr *MockConfigCenterServiceClientMockRecorder) BatchUpsertClusterCustomParams(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, "BatchUpsertClusterCustomParams", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).BatchUpsertClusterCustomParams), varargs...)
}

// CopyConfigurationDictFromOldVersion mocks base method.
func (m *MockConfigCenterServiceClient) CopyConfigurationDictFromOldVersion(ctx context.Context, in *config_center.CopyConfigurationDictFromOldVersionRequest, 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, "CopyConfigurationDictFromOldVersion", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CopyConfigurationDictFromOldVersion indicates an expected call of CopyConfigurationDictFromOldVersion.
func (mr *MockConfigCenterServiceClientMockRecorder) CopyConfigurationDictFromOldVersion(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, "CopyConfigurationDictFromOldVersion", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).CopyConfigurationDictFromOldVersion), varargs...)
}

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

// CreateClusterConfigurationFile indicates an expected call of CreateClusterConfigurationFile.
func (mr *MockConfigCenterServiceClientMockRecorder) CreateClusterConfigurationFile(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, "CreateClusterConfigurationFile", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).CreateClusterConfigurationFile), varargs...)
}

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

// CreateConfigurationTemplate indicates an expected call of CreateConfigurationTemplate.
func (mr *MockConfigCenterServiceClientMockRecorder) CreateConfigurationTemplate(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, "CreateConfigurationTemplate", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).CreateConfigurationTemplate), varargs...)
}

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

// CreateMetaProfile indicates an expected call of CreateMetaProfile.
func (mr *MockConfigCenterServiceClientMockRecorder) CreateMetaProfile(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, "CreateMetaProfile", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).CreateMetaProfile), varargs...)
}

// DeleteClusterConfigurationFile mocks base method.
func (m *MockConfigCenterServiceClient) DeleteClusterConfigurationFile(ctx context.Context, in *config_center.DeleteClusterConfigurationFileRequest, 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, "DeleteClusterConfigurationFile", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteClusterConfigurationFile indicates an expected call of DeleteClusterConfigurationFile.
func (mr *MockConfigCenterServiceClientMockRecorder) DeleteClusterConfigurationFile(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, "DeleteClusterConfigurationFile", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).DeleteClusterConfigurationFile), varargs...)
}

// DeleteClusterMeta mocks base method.
func (m *MockConfigCenterServiceClient) DeleteClusterMeta(ctx context.Context, in *config_center.DeleteClusterMetaRequest, 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, "DeleteClusterMeta", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteClusterMeta indicates an expected call of DeleteClusterMeta.
func (mr *MockConfigCenterServiceClientMockRecorder) DeleteClusterMeta(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, "DeleteClusterMeta", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).DeleteClusterMeta), varargs...)
}

// DeleteConfigurationTemplate mocks base method.
func (m *MockConfigCenterServiceClient) DeleteConfigurationTemplate(ctx context.Context, in *config_center.DeleteConfigurationTemplateRequest, 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, "DeleteConfigurationTemplate", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteConfigurationTemplate indicates an expected call of DeleteConfigurationTemplate.
func (mr *MockConfigCenterServiceClientMockRecorder) DeleteConfigurationTemplate(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, "DeleteConfigurationTemplate", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).DeleteConfigurationTemplate), varargs...)
}

// DeleteDefaultConfigurationTemplate mocks base method.
func (m *MockConfigCenterServiceClient) DeleteDefaultConfigurationTemplate(ctx context.Context, in *config_center.DeleteDefaultConfigurationTemplateRequest, 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, "DeleteDefaultConfigurationTemplate", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteDefaultConfigurationTemplate indicates an expected call of DeleteDefaultConfigurationTemplate.
func (mr *MockConfigCenterServiceClientMockRecorder) DeleteDefaultConfigurationTemplate(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, "DeleteDefaultConfigurationTemplate", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).DeleteDefaultConfigurationTemplate), varargs...)
}

// DeleteDefaultVersion mocks base method.
func (m *MockConfigCenterServiceClient) DeleteDefaultVersion(ctx context.Context, in *config_center.DeleteDefaultVersionRequest, 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, "DeleteDefaultVersion", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteDefaultVersion indicates an expected call of DeleteDefaultVersion.
func (mr *MockConfigCenterServiceClientMockRecorder) DeleteDefaultVersion(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, "DeleteDefaultVersion", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).DeleteDefaultVersion), varargs...)
}

// DeleteMetaProfile mocks base method.
func (m *MockConfigCenterServiceClient) DeleteMetaProfile(ctx context.Context, in *config_center.DeleteMetaProfileRequest, 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, "DeleteMetaProfile", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteMetaProfile indicates an expected call of DeleteMetaProfile.
func (mr *MockConfigCenterServiceClientMockRecorder) DeleteMetaProfile(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, "DeleteMetaProfile", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).DeleteMetaProfile), varargs...)
}

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

// GetClusterComponent indicates an expected call of GetClusterComponent.
func (mr *MockConfigCenterServiceClientMockRecorder) GetClusterComponent(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, "GetClusterComponent", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).GetClusterComponent), varargs...)
}

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

// GetClusterConfigurationFile indicates an expected call of GetClusterConfigurationFile.
func (mr *MockConfigCenterServiceClientMockRecorder) GetClusterConfigurationFile(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, "GetClusterConfigurationFile", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).GetClusterConfigurationFile), varargs...)
}

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

// GetClusterMeta indicates an expected call of GetClusterMeta.
func (mr *MockConfigCenterServiceClientMockRecorder) GetClusterMeta(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, "GetClusterMeta", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).GetClusterMeta), varargs...)
}

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

// GetComponentImage indicates an expected call of GetComponentImage.
func (mr *MockConfigCenterServiceClientMockRecorder) GetComponentImage(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, "GetComponentImage", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).GetComponentImage), varargs...)
}

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

// GetConfigurationDictItem indicates an expected call of GetConfigurationDictItem.
func (mr *MockConfigCenterServiceClientMockRecorder) GetConfigurationDictItem(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, "GetConfigurationDictItem", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).GetConfigurationDictItem), varargs...)
}

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

// GetConfigurationTemplate indicates an expected call of GetConfigurationTemplate.
func (mr *MockConfigCenterServiceClientMockRecorder) GetConfigurationTemplate(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, "GetConfigurationTemplate", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).GetConfigurationTemplate), varargs...)
}

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

// GetDefaultVersion indicates an expected call of GetDefaultVersion.
func (mr *MockConfigCenterServiceClientMockRecorder) GetDefaultVersion(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, "GetDefaultVersion", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).GetDefaultVersion), varargs...)
}

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

// GetMetaProfile indicates an expected call of GetMetaProfile.
func (mr *MockConfigCenterServiceClientMockRecorder) GetMetaProfile(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, "GetMetaProfile", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).GetMetaProfile), varargs...)
}

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

// GetRegionalServer indicates an expected call of GetRegionalServer.
func (mr *MockConfigCenterServiceClientMockRecorder) GetRegionalServer(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, "GetRegionalServer", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).GetRegionalServer), varargs...)
}

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

// GetTemplateUsage indicates an expected call of GetTemplateUsage.
func (mr *MockConfigCenterServiceClientMockRecorder) GetTemplateUsage(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, "GetTemplateUsage", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).GetTemplateUsage), varargs...)
}

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

// GetTenantInitialCustomParams indicates an expected call of GetTenantInitialCustomParams.
func (mr *MockConfigCenterServiceClientMockRecorder) GetTenantInitialCustomParams(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, "GetTenantInitialCustomParams", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).GetTenantInitialCustomParams), varargs...)
}

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

// InitClusterMeta indicates an expected call of InitClusterMeta.
func (mr *MockConfigCenterServiceClientMockRecorder) InitClusterMeta(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, "InitClusterMeta", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).InitClusterMeta), varargs...)
}

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

// ListAvailableInstances indicates an expected call of ListAvailableInstances.
func (mr *MockConfigCenterServiceClientMockRecorder) ListAvailableInstances(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, "ListAvailableInstances", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).ListAvailableInstances), varargs...)
}

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

// ListAvailableVersions indicates an expected call of ListAvailableVersions.
func (mr *MockConfigCenterServiceClientMockRecorder) ListAvailableVersions(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, "ListAvailableVersions", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).ListAvailableVersions), varargs...)
}

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

// ListClusterComponents indicates an expected call of ListClusterComponents.
func (mr *MockConfigCenterServiceClientMockRecorder) ListClusterComponents(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, "ListClusterComponents", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).ListClusterComponents), varargs...)
}

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

// ListClusterConfigurationFiles indicates an expected call of ListClusterConfigurationFiles.
func (mr *MockConfigCenterServiceClientMockRecorder) ListClusterConfigurationFiles(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, "ListClusterConfigurationFiles", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).ListClusterConfigurationFiles), varargs...)
}

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

// ListComponentImages indicates an expected call of ListComponentImages.
func (mr *MockConfigCenterServiceClientMockRecorder) ListComponentImages(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, "ListComponentImages", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).ListComponentImages), varargs...)
}

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

// ListConfigurationDictItems indicates an expected call of ListConfigurationDictItems.
func (mr *MockConfigCenterServiceClientMockRecorder) ListConfigurationDictItems(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, "ListConfigurationDictItems", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).ListConfigurationDictItems), varargs...)
}

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

// ListConfigurationDictVersions indicates an expected call of ListConfigurationDictVersions.
func (mr *MockConfigCenterServiceClientMockRecorder) ListConfigurationDictVersions(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, "ListConfigurationDictVersions", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).ListConfigurationDictVersions), varargs...)
}

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

// ListConfigurationTemplateDefaultCaseBindings indicates an expected call of ListConfigurationTemplateDefaultCaseBindings.
func (mr *MockConfigCenterServiceClientMockRecorder) ListConfigurationTemplateDefaultCaseBindings(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, "ListConfigurationTemplateDefaultCaseBindings", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).ListConfigurationTemplateDefaultCaseBindings), varargs...)
}

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

// ListConfigurationTemplates indicates an expected call of ListConfigurationTemplates.
func (mr *MockConfigCenterServiceClientMockRecorder) ListConfigurationTemplates(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, "ListConfigurationTemplates", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).ListConfigurationTemplates), varargs...)
}

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

// ListDefaultVersionRules indicates an expected call of ListDefaultVersionRules.
func (mr *MockConfigCenterServiceClientMockRecorder) ListDefaultVersionRules(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, "ListDefaultVersionRules", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).ListDefaultVersionRules), varargs...)
}

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

// ListMetaProfiles indicates an expected call of ListMetaProfiles.
func (mr *MockConfigCenterServiceClientMockRecorder) ListMetaProfiles(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, "ListMetaProfiles", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).ListMetaProfiles), varargs...)
}

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

// ListRegionalServers indicates an expected call of ListRegionalServers.
func (mr *MockConfigCenterServiceClientMockRecorder) ListRegionalServers(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, "ListRegionalServers", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).ListRegionalServers), varargs...)
}

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

// ListTenantInitialCustomParams indicates an expected call of ListTenantInitialCustomParams.
func (mr *MockConfigCenterServiceClientMockRecorder) ListTenantInitialCustomParams(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, "ListTenantInitialCustomParams", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).ListTenantInitialCustomParams), varargs...)
}

// OfflineRegionalServer mocks base method.
func (m *MockConfigCenterServiceClient) OfflineRegionalServer(ctx context.Context, in *config_center.OfflineRegionalServerRequest, 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, "OfflineRegionalServer", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OfflineRegionalServer indicates an expected call of OfflineRegionalServer.
func (mr *MockConfigCenterServiceClientMockRecorder) OfflineRegionalServer(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, "OfflineRegionalServer", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).OfflineRegionalServer), varargs...)
}

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

// PurgeDictItems indicates an expected call of PurgeDictItems.
func (mr *MockConfigCenterServiceClientMockRecorder) PurgeDictItems(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, "PurgeDictItems", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).PurgeDictItems), varargs...)
}

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

// RegisterRegionalServer indicates an expected call of RegisterRegionalServer.
func (mr *MockConfigCenterServiceClientMockRecorder) RegisterRegionalServer(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, "RegisterRegionalServer", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).RegisterRegionalServer), varargs...)
}

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

// SearchClusterComponents indicates an expected call of SearchClusterComponents.
func (mr *MockConfigCenterServiceClientMockRecorder) SearchClusterComponents(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, "SearchClusterComponents", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).SearchClusterComponents), varargs...)
}

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

// SearchDefaultConfigurationTemplate indicates an expected call of SearchDefaultConfigurationTemplate.
func (mr *MockConfigCenterServiceClientMockRecorder) SearchDefaultConfigurationTemplate(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, "SearchDefaultConfigurationTemplate", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).SearchDefaultConfigurationTemplate), varargs...)
}

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

// SyncRegionalServer indicates an expected call of SyncRegionalServer.
func (mr *MockConfigCenterServiceClientMockRecorder) SyncRegionalServer(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, "SyncRegionalServer", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).SyncRegionalServer), varargs...)
}

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

// UpdateClusterComponent indicates an expected call of UpdateClusterComponent.
func (mr *MockConfigCenterServiceClientMockRecorder) UpdateClusterComponent(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, "UpdateClusterComponent", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).UpdateClusterComponent), varargs...)
}

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

// UpdateClusterConfigurationFile indicates an expected call of UpdateClusterConfigurationFile.
func (mr *MockConfigCenterServiceClientMockRecorder) UpdateClusterConfigurationFile(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, "UpdateClusterConfigurationFile", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).UpdateClusterConfigurationFile), varargs...)
}

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

// UpdateClusterMeta indicates an expected call of UpdateClusterMeta.
func (mr *MockConfigCenterServiceClientMockRecorder) UpdateClusterMeta(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, "UpdateClusterMeta", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).UpdateClusterMeta), varargs...)
}

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

// UpdateComponentImage indicates an expected call of UpdateComponentImage.
func (mr *MockConfigCenterServiceClientMockRecorder) UpdateComponentImage(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, "UpdateComponentImage", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).UpdateComponentImage), varargs...)
}

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

// UpdateConfigurationDictItem indicates an expected call of UpdateConfigurationDictItem.
func (mr *MockConfigCenterServiceClientMockRecorder) UpdateConfigurationDictItem(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, "UpdateConfigurationDictItem", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).UpdateConfigurationDictItem), varargs...)
}

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

// UpdateDefaultConfigurationTemplate indicates an expected call of UpdateDefaultConfigurationTemplate.
func (mr *MockConfigCenterServiceClientMockRecorder) UpdateDefaultConfigurationTemplate(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, "UpdateDefaultConfigurationTemplate", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).UpdateDefaultConfigurationTemplate), varargs...)
}

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

// UpdateDefaultVersion indicates an expected call of UpdateDefaultVersion.
func (mr *MockConfigCenterServiceClientMockRecorder) UpdateDefaultVersion(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, "UpdateDefaultVersion", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).UpdateDefaultVersion), varargs...)
}

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

// UpdateTenantInitialCustomParams indicates an expected call of UpdateTenantInitialCustomParams.
func (mr *MockConfigCenterServiceClientMockRecorder) UpdateTenantInitialCustomParams(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, "UpdateTenantInitialCustomParams", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).UpdateTenantInitialCustomParams), varargs...)
}

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

// UpsertClusterCustomParams indicates an expected call of UpsertClusterCustomParams.
func (mr *MockConfigCenterServiceClientMockRecorder) UpsertClusterCustomParams(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, "UpsertClusterCustomParams", reflect.TypeOf((*MockConfigCenterServiceClient)(nil).UpsertClusterCustomParams), varargs...)
}