// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package mocks

import (
	"context"

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

// newIsCreateClusterConfigFileRequest_SystemTemplateSource creates a new instance of isCreateClusterConfigFileRequest_SystemTemplateSource. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func newIsCreateClusterConfigFileRequest_SystemTemplateSource(t interface {
	mock.TestingT
	Cleanup(func())
}) *isCreateClusterConfigFileRequest_SystemTemplateSource {
	mock := &isCreateClusterConfigFileRequest_SystemTemplateSource{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// isCreateClusterConfigFileRequest_SystemTemplateSource is an autogenerated mock type for the isCreateClusterConfigFileRequest_SystemTemplateSource type
type isCreateClusterConfigFileRequest_SystemTemplateSource struct {
	mock.Mock
}

type isCreateClusterConfigFileRequest_SystemTemplateSource_Expecter struct {
	mock *mock.Mock
}

func (_m *isCreateClusterConfigFileRequest_SystemTemplateSource) EXPECT() *isCreateClusterConfigFileRequest_SystemTemplateSource_Expecter {
	return &isCreateClusterConfigFileRequest_SystemTemplateSource_Expecter{mock: &_m.Mock}
}

// isCreateClusterConfigFileRequest_SystemTemplateSource provides a mock function for the type isCreateClusterConfigFileRequest_SystemTemplateSource
func (_mock *isCreateClusterConfigFileRequest_SystemTemplateSource) isCreateClusterConfigFileRequest_SystemTemplateSource() {
	_mock.Called()
	return
}

// isCreateClusterConfigFileRequest_SystemTemplateSource_isCreateClusterConfigFileRequest_SystemTemplateSource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isCreateClusterConfigFileRequest_SystemTemplateSource'
type isCreateClusterConfigFileRequest_SystemTemplateSource_isCreateClusterConfigFileRequest_SystemTemplateSource_Call struct {
	*mock.Call
}

// isCreateClusterConfigFileRequest_SystemTemplateSource is a helper method to define mock.On call
func (_e *isCreateClusterConfigFileRequest_SystemTemplateSource_Expecter) isCreateClusterConfigFileRequest_SystemTemplateSource() *isCreateClusterConfigFileRequest_SystemTemplateSource_isCreateClusterConfigFileRequest_SystemTemplateSource_Call {
	return &isCreateClusterConfigFileRequest_SystemTemplateSource_isCreateClusterConfigFileRequest_SystemTemplateSource_Call{Call: _e.mock.On("isCreateClusterConfigFileRequest_SystemTemplateSource")}
}

func (_c *isCreateClusterConfigFileRequest_SystemTemplateSource_isCreateClusterConfigFileRequest_SystemTemplateSource_Call) Run(run func()) *isCreateClusterConfigFileRequest_SystemTemplateSource_isCreateClusterConfigFileRequest_SystemTemplateSource_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *isCreateClusterConfigFileRequest_SystemTemplateSource_isCreateClusterConfigFileRequest_SystemTemplateSource_Call) Return() *isCreateClusterConfigFileRequest_SystemTemplateSource_isCreateClusterConfigFileRequest_SystemTemplateSource_Call {
	_c.Call.Return()
	return _c
}

func (_c *isCreateClusterConfigFileRequest_SystemTemplateSource_isCreateClusterConfigFileRequest_SystemTemplateSource_Call) RunAndReturn(run func()) *isCreateClusterConfigFileRequest_SystemTemplateSource_isCreateClusterConfigFileRequest_SystemTemplateSource_Call {
	_c.Run(run)
	return _c
}

// newIsCreateClusterConfigFileRequest_CustomParamsSource creates a new instance of isCreateClusterConfigFileRequest_CustomParamsSource. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func newIsCreateClusterConfigFileRequest_CustomParamsSource(t interface {
	mock.TestingT
	Cleanup(func())
}) *isCreateClusterConfigFileRequest_CustomParamsSource {
	mock := &isCreateClusterConfigFileRequest_CustomParamsSource{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// isCreateClusterConfigFileRequest_CustomParamsSource is an autogenerated mock type for the isCreateClusterConfigFileRequest_CustomParamsSource type
type isCreateClusterConfigFileRequest_CustomParamsSource struct {
	mock.Mock
}

type isCreateClusterConfigFileRequest_CustomParamsSource_Expecter struct {
	mock *mock.Mock
}

func (_m *isCreateClusterConfigFileRequest_CustomParamsSource) EXPECT() *isCreateClusterConfigFileRequest_CustomParamsSource_Expecter {
	return &isCreateClusterConfigFileRequest_CustomParamsSource_Expecter{mock: &_m.Mock}
}

// isCreateClusterConfigFileRequest_CustomParamsSource provides a mock function for the type isCreateClusterConfigFileRequest_CustomParamsSource
func (_mock *isCreateClusterConfigFileRequest_CustomParamsSource) isCreateClusterConfigFileRequest_CustomParamsSource() {
	_mock.Called()
	return
}

// isCreateClusterConfigFileRequest_CustomParamsSource_isCreateClusterConfigFileRequest_CustomParamsSource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isCreateClusterConfigFileRequest_CustomParamsSource'
type isCreateClusterConfigFileRequest_CustomParamsSource_isCreateClusterConfigFileRequest_CustomParamsSource_Call struct {
	*mock.Call
}

// isCreateClusterConfigFileRequest_CustomParamsSource is a helper method to define mock.On call
func (_e *isCreateClusterConfigFileRequest_CustomParamsSource_Expecter) isCreateClusterConfigFileRequest_CustomParamsSource() *isCreateClusterConfigFileRequest_CustomParamsSource_isCreateClusterConfigFileRequest_CustomParamsSource_Call {
	return &isCreateClusterConfigFileRequest_CustomParamsSource_isCreateClusterConfigFileRequest_CustomParamsSource_Call{Call: _e.mock.On("isCreateClusterConfigFileRequest_CustomParamsSource")}
}

func (_c *isCreateClusterConfigFileRequest_CustomParamsSource_isCreateClusterConfigFileRequest_CustomParamsSource_Call) Run(run func()) *isCreateClusterConfigFileRequest_CustomParamsSource_isCreateClusterConfigFileRequest_CustomParamsSource_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *isCreateClusterConfigFileRequest_CustomParamsSource_isCreateClusterConfigFileRequest_CustomParamsSource_Call) Return() *isCreateClusterConfigFileRequest_CustomParamsSource_isCreateClusterConfigFileRequest_CustomParamsSource_Call {
	_c.Call.Return()
	return _c
}

func (_c *isCreateClusterConfigFileRequest_CustomParamsSource_isCreateClusterConfigFileRequest_CustomParamsSource_Call) RunAndReturn(run func()) *isCreateClusterConfigFileRequest_CustomParamsSource_isCreateClusterConfigFileRequest_CustomParamsSource_Call {
	_c.Run(run)
	return _c
}

// NewConfigCenterServiceClient creates a new instance of ConfigCenterServiceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewConfigCenterServiceClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *ConfigCenterServiceClient {
	mock := &ConfigCenterServiceClient{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// ConfigCenterServiceClient is an autogenerated mock type for the ConfigCenterServiceClient type
type ConfigCenterServiceClient struct {
	mock.Mock
}

type ConfigCenterServiceClient_Expecter struct {
	mock *mock.Mock
}

func (_m *ConfigCenterServiceClient) EXPECT() *ConfigCenterServiceClient_Expecter {
	return &ConfigCenterServiceClient_Expecter{mock: &_m.Mock}
}

// AutoUpdateClusterConfigurationFile provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) AutoUpdateClusterConfigurationFile(ctx context.Context, in *config_center.AutoUpdateClusterConfigurationFileRequest, opts ...grpc.CallOption) (*config_center.ConfigurationFile, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for AutoUpdateClusterConfigurationFile")
	}

	var r0 *config_center.ConfigurationFile
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.AutoUpdateClusterConfigurationFileRequest, ...grpc.CallOption) (*config_center.ConfigurationFile, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.AutoUpdateClusterConfigurationFileRequest, ...grpc.CallOption) *config_center.ConfigurationFile); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationFile)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.AutoUpdateClusterConfigurationFileRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_AutoUpdateClusterConfigurationFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AutoUpdateClusterConfigurationFile'
type ConfigCenterServiceClient_AutoUpdateClusterConfigurationFile_Call struct {
	*mock.Call
}

// AutoUpdateClusterConfigurationFile is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.AutoUpdateClusterConfigurationFileRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) AutoUpdateClusterConfigurationFile(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_AutoUpdateClusterConfigurationFile_Call {
	return &ConfigCenterServiceClient_AutoUpdateClusterConfigurationFile_Call{Call: _e.mock.On("AutoUpdateClusterConfigurationFile",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_AutoUpdateClusterConfigurationFile_Call) Run(run func(ctx context.Context, in *config_center.AutoUpdateClusterConfigurationFileRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_AutoUpdateClusterConfigurationFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.AutoUpdateClusterConfigurationFileRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.AutoUpdateClusterConfigurationFileRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_AutoUpdateClusterConfigurationFile_Call) Return(configurationFile *config_center.ConfigurationFile, err error) *ConfigCenterServiceClient_AutoUpdateClusterConfigurationFile_Call {
	_c.Call.Return(configurationFile, err)
	return _c
}

func (_c *ConfigCenterServiceClient_AutoUpdateClusterConfigurationFile_Call) RunAndReturn(run func(ctx context.Context, in *config_center.AutoUpdateClusterConfigurationFileRequest, opts ...grpc.CallOption) (*config_center.ConfigurationFile, error)) *ConfigCenterServiceClient_AutoUpdateClusterConfigurationFile_Call {
	_c.Call.Return(run)
	return _c
}

// AutoUpdateClusterMeta provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) AutoUpdateClusterMeta(ctx context.Context, in *config_center.AutoUpdateClusterMetaRequest, opts ...grpc.CallOption) (*config_center.AutoUpdateClusterMetaResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for AutoUpdateClusterMeta")
	}

	var r0 *config_center.AutoUpdateClusterMetaResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.AutoUpdateClusterMetaRequest, ...grpc.CallOption) (*config_center.AutoUpdateClusterMetaResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.AutoUpdateClusterMetaRequest, ...grpc.CallOption) *config_center.AutoUpdateClusterMetaResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.AutoUpdateClusterMetaResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.AutoUpdateClusterMetaRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_AutoUpdateClusterMeta_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AutoUpdateClusterMeta'
type ConfigCenterServiceClient_AutoUpdateClusterMeta_Call struct {
	*mock.Call
}

// AutoUpdateClusterMeta is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.AutoUpdateClusterMetaRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) AutoUpdateClusterMeta(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_AutoUpdateClusterMeta_Call {
	return &ConfigCenterServiceClient_AutoUpdateClusterMeta_Call{Call: _e.mock.On("AutoUpdateClusterMeta",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_AutoUpdateClusterMeta_Call) Run(run func(ctx context.Context, in *config_center.AutoUpdateClusterMetaRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_AutoUpdateClusterMeta_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.AutoUpdateClusterMetaRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.AutoUpdateClusterMetaRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_AutoUpdateClusterMeta_Call) Return(autoUpdateClusterMetaResponse *config_center.AutoUpdateClusterMetaResponse, err error) *ConfigCenterServiceClient_AutoUpdateClusterMeta_Call {
	_c.Call.Return(autoUpdateClusterMetaResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_AutoUpdateClusterMeta_Call) RunAndReturn(run func(ctx context.Context, in *config_center.AutoUpdateClusterMetaRequest, opts ...grpc.CallOption) (*config_center.AutoUpdateClusterMetaResponse, error)) *ConfigCenterServiceClient_AutoUpdateClusterMeta_Call {
	_c.Call.Return(run)
	return _c
}

// BatchAutoUpdateClusterConfigurationFiles provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) BatchAutoUpdateClusterConfigurationFiles(ctx context.Context, in *config_center.BatchAutoUpdateClusterConfigurationFilesRequest, opts ...grpc.CallOption) (*config_center.BatchAutoUpdateClusterConfigurationFilesResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for BatchAutoUpdateClusterConfigurationFiles")
	}

	var r0 *config_center.BatchAutoUpdateClusterConfigurationFilesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchAutoUpdateClusterConfigurationFilesRequest, ...grpc.CallOption) (*config_center.BatchAutoUpdateClusterConfigurationFilesResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchAutoUpdateClusterConfigurationFilesRequest, ...grpc.CallOption) *config_center.BatchAutoUpdateClusterConfigurationFilesResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.BatchAutoUpdateClusterConfigurationFilesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchAutoUpdateClusterConfigurationFilesRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_BatchAutoUpdateClusterConfigurationFiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchAutoUpdateClusterConfigurationFiles'
type ConfigCenterServiceClient_BatchAutoUpdateClusterConfigurationFiles_Call struct {
	*mock.Call
}

// BatchAutoUpdateClusterConfigurationFiles is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.BatchAutoUpdateClusterConfigurationFilesRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) BatchAutoUpdateClusterConfigurationFiles(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_BatchAutoUpdateClusterConfigurationFiles_Call {
	return &ConfigCenterServiceClient_BatchAutoUpdateClusterConfigurationFiles_Call{Call: _e.mock.On("BatchAutoUpdateClusterConfigurationFiles",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_BatchAutoUpdateClusterConfigurationFiles_Call) Run(run func(ctx context.Context, in *config_center.BatchAutoUpdateClusterConfigurationFilesRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_BatchAutoUpdateClusterConfigurationFiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchAutoUpdateClusterConfigurationFilesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchAutoUpdateClusterConfigurationFilesRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_BatchAutoUpdateClusterConfigurationFiles_Call) Return(batchAutoUpdateClusterConfigurationFilesResponse *config_center.BatchAutoUpdateClusterConfigurationFilesResponse, err error) *ConfigCenterServiceClient_BatchAutoUpdateClusterConfigurationFiles_Call {
	_c.Call.Return(batchAutoUpdateClusterConfigurationFilesResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_BatchAutoUpdateClusterConfigurationFiles_Call) RunAndReturn(run func(ctx context.Context, in *config_center.BatchAutoUpdateClusterConfigurationFilesRequest, opts ...grpc.CallOption) (*config_center.BatchAutoUpdateClusterConfigurationFilesResponse, error)) *ConfigCenterServiceClient_BatchAutoUpdateClusterConfigurationFiles_Call {
	_c.Call.Return(run)
	return _c
}

// BatchCreateClusterConfigurationFiles provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) BatchCreateClusterConfigurationFiles(ctx context.Context, in *config_center.BatchCreateClusterConfigurationFilesRequest, opts ...grpc.CallOption) (*config_center.BatchCreateClusterConfigurationFilesResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for BatchCreateClusterConfigurationFiles")
	}

	var r0 *config_center.BatchCreateClusterConfigurationFilesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchCreateClusterConfigurationFilesRequest, ...grpc.CallOption) (*config_center.BatchCreateClusterConfigurationFilesResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchCreateClusterConfigurationFilesRequest, ...grpc.CallOption) *config_center.BatchCreateClusterConfigurationFilesResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.BatchCreateClusterConfigurationFilesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchCreateClusterConfigurationFilesRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_BatchCreateClusterConfigurationFiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchCreateClusterConfigurationFiles'
type ConfigCenterServiceClient_BatchCreateClusterConfigurationFiles_Call struct {
	*mock.Call
}

// BatchCreateClusterConfigurationFiles is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.BatchCreateClusterConfigurationFilesRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) BatchCreateClusterConfigurationFiles(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_BatchCreateClusterConfigurationFiles_Call {
	return &ConfigCenterServiceClient_BatchCreateClusterConfigurationFiles_Call{Call: _e.mock.On("BatchCreateClusterConfigurationFiles",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_BatchCreateClusterConfigurationFiles_Call) Run(run func(ctx context.Context, in *config_center.BatchCreateClusterConfigurationFilesRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_BatchCreateClusterConfigurationFiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchCreateClusterConfigurationFilesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchCreateClusterConfigurationFilesRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_BatchCreateClusterConfigurationFiles_Call) Return(batchCreateClusterConfigurationFilesResponse *config_center.BatchCreateClusterConfigurationFilesResponse, err error) *ConfigCenterServiceClient_BatchCreateClusterConfigurationFiles_Call {
	_c.Call.Return(batchCreateClusterConfigurationFilesResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_BatchCreateClusterConfigurationFiles_Call) RunAndReturn(run func(ctx context.Context, in *config_center.BatchCreateClusterConfigurationFilesRequest, opts ...grpc.CallOption) (*config_center.BatchCreateClusterConfigurationFilesResponse, error)) *ConfigCenterServiceClient_BatchCreateClusterConfigurationFiles_Call {
	_c.Call.Return(run)
	return _c
}

// BatchCreateConfigurationDictItems provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) BatchCreateConfigurationDictItems(ctx context.Context, in *config_center.BatchCreateConfigurationDictRequest, opts ...grpc.CallOption) (*config_center.BatchCreateConfigurationDictResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for BatchCreateConfigurationDictItems")
	}

	var r0 *config_center.BatchCreateConfigurationDictResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchCreateConfigurationDictRequest, ...grpc.CallOption) (*config_center.BatchCreateConfigurationDictResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchCreateConfigurationDictRequest, ...grpc.CallOption) *config_center.BatchCreateConfigurationDictResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.BatchCreateConfigurationDictResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchCreateConfigurationDictRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_BatchCreateConfigurationDictItems_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchCreateConfigurationDictItems'
type ConfigCenterServiceClient_BatchCreateConfigurationDictItems_Call struct {
	*mock.Call
}

// BatchCreateConfigurationDictItems is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.BatchCreateConfigurationDictRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) BatchCreateConfigurationDictItems(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_BatchCreateConfigurationDictItems_Call {
	return &ConfigCenterServiceClient_BatchCreateConfigurationDictItems_Call{Call: _e.mock.On("BatchCreateConfigurationDictItems",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_BatchCreateConfigurationDictItems_Call) Run(run func(ctx context.Context, in *config_center.BatchCreateConfigurationDictRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_BatchCreateConfigurationDictItems_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchCreateConfigurationDictRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchCreateConfigurationDictRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_BatchCreateConfigurationDictItems_Call) Return(batchCreateConfigurationDictResponse *config_center.BatchCreateConfigurationDictResponse, err error) *ConfigCenterServiceClient_BatchCreateConfigurationDictItems_Call {
	_c.Call.Return(batchCreateConfigurationDictResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_BatchCreateConfigurationDictItems_Call) RunAndReturn(run func(ctx context.Context, in *config_center.BatchCreateConfigurationDictRequest, opts ...grpc.CallOption) (*config_center.BatchCreateConfigurationDictResponse, error)) *ConfigCenterServiceClient_BatchCreateConfigurationDictItems_Call {
	_c.Call.Return(run)
	return _c
}

// BatchCreateConfigurationTemplates provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) BatchCreateConfigurationTemplates(ctx context.Context, in *config_center.BatchCreateConfigurationTemplatesRequest, opts ...grpc.CallOption) (*config_center.BatchCreateConfigurationTemplatesResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for BatchCreateConfigurationTemplates")
	}

	var r0 *config_center.BatchCreateConfigurationTemplatesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchCreateConfigurationTemplatesRequest, ...grpc.CallOption) (*config_center.BatchCreateConfigurationTemplatesResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchCreateConfigurationTemplatesRequest, ...grpc.CallOption) *config_center.BatchCreateConfigurationTemplatesResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.BatchCreateConfigurationTemplatesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchCreateConfigurationTemplatesRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_BatchCreateConfigurationTemplates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchCreateConfigurationTemplates'
type ConfigCenterServiceClient_BatchCreateConfigurationTemplates_Call struct {
	*mock.Call
}

// BatchCreateConfigurationTemplates is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.BatchCreateConfigurationTemplatesRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) BatchCreateConfigurationTemplates(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_BatchCreateConfigurationTemplates_Call {
	return &ConfigCenterServiceClient_BatchCreateConfigurationTemplates_Call{Call: _e.mock.On("BatchCreateConfigurationTemplates",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_BatchCreateConfigurationTemplates_Call) Run(run func(ctx context.Context, in *config_center.BatchCreateConfigurationTemplatesRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_BatchCreateConfigurationTemplates_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchCreateConfigurationTemplatesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchCreateConfigurationTemplatesRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_BatchCreateConfigurationTemplates_Call) Return(batchCreateConfigurationTemplatesResponse *config_center.BatchCreateConfigurationTemplatesResponse, err error) *ConfigCenterServiceClient_BatchCreateConfigurationTemplates_Call {
	_c.Call.Return(batchCreateConfigurationTemplatesResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_BatchCreateConfigurationTemplates_Call) RunAndReturn(run func(ctx context.Context, in *config_center.BatchCreateConfigurationTemplatesRequest, opts ...grpc.CallOption) (*config_center.BatchCreateConfigurationTemplatesResponse, error)) *ConfigCenterServiceClient_BatchCreateConfigurationTemplates_Call {
	_c.Call.Return(run)
	return _c
}

// BatchDeleteClusterConfigurationFiles provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) BatchDeleteClusterConfigurationFiles(ctx context.Context, in *config_center.BatchDeleteClusterConfigurationFilesRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for BatchDeleteClusterConfigurationFiles")
	}

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchDeleteClusterConfigurationFilesRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchDeleteClusterConfigurationFilesRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchDeleteClusterConfigurationFilesRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_BatchDeleteClusterConfigurationFiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchDeleteClusterConfigurationFiles'
type ConfigCenterServiceClient_BatchDeleteClusterConfigurationFiles_Call struct {
	*mock.Call
}

// BatchDeleteClusterConfigurationFiles is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.BatchDeleteClusterConfigurationFilesRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) BatchDeleteClusterConfigurationFiles(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_BatchDeleteClusterConfigurationFiles_Call {
	return &ConfigCenterServiceClient_BatchDeleteClusterConfigurationFiles_Call{Call: _e.mock.On("BatchDeleteClusterConfigurationFiles",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_BatchDeleteClusterConfigurationFiles_Call) Run(run func(ctx context.Context, in *config_center.BatchDeleteClusterConfigurationFilesRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_BatchDeleteClusterConfigurationFiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchDeleteClusterConfigurationFilesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchDeleteClusterConfigurationFilesRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_BatchDeleteClusterConfigurationFiles_Call) Return(empty *emptypb.Empty, err error) *ConfigCenterServiceClient_BatchDeleteClusterConfigurationFiles_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *ConfigCenterServiceClient_BatchDeleteClusterConfigurationFiles_Call) RunAndReturn(run func(ctx context.Context, in *config_center.BatchDeleteClusterConfigurationFilesRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *ConfigCenterServiceClient_BatchDeleteClusterConfigurationFiles_Call {
	_c.Call.Return(run)
	return _c
}

// BatchDeleteClusterMeta provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) BatchDeleteClusterMeta(ctx context.Context, in *config_center.BatchDeleteClusterMetaRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for BatchDeleteClusterMeta")
	}

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchDeleteClusterMetaRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchDeleteClusterMetaRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchDeleteClusterMetaRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_BatchDeleteClusterMeta_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchDeleteClusterMeta'
type ConfigCenterServiceClient_BatchDeleteClusterMeta_Call struct {
	*mock.Call
}

// BatchDeleteClusterMeta is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.BatchDeleteClusterMetaRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) BatchDeleteClusterMeta(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_BatchDeleteClusterMeta_Call {
	return &ConfigCenterServiceClient_BatchDeleteClusterMeta_Call{Call: _e.mock.On("BatchDeleteClusterMeta",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_BatchDeleteClusterMeta_Call) Run(run func(ctx context.Context, in *config_center.BatchDeleteClusterMetaRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_BatchDeleteClusterMeta_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchDeleteClusterMetaRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchDeleteClusterMetaRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_BatchDeleteClusterMeta_Call) Return(empty *emptypb.Empty, err error) *ConfigCenterServiceClient_BatchDeleteClusterMeta_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *ConfigCenterServiceClient_BatchDeleteClusterMeta_Call) RunAndReturn(run func(ctx context.Context, in *config_center.BatchDeleteClusterMetaRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *ConfigCenterServiceClient_BatchDeleteClusterMeta_Call {
	_c.Call.Return(run)
	return _c
}

// BatchSearchDefaultConfigurationTemplate provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) BatchSearchDefaultConfigurationTemplate(ctx context.Context, in *config_center.BatchSearchDefaultConfigurationTemplateRequest, opts ...grpc.CallOption) (*config_center.BatchSearchDefaultConfigurationTemplateResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for BatchSearchDefaultConfigurationTemplate")
	}

	var r0 *config_center.BatchSearchDefaultConfigurationTemplateResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchSearchDefaultConfigurationTemplateRequest, ...grpc.CallOption) (*config_center.BatchSearchDefaultConfigurationTemplateResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchSearchDefaultConfigurationTemplateRequest, ...grpc.CallOption) *config_center.BatchSearchDefaultConfigurationTemplateResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.BatchSearchDefaultConfigurationTemplateResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchSearchDefaultConfigurationTemplateRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_BatchSearchDefaultConfigurationTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchSearchDefaultConfigurationTemplate'
type ConfigCenterServiceClient_BatchSearchDefaultConfigurationTemplate_Call struct {
	*mock.Call
}

// BatchSearchDefaultConfigurationTemplate is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.BatchSearchDefaultConfigurationTemplateRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) BatchSearchDefaultConfigurationTemplate(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_BatchSearchDefaultConfigurationTemplate_Call {
	return &ConfigCenterServiceClient_BatchSearchDefaultConfigurationTemplate_Call{Call: _e.mock.On("BatchSearchDefaultConfigurationTemplate",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_BatchSearchDefaultConfigurationTemplate_Call) Run(run func(ctx context.Context, in *config_center.BatchSearchDefaultConfigurationTemplateRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_BatchSearchDefaultConfigurationTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchSearchDefaultConfigurationTemplateRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchSearchDefaultConfigurationTemplateRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_BatchSearchDefaultConfigurationTemplate_Call) Return(batchSearchDefaultConfigurationTemplateResponse *config_center.BatchSearchDefaultConfigurationTemplateResponse, err error) *ConfigCenterServiceClient_BatchSearchDefaultConfigurationTemplate_Call {
	_c.Call.Return(batchSearchDefaultConfigurationTemplateResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_BatchSearchDefaultConfigurationTemplate_Call) RunAndReturn(run func(ctx context.Context, in *config_center.BatchSearchDefaultConfigurationTemplateRequest, opts ...grpc.CallOption) (*config_center.BatchSearchDefaultConfigurationTemplateResponse, error)) *ConfigCenterServiceClient_BatchSearchDefaultConfigurationTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// BatchUpdateClusterComponents provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) BatchUpdateClusterComponents(ctx context.Context, in *config_center.BatchUpdateClusterComponentsRequest, opts ...grpc.CallOption) (*config_center.BatchUpdateClusterComponentsResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for BatchUpdateClusterComponents")
	}

	var r0 *config_center.BatchUpdateClusterComponentsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchUpdateClusterComponentsRequest, ...grpc.CallOption) (*config_center.BatchUpdateClusterComponentsResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchUpdateClusterComponentsRequest, ...grpc.CallOption) *config_center.BatchUpdateClusterComponentsResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.BatchUpdateClusterComponentsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchUpdateClusterComponentsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_BatchUpdateClusterComponents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchUpdateClusterComponents'
type ConfigCenterServiceClient_BatchUpdateClusterComponents_Call struct {
	*mock.Call
}

// BatchUpdateClusterComponents is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.BatchUpdateClusterComponentsRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) BatchUpdateClusterComponents(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_BatchUpdateClusterComponents_Call {
	return &ConfigCenterServiceClient_BatchUpdateClusterComponents_Call{Call: _e.mock.On("BatchUpdateClusterComponents",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_BatchUpdateClusterComponents_Call) Run(run func(ctx context.Context, in *config_center.BatchUpdateClusterComponentsRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_BatchUpdateClusterComponents_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchUpdateClusterComponentsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchUpdateClusterComponentsRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_BatchUpdateClusterComponents_Call) Return(batchUpdateClusterComponentsResponse *config_center.BatchUpdateClusterComponentsResponse, err error) *ConfigCenterServiceClient_BatchUpdateClusterComponents_Call {
	_c.Call.Return(batchUpdateClusterComponentsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_BatchUpdateClusterComponents_Call) RunAndReturn(run func(ctx context.Context, in *config_center.BatchUpdateClusterComponentsRequest, opts ...grpc.CallOption) (*config_center.BatchUpdateClusterComponentsResponse, error)) *ConfigCenterServiceClient_BatchUpdateClusterComponents_Call {
	_c.Call.Return(run)
	return _c
}

// BatchUpdateClusterConfigurationFiles provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) BatchUpdateClusterConfigurationFiles(ctx context.Context, in *config_center.BatchUpdateClusterConfigurationFilesRequest, opts ...grpc.CallOption) (*config_center.BatchUpdateClusterConfigurationFilesResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for BatchUpdateClusterConfigurationFiles")
	}

	var r0 *config_center.BatchUpdateClusterConfigurationFilesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchUpdateClusterConfigurationFilesRequest, ...grpc.CallOption) (*config_center.BatchUpdateClusterConfigurationFilesResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchUpdateClusterConfigurationFilesRequest, ...grpc.CallOption) *config_center.BatchUpdateClusterConfigurationFilesResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.BatchUpdateClusterConfigurationFilesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchUpdateClusterConfigurationFilesRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_BatchUpdateClusterConfigurationFiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchUpdateClusterConfigurationFiles'
type ConfigCenterServiceClient_BatchUpdateClusterConfigurationFiles_Call struct {
	*mock.Call
}

// BatchUpdateClusterConfigurationFiles is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.BatchUpdateClusterConfigurationFilesRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) BatchUpdateClusterConfigurationFiles(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_BatchUpdateClusterConfigurationFiles_Call {
	return &ConfigCenterServiceClient_BatchUpdateClusterConfigurationFiles_Call{Call: _e.mock.On("BatchUpdateClusterConfigurationFiles",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_BatchUpdateClusterConfigurationFiles_Call) Run(run func(ctx context.Context, in *config_center.BatchUpdateClusterConfigurationFilesRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_BatchUpdateClusterConfigurationFiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchUpdateClusterConfigurationFilesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchUpdateClusterConfigurationFilesRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_BatchUpdateClusterConfigurationFiles_Call) Return(batchUpdateClusterConfigurationFilesResponse *config_center.BatchUpdateClusterConfigurationFilesResponse, err error) *ConfigCenterServiceClient_BatchUpdateClusterConfigurationFiles_Call {
	_c.Call.Return(batchUpdateClusterConfigurationFilesResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_BatchUpdateClusterConfigurationFiles_Call) RunAndReturn(run func(ctx context.Context, in *config_center.BatchUpdateClusterConfigurationFilesRequest, opts ...grpc.CallOption) (*config_center.BatchUpdateClusterConfigurationFilesResponse, error)) *ConfigCenterServiceClient_BatchUpdateClusterConfigurationFiles_Call {
	_c.Call.Return(run)
	return _c
}

// BatchUpdateDefaultConfigurationTemplate provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) BatchUpdateDefaultConfigurationTemplate(ctx context.Context, in *config_center.BatchUpdateDefaultConfigurationTemplateRequest, opts ...grpc.CallOption) (*config_center.BatchUpdateDefaultConfigurationTemplateResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for BatchUpdateDefaultConfigurationTemplate")
	}

	var r0 *config_center.BatchUpdateDefaultConfigurationTemplateResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchUpdateDefaultConfigurationTemplateRequest, ...grpc.CallOption) (*config_center.BatchUpdateDefaultConfigurationTemplateResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchUpdateDefaultConfigurationTemplateRequest, ...grpc.CallOption) *config_center.BatchUpdateDefaultConfigurationTemplateResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.BatchUpdateDefaultConfigurationTemplateResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchUpdateDefaultConfigurationTemplateRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_BatchUpdateDefaultConfigurationTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchUpdateDefaultConfigurationTemplate'
type ConfigCenterServiceClient_BatchUpdateDefaultConfigurationTemplate_Call struct {
	*mock.Call
}

// BatchUpdateDefaultConfigurationTemplate is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.BatchUpdateDefaultConfigurationTemplateRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) BatchUpdateDefaultConfigurationTemplate(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_BatchUpdateDefaultConfigurationTemplate_Call {
	return &ConfigCenterServiceClient_BatchUpdateDefaultConfigurationTemplate_Call{Call: _e.mock.On("BatchUpdateDefaultConfigurationTemplate",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_BatchUpdateDefaultConfigurationTemplate_Call) Run(run func(ctx context.Context, in *config_center.BatchUpdateDefaultConfigurationTemplateRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_BatchUpdateDefaultConfigurationTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchUpdateDefaultConfigurationTemplateRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchUpdateDefaultConfigurationTemplateRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_BatchUpdateDefaultConfigurationTemplate_Call) Return(batchUpdateDefaultConfigurationTemplateResponse *config_center.BatchUpdateDefaultConfigurationTemplateResponse, err error) *ConfigCenterServiceClient_BatchUpdateDefaultConfigurationTemplate_Call {
	_c.Call.Return(batchUpdateDefaultConfigurationTemplateResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_BatchUpdateDefaultConfigurationTemplate_Call) RunAndReturn(run func(ctx context.Context, in *config_center.BatchUpdateDefaultConfigurationTemplateRequest, opts ...grpc.CallOption) (*config_center.BatchUpdateDefaultConfigurationTemplateResponse, error)) *ConfigCenterServiceClient_BatchUpdateDefaultConfigurationTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// BatchUpdateTenantInitialCustomParams provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) BatchUpdateTenantInitialCustomParams(ctx context.Context, in *config_center.BatchUpdateTenantInitialCustomParamsRequest, opts ...grpc.CallOption) (*config_center.BatchUpdateTenantInitialCustomParamsResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for BatchUpdateTenantInitialCustomParams")
	}

	var r0 *config_center.BatchUpdateTenantInitialCustomParamsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchUpdateTenantInitialCustomParamsRequest, ...grpc.CallOption) (*config_center.BatchUpdateTenantInitialCustomParamsResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchUpdateTenantInitialCustomParamsRequest, ...grpc.CallOption) *config_center.BatchUpdateTenantInitialCustomParamsResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.BatchUpdateTenantInitialCustomParamsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchUpdateTenantInitialCustomParamsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_BatchUpdateTenantInitialCustomParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchUpdateTenantInitialCustomParams'
type ConfigCenterServiceClient_BatchUpdateTenantInitialCustomParams_Call struct {
	*mock.Call
}

// BatchUpdateTenantInitialCustomParams is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.BatchUpdateTenantInitialCustomParamsRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) BatchUpdateTenantInitialCustomParams(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_BatchUpdateTenantInitialCustomParams_Call {
	return &ConfigCenterServiceClient_BatchUpdateTenantInitialCustomParams_Call{Call: _e.mock.On("BatchUpdateTenantInitialCustomParams",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_BatchUpdateTenantInitialCustomParams_Call) Run(run func(ctx context.Context, in *config_center.BatchUpdateTenantInitialCustomParamsRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_BatchUpdateTenantInitialCustomParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchUpdateTenantInitialCustomParamsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchUpdateTenantInitialCustomParamsRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_BatchUpdateTenantInitialCustomParams_Call) Return(batchUpdateTenantInitialCustomParamsResponse *config_center.BatchUpdateTenantInitialCustomParamsResponse, err error) *ConfigCenterServiceClient_BatchUpdateTenantInitialCustomParams_Call {
	_c.Call.Return(batchUpdateTenantInitialCustomParamsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_BatchUpdateTenantInitialCustomParams_Call) RunAndReturn(run func(ctx context.Context, in *config_center.BatchUpdateTenantInitialCustomParamsRequest, opts ...grpc.CallOption) (*config_center.BatchUpdateTenantInitialCustomParamsResponse, error)) *ConfigCenterServiceClient_BatchUpdateTenantInitialCustomParams_Call {
	_c.Call.Return(run)
	return _c
}

// BatchUpsertClusterCustomParams provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) BatchUpsertClusterCustomParams(ctx context.Context, in *config_center.BatchUpsertClusterCustomParamsRequest, opts ...grpc.CallOption) (*config_center.BatchUpsertClusterCustomParamsResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for BatchUpsertClusterCustomParams")
	}

	var r0 *config_center.BatchUpsertClusterCustomParamsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchUpsertClusterCustomParamsRequest, ...grpc.CallOption) (*config_center.BatchUpsertClusterCustomParamsResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchUpsertClusterCustomParamsRequest, ...grpc.CallOption) *config_center.BatchUpsertClusterCustomParamsResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.BatchUpsertClusterCustomParamsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchUpsertClusterCustomParamsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_BatchUpsertClusterCustomParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchUpsertClusterCustomParams'
type ConfigCenterServiceClient_BatchUpsertClusterCustomParams_Call struct {
	*mock.Call
}

// BatchUpsertClusterCustomParams is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.BatchUpsertClusterCustomParamsRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) BatchUpsertClusterCustomParams(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_BatchUpsertClusterCustomParams_Call {
	return &ConfigCenterServiceClient_BatchUpsertClusterCustomParams_Call{Call: _e.mock.On("BatchUpsertClusterCustomParams",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_BatchUpsertClusterCustomParams_Call) Run(run func(ctx context.Context, in *config_center.BatchUpsertClusterCustomParamsRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_BatchUpsertClusterCustomParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchUpsertClusterCustomParamsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchUpsertClusterCustomParamsRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_BatchUpsertClusterCustomParams_Call) Return(batchUpsertClusterCustomParamsResponse *config_center.BatchUpsertClusterCustomParamsResponse, err error) *ConfigCenterServiceClient_BatchUpsertClusterCustomParams_Call {
	_c.Call.Return(batchUpsertClusterCustomParamsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_BatchUpsertClusterCustomParams_Call) RunAndReturn(run func(ctx context.Context, in *config_center.BatchUpsertClusterCustomParamsRequest, opts ...grpc.CallOption) (*config_center.BatchUpsertClusterCustomParamsResponse, error)) *ConfigCenterServiceClient_BatchUpsertClusterCustomParams_Call {
	_c.Call.Return(run)
	return _c
}

// CopyConfigurationDictFromOldVersion provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) CopyConfigurationDictFromOldVersion(ctx context.Context, in *config_center.CopyConfigurationDictFromOldVersionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for CopyConfigurationDictFromOldVersion")
	}

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.CopyConfigurationDictFromOldVersionRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.CopyConfigurationDictFromOldVersionRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.CopyConfigurationDictFromOldVersionRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_CopyConfigurationDictFromOldVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CopyConfigurationDictFromOldVersion'
type ConfigCenterServiceClient_CopyConfigurationDictFromOldVersion_Call struct {
	*mock.Call
}

// CopyConfigurationDictFromOldVersion is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.CopyConfigurationDictFromOldVersionRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) CopyConfigurationDictFromOldVersion(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_CopyConfigurationDictFromOldVersion_Call {
	return &ConfigCenterServiceClient_CopyConfigurationDictFromOldVersion_Call{Call: _e.mock.On("CopyConfigurationDictFromOldVersion",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_CopyConfigurationDictFromOldVersion_Call) Run(run func(ctx context.Context, in *config_center.CopyConfigurationDictFromOldVersionRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_CopyConfigurationDictFromOldVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.CopyConfigurationDictFromOldVersionRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.CopyConfigurationDictFromOldVersionRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_CopyConfigurationDictFromOldVersion_Call) Return(empty *emptypb.Empty, err error) *ConfigCenterServiceClient_CopyConfigurationDictFromOldVersion_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *ConfigCenterServiceClient_CopyConfigurationDictFromOldVersion_Call) RunAndReturn(run func(ctx context.Context, in *config_center.CopyConfigurationDictFromOldVersionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *ConfigCenterServiceClient_CopyConfigurationDictFromOldVersion_Call {
	_c.Call.Return(run)
	return _c
}

// CreateClusterConfigurationFile provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) CreateClusterConfigurationFile(ctx context.Context, in *config_center.CreateClusterConfigurationFileRequest, opts ...grpc.CallOption) (*config_center.ConfigurationFile, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for CreateClusterConfigurationFile")
	}

	var r0 *config_center.ConfigurationFile
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.CreateClusterConfigurationFileRequest, ...grpc.CallOption) (*config_center.ConfigurationFile, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.CreateClusterConfigurationFileRequest, ...grpc.CallOption) *config_center.ConfigurationFile); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationFile)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.CreateClusterConfigurationFileRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_CreateClusterConfigurationFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateClusterConfigurationFile'
type ConfigCenterServiceClient_CreateClusterConfigurationFile_Call struct {
	*mock.Call
}

// CreateClusterConfigurationFile is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.CreateClusterConfigurationFileRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) CreateClusterConfigurationFile(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_CreateClusterConfigurationFile_Call {
	return &ConfigCenterServiceClient_CreateClusterConfigurationFile_Call{Call: _e.mock.On("CreateClusterConfigurationFile",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_CreateClusterConfigurationFile_Call) Run(run func(ctx context.Context, in *config_center.CreateClusterConfigurationFileRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_CreateClusterConfigurationFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.CreateClusterConfigurationFileRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.CreateClusterConfigurationFileRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_CreateClusterConfigurationFile_Call) Return(configurationFile *config_center.ConfigurationFile, err error) *ConfigCenterServiceClient_CreateClusterConfigurationFile_Call {
	_c.Call.Return(configurationFile, err)
	return _c
}

func (_c *ConfigCenterServiceClient_CreateClusterConfigurationFile_Call) RunAndReturn(run func(ctx context.Context, in *config_center.CreateClusterConfigurationFileRequest, opts ...grpc.CallOption) (*config_center.ConfigurationFile, error)) *ConfigCenterServiceClient_CreateClusterConfigurationFile_Call {
	_c.Call.Return(run)
	return _c
}

// CreateConfigurationTemplate provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) CreateConfigurationTemplate(ctx context.Context, in *config_center.CreateConfigurationTemplateRequest, opts ...grpc.CallOption) (*config_center.ConfigurationTemplate, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for CreateConfigurationTemplate")
	}

	var r0 *config_center.ConfigurationTemplate
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.CreateConfigurationTemplateRequest, ...grpc.CallOption) (*config_center.ConfigurationTemplate, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.CreateConfigurationTemplateRequest, ...grpc.CallOption) *config_center.ConfigurationTemplate); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationTemplate)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.CreateConfigurationTemplateRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_CreateConfigurationTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateConfigurationTemplate'
type ConfigCenterServiceClient_CreateConfigurationTemplate_Call struct {
	*mock.Call
}

// CreateConfigurationTemplate is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.CreateConfigurationTemplateRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) CreateConfigurationTemplate(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_CreateConfigurationTemplate_Call {
	return &ConfigCenterServiceClient_CreateConfigurationTemplate_Call{Call: _e.mock.On("CreateConfigurationTemplate",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_CreateConfigurationTemplate_Call) Run(run func(ctx context.Context, in *config_center.CreateConfigurationTemplateRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_CreateConfigurationTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.CreateConfigurationTemplateRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.CreateConfigurationTemplateRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_CreateConfigurationTemplate_Call) Return(configurationTemplate *config_center.ConfigurationTemplate, err error) *ConfigCenterServiceClient_CreateConfigurationTemplate_Call {
	_c.Call.Return(configurationTemplate, err)
	return _c
}

func (_c *ConfigCenterServiceClient_CreateConfigurationTemplate_Call) RunAndReturn(run func(ctx context.Context, in *config_center.CreateConfigurationTemplateRequest, opts ...grpc.CallOption) (*config_center.ConfigurationTemplate, error)) *ConfigCenterServiceClient_CreateConfigurationTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// CreateMetaProfile provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) CreateMetaProfile(ctx context.Context, in *config_center.CreateMetaProfileRequest, opts ...grpc.CallOption) (*config_center.MetaProfile, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for CreateMetaProfile")
	}

	var r0 *config_center.MetaProfile
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.CreateMetaProfileRequest, ...grpc.CallOption) (*config_center.MetaProfile, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.CreateMetaProfileRequest, ...grpc.CallOption) *config_center.MetaProfile); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.MetaProfile)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.CreateMetaProfileRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_CreateMetaProfile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMetaProfile'
type ConfigCenterServiceClient_CreateMetaProfile_Call struct {
	*mock.Call
}

// CreateMetaProfile is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.CreateMetaProfileRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) CreateMetaProfile(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_CreateMetaProfile_Call {
	return &ConfigCenterServiceClient_CreateMetaProfile_Call{Call: _e.mock.On("CreateMetaProfile",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_CreateMetaProfile_Call) Run(run func(ctx context.Context, in *config_center.CreateMetaProfileRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_CreateMetaProfile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.CreateMetaProfileRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.CreateMetaProfileRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_CreateMetaProfile_Call) Return(metaProfile *config_center.MetaProfile, err error) *ConfigCenterServiceClient_CreateMetaProfile_Call {
	_c.Call.Return(metaProfile, err)
	return _c
}

func (_c *ConfigCenterServiceClient_CreateMetaProfile_Call) RunAndReturn(run func(ctx context.Context, in *config_center.CreateMetaProfileRequest, opts ...grpc.CallOption) (*config_center.MetaProfile, error)) *ConfigCenterServiceClient_CreateMetaProfile_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteClusterConfigurationFile provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) DeleteClusterConfigurationFile(ctx context.Context, in *config_center.DeleteClusterConfigurationFileRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for DeleteClusterConfigurationFile")
	}

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteClusterConfigurationFileRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteClusterConfigurationFileRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.DeleteClusterConfigurationFileRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_DeleteClusterConfigurationFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteClusterConfigurationFile'
type ConfigCenterServiceClient_DeleteClusterConfigurationFile_Call struct {
	*mock.Call
}

// DeleteClusterConfigurationFile is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.DeleteClusterConfigurationFileRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) DeleteClusterConfigurationFile(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_DeleteClusterConfigurationFile_Call {
	return &ConfigCenterServiceClient_DeleteClusterConfigurationFile_Call{Call: _e.mock.On("DeleteClusterConfigurationFile",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_DeleteClusterConfigurationFile_Call) Run(run func(ctx context.Context, in *config_center.DeleteClusterConfigurationFileRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_DeleteClusterConfigurationFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.DeleteClusterConfigurationFileRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.DeleteClusterConfigurationFileRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_DeleteClusterConfigurationFile_Call) Return(empty *emptypb.Empty, err error) *ConfigCenterServiceClient_DeleteClusterConfigurationFile_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *ConfigCenterServiceClient_DeleteClusterConfigurationFile_Call) RunAndReturn(run func(ctx context.Context, in *config_center.DeleteClusterConfigurationFileRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *ConfigCenterServiceClient_DeleteClusterConfigurationFile_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteClusterMeta provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) DeleteClusterMeta(ctx context.Context, in *config_center.DeleteClusterMetaRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for DeleteClusterMeta")
	}

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteClusterMetaRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteClusterMetaRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.DeleteClusterMetaRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_DeleteClusterMeta_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteClusterMeta'
type ConfigCenterServiceClient_DeleteClusterMeta_Call struct {
	*mock.Call
}

// DeleteClusterMeta is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.DeleteClusterMetaRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) DeleteClusterMeta(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_DeleteClusterMeta_Call {
	return &ConfigCenterServiceClient_DeleteClusterMeta_Call{Call: _e.mock.On("DeleteClusterMeta",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_DeleteClusterMeta_Call) Run(run func(ctx context.Context, in *config_center.DeleteClusterMetaRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_DeleteClusterMeta_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.DeleteClusterMetaRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.DeleteClusterMetaRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_DeleteClusterMeta_Call) Return(empty *emptypb.Empty, err error) *ConfigCenterServiceClient_DeleteClusterMeta_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *ConfigCenterServiceClient_DeleteClusterMeta_Call) RunAndReturn(run func(ctx context.Context, in *config_center.DeleteClusterMetaRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *ConfigCenterServiceClient_DeleteClusterMeta_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteConfigurationTemplate provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) DeleteConfigurationTemplate(ctx context.Context, in *config_center.DeleteConfigurationTemplateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for DeleteConfigurationTemplate")
	}

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteConfigurationTemplateRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteConfigurationTemplateRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.DeleteConfigurationTemplateRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_DeleteConfigurationTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteConfigurationTemplate'
type ConfigCenterServiceClient_DeleteConfigurationTemplate_Call struct {
	*mock.Call
}

// DeleteConfigurationTemplate is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.DeleteConfigurationTemplateRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) DeleteConfigurationTemplate(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_DeleteConfigurationTemplate_Call {
	return &ConfigCenterServiceClient_DeleteConfigurationTemplate_Call{Call: _e.mock.On("DeleteConfigurationTemplate",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_DeleteConfigurationTemplate_Call) Run(run func(ctx context.Context, in *config_center.DeleteConfigurationTemplateRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_DeleteConfigurationTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.DeleteConfigurationTemplateRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.DeleteConfigurationTemplateRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_DeleteConfigurationTemplate_Call) Return(empty *emptypb.Empty, err error) *ConfigCenterServiceClient_DeleteConfigurationTemplate_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *ConfigCenterServiceClient_DeleteConfigurationTemplate_Call) RunAndReturn(run func(ctx context.Context, in *config_center.DeleteConfigurationTemplateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *ConfigCenterServiceClient_DeleteConfigurationTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDefaultConfigurationTemplate provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) DeleteDefaultConfigurationTemplate(ctx context.Context, in *config_center.DeleteDefaultConfigurationTemplateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for DeleteDefaultConfigurationTemplate")
	}

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteDefaultConfigurationTemplateRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteDefaultConfigurationTemplateRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.DeleteDefaultConfigurationTemplateRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_DeleteDefaultConfigurationTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteDefaultConfigurationTemplate'
type ConfigCenterServiceClient_DeleteDefaultConfigurationTemplate_Call struct {
	*mock.Call
}

// DeleteDefaultConfigurationTemplate is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.DeleteDefaultConfigurationTemplateRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) DeleteDefaultConfigurationTemplate(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_DeleteDefaultConfigurationTemplate_Call {
	return &ConfigCenterServiceClient_DeleteDefaultConfigurationTemplate_Call{Call: _e.mock.On("DeleteDefaultConfigurationTemplate",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_DeleteDefaultConfigurationTemplate_Call) Run(run func(ctx context.Context, in *config_center.DeleteDefaultConfigurationTemplateRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_DeleteDefaultConfigurationTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.DeleteDefaultConfigurationTemplateRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.DeleteDefaultConfigurationTemplateRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_DeleteDefaultConfigurationTemplate_Call) Return(empty *emptypb.Empty, err error) *ConfigCenterServiceClient_DeleteDefaultConfigurationTemplate_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *ConfigCenterServiceClient_DeleteDefaultConfigurationTemplate_Call) RunAndReturn(run func(ctx context.Context, in *config_center.DeleteDefaultConfigurationTemplateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *ConfigCenterServiceClient_DeleteDefaultConfigurationTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDefaultVersion provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) DeleteDefaultVersion(ctx context.Context, in *config_center.DeleteDefaultVersionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for DeleteDefaultVersion")
	}

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteDefaultVersionRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteDefaultVersionRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.DeleteDefaultVersionRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_DeleteDefaultVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteDefaultVersion'
type ConfigCenterServiceClient_DeleteDefaultVersion_Call struct {
	*mock.Call
}

// DeleteDefaultVersion is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.DeleteDefaultVersionRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) DeleteDefaultVersion(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_DeleteDefaultVersion_Call {
	return &ConfigCenterServiceClient_DeleteDefaultVersion_Call{Call: _e.mock.On("DeleteDefaultVersion",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_DeleteDefaultVersion_Call) Run(run func(ctx context.Context, in *config_center.DeleteDefaultVersionRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_DeleteDefaultVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.DeleteDefaultVersionRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.DeleteDefaultVersionRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_DeleteDefaultVersion_Call) Return(empty *emptypb.Empty, err error) *ConfigCenterServiceClient_DeleteDefaultVersion_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *ConfigCenterServiceClient_DeleteDefaultVersion_Call) RunAndReturn(run func(ctx context.Context, in *config_center.DeleteDefaultVersionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *ConfigCenterServiceClient_DeleteDefaultVersion_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteMetaProfile provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) DeleteMetaProfile(ctx context.Context, in *config_center.DeleteMetaProfileRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for DeleteMetaProfile")
	}

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteMetaProfileRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteMetaProfileRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.DeleteMetaProfileRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_DeleteMetaProfile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMetaProfile'
type ConfigCenterServiceClient_DeleteMetaProfile_Call struct {
	*mock.Call
}

// DeleteMetaProfile is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.DeleteMetaProfileRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) DeleteMetaProfile(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_DeleteMetaProfile_Call {
	return &ConfigCenterServiceClient_DeleteMetaProfile_Call{Call: _e.mock.On("DeleteMetaProfile",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_DeleteMetaProfile_Call) Run(run func(ctx context.Context, in *config_center.DeleteMetaProfileRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_DeleteMetaProfile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.DeleteMetaProfileRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.DeleteMetaProfileRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_DeleteMetaProfile_Call) Return(empty *emptypb.Empty, err error) *ConfigCenterServiceClient_DeleteMetaProfile_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *ConfigCenterServiceClient_DeleteMetaProfile_Call) RunAndReturn(run func(ctx context.Context, in *config_center.DeleteMetaProfileRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *ConfigCenterServiceClient_DeleteMetaProfile_Call {
	_c.Call.Return(run)
	return _c
}

// GetClusterComponent provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) GetClusterComponent(ctx context.Context, in *config_center.GetClusterComponentRequest, opts ...grpc.CallOption) (*config_center.ClusterComponent, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for GetClusterComponent")
	}

	var r0 *config_center.ClusterComponent
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetClusterComponentRequest, ...grpc.CallOption) (*config_center.ClusterComponent, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetClusterComponentRequest, ...grpc.CallOption) *config_center.ClusterComponent); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ClusterComponent)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetClusterComponentRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_GetClusterComponent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClusterComponent'
type ConfigCenterServiceClient_GetClusterComponent_Call struct {
	*mock.Call
}

// GetClusterComponent is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.GetClusterComponentRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) GetClusterComponent(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_GetClusterComponent_Call {
	return &ConfigCenterServiceClient_GetClusterComponent_Call{Call: _e.mock.On("GetClusterComponent",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_GetClusterComponent_Call) Run(run func(ctx context.Context, in *config_center.GetClusterComponentRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_GetClusterComponent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetClusterComponentRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetClusterComponentRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_GetClusterComponent_Call) Return(clusterComponent *config_center.ClusterComponent, err error) *ConfigCenterServiceClient_GetClusterComponent_Call {
	_c.Call.Return(clusterComponent, err)
	return _c
}

func (_c *ConfigCenterServiceClient_GetClusterComponent_Call) RunAndReturn(run func(ctx context.Context, in *config_center.GetClusterComponentRequest, opts ...grpc.CallOption) (*config_center.ClusterComponent, error)) *ConfigCenterServiceClient_GetClusterComponent_Call {
	_c.Call.Return(run)
	return _c
}

// GetClusterConfigurationFile provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) GetClusterConfigurationFile(ctx context.Context, in *config_center.GetClusterConfigurationFileRequest, opts ...grpc.CallOption) (*config_center.ConfigurationFile, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for GetClusterConfigurationFile")
	}

	var r0 *config_center.ConfigurationFile
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetClusterConfigurationFileRequest, ...grpc.CallOption) (*config_center.ConfigurationFile, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetClusterConfigurationFileRequest, ...grpc.CallOption) *config_center.ConfigurationFile); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationFile)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetClusterConfigurationFileRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_GetClusterConfigurationFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClusterConfigurationFile'
type ConfigCenterServiceClient_GetClusterConfigurationFile_Call struct {
	*mock.Call
}

// GetClusterConfigurationFile is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.GetClusterConfigurationFileRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) GetClusterConfigurationFile(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_GetClusterConfigurationFile_Call {
	return &ConfigCenterServiceClient_GetClusterConfigurationFile_Call{Call: _e.mock.On("GetClusterConfigurationFile",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_GetClusterConfigurationFile_Call) Run(run func(ctx context.Context, in *config_center.GetClusterConfigurationFileRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_GetClusterConfigurationFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetClusterConfigurationFileRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetClusterConfigurationFileRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_GetClusterConfigurationFile_Call) Return(configurationFile *config_center.ConfigurationFile, err error) *ConfigCenterServiceClient_GetClusterConfigurationFile_Call {
	_c.Call.Return(configurationFile, err)
	return _c
}

func (_c *ConfigCenterServiceClient_GetClusterConfigurationFile_Call) RunAndReturn(run func(ctx context.Context, in *config_center.GetClusterConfigurationFileRequest, opts ...grpc.CallOption) (*config_center.ConfigurationFile, error)) *ConfigCenterServiceClient_GetClusterConfigurationFile_Call {
	_c.Call.Return(run)
	return _c
}

// GetClusterMeta provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) GetClusterMeta(ctx context.Context, in *config_center.GetClusterMetaRequest, opts ...grpc.CallOption) (*config_center.ClusterMeta, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for GetClusterMeta")
	}

	var r0 *config_center.ClusterMeta
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetClusterMetaRequest, ...grpc.CallOption) (*config_center.ClusterMeta, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetClusterMetaRequest, ...grpc.CallOption) *config_center.ClusterMeta); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ClusterMeta)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetClusterMetaRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_GetClusterMeta_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClusterMeta'
type ConfigCenterServiceClient_GetClusterMeta_Call struct {
	*mock.Call
}

// GetClusterMeta is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.GetClusterMetaRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) GetClusterMeta(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_GetClusterMeta_Call {
	return &ConfigCenterServiceClient_GetClusterMeta_Call{Call: _e.mock.On("GetClusterMeta",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_GetClusterMeta_Call) Run(run func(ctx context.Context, in *config_center.GetClusterMetaRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_GetClusterMeta_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetClusterMetaRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetClusterMetaRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_GetClusterMeta_Call) Return(clusterMeta *config_center.ClusterMeta, err error) *ConfigCenterServiceClient_GetClusterMeta_Call {
	_c.Call.Return(clusterMeta, err)
	return _c
}

func (_c *ConfigCenterServiceClient_GetClusterMeta_Call) RunAndReturn(run func(ctx context.Context, in *config_center.GetClusterMetaRequest, opts ...grpc.CallOption) (*config_center.ClusterMeta, error)) *ConfigCenterServiceClient_GetClusterMeta_Call {
	_c.Call.Return(run)
	return _c
}

// GetComponentImage provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) GetComponentImage(ctx context.Context, in *config_center.GetComponentImageRequest, opts ...grpc.CallOption) (*config_center.ComponentImage, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for GetComponentImage")
	}

	var r0 *config_center.ComponentImage
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetComponentImageRequest, ...grpc.CallOption) (*config_center.ComponentImage, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetComponentImageRequest, ...grpc.CallOption) *config_center.ComponentImage); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ComponentImage)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetComponentImageRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_GetComponentImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetComponentImage'
type ConfigCenterServiceClient_GetComponentImage_Call struct {
	*mock.Call
}

// GetComponentImage is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.GetComponentImageRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) GetComponentImage(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_GetComponentImage_Call {
	return &ConfigCenterServiceClient_GetComponentImage_Call{Call: _e.mock.On("GetComponentImage",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_GetComponentImage_Call) Run(run func(ctx context.Context, in *config_center.GetComponentImageRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_GetComponentImage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetComponentImageRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetComponentImageRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_GetComponentImage_Call) Return(componentImage *config_center.ComponentImage, err error) *ConfigCenterServiceClient_GetComponentImage_Call {
	_c.Call.Return(componentImage, err)
	return _c
}

func (_c *ConfigCenterServiceClient_GetComponentImage_Call) RunAndReturn(run func(ctx context.Context, in *config_center.GetComponentImageRequest, opts ...grpc.CallOption) (*config_center.ComponentImage, error)) *ConfigCenterServiceClient_GetComponentImage_Call {
	_c.Call.Return(run)
	return _c
}

// GetConfigurationDictItem provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) GetConfigurationDictItem(ctx context.Context, in *config_center.GetConfigurationDictItemRequest, opts ...grpc.CallOption) (*config_center.ConfigurationDictItem, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for GetConfigurationDictItem")
	}

	var r0 *config_center.ConfigurationDictItem
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetConfigurationDictItemRequest, ...grpc.CallOption) (*config_center.ConfigurationDictItem, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetConfigurationDictItemRequest, ...grpc.CallOption) *config_center.ConfigurationDictItem); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationDictItem)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetConfigurationDictItemRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_GetConfigurationDictItem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConfigurationDictItem'
type ConfigCenterServiceClient_GetConfigurationDictItem_Call struct {
	*mock.Call
}

// GetConfigurationDictItem is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.GetConfigurationDictItemRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) GetConfigurationDictItem(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_GetConfigurationDictItem_Call {
	return &ConfigCenterServiceClient_GetConfigurationDictItem_Call{Call: _e.mock.On("GetConfigurationDictItem",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_GetConfigurationDictItem_Call) Run(run func(ctx context.Context, in *config_center.GetConfigurationDictItemRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_GetConfigurationDictItem_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetConfigurationDictItemRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetConfigurationDictItemRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_GetConfigurationDictItem_Call) Return(configurationDictItem *config_center.ConfigurationDictItem, err error) *ConfigCenterServiceClient_GetConfigurationDictItem_Call {
	_c.Call.Return(configurationDictItem, err)
	return _c
}

func (_c *ConfigCenterServiceClient_GetConfigurationDictItem_Call) RunAndReturn(run func(ctx context.Context, in *config_center.GetConfigurationDictItemRequest, opts ...grpc.CallOption) (*config_center.ConfigurationDictItem, error)) *ConfigCenterServiceClient_GetConfigurationDictItem_Call {
	_c.Call.Return(run)
	return _c
}

// GetConfigurationTemplate provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) GetConfigurationTemplate(ctx context.Context, in *config_center.GetConfigurationTemplateRequest, opts ...grpc.CallOption) (*config_center.ConfigurationTemplate, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for GetConfigurationTemplate")
	}

	var r0 *config_center.ConfigurationTemplate
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetConfigurationTemplateRequest, ...grpc.CallOption) (*config_center.ConfigurationTemplate, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetConfigurationTemplateRequest, ...grpc.CallOption) *config_center.ConfigurationTemplate); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationTemplate)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetConfigurationTemplateRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_GetConfigurationTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConfigurationTemplate'
type ConfigCenterServiceClient_GetConfigurationTemplate_Call struct {
	*mock.Call
}

// GetConfigurationTemplate is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.GetConfigurationTemplateRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) GetConfigurationTemplate(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_GetConfigurationTemplate_Call {
	return &ConfigCenterServiceClient_GetConfigurationTemplate_Call{Call: _e.mock.On("GetConfigurationTemplate",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_GetConfigurationTemplate_Call) Run(run func(ctx context.Context, in *config_center.GetConfigurationTemplateRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_GetConfigurationTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetConfigurationTemplateRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetConfigurationTemplateRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_GetConfigurationTemplate_Call) Return(configurationTemplate *config_center.ConfigurationTemplate, err error) *ConfigCenterServiceClient_GetConfigurationTemplate_Call {
	_c.Call.Return(configurationTemplate, err)
	return _c
}

func (_c *ConfigCenterServiceClient_GetConfigurationTemplate_Call) RunAndReturn(run func(ctx context.Context, in *config_center.GetConfigurationTemplateRequest, opts ...grpc.CallOption) (*config_center.ConfigurationTemplate, error)) *ConfigCenterServiceClient_GetConfigurationTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// GetDefaultVersion provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) GetDefaultVersion(ctx context.Context, in *config_center.GetDefaultVersionRequest, opts ...grpc.CallOption) (*config_center.DefaultVersion, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for GetDefaultVersion")
	}

	var r0 *config_center.DefaultVersion
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetDefaultVersionRequest, ...grpc.CallOption) (*config_center.DefaultVersion, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetDefaultVersionRequest, ...grpc.CallOption) *config_center.DefaultVersion); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.DefaultVersion)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetDefaultVersionRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_GetDefaultVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDefaultVersion'
type ConfigCenterServiceClient_GetDefaultVersion_Call struct {
	*mock.Call
}

// GetDefaultVersion is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.GetDefaultVersionRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) GetDefaultVersion(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_GetDefaultVersion_Call {
	return &ConfigCenterServiceClient_GetDefaultVersion_Call{Call: _e.mock.On("GetDefaultVersion",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_GetDefaultVersion_Call) Run(run func(ctx context.Context, in *config_center.GetDefaultVersionRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_GetDefaultVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetDefaultVersionRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetDefaultVersionRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_GetDefaultVersion_Call) Return(defaultVersion *config_center.DefaultVersion, err error) *ConfigCenterServiceClient_GetDefaultVersion_Call {
	_c.Call.Return(defaultVersion, err)
	return _c
}

func (_c *ConfigCenterServiceClient_GetDefaultVersion_Call) RunAndReturn(run func(ctx context.Context, in *config_center.GetDefaultVersionRequest, opts ...grpc.CallOption) (*config_center.DefaultVersion, error)) *ConfigCenterServiceClient_GetDefaultVersion_Call {
	_c.Call.Return(run)
	return _c
}

// GetMetaProfile provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) GetMetaProfile(ctx context.Context, in *config_center.GetMetaProfileRequest, opts ...grpc.CallOption) (*config_center.MetaProfile, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for GetMetaProfile")
	}

	var r0 *config_center.MetaProfile
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetMetaProfileRequest, ...grpc.CallOption) (*config_center.MetaProfile, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetMetaProfileRequest, ...grpc.CallOption) *config_center.MetaProfile); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.MetaProfile)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetMetaProfileRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_GetMetaProfile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMetaProfile'
type ConfigCenterServiceClient_GetMetaProfile_Call struct {
	*mock.Call
}

// GetMetaProfile is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.GetMetaProfileRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) GetMetaProfile(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_GetMetaProfile_Call {
	return &ConfigCenterServiceClient_GetMetaProfile_Call{Call: _e.mock.On("GetMetaProfile",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_GetMetaProfile_Call) Run(run func(ctx context.Context, in *config_center.GetMetaProfileRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_GetMetaProfile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetMetaProfileRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetMetaProfileRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_GetMetaProfile_Call) Return(metaProfile *config_center.MetaProfile, err error) *ConfigCenterServiceClient_GetMetaProfile_Call {
	_c.Call.Return(metaProfile, err)
	return _c
}

func (_c *ConfigCenterServiceClient_GetMetaProfile_Call) RunAndReturn(run func(ctx context.Context, in *config_center.GetMetaProfileRequest, opts ...grpc.CallOption) (*config_center.MetaProfile, error)) *ConfigCenterServiceClient_GetMetaProfile_Call {
	_c.Call.Return(run)
	return _c
}

// GetRegionalServer provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) GetRegionalServer(ctx context.Context, in *config_center.GetRegionalServerRequest, opts ...grpc.CallOption) (*config_center.RegionalServer, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for GetRegionalServer")
	}

	var r0 *config_center.RegionalServer
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetRegionalServerRequest, ...grpc.CallOption) (*config_center.RegionalServer, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetRegionalServerRequest, ...grpc.CallOption) *config_center.RegionalServer); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.RegionalServer)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetRegionalServerRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_GetRegionalServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRegionalServer'
type ConfigCenterServiceClient_GetRegionalServer_Call struct {
	*mock.Call
}

// GetRegionalServer is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.GetRegionalServerRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) GetRegionalServer(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_GetRegionalServer_Call {
	return &ConfigCenterServiceClient_GetRegionalServer_Call{Call: _e.mock.On("GetRegionalServer",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_GetRegionalServer_Call) Run(run func(ctx context.Context, in *config_center.GetRegionalServerRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_GetRegionalServer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetRegionalServerRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetRegionalServerRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_GetRegionalServer_Call) Return(regionalServer *config_center.RegionalServer, err error) *ConfigCenterServiceClient_GetRegionalServer_Call {
	_c.Call.Return(regionalServer, err)
	return _c
}

func (_c *ConfigCenterServiceClient_GetRegionalServer_Call) RunAndReturn(run func(ctx context.Context, in *config_center.GetRegionalServerRequest, opts ...grpc.CallOption) (*config_center.RegionalServer, error)) *ConfigCenterServiceClient_GetRegionalServer_Call {
	_c.Call.Return(run)
	return _c
}

// GetTemplateUsage provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) GetTemplateUsage(ctx context.Context, in *config_center.GetTemplateUsageRequest, opts ...grpc.CallOption) (*config_center.TemplateUsage, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for GetTemplateUsage")
	}

	var r0 *config_center.TemplateUsage
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetTemplateUsageRequest, ...grpc.CallOption) (*config_center.TemplateUsage, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetTemplateUsageRequest, ...grpc.CallOption) *config_center.TemplateUsage); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.TemplateUsage)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetTemplateUsageRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_GetTemplateUsage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTemplateUsage'
type ConfigCenterServiceClient_GetTemplateUsage_Call struct {
	*mock.Call
}

// GetTemplateUsage is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.GetTemplateUsageRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) GetTemplateUsage(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_GetTemplateUsage_Call {
	return &ConfigCenterServiceClient_GetTemplateUsage_Call{Call: _e.mock.On("GetTemplateUsage",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_GetTemplateUsage_Call) Run(run func(ctx context.Context, in *config_center.GetTemplateUsageRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_GetTemplateUsage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetTemplateUsageRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetTemplateUsageRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_GetTemplateUsage_Call) Return(templateUsage *config_center.TemplateUsage, err error) *ConfigCenterServiceClient_GetTemplateUsage_Call {
	_c.Call.Return(templateUsage, err)
	return _c
}

func (_c *ConfigCenterServiceClient_GetTemplateUsage_Call) RunAndReturn(run func(ctx context.Context, in *config_center.GetTemplateUsageRequest, opts ...grpc.CallOption) (*config_center.TemplateUsage, error)) *ConfigCenterServiceClient_GetTemplateUsage_Call {
	_c.Call.Return(run)
	return _c
}

// GetTenantInitialCustomParams provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) GetTenantInitialCustomParams(ctx context.Context, in *config_center.GetTenantInitialCustomParamsRequest, opts ...grpc.CallOption) (*config_center.TenantInitialCustomPatams, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for GetTenantInitialCustomParams")
	}

	var r0 *config_center.TenantInitialCustomPatams
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetTenantInitialCustomParamsRequest, ...grpc.CallOption) (*config_center.TenantInitialCustomPatams, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetTenantInitialCustomParamsRequest, ...grpc.CallOption) *config_center.TenantInitialCustomPatams); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.TenantInitialCustomPatams)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetTenantInitialCustomParamsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_GetTenantInitialCustomParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTenantInitialCustomParams'
type ConfigCenterServiceClient_GetTenantInitialCustomParams_Call struct {
	*mock.Call
}

// GetTenantInitialCustomParams is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.GetTenantInitialCustomParamsRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) GetTenantInitialCustomParams(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_GetTenantInitialCustomParams_Call {
	return &ConfigCenterServiceClient_GetTenantInitialCustomParams_Call{Call: _e.mock.On("GetTenantInitialCustomParams",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_GetTenantInitialCustomParams_Call) Run(run func(ctx context.Context, in *config_center.GetTenantInitialCustomParamsRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_GetTenantInitialCustomParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetTenantInitialCustomParamsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetTenantInitialCustomParamsRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_GetTenantInitialCustomParams_Call) Return(tenantInitialCustomPatams *config_center.TenantInitialCustomPatams, err error) *ConfigCenterServiceClient_GetTenantInitialCustomParams_Call {
	_c.Call.Return(tenantInitialCustomPatams, err)
	return _c
}

func (_c *ConfigCenterServiceClient_GetTenantInitialCustomParams_Call) RunAndReturn(run func(ctx context.Context, in *config_center.GetTenantInitialCustomParamsRequest, opts ...grpc.CallOption) (*config_center.TenantInitialCustomPatams, error)) *ConfigCenterServiceClient_GetTenantInitialCustomParams_Call {
	_c.Call.Return(run)
	return _c
}

// InitClusterMeta provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) InitClusterMeta(ctx context.Context, in *config_center.InitClusterMetaRequest, opts ...grpc.CallOption) (*config_center.ClusterMeta, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for InitClusterMeta")
	}

	var r0 *config_center.ClusterMeta
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.InitClusterMetaRequest, ...grpc.CallOption) (*config_center.ClusterMeta, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.InitClusterMetaRequest, ...grpc.CallOption) *config_center.ClusterMeta); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ClusterMeta)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.InitClusterMetaRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_InitClusterMeta_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InitClusterMeta'
type ConfigCenterServiceClient_InitClusterMeta_Call struct {
	*mock.Call
}

// InitClusterMeta is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.InitClusterMetaRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) InitClusterMeta(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_InitClusterMeta_Call {
	return &ConfigCenterServiceClient_InitClusterMeta_Call{Call: _e.mock.On("InitClusterMeta",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_InitClusterMeta_Call) Run(run func(ctx context.Context, in *config_center.InitClusterMetaRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_InitClusterMeta_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.InitClusterMetaRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.InitClusterMetaRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_InitClusterMeta_Call) Return(clusterMeta *config_center.ClusterMeta, err error) *ConfigCenterServiceClient_InitClusterMeta_Call {
	_c.Call.Return(clusterMeta, err)
	return _c
}

func (_c *ConfigCenterServiceClient_InitClusterMeta_Call) RunAndReturn(run func(ctx context.Context, in *config_center.InitClusterMetaRequest, opts ...grpc.CallOption) (*config_center.ClusterMeta, error)) *ConfigCenterServiceClient_InitClusterMeta_Call {
	_c.Call.Return(run)
	return _c
}

// ListAvailableInstances provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) ListAvailableInstances(ctx context.Context, in *config_center.ListAvailableInstancesRequest, opts ...grpc.CallOption) (*config_center.ListAvailableInstancesResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for ListAvailableInstances")
	}

	var r0 *config_center.ListAvailableInstancesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListAvailableInstancesRequest, ...grpc.CallOption) (*config_center.ListAvailableInstancesResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListAvailableInstancesRequest, ...grpc.CallOption) *config_center.ListAvailableInstancesResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListAvailableInstancesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListAvailableInstancesRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_ListAvailableInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAvailableInstances'
type ConfigCenterServiceClient_ListAvailableInstances_Call struct {
	*mock.Call
}

// ListAvailableInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.ListAvailableInstancesRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) ListAvailableInstances(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_ListAvailableInstances_Call {
	return &ConfigCenterServiceClient_ListAvailableInstances_Call{Call: _e.mock.On("ListAvailableInstances",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_ListAvailableInstances_Call) Run(run func(ctx context.Context, in *config_center.ListAvailableInstancesRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_ListAvailableInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListAvailableInstancesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListAvailableInstancesRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_ListAvailableInstances_Call) Return(listAvailableInstancesResponse *config_center.ListAvailableInstancesResponse, err error) *ConfigCenterServiceClient_ListAvailableInstances_Call {
	_c.Call.Return(listAvailableInstancesResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_ListAvailableInstances_Call) RunAndReturn(run func(ctx context.Context, in *config_center.ListAvailableInstancesRequest, opts ...grpc.CallOption) (*config_center.ListAvailableInstancesResponse, error)) *ConfigCenterServiceClient_ListAvailableInstances_Call {
	_c.Call.Return(run)
	return _c
}

// ListAvailableVersions provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) ListAvailableVersions(ctx context.Context, in *config_center.ListAvailableVersionsRequest, opts ...grpc.CallOption) (*config_center.ListAvailableVersionsResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for ListAvailableVersions")
	}

	var r0 *config_center.ListAvailableVersionsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListAvailableVersionsRequest, ...grpc.CallOption) (*config_center.ListAvailableVersionsResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListAvailableVersionsRequest, ...grpc.CallOption) *config_center.ListAvailableVersionsResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListAvailableVersionsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListAvailableVersionsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_ListAvailableVersions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAvailableVersions'
type ConfigCenterServiceClient_ListAvailableVersions_Call struct {
	*mock.Call
}

// ListAvailableVersions is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.ListAvailableVersionsRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) ListAvailableVersions(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_ListAvailableVersions_Call {
	return &ConfigCenterServiceClient_ListAvailableVersions_Call{Call: _e.mock.On("ListAvailableVersions",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_ListAvailableVersions_Call) Run(run func(ctx context.Context, in *config_center.ListAvailableVersionsRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_ListAvailableVersions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListAvailableVersionsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListAvailableVersionsRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_ListAvailableVersions_Call) Return(listAvailableVersionsResponse *config_center.ListAvailableVersionsResponse, err error) *ConfigCenterServiceClient_ListAvailableVersions_Call {
	_c.Call.Return(listAvailableVersionsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_ListAvailableVersions_Call) RunAndReturn(run func(ctx context.Context, in *config_center.ListAvailableVersionsRequest, opts ...grpc.CallOption) (*config_center.ListAvailableVersionsResponse, error)) *ConfigCenterServiceClient_ListAvailableVersions_Call {
	_c.Call.Return(run)
	return _c
}

// ListClusterComponents provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) ListClusterComponents(ctx context.Context, in *config_center.ListClusterComponentsRequest, opts ...grpc.CallOption) (*config_center.ListClusterComponentsResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for ListClusterComponents")
	}

	var r0 *config_center.ListClusterComponentsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListClusterComponentsRequest, ...grpc.CallOption) (*config_center.ListClusterComponentsResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListClusterComponentsRequest, ...grpc.CallOption) *config_center.ListClusterComponentsResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListClusterComponentsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListClusterComponentsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_ListClusterComponents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClusterComponents'
type ConfigCenterServiceClient_ListClusterComponents_Call struct {
	*mock.Call
}

// ListClusterComponents is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.ListClusterComponentsRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) ListClusterComponents(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_ListClusterComponents_Call {
	return &ConfigCenterServiceClient_ListClusterComponents_Call{Call: _e.mock.On("ListClusterComponents",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_ListClusterComponents_Call) Run(run func(ctx context.Context, in *config_center.ListClusterComponentsRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_ListClusterComponents_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListClusterComponentsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListClusterComponentsRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_ListClusterComponents_Call) Return(listClusterComponentsResponse *config_center.ListClusterComponentsResponse, err error) *ConfigCenterServiceClient_ListClusterComponents_Call {
	_c.Call.Return(listClusterComponentsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_ListClusterComponents_Call) RunAndReturn(run func(ctx context.Context, in *config_center.ListClusterComponentsRequest, opts ...grpc.CallOption) (*config_center.ListClusterComponentsResponse, error)) *ConfigCenterServiceClient_ListClusterComponents_Call {
	_c.Call.Return(run)
	return _c
}

// ListClusterConfigurationFiles provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) ListClusterConfigurationFiles(ctx context.Context, in *config_center.ListClusterConfigurationFilesRequest, opts ...grpc.CallOption) (*config_center.ListClusterConfigurationFilesResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for ListClusterConfigurationFiles")
	}

	var r0 *config_center.ListClusterConfigurationFilesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListClusterConfigurationFilesRequest, ...grpc.CallOption) (*config_center.ListClusterConfigurationFilesResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListClusterConfigurationFilesRequest, ...grpc.CallOption) *config_center.ListClusterConfigurationFilesResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListClusterConfigurationFilesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListClusterConfigurationFilesRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_ListClusterConfigurationFiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClusterConfigurationFiles'
type ConfigCenterServiceClient_ListClusterConfigurationFiles_Call struct {
	*mock.Call
}

// ListClusterConfigurationFiles is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.ListClusterConfigurationFilesRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) ListClusterConfigurationFiles(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_ListClusterConfigurationFiles_Call {
	return &ConfigCenterServiceClient_ListClusterConfigurationFiles_Call{Call: _e.mock.On("ListClusterConfigurationFiles",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_ListClusterConfigurationFiles_Call) Run(run func(ctx context.Context, in *config_center.ListClusterConfigurationFilesRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_ListClusterConfigurationFiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListClusterConfigurationFilesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListClusterConfigurationFilesRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_ListClusterConfigurationFiles_Call) Return(listClusterConfigurationFilesResponse *config_center.ListClusterConfigurationFilesResponse, err error) *ConfigCenterServiceClient_ListClusterConfigurationFiles_Call {
	_c.Call.Return(listClusterConfigurationFilesResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_ListClusterConfigurationFiles_Call) RunAndReturn(run func(ctx context.Context, in *config_center.ListClusterConfigurationFilesRequest, opts ...grpc.CallOption) (*config_center.ListClusterConfigurationFilesResponse, error)) *ConfigCenterServiceClient_ListClusterConfigurationFiles_Call {
	_c.Call.Return(run)
	return _c
}

// ListComponentImages provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) ListComponentImages(ctx context.Context, in *config_center.ListComponentImagesRequest, opts ...grpc.CallOption) (*config_center.ListComponentImagesResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for ListComponentImages")
	}

	var r0 *config_center.ListComponentImagesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListComponentImagesRequest, ...grpc.CallOption) (*config_center.ListComponentImagesResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListComponentImagesRequest, ...grpc.CallOption) *config_center.ListComponentImagesResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListComponentImagesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListComponentImagesRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_ListComponentImages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListComponentImages'
type ConfigCenterServiceClient_ListComponentImages_Call struct {
	*mock.Call
}

// ListComponentImages is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.ListComponentImagesRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) ListComponentImages(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_ListComponentImages_Call {
	return &ConfigCenterServiceClient_ListComponentImages_Call{Call: _e.mock.On("ListComponentImages",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_ListComponentImages_Call) Run(run func(ctx context.Context, in *config_center.ListComponentImagesRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_ListComponentImages_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListComponentImagesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListComponentImagesRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_ListComponentImages_Call) Return(listComponentImagesResponse *config_center.ListComponentImagesResponse, err error) *ConfigCenterServiceClient_ListComponentImages_Call {
	_c.Call.Return(listComponentImagesResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_ListComponentImages_Call) RunAndReturn(run func(ctx context.Context, in *config_center.ListComponentImagesRequest, opts ...grpc.CallOption) (*config_center.ListComponentImagesResponse, error)) *ConfigCenterServiceClient_ListComponentImages_Call {
	_c.Call.Return(run)
	return _c
}

// ListConfigurationDictItems provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) ListConfigurationDictItems(ctx context.Context, in *config_center.ListConfigurationDictItemsRequest, opts ...grpc.CallOption) (*config_center.ListConfigurationDictItemsResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for ListConfigurationDictItems")
	}

	var r0 *config_center.ListConfigurationDictItemsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListConfigurationDictItemsRequest, ...grpc.CallOption) (*config_center.ListConfigurationDictItemsResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListConfigurationDictItemsRequest, ...grpc.CallOption) *config_center.ListConfigurationDictItemsResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListConfigurationDictItemsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListConfigurationDictItemsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_ListConfigurationDictItems_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListConfigurationDictItems'
type ConfigCenterServiceClient_ListConfigurationDictItems_Call struct {
	*mock.Call
}

// ListConfigurationDictItems is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.ListConfigurationDictItemsRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) ListConfigurationDictItems(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_ListConfigurationDictItems_Call {
	return &ConfigCenterServiceClient_ListConfigurationDictItems_Call{Call: _e.mock.On("ListConfigurationDictItems",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_ListConfigurationDictItems_Call) Run(run func(ctx context.Context, in *config_center.ListConfigurationDictItemsRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_ListConfigurationDictItems_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListConfigurationDictItemsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListConfigurationDictItemsRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_ListConfigurationDictItems_Call) Return(listConfigurationDictItemsResponse *config_center.ListConfigurationDictItemsResponse, err error) *ConfigCenterServiceClient_ListConfigurationDictItems_Call {
	_c.Call.Return(listConfigurationDictItemsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_ListConfigurationDictItems_Call) RunAndReturn(run func(ctx context.Context, in *config_center.ListConfigurationDictItemsRequest, opts ...grpc.CallOption) (*config_center.ListConfigurationDictItemsResponse, error)) *ConfigCenterServiceClient_ListConfigurationDictItems_Call {
	_c.Call.Return(run)
	return _c
}

// ListConfigurationDictVersions provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) ListConfigurationDictVersions(ctx context.Context, in *config_center.ListConfigurationDictVersionsRequest, opts ...grpc.CallOption) (*config_center.ListConfigurationDictVersionsResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for ListConfigurationDictVersions")
	}

	var r0 *config_center.ListConfigurationDictVersionsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListConfigurationDictVersionsRequest, ...grpc.CallOption) (*config_center.ListConfigurationDictVersionsResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListConfigurationDictVersionsRequest, ...grpc.CallOption) *config_center.ListConfigurationDictVersionsResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListConfigurationDictVersionsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListConfigurationDictVersionsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_ListConfigurationDictVersions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListConfigurationDictVersions'
type ConfigCenterServiceClient_ListConfigurationDictVersions_Call struct {
	*mock.Call
}

// ListConfigurationDictVersions is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.ListConfigurationDictVersionsRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) ListConfigurationDictVersions(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_ListConfigurationDictVersions_Call {
	return &ConfigCenterServiceClient_ListConfigurationDictVersions_Call{Call: _e.mock.On("ListConfigurationDictVersions",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_ListConfigurationDictVersions_Call) Run(run func(ctx context.Context, in *config_center.ListConfigurationDictVersionsRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_ListConfigurationDictVersions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListConfigurationDictVersionsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListConfigurationDictVersionsRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_ListConfigurationDictVersions_Call) Return(listConfigurationDictVersionsResponse *config_center.ListConfigurationDictVersionsResponse, err error) *ConfigCenterServiceClient_ListConfigurationDictVersions_Call {
	_c.Call.Return(listConfigurationDictVersionsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_ListConfigurationDictVersions_Call) RunAndReturn(run func(ctx context.Context, in *config_center.ListConfigurationDictVersionsRequest, opts ...grpc.CallOption) (*config_center.ListConfigurationDictVersionsResponse, error)) *ConfigCenterServiceClient_ListConfigurationDictVersions_Call {
	_c.Call.Return(run)
	return _c
}

// ListConfigurationTemplateDefaultCaseBindings provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) ListConfigurationTemplateDefaultCaseBindings(ctx context.Context, in *config_center.ListConfigurationTemplateDefaultCaseBindingsRequest, opts ...grpc.CallOption) (*config_center.ListConfigurationTemplateDefaultCaseBindingsResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for ListConfigurationTemplateDefaultCaseBindings")
	}

	var r0 *config_center.ListConfigurationTemplateDefaultCaseBindingsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListConfigurationTemplateDefaultCaseBindingsRequest, ...grpc.CallOption) (*config_center.ListConfigurationTemplateDefaultCaseBindingsResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListConfigurationTemplateDefaultCaseBindingsRequest, ...grpc.CallOption) *config_center.ListConfigurationTemplateDefaultCaseBindingsResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListConfigurationTemplateDefaultCaseBindingsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListConfigurationTemplateDefaultCaseBindingsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_ListConfigurationTemplateDefaultCaseBindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListConfigurationTemplateDefaultCaseBindings'
type ConfigCenterServiceClient_ListConfigurationTemplateDefaultCaseBindings_Call struct {
	*mock.Call
}

// ListConfigurationTemplateDefaultCaseBindings is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.ListConfigurationTemplateDefaultCaseBindingsRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) ListConfigurationTemplateDefaultCaseBindings(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_ListConfigurationTemplateDefaultCaseBindings_Call {
	return &ConfigCenterServiceClient_ListConfigurationTemplateDefaultCaseBindings_Call{Call: _e.mock.On("ListConfigurationTemplateDefaultCaseBindings",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_ListConfigurationTemplateDefaultCaseBindings_Call) Run(run func(ctx context.Context, in *config_center.ListConfigurationTemplateDefaultCaseBindingsRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_ListConfigurationTemplateDefaultCaseBindings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListConfigurationTemplateDefaultCaseBindingsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListConfigurationTemplateDefaultCaseBindingsRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_ListConfigurationTemplateDefaultCaseBindings_Call) Return(listConfigurationTemplateDefaultCaseBindingsResponse *config_center.ListConfigurationTemplateDefaultCaseBindingsResponse, err error) *ConfigCenterServiceClient_ListConfigurationTemplateDefaultCaseBindings_Call {
	_c.Call.Return(listConfigurationTemplateDefaultCaseBindingsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_ListConfigurationTemplateDefaultCaseBindings_Call) RunAndReturn(run func(ctx context.Context, in *config_center.ListConfigurationTemplateDefaultCaseBindingsRequest, opts ...grpc.CallOption) (*config_center.ListConfigurationTemplateDefaultCaseBindingsResponse, error)) *ConfigCenterServiceClient_ListConfigurationTemplateDefaultCaseBindings_Call {
	_c.Call.Return(run)
	return _c
}

// ListConfigurationTemplates provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) ListConfigurationTemplates(ctx context.Context, in *config_center.ListConfigurationTemplatesRequest, opts ...grpc.CallOption) (*config_center.ListConfigurationTemplatesResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for ListConfigurationTemplates")
	}

	var r0 *config_center.ListConfigurationTemplatesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListConfigurationTemplatesRequest, ...grpc.CallOption) (*config_center.ListConfigurationTemplatesResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListConfigurationTemplatesRequest, ...grpc.CallOption) *config_center.ListConfigurationTemplatesResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListConfigurationTemplatesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListConfigurationTemplatesRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_ListConfigurationTemplates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListConfigurationTemplates'
type ConfigCenterServiceClient_ListConfigurationTemplates_Call struct {
	*mock.Call
}

// ListConfigurationTemplates is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.ListConfigurationTemplatesRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) ListConfigurationTemplates(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_ListConfigurationTemplates_Call {
	return &ConfigCenterServiceClient_ListConfigurationTemplates_Call{Call: _e.mock.On("ListConfigurationTemplates",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_ListConfigurationTemplates_Call) Run(run func(ctx context.Context, in *config_center.ListConfigurationTemplatesRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_ListConfigurationTemplates_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListConfigurationTemplatesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListConfigurationTemplatesRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_ListConfigurationTemplates_Call) Return(listConfigurationTemplatesResponse *config_center.ListConfigurationTemplatesResponse, err error) *ConfigCenterServiceClient_ListConfigurationTemplates_Call {
	_c.Call.Return(listConfigurationTemplatesResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_ListConfigurationTemplates_Call) RunAndReturn(run func(ctx context.Context, in *config_center.ListConfigurationTemplatesRequest, opts ...grpc.CallOption) (*config_center.ListConfigurationTemplatesResponse, error)) *ConfigCenterServiceClient_ListConfigurationTemplates_Call {
	_c.Call.Return(run)
	return _c
}

// ListDefaultVersionRules provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) ListDefaultVersionRules(ctx context.Context, in *config_center.ListDefaultVersionRulesRequest, opts ...grpc.CallOption) (*config_center.ListDefaultVersionRulesResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for ListDefaultVersionRules")
	}

	var r0 *config_center.ListDefaultVersionRulesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListDefaultVersionRulesRequest, ...grpc.CallOption) (*config_center.ListDefaultVersionRulesResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListDefaultVersionRulesRequest, ...grpc.CallOption) *config_center.ListDefaultVersionRulesResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListDefaultVersionRulesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListDefaultVersionRulesRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_ListDefaultVersionRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDefaultVersionRules'
type ConfigCenterServiceClient_ListDefaultVersionRules_Call struct {
	*mock.Call
}

// ListDefaultVersionRules is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.ListDefaultVersionRulesRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) ListDefaultVersionRules(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_ListDefaultVersionRules_Call {
	return &ConfigCenterServiceClient_ListDefaultVersionRules_Call{Call: _e.mock.On("ListDefaultVersionRules",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_ListDefaultVersionRules_Call) Run(run func(ctx context.Context, in *config_center.ListDefaultVersionRulesRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_ListDefaultVersionRules_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListDefaultVersionRulesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListDefaultVersionRulesRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_ListDefaultVersionRules_Call) Return(listDefaultVersionRulesResponse *config_center.ListDefaultVersionRulesResponse, err error) *ConfigCenterServiceClient_ListDefaultVersionRules_Call {
	_c.Call.Return(listDefaultVersionRulesResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_ListDefaultVersionRules_Call) RunAndReturn(run func(ctx context.Context, in *config_center.ListDefaultVersionRulesRequest, opts ...grpc.CallOption) (*config_center.ListDefaultVersionRulesResponse, error)) *ConfigCenterServiceClient_ListDefaultVersionRules_Call {
	_c.Call.Return(run)
	return _c
}

// ListMetaProfiles provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) ListMetaProfiles(ctx context.Context, in *config_center.ListMetaProfilesRequest, opts ...grpc.CallOption) (*config_center.ListMetaProfilesResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for ListMetaProfiles")
	}

	var r0 *config_center.ListMetaProfilesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListMetaProfilesRequest, ...grpc.CallOption) (*config_center.ListMetaProfilesResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListMetaProfilesRequest, ...grpc.CallOption) *config_center.ListMetaProfilesResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListMetaProfilesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListMetaProfilesRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_ListMetaProfiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListMetaProfiles'
type ConfigCenterServiceClient_ListMetaProfiles_Call struct {
	*mock.Call
}

// ListMetaProfiles is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.ListMetaProfilesRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) ListMetaProfiles(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_ListMetaProfiles_Call {
	return &ConfigCenterServiceClient_ListMetaProfiles_Call{Call: _e.mock.On("ListMetaProfiles",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_ListMetaProfiles_Call) Run(run func(ctx context.Context, in *config_center.ListMetaProfilesRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_ListMetaProfiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListMetaProfilesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListMetaProfilesRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_ListMetaProfiles_Call) Return(listMetaProfilesResponse *config_center.ListMetaProfilesResponse, err error) *ConfigCenterServiceClient_ListMetaProfiles_Call {
	_c.Call.Return(listMetaProfilesResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_ListMetaProfiles_Call) RunAndReturn(run func(ctx context.Context, in *config_center.ListMetaProfilesRequest, opts ...grpc.CallOption) (*config_center.ListMetaProfilesResponse, error)) *ConfigCenterServiceClient_ListMetaProfiles_Call {
	_c.Call.Return(run)
	return _c
}

// ListRegionalServers provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) ListRegionalServers(ctx context.Context, in *config_center.ListRegionalServersRequest, opts ...grpc.CallOption) (*config_center.ListRegionalServersResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for ListRegionalServers")
	}

	var r0 *config_center.ListRegionalServersResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListRegionalServersRequest, ...grpc.CallOption) (*config_center.ListRegionalServersResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListRegionalServersRequest, ...grpc.CallOption) *config_center.ListRegionalServersResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListRegionalServersResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListRegionalServersRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_ListRegionalServers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRegionalServers'
type ConfigCenterServiceClient_ListRegionalServers_Call struct {
	*mock.Call
}

// ListRegionalServers is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.ListRegionalServersRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) ListRegionalServers(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_ListRegionalServers_Call {
	return &ConfigCenterServiceClient_ListRegionalServers_Call{Call: _e.mock.On("ListRegionalServers",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_ListRegionalServers_Call) Run(run func(ctx context.Context, in *config_center.ListRegionalServersRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_ListRegionalServers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListRegionalServersRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListRegionalServersRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_ListRegionalServers_Call) Return(listRegionalServersResponse *config_center.ListRegionalServersResponse, err error) *ConfigCenterServiceClient_ListRegionalServers_Call {
	_c.Call.Return(listRegionalServersResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_ListRegionalServers_Call) RunAndReturn(run func(ctx context.Context, in *config_center.ListRegionalServersRequest, opts ...grpc.CallOption) (*config_center.ListRegionalServersResponse, error)) *ConfigCenterServiceClient_ListRegionalServers_Call {
	_c.Call.Return(run)
	return _c
}

// ListTenantInitialCustomParams provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) ListTenantInitialCustomParams(ctx context.Context, in *config_center.ListTenantInitialCustomParamsRequest, opts ...grpc.CallOption) (*config_center.ListTenantInitialCustomParamsResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for ListTenantInitialCustomParams")
	}

	var r0 *config_center.ListTenantInitialCustomParamsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListTenantInitialCustomParamsRequest, ...grpc.CallOption) (*config_center.ListTenantInitialCustomParamsResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListTenantInitialCustomParamsRequest, ...grpc.CallOption) *config_center.ListTenantInitialCustomParamsResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListTenantInitialCustomParamsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListTenantInitialCustomParamsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_ListTenantInitialCustomParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTenantInitialCustomParams'
type ConfigCenterServiceClient_ListTenantInitialCustomParams_Call struct {
	*mock.Call
}

// ListTenantInitialCustomParams is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.ListTenantInitialCustomParamsRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) ListTenantInitialCustomParams(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_ListTenantInitialCustomParams_Call {
	return &ConfigCenterServiceClient_ListTenantInitialCustomParams_Call{Call: _e.mock.On("ListTenantInitialCustomParams",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_ListTenantInitialCustomParams_Call) Run(run func(ctx context.Context, in *config_center.ListTenantInitialCustomParamsRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_ListTenantInitialCustomParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListTenantInitialCustomParamsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListTenantInitialCustomParamsRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_ListTenantInitialCustomParams_Call) Return(listTenantInitialCustomParamsResponse *config_center.ListTenantInitialCustomParamsResponse, err error) *ConfigCenterServiceClient_ListTenantInitialCustomParams_Call {
	_c.Call.Return(listTenantInitialCustomParamsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_ListTenantInitialCustomParams_Call) RunAndReturn(run func(ctx context.Context, in *config_center.ListTenantInitialCustomParamsRequest, opts ...grpc.CallOption) (*config_center.ListTenantInitialCustomParamsResponse, error)) *ConfigCenterServiceClient_ListTenantInitialCustomParams_Call {
	_c.Call.Return(run)
	return _c
}

// OfflineRegionalServer provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) OfflineRegionalServer(ctx context.Context, in *config_center.OfflineRegionalServerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for OfflineRegionalServer")
	}

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.OfflineRegionalServerRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.OfflineRegionalServerRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.OfflineRegionalServerRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_OfflineRegionalServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OfflineRegionalServer'
type ConfigCenterServiceClient_OfflineRegionalServer_Call struct {
	*mock.Call
}

// OfflineRegionalServer is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.OfflineRegionalServerRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) OfflineRegionalServer(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_OfflineRegionalServer_Call {
	return &ConfigCenterServiceClient_OfflineRegionalServer_Call{Call: _e.mock.On("OfflineRegionalServer",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_OfflineRegionalServer_Call) Run(run func(ctx context.Context, in *config_center.OfflineRegionalServerRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_OfflineRegionalServer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.OfflineRegionalServerRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.OfflineRegionalServerRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_OfflineRegionalServer_Call) Return(empty *emptypb.Empty, err error) *ConfigCenterServiceClient_OfflineRegionalServer_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *ConfigCenterServiceClient_OfflineRegionalServer_Call) RunAndReturn(run func(ctx context.Context, in *config_center.OfflineRegionalServerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *ConfigCenterServiceClient_OfflineRegionalServer_Call {
	_c.Call.Return(run)
	return _c
}

// PurgeDictItems provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) PurgeDictItems(ctx context.Context, in *config_center.PurgeDictItemsRequest, opts ...grpc.CallOption) (*config_center.PurgeDictItemsResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for PurgeDictItems")
	}

	var r0 *config_center.PurgeDictItemsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.PurgeDictItemsRequest, ...grpc.CallOption) (*config_center.PurgeDictItemsResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.PurgeDictItemsRequest, ...grpc.CallOption) *config_center.PurgeDictItemsResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.PurgeDictItemsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.PurgeDictItemsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_PurgeDictItems_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PurgeDictItems'
type ConfigCenterServiceClient_PurgeDictItems_Call struct {
	*mock.Call
}

// PurgeDictItems is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.PurgeDictItemsRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) PurgeDictItems(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_PurgeDictItems_Call {
	return &ConfigCenterServiceClient_PurgeDictItems_Call{Call: _e.mock.On("PurgeDictItems",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_PurgeDictItems_Call) Run(run func(ctx context.Context, in *config_center.PurgeDictItemsRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_PurgeDictItems_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.PurgeDictItemsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.PurgeDictItemsRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_PurgeDictItems_Call) Return(purgeDictItemsResponse *config_center.PurgeDictItemsResponse, err error) *ConfigCenterServiceClient_PurgeDictItems_Call {
	_c.Call.Return(purgeDictItemsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_PurgeDictItems_Call) RunAndReturn(run func(ctx context.Context, in *config_center.PurgeDictItemsRequest, opts ...grpc.CallOption) (*config_center.PurgeDictItemsResponse, error)) *ConfigCenterServiceClient_PurgeDictItems_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterRegionalServer provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) RegisterRegionalServer(ctx context.Context, in *config_center.RegisterRegionalServerRequest, opts ...grpc.CallOption) (*config_center.RegionalServer, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for RegisterRegionalServer")
	}

	var r0 *config_center.RegionalServer
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.RegisterRegionalServerRequest, ...grpc.CallOption) (*config_center.RegionalServer, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.RegisterRegionalServerRequest, ...grpc.CallOption) *config_center.RegionalServer); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.RegionalServer)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.RegisterRegionalServerRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_RegisterRegionalServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterRegionalServer'
type ConfigCenterServiceClient_RegisterRegionalServer_Call struct {
	*mock.Call
}

// RegisterRegionalServer is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.RegisterRegionalServerRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) RegisterRegionalServer(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_RegisterRegionalServer_Call {
	return &ConfigCenterServiceClient_RegisterRegionalServer_Call{Call: _e.mock.On("RegisterRegionalServer",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_RegisterRegionalServer_Call) Run(run func(ctx context.Context, in *config_center.RegisterRegionalServerRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_RegisterRegionalServer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.RegisterRegionalServerRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.RegisterRegionalServerRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_RegisterRegionalServer_Call) Return(regionalServer *config_center.RegionalServer, err error) *ConfigCenterServiceClient_RegisterRegionalServer_Call {
	_c.Call.Return(regionalServer, err)
	return _c
}

func (_c *ConfigCenterServiceClient_RegisterRegionalServer_Call) RunAndReturn(run func(ctx context.Context, in *config_center.RegisterRegionalServerRequest, opts ...grpc.CallOption) (*config_center.RegionalServer, error)) *ConfigCenterServiceClient_RegisterRegionalServer_Call {
	_c.Call.Return(run)
	return _c
}

// SearchClusterComponents provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) SearchClusterComponents(ctx context.Context, in *config_center.SearchClusterComponentsRequest, opts ...grpc.CallOption) (*config_center.SearchClusterComponentsResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for SearchClusterComponents")
	}

	var r0 *config_center.SearchClusterComponentsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.SearchClusterComponentsRequest, ...grpc.CallOption) (*config_center.SearchClusterComponentsResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.SearchClusterComponentsRequest, ...grpc.CallOption) *config_center.SearchClusterComponentsResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.SearchClusterComponentsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.SearchClusterComponentsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_SearchClusterComponents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchClusterComponents'
type ConfigCenterServiceClient_SearchClusterComponents_Call struct {
	*mock.Call
}

// SearchClusterComponents is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.SearchClusterComponentsRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) SearchClusterComponents(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_SearchClusterComponents_Call {
	return &ConfigCenterServiceClient_SearchClusterComponents_Call{Call: _e.mock.On("SearchClusterComponents",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_SearchClusterComponents_Call) Run(run func(ctx context.Context, in *config_center.SearchClusterComponentsRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_SearchClusterComponents_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.SearchClusterComponentsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.SearchClusterComponentsRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_SearchClusterComponents_Call) Return(searchClusterComponentsResponse *config_center.SearchClusterComponentsResponse, err error) *ConfigCenterServiceClient_SearchClusterComponents_Call {
	_c.Call.Return(searchClusterComponentsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_SearchClusterComponents_Call) RunAndReturn(run func(ctx context.Context, in *config_center.SearchClusterComponentsRequest, opts ...grpc.CallOption) (*config_center.SearchClusterComponentsResponse, error)) *ConfigCenterServiceClient_SearchClusterComponents_Call {
	_c.Call.Return(run)
	return _c
}

// SearchDefaultConfigurationTemplate provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) SearchDefaultConfigurationTemplate(ctx context.Context, in *config_center.SearchDefaultConfigurationTemplateRequest, opts ...grpc.CallOption) (*config_center.ConfigurationTemplate, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for SearchDefaultConfigurationTemplate")
	}

	var r0 *config_center.ConfigurationTemplate
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.SearchDefaultConfigurationTemplateRequest, ...grpc.CallOption) (*config_center.ConfigurationTemplate, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.SearchDefaultConfigurationTemplateRequest, ...grpc.CallOption) *config_center.ConfigurationTemplate); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationTemplate)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.SearchDefaultConfigurationTemplateRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_SearchDefaultConfigurationTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchDefaultConfigurationTemplate'
type ConfigCenterServiceClient_SearchDefaultConfigurationTemplate_Call struct {
	*mock.Call
}

// SearchDefaultConfigurationTemplate is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.SearchDefaultConfigurationTemplateRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) SearchDefaultConfigurationTemplate(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_SearchDefaultConfigurationTemplate_Call {
	return &ConfigCenterServiceClient_SearchDefaultConfigurationTemplate_Call{Call: _e.mock.On("SearchDefaultConfigurationTemplate",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_SearchDefaultConfigurationTemplate_Call) Run(run func(ctx context.Context, in *config_center.SearchDefaultConfigurationTemplateRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_SearchDefaultConfigurationTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.SearchDefaultConfigurationTemplateRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.SearchDefaultConfigurationTemplateRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_SearchDefaultConfigurationTemplate_Call) Return(configurationTemplate *config_center.ConfigurationTemplate, err error) *ConfigCenterServiceClient_SearchDefaultConfigurationTemplate_Call {
	_c.Call.Return(configurationTemplate, err)
	return _c
}

func (_c *ConfigCenterServiceClient_SearchDefaultConfigurationTemplate_Call) RunAndReturn(run func(ctx context.Context, in *config_center.SearchDefaultConfigurationTemplateRequest, opts ...grpc.CallOption) (*config_center.ConfigurationTemplate, error)) *ConfigCenterServiceClient_SearchDefaultConfigurationTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// SyncRegionalServer provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) SyncRegionalServer(ctx context.Context, in *config_center.SyncRegionalServerRequest, opts ...grpc.CallOption) (*config_center.RegionalServer, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for SyncRegionalServer")
	}

	var r0 *config_center.RegionalServer
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.SyncRegionalServerRequest, ...grpc.CallOption) (*config_center.RegionalServer, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.SyncRegionalServerRequest, ...grpc.CallOption) *config_center.RegionalServer); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.RegionalServer)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.SyncRegionalServerRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_SyncRegionalServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SyncRegionalServer'
type ConfigCenterServiceClient_SyncRegionalServer_Call struct {
	*mock.Call
}

// SyncRegionalServer is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.SyncRegionalServerRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) SyncRegionalServer(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_SyncRegionalServer_Call {
	return &ConfigCenterServiceClient_SyncRegionalServer_Call{Call: _e.mock.On("SyncRegionalServer",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_SyncRegionalServer_Call) Run(run func(ctx context.Context, in *config_center.SyncRegionalServerRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_SyncRegionalServer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.SyncRegionalServerRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.SyncRegionalServerRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_SyncRegionalServer_Call) Return(regionalServer *config_center.RegionalServer, err error) *ConfigCenterServiceClient_SyncRegionalServer_Call {
	_c.Call.Return(regionalServer, err)
	return _c
}

func (_c *ConfigCenterServiceClient_SyncRegionalServer_Call) RunAndReturn(run func(ctx context.Context, in *config_center.SyncRegionalServerRequest, opts ...grpc.CallOption) (*config_center.RegionalServer, error)) *ConfigCenterServiceClient_SyncRegionalServer_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateClusterComponent provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) UpdateClusterComponent(ctx context.Context, in *config_center.UpdateClusterComponentRequest, opts ...grpc.CallOption) (*config_center.ClusterComponent, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for UpdateClusterComponent")
	}

	var r0 *config_center.ClusterComponent
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateClusterComponentRequest, ...grpc.CallOption) (*config_center.ClusterComponent, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateClusterComponentRequest, ...grpc.CallOption) *config_center.ClusterComponent); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ClusterComponent)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.UpdateClusterComponentRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_UpdateClusterComponent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateClusterComponent'
type ConfigCenterServiceClient_UpdateClusterComponent_Call struct {
	*mock.Call
}

// UpdateClusterComponent is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.UpdateClusterComponentRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) UpdateClusterComponent(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_UpdateClusterComponent_Call {
	return &ConfigCenterServiceClient_UpdateClusterComponent_Call{Call: _e.mock.On("UpdateClusterComponent",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_UpdateClusterComponent_Call) Run(run func(ctx context.Context, in *config_center.UpdateClusterComponentRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_UpdateClusterComponent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.UpdateClusterComponentRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.UpdateClusterComponentRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_UpdateClusterComponent_Call) Return(clusterComponent *config_center.ClusterComponent, err error) *ConfigCenterServiceClient_UpdateClusterComponent_Call {
	_c.Call.Return(clusterComponent, err)
	return _c
}

func (_c *ConfigCenterServiceClient_UpdateClusterComponent_Call) RunAndReturn(run func(ctx context.Context, in *config_center.UpdateClusterComponentRequest, opts ...grpc.CallOption) (*config_center.ClusterComponent, error)) *ConfigCenterServiceClient_UpdateClusterComponent_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateClusterConfigurationFile provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) UpdateClusterConfigurationFile(ctx context.Context, in *config_center.UpdateClusterConfigurationFileRequest, opts ...grpc.CallOption) (*config_center.ConfigurationFile, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for UpdateClusterConfigurationFile")
	}

	var r0 *config_center.ConfigurationFile
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateClusterConfigurationFileRequest, ...grpc.CallOption) (*config_center.ConfigurationFile, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateClusterConfigurationFileRequest, ...grpc.CallOption) *config_center.ConfigurationFile); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationFile)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.UpdateClusterConfigurationFileRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_UpdateClusterConfigurationFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateClusterConfigurationFile'
type ConfigCenterServiceClient_UpdateClusterConfigurationFile_Call struct {
	*mock.Call
}

// UpdateClusterConfigurationFile is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.UpdateClusterConfigurationFileRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) UpdateClusterConfigurationFile(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_UpdateClusterConfigurationFile_Call {
	return &ConfigCenterServiceClient_UpdateClusterConfigurationFile_Call{Call: _e.mock.On("UpdateClusterConfigurationFile",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_UpdateClusterConfigurationFile_Call) Run(run func(ctx context.Context, in *config_center.UpdateClusterConfigurationFileRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_UpdateClusterConfigurationFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.UpdateClusterConfigurationFileRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.UpdateClusterConfigurationFileRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_UpdateClusterConfigurationFile_Call) Return(configurationFile *config_center.ConfigurationFile, err error) *ConfigCenterServiceClient_UpdateClusterConfigurationFile_Call {
	_c.Call.Return(configurationFile, err)
	return _c
}

func (_c *ConfigCenterServiceClient_UpdateClusterConfigurationFile_Call) RunAndReturn(run func(ctx context.Context, in *config_center.UpdateClusterConfigurationFileRequest, opts ...grpc.CallOption) (*config_center.ConfigurationFile, error)) *ConfigCenterServiceClient_UpdateClusterConfigurationFile_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateClusterMeta provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) UpdateClusterMeta(ctx context.Context, in *config_center.UpdateClusterMetaRequest, opts ...grpc.CallOption) (*config_center.UpdateClusterMetaResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for UpdateClusterMeta")
	}

	var r0 *config_center.UpdateClusterMetaResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateClusterMetaRequest, ...grpc.CallOption) (*config_center.UpdateClusterMetaResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateClusterMetaRequest, ...grpc.CallOption) *config_center.UpdateClusterMetaResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.UpdateClusterMetaResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.UpdateClusterMetaRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_UpdateClusterMeta_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateClusterMeta'
type ConfigCenterServiceClient_UpdateClusterMeta_Call struct {
	*mock.Call
}

// UpdateClusterMeta is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.UpdateClusterMetaRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) UpdateClusterMeta(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_UpdateClusterMeta_Call {
	return &ConfigCenterServiceClient_UpdateClusterMeta_Call{Call: _e.mock.On("UpdateClusterMeta",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_UpdateClusterMeta_Call) Run(run func(ctx context.Context, in *config_center.UpdateClusterMetaRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_UpdateClusterMeta_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.UpdateClusterMetaRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.UpdateClusterMetaRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_UpdateClusterMeta_Call) Return(updateClusterMetaResponse *config_center.UpdateClusterMetaResponse, err error) *ConfigCenterServiceClient_UpdateClusterMeta_Call {
	_c.Call.Return(updateClusterMetaResponse, err)
	return _c
}

func (_c *ConfigCenterServiceClient_UpdateClusterMeta_Call) RunAndReturn(run func(ctx context.Context, in *config_center.UpdateClusterMetaRequest, opts ...grpc.CallOption) (*config_center.UpdateClusterMetaResponse, error)) *ConfigCenterServiceClient_UpdateClusterMeta_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateComponentImage provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) UpdateComponentImage(ctx context.Context, in *config_center.UpdateComponentImageRequest, opts ...grpc.CallOption) (*config_center.ComponentImage, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for UpdateComponentImage")
	}

	var r0 *config_center.ComponentImage
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateComponentImageRequest, ...grpc.CallOption) (*config_center.ComponentImage, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateComponentImageRequest, ...grpc.CallOption) *config_center.ComponentImage); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ComponentImage)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.UpdateComponentImageRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_UpdateComponentImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateComponentImage'
type ConfigCenterServiceClient_UpdateComponentImage_Call struct {
	*mock.Call
}

// UpdateComponentImage is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.UpdateComponentImageRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) UpdateComponentImage(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_UpdateComponentImage_Call {
	return &ConfigCenterServiceClient_UpdateComponentImage_Call{Call: _e.mock.On("UpdateComponentImage",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_UpdateComponentImage_Call) Run(run func(ctx context.Context, in *config_center.UpdateComponentImageRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_UpdateComponentImage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.UpdateComponentImageRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.UpdateComponentImageRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_UpdateComponentImage_Call) Return(componentImage *config_center.ComponentImage, err error) *ConfigCenterServiceClient_UpdateComponentImage_Call {
	_c.Call.Return(componentImage, err)
	return _c
}

func (_c *ConfigCenterServiceClient_UpdateComponentImage_Call) RunAndReturn(run func(ctx context.Context, in *config_center.UpdateComponentImageRequest, opts ...grpc.CallOption) (*config_center.ComponentImage, error)) *ConfigCenterServiceClient_UpdateComponentImage_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateConfigurationDictItem provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) UpdateConfigurationDictItem(ctx context.Context, in *config_center.UpdateConfigurationDictItemReq, opts ...grpc.CallOption) (*config_center.ConfigurationDictItem, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for UpdateConfigurationDictItem")
	}

	var r0 *config_center.ConfigurationDictItem
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateConfigurationDictItemReq, ...grpc.CallOption) (*config_center.ConfigurationDictItem, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateConfigurationDictItemReq, ...grpc.CallOption) *config_center.ConfigurationDictItem); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationDictItem)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.UpdateConfigurationDictItemReq, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_UpdateConfigurationDictItem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateConfigurationDictItem'
type ConfigCenterServiceClient_UpdateConfigurationDictItem_Call struct {
	*mock.Call
}

// UpdateConfigurationDictItem is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.UpdateConfigurationDictItemReq
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) UpdateConfigurationDictItem(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_UpdateConfigurationDictItem_Call {
	return &ConfigCenterServiceClient_UpdateConfigurationDictItem_Call{Call: _e.mock.On("UpdateConfigurationDictItem",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_UpdateConfigurationDictItem_Call) Run(run func(ctx context.Context, in *config_center.UpdateConfigurationDictItemReq, opts ...grpc.CallOption)) *ConfigCenterServiceClient_UpdateConfigurationDictItem_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.UpdateConfigurationDictItemReq
		if args[1] != nil {
			arg1 = args[1].(*config_center.UpdateConfigurationDictItemReq)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_UpdateConfigurationDictItem_Call) Return(configurationDictItem *config_center.ConfigurationDictItem, err error) *ConfigCenterServiceClient_UpdateConfigurationDictItem_Call {
	_c.Call.Return(configurationDictItem, err)
	return _c
}

func (_c *ConfigCenterServiceClient_UpdateConfigurationDictItem_Call) RunAndReturn(run func(ctx context.Context, in *config_center.UpdateConfigurationDictItemReq, opts ...grpc.CallOption) (*config_center.ConfigurationDictItem, error)) *ConfigCenterServiceClient_UpdateConfigurationDictItem_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDefaultConfigurationTemplate provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) UpdateDefaultConfigurationTemplate(ctx context.Context, in *config_center.UpdateDefaultConfigurationTemplateRequest, opts ...grpc.CallOption) (*config_center.ConfigurationTemplate, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for UpdateDefaultConfigurationTemplate")
	}

	var r0 *config_center.ConfigurationTemplate
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateDefaultConfigurationTemplateRequest, ...grpc.CallOption) (*config_center.ConfigurationTemplate, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateDefaultConfigurationTemplateRequest, ...grpc.CallOption) *config_center.ConfigurationTemplate); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationTemplate)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.UpdateDefaultConfigurationTemplateRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_UpdateDefaultConfigurationTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDefaultConfigurationTemplate'
type ConfigCenterServiceClient_UpdateDefaultConfigurationTemplate_Call struct {
	*mock.Call
}

// UpdateDefaultConfigurationTemplate is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.UpdateDefaultConfigurationTemplateRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) UpdateDefaultConfigurationTemplate(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_UpdateDefaultConfigurationTemplate_Call {
	return &ConfigCenterServiceClient_UpdateDefaultConfigurationTemplate_Call{Call: _e.mock.On("UpdateDefaultConfigurationTemplate",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_UpdateDefaultConfigurationTemplate_Call) Run(run func(ctx context.Context, in *config_center.UpdateDefaultConfigurationTemplateRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_UpdateDefaultConfigurationTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.UpdateDefaultConfigurationTemplateRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.UpdateDefaultConfigurationTemplateRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_UpdateDefaultConfigurationTemplate_Call) Return(configurationTemplate *config_center.ConfigurationTemplate, err error) *ConfigCenterServiceClient_UpdateDefaultConfigurationTemplate_Call {
	_c.Call.Return(configurationTemplate, err)
	return _c
}

func (_c *ConfigCenterServiceClient_UpdateDefaultConfigurationTemplate_Call) RunAndReturn(run func(ctx context.Context, in *config_center.UpdateDefaultConfigurationTemplateRequest, opts ...grpc.CallOption) (*config_center.ConfigurationTemplate, error)) *ConfigCenterServiceClient_UpdateDefaultConfigurationTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDefaultVersion provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) UpdateDefaultVersion(ctx context.Context, in *config_center.UpdateDefaultVersionRequest, opts ...grpc.CallOption) (*config_center.DefaultVersion, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for UpdateDefaultVersion")
	}

	var r0 *config_center.DefaultVersion
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateDefaultVersionRequest, ...grpc.CallOption) (*config_center.DefaultVersion, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateDefaultVersionRequest, ...grpc.CallOption) *config_center.DefaultVersion); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.DefaultVersion)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.UpdateDefaultVersionRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_UpdateDefaultVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDefaultVersion'
type ConfigCenterServiceClient_UpdateDefaultVersion_Call struct {
	*mock.Call
}

// UpdateDefaultVersion is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.UpdateDefaultVersionRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) UpdateDefaultVersion(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_UpdateDefaultVersion_Call {
	return &ConfigCenterServiceClient_UpdateDefaultVersion_Call{Call: _e.mock.On("UpdateDefaultVersion",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_UpdateDefaultVersion_Call) Run(run func(ctx context.Context, in *config_center.UpdateDefaultVersionRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_UpdateDefaultVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.UpdateDefaultVersionRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.UpdateDefaultVersionRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_UpdateDefaultVersion_Call) Return(defaultVersion *config_center.DefaultVersion, err error) *ConfigCenterServiceClient_UpdateDefaultVersion_Call {
	_c.Call.Return(defaultVersion, err)
	return _c
}

func (_c *ConfigCenterServiceClient_UpdateDefaultVersion_Call) RunAndReturn(run func(ctx context.Context, in *config_center.UpdateDefaultVersionRequest, opts ...grpc.CallOption) (*config_center.DefaultVersion, error)) *ConfigCenterServiceClient_UpdateDefaultVersion_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTenantInitialCustomParams provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) UpdateTenantInitialCustomParams(ctx context.Context, in *config_center.UpdateTenantInitialCustomParamsRequest, opts ...grpc.CallOption) (*config_center.TenantInitialCustomPatams, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for UpdateTenantInitialCustomParams")
	}

	var r0 *config_center.TenantInitialCustomPatams
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateTenantInitialCustomParamsRequest, ...grpc.CallOption) (*config_center.TenantInitialCustomPatams, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateTenantInitialCustomParamsRequest, ...grpc.CallOption) *config_center.TenantInitialCustomPatams); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.TenantInitialCustomPatams)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.UpdateTenantInitialCustomParamsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_UpdateTenantInitialCustomParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTenantInitialCustomParams'
type ConfigCenterServiceClient_UpdateTenantInitialCustomParams_Call struct {
	*mock.Call
}

// UpdateTenantInitialCustomParams is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.UpdateTenantInitialCustomParamsRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) UpdateTenantInitialCustomParams(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_UpdateTenantInitialCustomParams_Call {
	return &ConfigCenterServiceClient_UpdateTenantInitialCustomParams_Call{Call: _e.mock.On("UpdateTenantInitialCustomParams",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_UpdateTenantInitialCustomParams_Call) Run(run func(ctx context.Context, in *config_center.UpdateTenantInitialCustomParamsRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_UpdateTenantInitialCustomParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.UpdateTenantInitialCustomParamsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.UpdateTenantInitialCustomParamsRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_UpdateTenantInitialCustomParams_Call) Return(tenantInitialCustomPatams *config_center.TenantInitialCustomPatams, err error) *ConfigCenterServiceClient_UpdateTenantInitialCustomParams_Call {
	_c.Call.Return(tenantInitialCustomPatams, err)
	return _c
}

func (_c *ConfigCenterServiceClient_UpdateTenantInitialCustomParams_Call) RunAndReturn(run func(ctx context.Context, in *config_center.UpdateTenantInitialCustomParamsRequest, opts ...grpc.CallOption) (*config_center.TenantInitialCustomPatams, error)) *ConfigCenterServiceClient_UpdateTenantInitialCustomParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpsertClusterCustomParams provides a mock function for the type ConfigCenterServiceClient
func (_mock *ConfigCenterServiceClient) UpsertClusterCustomParams(ctx context.Context, in *config_center.UpsertClusterCustomParamsRequest, opts ...grpc.CallOption) (*config_center.ConfigurationFile, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for UpsertClusterCustomParams")
	}

	var r0 *config_center.ConfigurationFile
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpsertClusterCustomParamsRequest, ...grpc.CallOption) (*config_center.ConfigurationFile, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpsertClusterCustomParamsRequest, ...grpc.CallOption) *config_center.ConfigurationFile); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationFile)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.UpsertClusterCustomParamsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceClient_UpsertClusterCustomParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpsertClusterCustomParams'
type ConfigCenterServiceClient_UpsertClusterCustomParams_Call struct {
	*mock.Call
}

// UpsertClusterCustomParams is a helper method to define mock.On call
//   - ctx context.Context
//   - in *config_center.UpsertClusterCustomParamsRequest
//   - opts ...grpc.CallOption
func (_e *ConfigCenterServiceClient_Expecter) UpsertClusterCustomParams(ctx interface{}, in interface{}, opts ...interface{}) *ConfigCenterServiceClient_UpsertClusterCustomParams_Call {
	return &ConfigCenterServiceClient_UpsertClusterCustomParams_Call{Call: _e.mock.On("UpsertClusterCustomParams",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ConfigCenterServiceClient_UpsertClusterCustomParams_Call) Run(run func(ctx context.Context, in *config_center.UpsertClusterCustomParamsRequest, opts ...grpc.CallOption)) *ConfigCenterServiceClient_UpsertClusterCustomParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.UpsertClusterCustomParamsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.UpsertClusterCustomParamsRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceClient_UpsertClusterCustomParams_Call) Return(configurationFile *config_center.ConfigurationFile, err error) *ConfigCenterServiceClient_UpsertClusterCustomParams_Call {
	_c.Call.Return(configurationFile, err)
	return _c
}

func (_c *ConfigCenterServiceClient_UpsertClusterCustomParams_Call) RunAndReturn(run func(ctx context.Context, in *config_center.UpsertClusterCustomParamsRequest, opts ...grpc.CallOption) (*config_center.ConfigurationFile, error)) *ConfigCenterServiceClient_UpsertClusterCustomParams_Call {
	_c.Call.Return(run)
	return _c
}

// NewConfigCenterServiceServer creates a new instance of ConfigCenterServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewConfigCenterServiceServer(t interface {
	mock.TestingT
	Cleanup(func())
}) *ConfigCenterServiceServer {
	mock := &ConfigCenterServiceServer{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// ConfigCenterServiceServer is an autogenerated mock type for the ConfigCenterServiceServer type
type ConfigCenterServiceServer struct {
	mock.Mock
}

type ConfigCenterServiceServer_Expecter struct {
	mock *mock.Mock
}

func (_m *ConfigCenterServiceServer) EXPECT() *ConfigCenterServiceServer_Expecter {
	return &ConfigCenterServiceServer_Expecter{mock: &_m.Mock}
}

// AutoUpdateClusterConfigurationFile provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) AutoUpdateClusterConfigurationFile(context1 context.Context, autoUpdateClusterConfigurationFileRequest *config_center.AutoUpdateClusterConfigurationFileRequest) (*config_center.ConfigurationFile, error) {
	ret := _mock.Called(context1, autoUpdateClusterConfigurationFileRequest)

	if len(ret) == 0 {
		panic("no return value specified for AutoUpdateClusterConfigurationFile")
	}

	var r0 *config_center.ConfigurationFile
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.AutoUpdateClusterConfigurationFileRequest) (*config_center.ConfigurationFile, error)); ok {
		return returnFunc(context1, autoUpdateClusterConfigurationFileRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.AutoUpdateClusterConfigurationFileRequest) *config_center.ConfigurationFile); ok {
		r0 = returnFunc(context1, autoUpdateClusterConfigurationFileRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationFile)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.AutoUpdateClusterConfigurationFileRequest) error); ok {
		r1 = returnFunc(context1, autoUpdateClusterConfigurationFileRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_AutoUpdateClusterConfigurationFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AutoUpdateClusterConfigurationFile'
type ConfigCenterServiceServer_AutoUpdateClusterConfigurationFile_Call struct {
	*mock.Call
}

// AutoUpdateClusterConfigurationFile is a helper method to define mock.On call
//   - context1 context.Context
//   - autoUpdateClusterConfigurationFileRequest *config_center.AutoUpdateClusterConfigurationFileRequest
func (_e *ConfigCenterServiceServer_Expecter) AutoUpdateClusterConfigurationFile(context1 interface{}, autoUpdateClusterConfigurationFileRequest interface{}) *ConfigCenterServiceServer_AutoUpdateClusterConfigurationFile_Call {
	return &ConfigCenterServiceServer_AutoUpdateClusterConfigurationFile_Call{Call: _e.mock.On("AutoUpdateClusterConfigurationFile", context1, autoUpdateClusterConfigurationFileRequest)}
}

func (_c *ConfigCenterServiceServer_AutoUpdateClusterConfigurationFile_Call) Run(run func(context1 context.Context, autoUpdateClusterConfigurationFileRequest *config_center.AutoUpdateClusterConfigurationFileRequest)) *ConfigCenterServiceServer_AutoUpdateClusterConfigurationFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.AutoUpdateClusterConfigurationFileRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.AutoUpdateClusterConfigurationFileRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_AutoUpdateClusterConfigurationFile_Call) Return(configurationFile *config_center.ConfigurationFile, err error) *ConfigCenterServiceServer_AutoUpdateClusterConfigurationFile_Call {
	_c.Call.Return(configurationFile, err)
	return _c
}

func (_c *ConfigCenterServiceServer_AutoUpdateClusterConfigurationFile_Call) RunAndReturn(run func(context1 context.Context, autoUpdateClusterConfigurationFileRequest *config_center.AutoUpdateClusterConfigurationFileRequest) (*config_center.ConfigurationFile, error)) *ConfigCenterServiceServer_AutoUpdateClusterConfigurationFile_Call {
	_c.Call.Return(run)
	return _c
}

// AutoUpdateClusterMeta provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) AutoUpdateClusterMeta(context1 context.Context, autoUpdateClusterMetaRequest *config_center.AutoUpdateClusterMetaRequest) (*config_center.AutoUpdateClusterMetaResponse, error) {
	ret := _mock.Called(context1, autoUpdateClusterMetaRequest)

	if len(ret) == 0 {
		panic("no return value specified for AutoUpdateClusterMeta")
	}

	var r0 *config_center.AutoUpdateClusterMetaResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.AutoUpdateClusterMetaRequest) (*config_center.AutoUpdateClusterMetaResponse, error)); ok {
		return returnFunc(context1, autoUpdateClusterMetaRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.AutoUpdateClusterMetaRequest) *config_center.AutoUpdateClusterMetaResponse); ok {
		r0 = returnFunc(context1, autoUpdateClusterMetaRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.AutoUpdateClusterMetaResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.AutoUpdateClusterMetaRequest) error); ok {
		r1 = returnFunc(context1, autoUpdateClusterMetaRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_AutoUpdateClusterMeta_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AutoUpdateClusterMeta'
type ConfigCenterServiceServer_AutoUpdateClusterMeta_Call struct {
	*mock.Call
}

// AutoUpdateClusterMeta is a helper method to define mock.On call
//   - context1 context.Context
//   - autoUpdateClusterMetaRequest *config_center.AutoUpdateClusterMetaRequest
func (_e *ConfigCenterServiceServer_Expecter) AutoUpdateClusterMeta(context1 interface{}, autoUpdateClusterMetaRequest interface{}) *ConfigCenterServiceServer_AutoUpdateClusterMeta_Call {
	return &ConfigCenterServiceServer_AutoUpdateClusterMeta_Call{Call: _e.mock.On("AutoUpdateClusterMeta", context1, autoUpdateClusterMetaRequest)}
}

func (_c *ConfigCenterServiceServer_AutoUpdateClusterMeta_Call) Run(run func(context1 context.Context, autoUpdateClusterMetaRequest *config_center.AutoUpdateClusterMetaRequest)) *ConfigCenterServiceServer_AutoUpdateClusterMeta_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.AutoUpdateClusterMetaRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.AutoUpdateClusterMetaRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_AutoUpdateClusterMeta_Call) Return(autoUpdateClusterMetaResponse *config_center.AutoUpdateClusterMetaResponse, err error) *ConfigCenterServiceServer_AutoUpdateClusterMeta_Call {
	_c.Call.Return(autoUpdateClusterMetaResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_AutoUpdateClusterMeta_Call) RunAndReturn(run func(context1 context.Context, autoUpdateClusterMetaRequest *config_center.AutoUpdateClusterMetaRequest) (*config_center.AutoUpdateClusterMetaResponse, error)) *ConfigCenterServiceServer_AutoUpdateClusterMeta_Call {
	_c.Call.Return(run)
	return _c
}

// BatchAutoUpdateClusterConfigurationFiles provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) BatchAutoUpdateClusterConfigurationFiles(context1 context.Context, batchAutoUpdateClusterConfigurationFilesRequest *config_center.BatchAutoUpdateClusterConfigurationFilesRequest) (*config_center.BatchAutoUpdateClusterConfigurationFilesResponse, error) {
	ret := _mock.Called(context1, batchAutoUpdateClusterConfigurationFilesRequest)

	if len(ret) == 0 {
		panic("no return value specified for BatchAutoUpdateClusterConfigurationFiles")
	}

	var r0 *config_center.BatchAutoUpdateClusterConfigurationFilesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchAutoUpdateClusterConfigurationFilesRequest) (*config_center.BatchAutoUpdateClusterConfigurationFilesResponse, error)); ok {
		return returnFunc(context1, batchAutoUpdateClusterConfigurationFilesRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchAutoUpdateClusterConfigurationFilesRequest) *config_center.BatchAutoUpdateClusterConfigurationFilesResponse); ok {
		r0 = returnFunc(context1, batchAutoUpdateClusterConfigurationFilesRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.BatchAutoUpdateClusterConfigurationFilesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchAutoUpdateClusterConfigurationFilesRequest) error); ok {
		r1 = returnFunc(context1, batchAutoUpdateClusterConfigurationFilesRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_BatchAutoUpdateClusterConfigurationFiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchAutoUpdateClusterConfigurationFiles'
type ConfigCenterServiceServer_BatchAutoUpdateClusterConfigurationFiles_Call struct {
	*mock.Call
}

// BatchAutoUpdateClusterConfigurationFiles is a helper method to define mock.On call
//   - context1 context.Context
//   - batchAutoUpdateClusterConfigurationFilesRequest *config_center.BatchAutoUpdateClusterConfigurationFilesRequest
func (_e *ConfigCenterServiceServer_Expecter) BatchAutoUpdateClusterConfigurationFiles(context1 interface{}, batchAutoUpdateClusterConfigurationFilesRequest interface{}) *ConfigCenterServiceServer_BatchAutoUpdateClusterConfigurationFiles_Call {
	return &ConfigCenterServiceServer_BatchAutoUpdateClusterConfigurationFiles_Call{Call: _e.mock.On("BatchAutoUpdateClusterConfigurationFiles", context1, batchAutoUpdateClusterConfigurationFilesRequest)}
}

func (_c *ConfigCenterServiceServer_BatchAutoUpdateClusterConfigurationFiles_Call) Run(run func(context1 context.Context, batchAutoUpdateClusterConfigurationFilesRequest *config_center.BatchAutoUpdateClusterConfigurationFilesRequest)) *ConfigCenterServiceServer_BatchAutoUpdateClusterConfigurationFiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchAutoUpdateClusterConfigurationFilesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchAutoUpdateClusterConfigurationFilesRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_BatchAutoUpdateClusterConfigurationFiles_Call) Return(batchAutoUpdateClusterConfigurationFilesResponse *config_center.BatchAutoUpdateClusterConfigurationFilesResponse, err error) *ConfigCenterServiceServer_BatchAutoUpdateClusterConfigurationFiles_Call {
	_c.Call.Return(batchAutoUpdateClusterConfigurationFilesResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_BatchAutoUpdateClusterConfigurationFiles_Call) RunAndReturn(run func(context1 context.Context, batchAutoUpdateClusterConfigurationFilesRequest *config_center.BatchAutoUpdateClusterConfigurationFilesRequest) (*config_center.BatchAutoUpdateClusterConfigurationFilesResponse, error)) *ConfigCenterServiceServer_BatchAutoUpdateClusterConfigurationFiles_Call {
	_c.Call.Return(run)
	return _c
}

// BatchCreateClusterConfigurationFiles provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) BatchCreateClusterConfigurationFiles(context1 context.Context, batchCreateClusterConfigurationFilesRequest *config_center.BatchCreateClusterConfigurationFilesRequest) (*config_center.BatchCreateClusterConfigurationFilesResponse, error) {
	ret := _mock.Called(context1, batchCreateClusterConfigurationFilesRequest)

	if len(ret) == 0 {
		panic("no return value specified for BatchCreateClusterConfigurationFiles")
	}

	var r0 *config_center.BatchCreateClusterConfigurationFilesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchCreateClusterConfigurationFilesRequest) (*config_center.BatchCreateClusterConfigurationFilesResponse, error)); ok {
		return returnFunc(context1, batchCreateClusterConfigurationFilesRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchCreateClusterConfigurationFilesRequest) *config_center.BatchCreateClusterConfigurationFilesResponse); ok {
		r0 = returnFunc(context1, batchCreateClusterConfigurationFilesRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.BatchCreateClusterConfigurationFilesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchCreateClusterConfigurationFilesRequest) error); ok {
		r1 = returnFunc(context1, batchCreateClusterConfigurationFilesRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_BatchCreateClusterConfigurationFiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchCreateClusterConfigurationFiles'
type ConfigCenterServiceServer_BatchCreateClusterConfigurationFiles_Call struct {
	*mock.Call
}

// BatchCreateClusterConfigurationFiles is a helper method to define mock.On call
//   - context1 context.Context
//   - batchCreateClusterConfigurationFilesRequest *config_center.BatchCreateClusterConfigurationFilesRequest
func (_e *ConfigCenterServiceServer_Expecter) BatchCreateClusterConfigurationFiles(context1 interface{}, batchCreateClusterConfigurationFilesRequest interface{}) *ConfigCenterServiceServer_BatchCreateClusterConfigurationFiles_Call {
	return &ConfigCenterServiceServer_BatchCreateClusterConfigurationFiles_Call{Call: _e.mock.On("BatchCreateClusterConfigurationFiles", context1, batchCreateClusterConfigurationFilesRequest)}
}

func (_c *ConfigCenterServiceServer_BatchCreateClusterConfigurationFiles_Call) Run(run func(context1 context.Context, batchCreateClusterConfigurationFilesRequest *config_center.BatchCreateClusterConfigurationFilesRequest)) *ConfigCenterServiceServer_BatchCreateClusterConfigurationFiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchCreateClusterConfigurationFilesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchCreateClusterConfigurationFilesRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_BatchCreateClusterConfigurationFiles_Call) Return(batchCreateClusterConfigurationFilesResponse *config_center.BatchCreateClusterConfigurationFilesResponse, err error) *ConfigCenterServiceServer_BatchCreateClusterConfigurationFiles_Call {
	_c.Call.Return(batchCreateClusterConfigurationFilesResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_BatchCreateClusterConfigurationFiles_Call) RunAndReturn(run func(context1 context.Context, batchCreateClusterConfigurationFilesRequest *config_center.BatchCreateClusterConfigurationFilesRequest) (*config_center.BatchCreateClusterConfigurationFilesResponse, error)) *ConfigCenterServiceServer_BatchCreateClusterConfigurationFiles_Call {
	_c.Call.Return(run)
	return _c
}

// BatchCreateConfigurationDictItems provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) BatchCreateConfigurationDictItems(context1 context.Context, batchCreateConfigurationDictRequest *config_center.BatchCreateConfigurationDictRequest) (*config_center.BatchCreateConfigurationDictResponse, error) {
	ret := _mock.Called(context1, batchCreateConfigurationDictRequest)

	if len(ret) == 0 {
		panic("no return value specified for BatchCreateConfigurationDictItems")
	}

	var r0 *config_center.BatchCreateConfigurationDictResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchCreateConfigurationDictRequest) (*config_center.BatchCreateConfigurationDictResponse, error)); ok {
		return returnFunc(context1, batchCreateConfigurationDictRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchCreateConfigurationDictRequest) *config_center.BatchCreateConfigurationDictResponse); ok {
		r0 = returnFunc(context1, batchCreateConfigurationDictRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.BatchCreateConfigurationDictResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchCreateConfigurationDictRequest) error); ok {
		r1 = returnFunc(context1, batchCreateConfigurationDictRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_BatchCreateConfigurationDictItems_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchCreateConfigurationDictItems'
type ConfigCenterServiceServer_BatchCreateConfigurationDictItems_Call struct {
	*mock.Call
}

// BatchCreateConfigurationDictItems is a helper method to define mock.On call
//   - context1 context.Context
//   - batchCreateConfigurationDictRequest *config_center.BatchCreateConfigurationDictRequest
func (_e *ConfigCenterServiceServer_Expecter) BatchCreateConfigurationDictItems(context1 interface{}, batchCreateConfigurationDictRequest interface{}) *ConfigCenterServiceServer_BatchCreateConfigurationDictItems_Call {
	return &ConfigCenterServiceServer_BatchCreateConfigurationDictItems_Call{Call: _e.mock.On("BatchCreateConfigurationDictItems", context1, batchCreateConfigurationDictRequest)}
}

func (_c *ConfigCenterServiceServer_BatchCreateConfigurationDictItems_Call) Run(run func(context1 context.Context, batchCreateConfigurationDictRequest *config_center.BatchCreateConfigurationDictRequest)) *ConfigCenterServiceServer_BatchCreateConfigurationDictItems_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchCreateConfigurationDictRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchCreateConfigurationDictRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_BatchCreateConfigurationDictItems_Call) Return(batchCreateConfigurationDictResponse *config_center.BatchCreateConfigurationDictResponse, err error) *ConfigCenterServiceServer_BatchCreateConfigurationDictItems_Call {
	_c.Call.Return(batchCreateConfigurationDictResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_BatchCreateConfigurationDictItems_Call) RunAndReturn(run func(context1 context.Context, batchCreateConfigurationDictRequest *config_center.BatchCreateConfigurationDictRequest) (*config_center.BatchCreateConfigurationDictResponse, error)) *ConfigCenterServiceServer_BatchCreateConfigurationDictItems_Call {
	_c.Call.Return(run)
	return _c
}

// BatchCreateConfigurationTemplates provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) BatchCreateConfigurationTemplates(context1 context.Context, batchCreateConfigurationTemplatesRequest *config_center.BatchCreateConfigurationTemplatesRequest) (*config_center.BatchCreateConfigurationTemplatesResponse, error) {
	ret := _mock.Called(context1, batchCreateConfigurationTemplatesRequest)

	if len(ret) == 0 {
		panic("no return value specified for BatchCreateConfigurationTemplates")
	}

	var r0 *config_center.BatchCreateConfigurationTemplatesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchCreateConfigurationTemplatesRequest) (*config_center.BatchCreateConfigurationTemplatesResponse, error)); ok {
		return returnFunc(context1, batchCreateConfigurationTemplatesRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchCreateConfigurationTemplatesRequest) *config_center.BatchCreateConfigurationTemplatesResponse); ok {
		r0 = returnFunc(context1, batchCreateConfigurationTemplatesRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.BatchCreateConfigurationTemplatesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchCreateConfigurationTemplatesRequest) error); ok {
		r1 = returnFunc(context1, batchCreateConfigurationTemplatesRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_BatchCreateConfigurationTemplates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchCreateConfigurationTemplates'
type ConfigCenterServiceServer_BatchCreateConfigurationTemplates_Call struct {
	*mock.Call
}

// BatchCreateConfigurationTemplates is a helper method to define mock.On call
//   - context1 context.Context
//   - batchCreateConfigurationTemplatesRequest *config_center.BatchCreateConfigurationTemplatesRequest
func (_e *ConfigCenterServiceServer_Expecter) BatchCreateConfigurationTemplates(context1 interface{}, batchCreateConfigurationTemplatesRequest interface{}) *ConfigCenterServiceServer_BatchCreateConfigurationTemplates_Call {
	return &ConfigCenterServiceServer_BatchCreateConfigurationTemplates_Call{Call: _e.mock.On("BatchCreateConfigurationTemplates", context1, batchCreateConfigurationTemplatesRequest)}
}

func (_c *ConfigCenterServiceServer_BatchCreateConfigurationTemplates_Call) Run(run func(context1 context.Context, batchCreateConfigurationTemplatesRequest *config_center.BatchCreateConfigurationTemplatesRequest)) *ConfigCenterServiceServer_BatchCreateConfigurationTemplates_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchCreateConfigurationTemplatesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchCreateConfigurationTemplatesRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_BatchCreateConfigurationTemplates_Call) Return(batchCreateConfigurationTemplatesResponse *config_center.BatchCreateConfigurationTemplatesResponse, err error) *ConfigCenterServiceServer_BatchCreateConfigurationTemplates_Call {
	_c.Call.Return(batchCreateConfigurationTemplatesResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_BatchCreateConfigurationTemplates_Call) RunAndReturn(run func(context1 context.Context, batchCreateConfigurationTemplatesRequest *config_center.BatchCreateConfigurationTemplatesRequest) (*config_center.BatchCreateConfigurationTemplatesResponse, error)) *ConfigCenterServiceServer_BatchCreateConfigurationTemplates_Call {
	_c.Call.Return(run)
	return _c
}

// BatchDeleteClusterConfigurationFiles provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) BatchDeleteClusterConfigurationFiles(context1 context.Context, batchDeleteClusterConfigurationFilesRequest *config_center.BatchDeleteClusterConfigurationFilesRequest) (*emptypb.Empty, error) {
	ret := _mock.Called(context1, batchDeleteClusterConfigurationFilesRequest)

	if len(ret) == 0 {
		panic("no return value specified for BatchDeleteClusterConfigurationFiles")
	}

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchDeleteClusterConfigurationFilesRequest) (*emptypb.Empty, error)); ok {
		return returnFunc(context1, batchDeleteClusterConfigurationFilesRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchDeleteClusterConfigurationFilesRequest) *emptypb.Empty); ok {
		r0 = returnFunc(context1, batchDeleteClusterConfigurationFilesRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchDeleteClusterConfigurationFilesRequest) error); ok {
		r1 = returnFunc(context1, batchDeleteClusterConfigurationFilesRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_BatchDeleteClusterConfigurationFiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchDeleteClusterConfigurationFiles'
type ConfigCenterServiceServer_BatchDeleteClusterConfigurationFiles_Call struct {
	*mock.Call
}

// BatchDeleteClusterConfigurationFiles is a helper method to define mock.On call
//   - context1 context.Context
//   - batchDeleteClusterConfigurationFilesRequest *config_center.BatchDeleteClusterConfigurationFilesRequest
func (_e *ConfigCenterServiceServer_Expecter) BatchDeleteClusterConfigurationFiles(context1 interface{}, batchDeleteClusterConfigurationFilesRequest interface{}) *ConfigCenterServiceServer_BatchDeleteClusterConfigurationFiles_Call {
	return &ConfigCenterServiceServer_BatchDeleteClusterConfigurationFiles_Call{Call: _e.mock.On("BatchDeleteClusterConfigurationFiles", context1, batchDeleteClusterConfigurationFilesRequest)}
}

func (_c *ConfigCenterServiceServer_BatchDeleteClusterConfigurationFiles_Call) Run(run func(context1 context.Context, batchDeleteClusterConfigurationFilesRequest *config_center.BatchDeleteClusterConfigurationFilesRequest)) *ConfigCenterServiceServer_BatchDeleteClusterConfigurationFiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchDeleteClusterConfigurationFilesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchDeleteClusterConfigurationFilesRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_BatchDeleteClusterConfigurationFiles_Call) Return(empty *emptypb.Empty, err error) *ConfigCenterServiceServer_BatchDeleteClusterConfigurationFiles_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *ConfigCenterServiceServer_BatchDeleteClusterConfigurationFiles_Call) RunAndReturn(run func(context1 context.Context, batchDeleteClusterConfigurationFilesRequest *config_center.BatchDeleteClusterConfigurationFilesRequest) (*emptypb.Empty, error)) *ConfigCenterServiceServer_BatchDeleteClusterConfigurationFiles_Call {
	_c.Call.Return(run)
	return _c
}

// BatchDeleteClusterMeta provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) BatchDeleteClusterMeta(context1 context.Context, batchDeleteClusterMetaRequest *config_center.BatchDeleteClusterMetaRequest) (*emptypb.Empty, error) {
	ret := _mock.Called(context1, batchDeleteClusterMetaRequest)

	if len(ret) == 0 {
		panic("no return value specified for BatchDeleteClusterMeta")
	}

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchDeleteClusterMetaRequest) (*emptypb.Empty, error)); ok {
		return returnFunc(context1, batchDeleteClusterMetaRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchDeleteClusterMetaRequest) *emptypb.Empty); ok {
		r0 = returnFunc(context1, batchDeleteClusterMetaRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchDeleteClusterMetaRequest) error); ok {
		r1 = returnFunc(context1, batchDeleteClusterMetaRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_BatchDeleteClusterMeta_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchDeleteClusterMeta'
type ConfigCenterServiceServer_BatchDeleteClusterMeta_Call struct {
	*mock.Call
}

// BatchDeleteClusterMeta is a helper method to define mock.On call
//   - context1 context.Context
//   - batchDeleteClusterMetaRequest *config_center.BatchDeleteClusterMetaRequest
func (_e *ConfigCenterServiceServer_Expecter) BatchDeleteClusterMeta(context1 interface{}, batchDeleteClusterMetaRequest interface{}) *ConfigCenterServiceServer_BatchDeleteClusterMeta_Call {
	return &ConfigCenterServiceServer_BatchDeleteClusterMeta_Call{Call: _e.mock.On("BatchDeleteClusterMeta", context1, batchDeleteClusterMetaRequest)}
}

func (_c *ConfigCenterServiceServer_BatchDeleteClusterMeta_Call) Run(run func(context1 context.Context, batchDeleteClusterMetaRequest *config_center.BatchDeleteClusterMetaRequest)) *ConfigCenterServiceServer_BatchDeleteClusterMeta_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchDeleteClusterMetaRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchDeleteClusterMetaRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_BatchDeleteClusterMeta_Call) Return(empty *emptypb.Empty, err error) *ConfigCenterServiceServer_BatchDeleteClusterMeta_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *ConfigCenterServiceServer_BatchDeleteClusterMeta_Call) RunAndReturn(run func(context1 context.Context, batchDeleteClusterMetaRequest *config_center.BatchDeleteClusterMetaRequest) (*emptypb.Empty, error)) *ConfigCenterServiceServer_BatchDeleteClusterMeta_Call {
	_c.Call.Return(run)
	return _c
}

// BatchSearchDefaultConfigurationTemplate provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) BatchSearchDefaultConfigurationTemplate(context1 context.Context, batchSearchDefaultConfigurationTemplateRequest *config_center.BatchSearchDefaultConfigurationTemplateRequest) (*config_center.BatchSearchDefaultConfigurationTemplateResponse, error) {
	ret := _mock.Called(context1, batchSearchDefaultConfigurationTemplateRequest)

	if len(ret) == 0 {
		panic("no return value specified for BatchSearchDefaultConfigurationTemplate")
	}

	var r0 *config_center.BatchSearchDefaultConfigurationTemplateResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchSearchDefaultConfigurationTemplateRequest) (*config_center.BatchSearchDefaultConfigurationTemplateResponse, error)); ok {
		return returnFunc(context1, batchSearchDefaultConfigurationTemplateRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchSearchDefaultConfigurationTemplateRequest) *config_center.BatchSearchDefaultConfigurationTemplateResponse); ok {
		r0 = returnFunc(context1, batchSearchDefaultConfigurationTemplateRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.BatchSearchDefaultConfigurationTemplateResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchSearchDefaultConfigurationTemplateRequest) error); ok {
		r1 = returnFunc(context1, batchSearchDefaultConfigurationTemplateRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_BatchSearchDefaultConfigurationTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchSearchDefaultConfigurationTemplate'
type ConfigCenterServiceServer_BatchSearchDefaultConfigurationTemplate_Call struct {
	*mock.Call
}

// BatchSearchDefaultConfigurationTemplate is a helper method to define mock.On call
//   - context1 context.Context
//   - batchSearchDefaultConfigurationTemplateRequest *config_center.BatchSearchDefaultConfigurationTemplateRequest
func (_e *ConfigCenterServiceServer_Expecter) BatchSearchDefaultConfigurationTemplate(context1 interface{}, batchSearchDefaultConfigurationTemplateRequest interface{}) *ConfigCenterServiceServer_BatchSearchDefaultConfigurationTemplate_Call {
	return &ConfigCenterServiceServer_BatchSearchDefaultConfigurationTemplate_Call{Call: _e.mock.On("BatchSearchDefaultConfigurationTemplate", context1, batchSearchDefaultConfigurationTemplateRequest)}
}

func (_c *ConfigCenterServiceServer_BatchSearchDefaultConfigurationTemplate_Call) Run(run func(context1 context.Context, batchSearchDefaultConfigurationTemplateRequest *config_center.BatchSearchDefaultConfigurationTemplateRequest)) *ConfigCenterServiceServer_BatchSearchDefaultConfigurationTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchSearchDefaultConfigurationTemplateRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchSearchDefaultConfigurationTemplateRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_BatchSearchDefaultConfigurationTemplate_Call) Return(batchSearchDefaultConfigurationTemplateResponse *config_center.BatchSearchDefaultConfigurationTemplateResponse, err error) *ConfigCenterServiceServer_BatchSearchDefaultConfigurationTemplate_Call {
	_c.Call.Return(batchSearchDefaultConfigurationTemplateResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_BatchSearchDefaultConfigurationTemplate_Call) RunAndReturn(run func(context1 context.Context, batchSearchDefaultConfigurationTemplateRequest *config_center.BatchSearchDefaultConfigurationTemplateRequest) (*config_center.BatchSearchDefaultConfigurationTemplateResponse, error)) *ConfigCenterServiceServer_BatchSearchDefaultConfigurationTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// BatchUpdateClusterComponents provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) BatchUpdateClusterComponents(context1 context.Context, batchUpdateClusterComponentsRequest *config_center.BatchUpdateClusterComponentsRequest) (*config_center.BatchUpdateClusterComponentsResponse, error) {
	ret := _mock.Called(context1, batchUpdateClusterComponentsRequest)

	if len(ret) == 0 {
		panic("no return value specified for BatchUpdateClusterComponents")
	}

	var r0 *config_center.BatchUpdateClusterComponentsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchUpdateClusterComponentsRequest) (*config_center.BatchUpdateClusterComponentsResponse, error)); ok {
		return returnFunc(context1, batchUpdateClusterComponentsRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchUpdateClusterComponentsRequest) *config_center.BatchUpdateClusterComponentsResponse); ok {
		r0 = returnFunc(context1, batchUpdateClusterComponentsRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.BatchUpdateClusterComponentsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchUpdateClusterComponentsRequest) error); ok {
		r1 = returnFunc(context1, batchUpdateClusterComponentsRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_BatchUpdateClusterComponents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchUpdateClusterComponents'
type ConfigCenterServiceServer_BatchUpdateClusterComponents_Call struct {
	*mock.Call
}

// BatchUpdateClusterComponents is a helper method to define mock.On call
//   - context1 context.Context
//   - batchUpdateClusterComponentsRequest *config_center.BatchUpdateClusterComponentsRequest
func (_e *ConfigCenterServiceServer_Expecter) BatchUpdateClusterComponents(context1 interface{}, batchUpdateClusterComponentsRequest interface{}) *ConfigCenterServiceServer_BatchUpdateClusterComponents_Call {
	return &ConfigCenterServiceServer_BatchUpdateClusterComponents_Call{Call: _e.mock.On("BatchUpdateClusterComponents", context1, batchUpdateClusterComponentsRequest)}
}

func (_c *ConfigCenterServiceServer_BatchUpdateClusterComponents_Call) Run(run func(context1 context.Context, batchUpdateClusterComponentsRequest *config_center.BatchUpdateClusterComponentsRequest)) *ConfigCenterServiceServer_BatchUpdateClusterComponents_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchUpdateClusterComponentsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchUpdateClusterComponentsRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_BatchUpdateClusterComponents_Call) Return(batchUpdateClusterComponentsResponse *config_center.BatchUpdateClusterComponentsResponse, err error) *ConfigCenterServiceServer_BatchUpdateClusterComponents_Call {
	_c.Call.Return(batchUpdateClusterComponentsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_BatchUpdateClusterComponents_Call) RunAndReturn(run func(context1 context.Context, batchUpdateClusterComponentsRequest *config_center.BatchUpdateClusterComponentsRequest) (*config_center.BatchUpdateClusterComponentsResponse, error)) *ConfigCenterServiceServer_BatchUpdateClusterComponents_Call {
	_c.Call.Return(run)
	return _c
}

// BatchUpdateClusterConfigurationFiles provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) BatchUpdateClusterConfigurationFiles(context1 context.Context, batchUpdateClusterConfigurationFilesRequest *config_center.BatchUpdateClusterConfigurationFilesRequest) (*config_center.BatchUpdateClusterConfigurationFilesResponse, error) {
	ret := _mock.Called(context1, batchUpdateClusterConfigurationFilesRequest)

	if len(ret) == 0 {
		panic("no return value specified for BatchUpdateClusterConfigurationFiles")
	}

	var r0 *config_center.BatchUpdateClusterConfigurationFilesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchUpdateClusterConfigurationFilesRequest) (*config_center.BatchUpdateClusterConfigurationFilesResponse, error)); ok {
		return returnFunc(context1, batchUpdateClusterConfigurationFilesRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchUpdateClusterConfigurationFilesRequest) *config_center.BatchUpdateClusterConfigurationFilesResponse); ok {
		r0 = returnFunc(context1, batchUpdateClusterConfigurationFilesRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.BatchUpdateClusterConfigurationFilesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchUpdateClusterConfigurationFilesRequest) error); ok {
		r1 = returnFunc(context1, batchUpdateClusterConfigurationFilesRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_BatchUpdateClusterConfigurationFiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchUpdateClusterConfigurationFiles'
type ConfigCenterServiceServer_BatchUpdateClusterConfigurationFiles_Call struct {
	*mock.Call
}

// BatchUpdateClusterConfigurationFiles is a helper method to define mock.On call
//   - context1 context.Context
//   - batchUpdateClusterConfigurationFilesRequest *config_center.BatchUpdateClusterConfigurationFilesRequest
func (_e *ConfigCenterServiceServer_Expecter) BatchUpdateClusterConfigurationFiles(context1 interface{}, batchUpdateClusterConfigurationFilesRequest interface{}) *ConfigCenterServiceServer_BatchUpdateClusterConfigurationFiles_Call {
	return &ConfigCenterServiceServer_BatchUpdateClusterConfigurationFiles_Call{Call: _e.mock.On("BatchUpdateClusterConfigurationFiles", context1, batchUpdateClusterConfigurationFilesRequest)}
}

func (_c *ConfigCenterServiceServer_BatchUpdateClusterConfigurationFiles_Call) Run(run func(context1 context.Context, batchUpdateClusterConfigurationFilesRequest *config_center.BatchUpdateClusterConfigurationFilesRequest)) *ConfigCenterServiceServer_BatchUpdateClusterConfigurationFiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchUpdateClusterConfigurationFilesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchUpdateClusterConfigurationFilesRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_BatchUpdateClusterConfigurationFiles_Call) Return(batchUpdateClusterConfigurationFilesResponse *config_center.BatchUpdateClusterConfigurationFilesResponse, err error) *ConfigCenterServiceServer_BatchUpdateClusterConfigurationFiles_Call {
	_c.Call.Return(batchUpdateClusterConfigurationFilesResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_BatchUpdateClusterConfigurationFiles_Call) RunAndReturn(run func(context1 context.Context, batchUpdateClusterConfigurationFilesRequest *config_center.BatchUpdateClusterConfigurationFilesRequest) (*config_center.BatchUpdateClusterConfigurationFilesResponse, error)) *ConfigCenterServiceServer_BatchUpdateClusterConfigurationFiles_Call {
	_c.Call.Return(run)
	return _c
}

// BatchUpdateDefaultConfigurationTemplate provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) BatchUpdateDefaultConfigurationTemplate(context1 context.Context, batchUpdateDefaultConfigurationTemplateRequest *config_center.BatchUpdateDefaultConfigurationTemplateRequest) (*config_center.BatchUpdateDefaultConfigurationTemplateResponse, error) {
	ret := _mock.Called(context1, batchUpdateDefaultConfigurationTemplateRequest)

	if len(ret) == 0 {
		panic("no return value specified for BatchUpdateDefaultConfigurationTemplate")
	}

	var r0 *config_center.BatchUpdateDefaultConfigurationTemplateResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchUpdateDefaultConfigurationTemplateRequest) (*config_center.BatchUpdateDefaultConfigurationTemplateResponse, error)); ok {
		return returnFunc(context1, batchUpdateDefaultConfigurationTemplateRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchUpdateDefaultConfigurationTemplateRequest) *config_center.BatchUpdateDefaultConfigurationTemplateResponse); ok {
		r0 = returnFunc(context1, batchUpdateDefaultConfigurationTemplateRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.BatchUpdateDefaultConfigurationTemplateResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchUpdateDefaultConfigurationTemplateRequest) error); ok {
		r1 = returnFunc(context1, batchUpdateDefaultConfigurationTemplateRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_BatchUpdateDefaultConfigurationTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchUpdateDefaultConfigurationTemplate'
type ConfigCenterServiceServer_BatchUpdateDefaultConfigurationTemplate_Call struct {
	*mock.Call
}

// BatchUpdateDefaultConfigurationTemplate is a helper method to define mock.On call
//   - context1 context.Context
//   - batchUpdateDefaultConfigurationTemplateRequest *config_center.BatchUpdateDefaultConfigurationTemplateRequest
func (_e *ConfigCenterServiceServer_Expecter) BatchUpdateDefaultConfigurationTemplate(context1 interface{}, batchUpdateDefaultConfigurationTemplateRequest interface{}) *ConfigCenterServiceServer_BatchUpdateDefaultConfigurationTemplate_Call {
	return &ConfigCenterServiceServer_BatchUpdateDefaultConfigurationTemplate_Call{Call: _e.mock.On("BatchUpdateDefaultConfigurationTemplate", context1, batchUpdateDefaultConfigurationTemplateRequest)}
}

func (_c *ConfigCenterServiceServer_BatchUpdateDefaultConfigurationTemplate_Call) Run(run func(context1 context.Context, batchUpdateDefaultConfigurationTemplateRequest *config_center.BatchUpdateDefaultConfigurationTemplateRequest)) *ConfigCenterServiceServer_BatchUpdateDefaultConfigurationTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchUpdateDefaultConfigurationTemplateRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchUpdateDefaultConfigurationTemplateRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_BatchUpdateDefaultConfigurationTemplate_Call) Return(batchUpdateDefaultConfigurationTemplateResponse *config_center.BatchUpdateDefaultConfigurationTemplateResponse, err error) *ConfigCenterServiceServer_BatchUpdateDefaultConfigurationTemplate_Call {
	_c.Call.Return(batchUpdateDefaultConfigurationTemplateResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_BatchUpdateDefaultConfigurationTemplate_Call) RunAndReturn(run func(context1 context.Context, batchUpdateDefaultConfigurationTemplateRequest *config_center.BatchUpdateDefaultConfigurationTemplateRequest) (*config_center.BatchUpdateDefaultConfigurationTemplateResponse, error)) *ConfigCenterServiceServer_BatchUpdateDefaultConfigurationTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// BatchUpdateTenantInitialCustomParams provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) BatchUpdateTenantInitialCustomParams(context1 context.Context, batchUpdateTenantInitialCustomParamsRequest *config_center.BatchUpdateTenantInitialCustomParamsRequest) (*config_center.BatchUpdateTenantInitialCustomParamsResponse, error) {
	ret := _mock.Called(context1, batchUpdateTenantInitialCustomParamsRequest)

	if len(ret) == 0 {
		panic("no return value specified for BatchUpdateTenantInitialCustomParams")
	}

	var r0 *config_center.BatchUpdateTenantInitialCustomParamsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchUpdateTenantInitialCustomParamsRequest) (*config_center.BatchUpdateTenantInitialCustomParamsResponse, error)); ok {
		return returnFunc(context1, batchUpdateTenantInitialCustomParamsRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchUpdateTenantInitialCustomParamsRequest) *config_center.BatchUpdateTenantInitialCustomParamsResponse); ok {
		r0 = returnFunc(context1, batchUpdateTenantInitialCustomParamsRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.BatchUpdateTenantInitialCustomParamsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchUpdateTenantInitialCustomParamsRequest) error); ok {
		r1 = returnFunc(context1, batchUpdateTenantInitialCustomParamsRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_BatchUpdateTenantInitialCustomParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchUpdateTenantInitialCustomParams'
type ConfigCenterServiceServer_BatchUpdateTenantInitialCustomParams_Call struct {
	*mock.Call
}

// BatchUpdateTenantInitialCustomParams is a helper method to define mock.On call
//   - context1 context.Context
//   - batchUpdateTenantInitialCustomParamsRequest *config_center.BatchUpdateTenantInitialCustomParamsRequest
func (_e *ConfigCenterServiceServer_Expecter) BatchUpdateTenantInitialCustomParams(context1 interface{}, batchUpdateTenantInitialCustomParamsRequest interface{}) *ConfigCenterServiceServer_BatchUpdateTenantInitialCustomParams_Call {
	return &ConfigCenterServiceServer_BatchUpdateTenantInitialCustomParams_Call{Call: _e.mock.On("BatchUpdateTenantInitialCustomParams", context1, batchUpdateTenantInitialCustomParamsRequest)}
}

func (_c *ConfigCenterServiceServer_BatchUpdateTenantInitialCustomParams_Call) Run(run func(context1 context.Context, batchUpdateTenantInitialCustomParamsRequest *config_center.BatchUpdateTenantInitialCustomParamsRequest)) *ConfigCenterServiceServer_BatchUpdateTenantInitialCustomParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchUpdateTenantInitialCustomParamsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchUpdateTenantInitialCustomParamsRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_BatchUpdateTenantInitialCustomParams_Call) Return(batchUpdateTenantInitialCustomParamsResponse *config_center.BatchUpdateTenantInitialCustomParamsResponse, err error) *ConfigCenterServiceServer_BatchUpdateTenantInitialCustomParams_Call {
	_c.Call.Return(batchUpdateTenantInitialCustomParamsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_BatchUpdateTenantInitialCustomParams_Call) RunAndReturn(run func(context1 context.Context, batchUpdateTenantInitialCustomParamsRequest *config_center.BatchUpdateTenantInitialCustomParamsRequest) (*config_center.BatchUpdateTenantInitialCustomParamsResponse, error)) *ConfigCenterServiceServer_BatchUpdateTenantInitialCustomParams_Call {
	_c.Call.Return(run)
	return _c
}

// BatchUpsertClusterCustomParams provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) BatchUpsertClusterCustomParams(context1 context.Context, batchUpsertClusterCustomParamsRequest *config_center.BatchUpsertClusterCustomParamsRequest) (*config_center.BatchUpsertClusterCustomParamsResponse, error) {
	ret := _mock.Called(context1, batchUpsertClusterCustomParamsRequest)

	if len(ret) == 0 {
		panic("no return value specified for BatchUpsertClusterCustomParams")
	}

	var r0 *config_center.BatchUpsertClusterCustomParamsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchUpsertClusterCustomParamsRequest) (*config_center.BatchUpsertClusterCustomParamsResponse, error)); ok {
		return returnFunc(context1, batchUpsertClusterCustomParamsRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.BatchUpsertClusterCustomParamsRequest) *config_center.BatchUpsertClusterCustomParamsResponse); ok {
		r0 = returnFunc(context1, batchUpsertClusterCustomParamsRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.BatchUpsertClusterCustomParamsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.BatchUpsertClusterCustomParamsRequest) error); ok {
		r1 = returnFunc(context1, batchUpsertClusterCustomParamsRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_BatchUpsertClusterCustomParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchUpsertClusterCustomParams'
type ConfigCenterServiceServer_BatchUpsertClusterCustomParams_Call struct {
	*mock.Call
}

// BatchUpsertClusterCustomParams is a helper method to define mock.On call
//   - context1 context.Context
//   - batchUpsertClusterCustomParamsRequest *config_center.BatchUpsertClusterCustomParamsRequest
func (_e *ConfigCenterServiceServer_Expecter) BatchUpsertClusterCustomParams(context1 interface{}, batchUpsertClusterCustomParamsRequest interface{}) *ConfigCenterServiceServer_BatchUpsertClusterCustomParams_Call {
	return &ConfigCenterServiceServer_BatchUpsertClusterCustomParams_Call{Call: _e.mock.On("BatchUpsertClusterCustomParams", context1, batchUpsertClusterCustomParamsRequest)}
}

func (_c *ConfigCenterServiceServer_BatchUpsertClusterCustomParams_Call) Run(run func(context1 context.Context, batchUpsertClusterCustomParamsRequest *config_center.BatchUpsertClusterCustomParamsRequest)) *ConfigCenterServiceServer_BatchUpsertClusterCustomParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.BatchUpsertClusterCustomParamsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.BatchUpsertClusterCustomParamsRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_BatchUpsertClusterCustomParams_Call) Return(batchUpsertClusterCustomParamsResponse *config_center.BatchUpsertClusterCustomParamsResponse, err error) *ConfigCenterServiceServer_BatchUpsertClusterCustomParams_Call {
	_c.Call.Return(batchUpsertClusterCustomParamsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_BatchUpsertClusterCustomParams_Call) RunAndReturn(run func(context1 context.Context, batchUpsertClusterCustomParamsRequest *config_center.BatchUpsertClusterCustomParamsRequest) (*config_center.BatchUpsertClusterCustomParamsResponse, error)) *ConfigCenterServiceServer_BatchUpsertClusterCustomParams_Call {
	_c.Call.Return(run)
	return _c
}

// CopyConfigurationDictFromOldVersion provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) CopyConfigurationDictFromOldVersion(context1 context.Context, copyConfigurationDictFromOldVersionRequest *config_center.CopyConfigurationDictFromOldVersionRequest) (*emptypb.Empty, error) {
	ret := _mock.Called(context1, copyConfigurationDictFromOldVersionRequest)

	if len(ret) == 0 {
		panic("no return value specified for CopyConfigurationDictFromOldVersion")
	}

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.CopyConfigurationDictFromOldVersionRequest) (*emptypb.Empty, error)); ok {
		return returnFunc(context1, copyConfigurationDictFromOldVersionRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.CopyConfigurationDictFromOldVersionRequest) *emptypb.Empty); ok {
		r0 = returnFunc(context1, copyConfigurationDictFromOldVersionRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.CopyConfigurationDictFromOldVersionRequest) error); ok {
		r1 = returnFunc(context1, copyConfigurationDictFromOldVersionRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_CopyConfigurationDictFromOldVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CopyConfigurationDictFromOldVersion'
type ConfigCenterServiceServer_CopyConfigurationDictFromOldVersion_Call struct {
	*mock.Call
}

// CopyConfigurationDictFromOldVersion is a helper method to define mock.On call
//   - context1 context.Context
//   - copyConfigurationDictFromOldVersionRequest *config_center.CopyConfigurationDictFromOldVersionRequest
func (_e *ConfigCenterServiceServer_Expecter) CopyConfigurationDictFromOldVersion(context1 interface{}, copyConfigurationDictFromOldVersionRequest interface{}) *ConfigCenterServiceServer_CopyConfigurationDictFromOldVersion_Call {
	return &ConfigCenterServiceServer_CopyConfigurationDictFromOldVersion_Call{Call: _e.mock.On("CopyConfigurationDictFromOldVersion", context1, copyConfigurationDictFromOldVersionRequest)}
}

func (_c *ConfigCenterServiceServer_CopyConfigurationDictFromOldVersion_Call) Run(run func(context1 context.Context, copyConfigurationDictFromOldVersionRequest *config_center.CopyConfigurationDictFromOldVersionRequest)) *ConfigCenterServiceServer_CopyConfigurationDictFromOldVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.CopyConfigurationDictFromOldVersionRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.CopyConfigurationDictFromOldVersionRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_CopyConfigurationDictFromOldVersion_Call) Return(empty *emptypb.Empty, err error) *ConfigCenterServiceServer_CopyConfigurationDictFromOldVersion_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *ConfigCenterServiceServer_CopyConfigurationDictFromOldVersion_Call) RunAndReturn(run func(context1 context.Context, copyConfigurationDictFromOldVersionRequest *config_center.CopyConfigurationDictFromOldVersionRequest) (*emptypb.Empty, error)) *ConfigCenterServiceServer_CopyConfigurationDictFromOldVersion_Call {
	_c.Call.Return(run)
	return _c
}

// CreateClusterConfigurationFile provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) CreateClusterConfigurationFile(context1 context.Context, createClusterConfigurationFileRequest *config_center.CreateClusterConfigurationFileRequest) (*config_center.ConfigurationFile, error) {
	ret := _mock.Called(context1, createClusterConfigurationFileRequest)

	if len(ret) == 0 {
		panic("no return value specified for CreateClusterConfigurationFile")
	}

	var r0 *config_center.ConfigurationFile
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.CreateClusterConfigurationFileRequest) (*config_center.ConfigurationFile, error)); ok {
		return returnFunc(context1, createClusterConfigurationFileRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.CreateClusterConfigurationFileRequest) *config_center.ConfigurationFile); ok {
		r0 = returnFunc(context1, createClusterConfigurationFileRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationFile)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.CreateClusterConfigurationFileRequest) error); ok {
		r1 = returnFunc(context1, createClusterConfigurationFileRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_CreateClusterConfigurationFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateClusterConfigurationFile'
type ConfigCenterServiceServer_CreateClusterConfigurationFile_Call struct {
	*mock.Call
}

// CreateClusterConfigurationFile is a helper method to define mock.On call
//   - context1 context.Context
//   - createClusterConfigurationFileRequest *config_center.CreateClusterConfigurationFileRequest
func (_e *ConfigCenterServiceServer_Expecter) CreateClusterConfigurationFile(context1 interface{}, createClusterConfigurationFileRequest interface{}) *ConfigCenterServiceServer_CreateClusterConfigurationFile_Call {
	return &ConfigCenterServiceServer_CreateClusterConfigurationFile_Call{Call: _e.mock.On("CreateClusterConfigurationFile", context1, createClusterConfigurationFileRequest)}
}

func (_c *ConfigCenterServiceServer_CreateClusterConfigurationFile_Call) Run(run func(context1 context.Context, createClusterConfigurationFileRequest *config_center.CreateClusterConfigurationFileRequest)) *ConfigCenterServiceServer_CreateClusterConfigurationFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.CreateClusterConfigurationFileRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.CreateClusterConfigurationFileRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_CreateClusterConfigurationFile_Call) Return(configurationFile *config_center.ConfigurationFile, err error) *ConfigCenterServiceServer_CreateClusterConfigurationFile_Call {
	_c.Call.Return(configurationFile, err)
	return _c
}

func (_c *ConfigCenterServiceServer_CreateClusterConfigurationFile_Call) RunAndReturn(run func(context1 context.Context, createClusterConfigurationFileRequest *config_center.CreateClusterConfigurationFileRequest) (*config_center.ConfigurationFile, error)) *ConfigCenterServiceServer_CreateClusterConfigurationFile_Call {
	_c.Call.Return(run)
	return _c
}

// CreateConfigurationTemplate provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) CreateConfigurationTemplate(context1 context.Context, createConfigurationTemplateRequest *config_center.CreateConfigurationTemplateRequest) (*config_center.ConfigurationTemplate, error) {
	ret := _mock.Called(context1, createConfigurationTemplateRequest)

	if len(ret) == 0 {
		panic("no return value specified for CreateConfigurationTemplate")
	}

	var r0 *config_center.ConfigurationTemplate
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.CreateConfigurationTemplateRequest) (*config_center.ConfigurationTemplate, error)); ok {
		return returnFunc(context1, createConfigurationTemplateRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.CreateConfigurationTemplateRequest) *config_center.ConfigurationTemplate); ok {
		r0 = returnFunc(context1, createConfigurationTemplateRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationTemplate)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.CreateConfigurationTemplateRequest) error); ok {
		r1 = returnFunc(context1, createConfigurationTemplateRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_CreateConfigurationTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateConfigurationTemplate'
type ConfigCenterServiceServer_CreateConfigurationTemplate_Call struct {
	*mock.Call
}

// CreateConfigurationTemplate is a helper method to define mock.On call
//   - context1 context.Context
//   - createConfigurationTemplateRequest *config_center.CreateConfigurationTemplateRequest
func (_e *ConfigCenterServiceServer_Expecter) CreateConfigurationTemplate(context1 interface{}, createConfigurationTemplateRequest interface{}) *ConfigCenterServiceServer_CreateConfigurationTemplate_Call {
	return &ConfigCenterServiceServer_CreateConfigurationTemplate_Call{Call: _e.mock.On("CreateConfigurationTemplate", context1, createConfigurationTemplateRequest)}
}

func (_c *ConfigCenterServiceServer_CreateConfigurationTemplate_Call) Run(run func(context1 context.Context, createConfigurationTemplateRequest *config_center.CreateConfigurationTemplateRequest)) *ConfigCenterServiceServer_CreateConfigurationTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.CreateConfigurationTemplateRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.CreateConfigurationTemplateRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_CreateConfigurationTemplate_Call) Return(configurationTemplate *config_center.ConfigurationTemplate, err error) *ConfigCenterServiceServer_CreateConfigurationTemplate_Call {
	_c.Call.Return(configurationTemplate, err)
	return _c
}

func (_c *ConfigCenterServiceServer_CreateConfigurationTemplate_Call) RunAndReturn(run func(context1 context.Context, createConfigurationTemplateRequest *config_center.CreateConfigurationTemplateRequest) (*config_center.ConfigurationTemplate, error)) *ConfigCenterServiceServer_CreateConfigurationTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// CreateMetaProfile provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) CreateMetaProfile(context1 context.Context, createMetaProfileRequest *config_center.CreateMetaProfileRequest) (*config_center.MetaProfile, error) {
	ret := _mock.Called(context1, createMetaProfileRequest)

	if len(ret) == 0 {
		panic("no return value specified for CreateMetaProfile")
	}

	var r0 *config_center.MetaProfile
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.CreateMetaProfileRequest) (*config_center.MetaProfile, error)); ok {
		return returnFunc(context1, createMetaProfileRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.CreateMetaProfileRequest) *config_center.MetaProfile); ok {
		r0 = returnFunc(context1, createMetaProfileRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.MetaProfile)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.CreateMetaProfileRequest) error); ok {
		r1 = returnFunc(context1, createMetaProfileRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_CreateMetaProfile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMetaProfile'
type ConfigCenterServiceServer_CreateMetaProfile_Call struct {
	*mock.Call
}

// CreateMetaProfile is a helper method to define mock.On call
//   - context1 context.Context
//   - createMetaProfileRequest *config_center.CreateMetaProfileRequest
func (_e *ConfigCenterServiceServer_Expecter) CreateMetaProfile(context1 interface{}, createMetaProfileRequest interface{}) *ConfigCenterServiceServer_CreateMetaProfile_Call {
	return &ConfigCenterServiceServer_CreateMetaProfile_Call{Call: _e.mock.On("CreateMetaProfile", context1, createMetaProfileRequest)}
}

func (_c *ConfigCenterServiceServer_CreateMetaProfile_Call) Run(run func(context1 context.Context, createMetaProfileRequest *config_center.CreateMetaProfileRequest)) *ConfigCenterServiceServer_CreateMetaProfile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.CreateMetaProfileRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.CreateMetaProfileRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_CreateMetaProfile_Call) Return(metaProfile *config_center.MetaProfile, err error) *ConfigCenterServiceServer_CreateMetaProfile_Call {
	_c.Call.Return(metaProfile, err)
	return _c
}

func (_c *ConfigCenterServiceServer_CreateMetaProfile_Call) RunAndReturn(run func(context1 context.Context, createMetaProfileRequest *config_center.CreateMetaProfileRequest) (*config_center.MetaProfile, error)) *ConfigCenterServiceServer_CreateMetaProfile_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteClusterConfigurationFile provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) DeleteClusterConfigurationFile(context1 context.Context, deleteClusterConfigurationFileRequest *config_center.DeleteClusterConfigurationFileRequest) (*emptypb.Empty, error) {
	ret := _mock.Called(context1, deleteClusterConfigurationFileRequest)

	if len(ret) == 0 {
		panic("no return value specified for DeleteClusterConfigurationFile")
	}

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteClusterConfigurationFileRequest) (*emptypb.Empty, error)); ok {
		return returnFunc(context1, deleteClusterConfigurationFileRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteClusterConfigurationFileRequest) *emptypb.Empty); ok {
		r0 = returnFunc(context1, deleteClusterConfigurationFileRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.DeleteClusterConfigurationFileRequest) error); ok {
		r1 = returnFunc(context1, deleteClusterConfigurationFileRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_DeleteClusterConfigurationFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteClusterConfigurationFile'
type ConfigCenterServiceServer_DeleteClusterConfigurationFile_Call struct {
	*mock.Call
}

// DeleteClusterConfigurationFile is a helper method to define mock.On call
//   - context1 context.Context
//   - deleteClusterConfigurationFileRequest *config_center.DeleteClusterConfigurationFileRequest
func (_e *ConfigCenterServiceServer_Expecter) DeleteClusterConfigurationFile(context1 interface{}, deleteClusterConfigurationFileRequest interface{}) *ConfigCenterServiceServer_DeleteClusterConfigurationFile_Call {
	return &ConfigCenterServiceServer_DeleteClusterConfigurationFile_Call{Call: _e.mock.On("DeleteClusterConfigurationFile", context1, deleteClusterConfigurationFileRequest)}
}

func (_c *ConfigCenterServiceServer_DeleteClusterConfigurationFile_Call) Run(run func(context1 context.Context, deleteClusterConfigurationFileRequest *config_center.DeleteClusterConfigurationFileRequest)) *ConfigCenterServiceServer_DeleteClusterConfigurationFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.DeleteClusterConfigurationFileRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.DeleteClusterConfigurationFileRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_DeleteClusterConfigurationFile_Call) Return(empty *emptypb.Empty, err error) *ConfigCenterServiceServer_DeleteClusterConfigurationFile_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *ConfigCenterServiceServer_DeleteClusterConfigurationFile_Call) RunAndReturn(run func(context1 context.Context, deleteClusterConfigurationFileRequest *config_center.DeleteClusterConfigurationFileRequest) (*emptypb.Empty, error)) *ConfigCenterServiceServer_DeleteClusterConfigurationFile_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteClusterMeta provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) DeleteClusterMeta(context1 context.Context, deleteClusterMetaRequest *config_center.DeleteClusterMetaRequest) (*emptypb.Empty, error) {
	ret := _mock.Called(context1, deleteClusterMetaRequest)

	if len(ret) == 0 {
		panic("no return value specified for DeleteClusterMeta")
	}

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteClusterMetaRequest) (*emptypb.Empty, error)); ok {
		return returnFunc(context1, deleteClusterMetaRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteClusterMetaRequest) *emptypb.Empty); ok {
		r0 = returnFunc(context1, deleteClusterMetaRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.DeleteClusterMetaRequest) error); ok {
		r1 = returnFunc(context1, deleteClusterMetaRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_DeleteClusterMeta_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteClusterMeta'
type ConfigCenterServiceServer_DeleteClusterMeta_Call struct {
	*mock.Call
}

// DeleteClusterMeta is a helper method to define mock.On call
//   - context1 context.Context
//   - deleteClusterMetaRequest *config_center.DeleteClusterMetaRequest
func (_e *ConfigCenterServiceServer_Expecter) DeleteClusterMeta(context1 interface{}, deleteClusterMetaRequest interface{}) *ConfigCenterServiceServer_DeleteClusterMeta_Call {
	return &ConfigCenterServiceServer_DeleteClusterMeta_Call{Call: _e.mock.On("DeleteClusterMeta", context1, deleteClusterMetaRequest)}
}

func (_c *ConfigCenterServiceServer_DeleteClusterMeta_Call) Run(run func(context1 context.Context, deleteClusterMetaRequest *config_center.DeleteClusterMetaRequest)) *ConfigCenterServiceServer_DeleteClusterMeta_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.DeleteClusterMetaRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.DeleteClusterMetaRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_DeleteClusterMeta_Call) Return(empty *emptypb.Empty, err error) *ConfigCenterServiceServer_DeleteClusterMeta_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *ConfigCenterServiceServer_DeleteClusterMeta_Call) RunAndReturn(run func(context1 context.Context, deleteClusterMetaRequest *config_center.DeleteClusterMetaRequest) (*emptypb.Empty, error)) *ConfigCenterServiceServer_DeleteClusterMeta_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteConfigurationTemplate provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) DeleteConfigurationTemplate(context1 context.Context, deleteConfigurationTemplateRequest *config_center.DeleteConfigurationTemplateRequest) (*emptypb.Empty, error) {
	ret := _mock.Called(context1, deleteConfigurationTemplateRequest)

	if len(ret) == 0 {
		panic("no return value specified for DeleteConfigurationTemplate")
	}

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteConfigurationTemplateRequest) (*emptypb.Empty, error)); ok {
		return returnFunc(context1, deleteConfigurationTemplateRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteConfigurationTemplateRequest) *emptypb.Empty); ok {
		r0 = returnFunc(context1, deleteConfigurationTemplateRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.DeleteConfigurationTemplateRequest) error); ok {
		r1 = returnFunc(context1, deleteConfigurationTemplateRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_DeleteConfigurationTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteConfigurationTemplate'
type ConfigCenterServiceServer_DeleteConfigurationTemplate_Call struct {
	*mock.Call
}

// DeleteConfigurationTemplate is a helper method to define mock.On call
//   - context1 context.Context
//   - deleteConfigurationTemplateRequest *config_center.DeleteConfigurationTemplateRequest
func (_e *ConfigCenterServiceServer_Expecter) DeleteConfigurationTemplate(context1 interface{}, deleteConfigurationTemplateRequest interface{}) *ConfigCenterServiceServer_DeleteConfigurationTemplate_Call {
	return &ConfigCenterServiceServer_DeleteConfigurationTemplate_Call{Call: _e.mock.On("DeleteConfigurationTemplate", context1, deleteConfigurationTemplateRequest)}
}

func (_c *ConfigCenterServiceServer_DeleteConfigurationTemplate_Call) Run(run func(context1 context.Context, deleteConfigurationTemplateRequest *config_center.DeleteConfigurationTemplateRequest)) *ConfigCenterServiceServer_DeleteConfigurationTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.DeleteConfigurationTemplateRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.DeleteConfigurationTemplateRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_DeleteConfigurationTemplate_Call) Return(empty *emptypb.Empty, err error) *ConfigCenterServiceServer_DeleteConfigurationTemplate_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *ConfigCenterServiceServer_DeleteConfigurationTemplate_Call) RunAndReturn(run func(context1 context.Context, deleteConfigurationTemplateRequest *config_center.DeleteConfigurationTemplateRequest) (*emptypb.Empty, error)) *ConfigCenterServiceServer_DeleteConfigurationTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDefaultConfigurationTemplate provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) DeleteDefaultConfigurationTemplate(context1 context.Context, deleteDefaultConfigurationTemplateRequest *config_center.DeleteDefaultConfigurationTemplateRequest) (*emptypb.Empty, error) {
	ret := _mock.Called(context1, deleteDefaultConfigurationTemplateRequest)

	if len(ret) == 0 {
		panic("no return value specified for DeleteDefaultConfigurationTemplate")
	}

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteDefaultConfigurationTemplateRequest) (*emptypb.Empty, error)); ok {
		return returnFunc(context1, deleteDefaultConfigurationTemplateRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteDefaultConfigurationTemplateRequest) *emptypb.Empty); ok {
		r0 = returnFunc(context1, deleteDefaultConfigurationTemplateRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.DeleteDefaultConfigurationTemplateRequest) error); ok {
		r1 = returnFunc(context1, deleteDefaultConfigurationTemplateRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_DeleteDefaultConfigurationTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteDefaultConfigurationTemplate'
type ConfigCenterServiceServer_DeleteDefaultConfigurationTemplate_Call struct {
	*mock.Call
}

// DeleteDefaultConfigurationTemplate is a helper method to define mock.On call
//   - context1 context.Context
//   - deleteDefaultConfigurationTemplateRequest *config_center.DeleteDefaultConfigurationTemplateRequest
func (_e *ConfigCenterServiceServer_Expecter) DeleteDefaultConfigurationTemplate(context1 interface{}, deleteDefaultConfigurationTemplateRequest interface{}) *ConfigCenterServiceServer_DeleteDefaultConfigurationTemplate_Call {
	return &ConfigCenterServiceServer_DeleteDefaultConfigurationTemplate_Call{Call: _e.mock.On("DeleteDefaultConfigurationTemplate", context1, deleteDefaultConfigurationTemplateRequest)}
}

func (_c *ConfigCenterServiceServer_DeleteDefaultConfigurationTemplate_Call) Run(run func(context1 context.Context, deleteDefaultConfigurationTemplateRequest *config_center.DeleteDefaultConfigurationTemplateRequest)) *ConfigCenterServiceServer_DeleteDefaultConfigurationTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.DeleteDefaultConfigurationTemplateRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.DeleteDefaultConfigurationTemplateRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_DeleteDefaultConfigurationTemplate_Call) Return(empty *emptypb.Empty, err error) *ConfigCenterServiceServer_DeleteDefaultConfigurationTemplate_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *ConfigCenterServiceServer_DeleteDefaultConfigurationTemplate_Call) RunAndReturn(run func(context1 context.Context, deleteDefaultConfigurationTemplateRequest *config_center.DeleteDefaultConfigurationTemplateRequest) (*emptypb.Empty, error)) *ConfigCenterServiceServer_DeleteDefaultConfigurationTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDefaultVersion provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) DeleteDefaultVersion(context1 context.Context, deleteDefaultVersionRequest *config_center.DeleteDefaultVersionRequest) (*emptypb.Empty, error) {
	ret := _mock.Called(context1, deleteDefaultVersionRequest)

	if len(ret) == 0 {
		panic("no return value specified for DeleteDefaultVersion")
	}

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteDefaultVersionRequest) (*emptypb.Empty, error)); ok {
		return returnFunc(context1, deleteDefaultVersionRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteDefaultVersionRequest) *emptypb.Empty); ok {
		r0 = returnFunc(context1, deleteDefaultVersionRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.DeleteDefaultVersionRequest) error); ok {
		r1 = returnFunc(context1, deleteDefaultVersionRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_DeleteDefaultVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteDefaultVersion'
type ConfigCenterServiceServer_DeleteDefaultVersion_Call struct {
	*mock.Call
}

// DeleteDefaultVersion is a helper method to define mock.On call
//   - context1 context.Context
//   - deleteDefaultVersionRequest *config_center.DeleteDefaultVersionRequest
func (_e *ConfigCenterServiceServer_Expecter) DeleteDefaultVersion(context1 interface{}, deleteDefaultVersionRequest interface{}) *ConfigCenterServiceServer_DeleteDefaultVersion_Call {
	return &ConfigCenterServiceServer_DeleteDefaultVersion_Call{Call: _e.mock.On("DeleteDefaultVersion", context1, deleteDefaultVersionRequest)}
}

func (_c *ConfigCenterServiceServer_DeleteDefaultVersion_Call) Run(run func(context1 context.Context, deleteDefaultVersionRequest *config_center.DeleteDefaultVersionRequest)) *ConfigCenterServiceServer_DeleteDefaultVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.DeleteDefaultVersionRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.DeleteDefaultVersionRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_DeleteDefaultVersion_Call) Return(empty *emptypb.Empty, err error) *ConfigCenterServiceServer_DeleteDefaultVersion_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *ConfigCenterServiceServer_DeleteDefaultVersion_Call) RunAndReturn(run func(context1 context.Context, deleteDefaultVersionRequest *config_center.DeleteDefaultVersionRequest) (*emptypb.Empty, error)) *ConfigCenterServiceServer_DeleteDefaultVersion_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteMetaProfile provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) DeleteMetaProfile(context1 context.Context, deleteMetaProfileRequest *config_center.DeleteMetaProfileRequest) (*emptypb.Empty, error) {
	ret := _mock.Called(context1, deleteMetaProfileRequest)

	if len(ret) == 0 {
		panic("no return value specified for DeleteMetaProfile")
	}

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteMetaProfileRequest) (*emptypb.Empty, error)); ok {
		return returnFunc(context1, deleteMetaProfileRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.DeleteMetaProfileRequest) *emptypb.Empty); ok {
		r0 = returnFunc(context1, deleteMetaProfileRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.DeleteMetaProfileRequest) error); ok {
		r1 = returnFunc(context1, deleteMetaProfileRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_DeleteMetaProfile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMetaProfile'
type ConfigCenterServiceServer_DeleteMetaProfile_Call struct {
	*mock.Call
}

// DeleteMetaProfile is a helper method to define mock.On call
//   - context1 context.Context
//   - deleteMetaProfileRequest *config_center.DeleteMetaProfileRequest
func (_e *ConfigCenterServiceServer_Expecter) DeleteMetaProfile(context1 interface{}, deleteMetaProfileRequest interface{}) *ConfigCenterServiceServer_DeleteMetaProfile_Call {
	return &ConfigCenterServiceServer_DeleteMetaProfile_Call{Call: _e.mock.On("DeleteMetaProfile", context1, deleteMetaProfileRequest)}
}

func (_c *ConfigCenterServiceServer_DeleteMetaProfile_Call) Run(run func(context1 context.Context, deleteMetaProfileRequest *config_center.DeleteMetaProfileRequest)) *ConfigCenterServiceServer_DeleteMetaProfile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.DeleteMetaProfileRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.DeleteMetaProfileRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_DeleteMetaProfile_Call) Return(empty *emptypb.Empty, err error) *ConfigCenterServiceServer_DeleteMetaProfile_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *ConfigCenterServiceServer_DeleteMetaProfile_Call) RunAndReturn(run func(context1 context.Context, deleteMetaProfileRequest *config_center.DeleteMetaProfileRequest) (*emptypb.Empty, error)) *ConfigCenterServiceServer_DeleteMetaProfile_Call {
	_c.Call.Return(run)
	return _c
}

// GetClusterComponent provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) GetClusterComponent(context1 context.Context, getClusterComponentRequest *config_center.GetClusterComponentRequest) (*config_center.ClusterComponent, error) {
	ret := _mock.Called(context1, getClusterComponentRequest)

	if len(ret) == 0 {
		panic("no return value specified for GetClusterComponent")
	}

	var r0 *config_center.ClusterComponent
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetClusterComponentRequest) (*config_center.ClusterComponent, error)); ok {
		return returnFunc(context1, getClusterComponentRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetClusterComponentRequest) *config_center.ClusterComponent); ok {
		r0 = returnFunc(context1, getClusterComponentRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ClusterComponent)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetClusterComponentRequest) error); ok {
		r1 = returnFunc(context1, getClusterComponentRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_GetClusterComponent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClusterComponent'
type ConfigCenterServiceServer_GetClusterComponent_Call struct {
	*mock.Call
}

// GetClusterComponent is a helper method to define mock.On call
//   - context1 context.Context
//   - getClusterComponentRequest *config_center.GetClusterComponentRequest
func (_e *ConfigCenterServiceServer_Expecter) GetClusterComponent(context1 interface{}, getClusterComponentRequest interface{}) *ConfigCenterServiceServer_GetClusterComponent_Call {
	return &ConfigCenterServiceServer_GetClusterComponent_Call{Call: _e.mock.On("GetClusterComponent", context1, getClusterComponentRequest)}
}

func (_c *ConfigCenterServiceServer_GetClusterComponent_Call) Run(run func(context1 context.Context, getClusterComponentRequest *config_center.GetClusterComponentRequest)) *ConfigCenterServiceServer_GetClusterComponent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetClusterComponentRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetClusterComponentRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_GetClusterComponent_Call) Return(clusterComponent *config_center.ClusterComponent, err error) *ConfigCenterServiceServer_GetClusterComponent_Call {
	_c.Call.Return(clusterComponent, err)
	return _c
}

func (_c *ConfigCenterServiceServer_GetClusterComponent_Call) RunAndReturn(run func(context1 context.Context, getClusterComponentRequest *config_center.GetClusterComponentRequest) (*config_center.ClusterComponent, error)) *ConfigCenterServiceServer_GetClusterComponent_Call {
	_c.Call.Return(run)
	return _c
}

// GetClusterConfigurationFile provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) GetClusterConfigurationFile(context1 context.Context, getClusterConfigurationFileRequest *config_center.GetClusterConfigurationFileRequest) (*config_center.ConfigurationFile, error) {
	ret := _mock.Called(context1, getClusterConfigurationFileRequest)

	if len(ret) == 0 {
		panic("no return value specified for GetClusterConfigurationFile")
	}

	var r0 *config_center.ConfigurationFile
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetClusterConfigurationFileRequest) (*config_center.ConfigurationFile, error)); ok {
		return returnFunc(context1, getClusterConfigurationFileRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetClusterConfigurationFileRequest) *config_center.ConfigurationFile); ok {
		r0 = returnFunc(context1, getClusterConfigurationFileRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationFile)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetClusterConfigurationFileRequest) error); ok {
		r1 = returnFunc(context1, getClusterConfigurationFileRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_GetClusterConfigurationFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClusterConfigurationFile'
type ConfigCenterServiceServer_GetClusterConfigurationFile_Call struct {
	*mock.Call
}

// GetClusterConfigurationFile is a helper method to define mock.On call
//   - context1 context.Context
//   - getClusterConfigurationFileRequest *config_center.GetClusterConfigurationFileRequest
func (_e *ConfigCenterServiceServer_Expecter) GetClusterConfigurationFile(context1 interface{}, getClusterConfigurationFileRequest interface{}) *ConfigCenterServiceServer_GetClusterConfigurationFile_Call {
	return &ConfigCenterServiceServer_GetClusterConfigurationFile_Call{Call: _e.mock.On("GetClusterConfigurationFile", context1, getClusterConfigurationFileRequest)}
}

func (_c *ConfigCenterServiceServer_GetClusterConfigurationFile_Call) Run(run func(context1 context.Context, getClusterConfigurationFileRequest *config_center.GetClusterConfigurationFileRequest)) *ConfigCenterServiceServer_GetClusterConfigurationFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetClusterConfigurationFileRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetClusterConfigurationFileRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_GetClusterConfigurationFile_Call) Return(configurationFile *config_center.ConfigurationFile, err error) *ConfigCenterServiceServer_GetClusterConfigurationFile_Call {
	_c.Call.Return(configurationFile, err)
	return _c
}

func (_c *ConfigCenterServiceServer_GetClusterConfigurationFile_Call) RunAndReturn(run func(context1 context.Context, getClusterConfigurationFileRequest *config_center.GetClusterConfigurationFileRequest) (*config_center.ConfigurationFile, error)) *ConfigCenterServiceServer_GetClusterConfigurationFile_Call {
	_c.Call.Return(run)
	return _c
}

// GetClusterMeta provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) GetClusterMeta(context1 context.Context, getClusterMetaRequest *config_center.GetClusterMetaRequest) (*config_center.ClusterMeta, error) {
	ret := _mock.Called(context1, getClusterMetaRequest)

	if len(ret) == 0 {
		panic("no return value specified for GetClusterMeta")
	}

	var r0 *config_center.ClusterMeta
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetClusterMetaRequest) (*config_center.ClusterMeta, error)); ok {
		return returnFunc(context1, getClusterMetaRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetClusterMetaRequest) *config_center.ClusterMeta); ok {
		r0 = returnFunc(context1, getClusterMetaRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ClusterMeta)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetClusterMetaRequest) error); ok {
		r1 = returnFunc(context1, getClusterMetaRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_GetClusterMeta_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClusterMeta'
type ConfigCenterServiceServer_GetClusterMeta_Call struct {
	*mock.Call
}

// GetClusterMeta is a helper method to define mock.On call
//   - context1 context.Context
//   - getClusterMetaRequest *config_center.GetClusterMetaRequest
func (_e *ConfigCenterServiceServer_Expecter) GetClusterMeta(context1 interface{}, getClusterMetaRequest interface{}) *ConfigCenterServiceServer_GetClusterMeta_Call {
	return &ConfigCenterServiceServer_GetClusterMeta_Call{Call: _e.mock.On("GetClusterMeta", context1, getClusterMetaRequest)}
}

func (_c *ConfigCenterServiceServer_GetClusterMeta_Call) Run(run func(context1 context.Context, getClusterMetaRequest *config_center.GetClusterMetaRequest)) *ConfigCenterServiceServer_GetClusterMeta_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetClusterMetaRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetClusterMetaRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_GetClusterMeta_Call) Return(clusterMeta *config_center.ClusterMeta, err error) *ConfigCenterServiceServer_GetClusterMeta_Call {
	_c.Call.Return(clusterMeta, err)
	return _c
}

func (_c *ConfigCenterServiceServer_GetClusterMeta_Call) RunAndReturn(run func(context1 context.Context, getClusterMetaRequest *config_center.GetClusterMetaRequest) (*config_center.ClusterMeta, error)) *ConfigCenterServiceServer_GetClusterMeta_Call {
	_c.Call.Return(run)
	return _c
}

// GetComponentImage provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) GetComponentImage(context1 context.Context, getComponentImageRequest *config_center.GetComponentImageRequest) (*config_center.ComponentImage, error) {
	ret := _mock.Called(context1, getComponentImageRequest)

	if len(ret) == 0 {
		panic("no return value specified for GetComponentImage")
	}

	var r0 *config_center.ComponentImage
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetComponentImageRequest) (*config_center.ComponentImage, error)); ok {
		return returnFunc(context1, getComponentImageRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetComponentImageRequest) *config_center.ComponentImage); ok {
		r0 = returnFunc(context1, getComponentImageRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ComponentImage)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetComponentImageRequest) error); ok {
		r1 = returnFunc(context1, getComponentImageRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_GetComponentImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetComponentImage'
type ConfigCenterServiceServer_GetComponentImage_Call struct {
	*mock.Call
}

// GetComponentImage is a helper method to define mock.On call
//   - context1 context.Context
//   - getComponentImageRequest *config_center.GetComponentImageRequest
func (_e *ConfigCenterServiceServer_Expecter) GetComponentImage(context1 interface{}, getComponentImageRequest interface{}) *ConfigCenterServiceServer_GetComponentImage_Call {
	return &ConfigCenterServiceServer_GetComponentImage_Call{Call: _e.mock.On("GetComponentImage", context1, getComponentImageRequest)}
}

func (_c *ConfigCenterServiceServer_GetComponentImage_Call) Run(run func(context1 context.Context, getComponentImageRequest *config_center.GetComponentImageRequest)) *ConfigCenterServiceServer_GetComponentImage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetComponentImageRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetComponentImageRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_GetComponentImage_Call) Return(componentImage *config_center.ComponentImage, err error) *ConfigCenterServiceServer_GetComponentImage_Call {
	_c.Call.Return(componentImage, err)
	return _c
}

func (_c *ConfigCenterServiceServer_GetComponentImage_Call) RunAndReturn(run func(context1 context.Context, getComponentImageRequest *config_center.GetComponentImageRequest) (*config_center.ComponentImage, error)) *ConfigCenterServiceServer_GetComponentImage_Call {
	_c.Call.Return(run)
	return _c
}

// GetConfigurationDictItem provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) GetConfigurationDictItem(context1 context.Context, getConfigurationDictItemRequest *config_center.GetConfigurationDictItemRequest) (*config_center.ConfigurationDictItem, error) {
	ret := _mock.Called(context1, getConfigurationDictItemRequest)

	if len(ret) == 0 {
		panic("no return value specified for GetConfigurationDictItem")
	}

	var r0 *config_center.ConfigurationDictItem
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetConfigurationDictItemRequest) (*config_center.ConfigurationDictItem, error)); ok {
		return returnFunc(context1, getConfigurationDictItemRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetConfigurationDictItemRequest) *config_center.ConfigurationDictItem); ok {
		r0 = returnFunc(context1, getConfigurationDictItemRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationDictItem)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetConfigurationDictItemRequest) error); ok {
		r1 = returnFunc(context1, getConfigurationDictItemRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_GetConfigurationDictItem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConfigurationDictItem'
type ConfigCenterServiceServer_GetConfigurationDictItem_Call struct {
	*mock.Call
}

// GetConfigurationDictItem is a helper method to define mock.On call
//   - context1 context.Context
//   - getConfigurationDictItemRequest *config_center.GetConfigurationDictItemRequest
func (_e *ConfigCenterServiceServer_Expecter) GetConfigurationDictItem(context1 interface{}, getConfigurationDictItemRequest interface{}) *ConfigCenterServiceServer_GetConfigurationDictItem_Call {
	return &ConfigCenterServiceServer_GetConfigurationDictItem_Call{Call: _e.mock.On("GetConfigurationDictItem", context1, getConfigurationDictItemRequest)}
}

func (_c *ConfigCenterServiceServer_GetConfigurationDictItem_Call) Run(run func(context1 context.Context, getConfigurationDictItemRequest *config_center.GetConfigurationDictItemRequest)) *ConfigCenterServiceServer_GetConfigurationDictItem_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetConfigurationDictItemRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetConfigurationDictItemRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_GetConfigurationDictItem_Call) Return(configurationDictItem *config_center.ConfigurationDictItem, err error) *ConfigCenterServiceServer_GetConfigurationDictItem_Call {
	_c.Call.Return(configurationDictItem, err)
	return _c
}

func (_c *ConfigCenterServiceServer_GetConfigurationDictItem_Call) RunAndReturn(run func(context1 context.Context, getConfigurationDictItemRequest *config_center.GetConfigurationDictItemRequest) (*config_center.ConfigurationDictItem, error)) *ConfigCenterServiceServer_GetConfigurationDictItem_Call {
	_c.Call.Return(run)
	return _c
}

// GetConfigurationTemplate provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) GetConfigurationTemplate(context1 context.Context, getConfigurationTemplateRequest *config_center.GetConfigurationTemplateRequest) (*config_center.ConfigurationTemplate, error) {
	ret := _mock.Called(context1, getConfigurationTemplateRequest)

	if len(ret) == 0 {
		panic("no return value specified for GetConfigurationTemplate")
	}

	var r0 *config_center.ConfigurationTemplate
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetConfigurationTemplateRequest) (*config_center.ConfigurationTemplate, error)); ok {
		return returnFunc(context1, getConfigurationTemplateRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetConfigurationTemplateRequest) *config_center.ConfigurationTemplate); ok {
		r0 = returnFunc(context1, getConfigurationTemplateRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationTemplate)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetConfigurationTemplateRequest) error); ok {
		r1 = returnFunc(context1, getConfigurationTemplateRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_GetConfigurationTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConfigurationTemplate'
type ConfigCenterServiceServer_GetConfigurationTemplate_Call struct {
	*mock.Call
}

// GetConfigurationTemplate is a helper method to define mock.On call
//   - context1 context.Context
//   - getConfigurationTemplateRequest *config_center.GetConfigurationTemplateRequest
func (_e *ConfigCenterServiceServer_Expecter) GetConfigurationTemplate(context1 interface{}, getConfigurationTemplateRequest interface{}) *ConfigCenterServiceServer_GetConfigurationTemplate_Call {
	return &ConfigCenterServiceServer_GetConfigurationTemplate_Call{Call: _e.mock.On("GetConfigurationTemplate", context1, getConfigurationTemplateRequest)}
}

func (_c *ConfigCenterServiceServer_GetConfigurationTemplate_Call) Run(run func(context1 context.Context, getConfigurationTemplateRequest *config_center.GetConfigurationTemplateRequest)) *ConfigCenterServiceServer_GetConfigurationTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetConfigurationTemplateRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetConfigurationTemplateRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_GetConfigurationTemplate_Call) Return(configurationTemplate *config_center.ConfigurationTemplate, err error) *ConfigCenterServiceServer_GetConfigurationTemplate_Call {
	_c.Call.Return(configurationTemplate, err)
	return _c
}

func (_c *ConfigCenterServiceServer_GetConfigurationTemplate_Call) RunAndReturn(run func(context1 context.Context, getConfigurationTemplateRequest *config_center.GetConfigurationTemplateRequest) (*config_center.ConfigurationTemplate, error)) *ConfigCenterServiceServer_GetConfigurationTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// GetDefaultVersion provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) GetDefaultVersion(context1 context.Context, getDefaultVersionRequest *config_center.GetDefaultVersionRequest) (*config_center.DefaultVersion, error) {
	ret := _mock.Called(context1, getDefaultVersionRequest)

	if len(ret) == 0 {
		panic("no return value specified for GetDefaultVersion")
	}

	var r0 *config_center.DefaultVersion
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetDefaultVersionRequest) (*config_center.DefaultVersion, error)); ok {
		return returnFunc(context1, getDefaultVersionRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetDefaultVersionRequest) *config_center.DefaultVersion); ok {
		r0 = returnFunc(context1, getDefaultVersionRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.DefaultVersion)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetDefaultVersionRequest) error); ok {
		r1 = returnFunc(context1, getDefaultVersionRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_GetDefaultVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDefaultVersion'
type ConfigCenterServiceServer_GetDefaultVersion_Call struct {
	*mock.Call
}

// GetDefaultVersion is a helper method to define mock.On call
//   - context1 context.Context
//   - getDefaultVersionRequest *config_center.GetDefaultVersionRequest
func (_e *ConfigCenterServiceServer_Expecter) GetDefaultVersion(context1 interface{}, getDefaultVersionRequest interface{}) *ConfigCenterServiceServer_GetDefaultVersion_Call {
	return &ConfigCenterServiceServer_GetDefaultVersion_Call{Call: _e.mock.On("GetDefaultVersion", context1, getDefaultVersionRequest)}
}

func (_c *ConfigCenterServiceServer_GetDefaultVersion_Call) Run(run func(context1 context.Context, getDefaultVersionRequest *config_center.GetDefaultVersionRequest)) *ConfigCenterServiceServer_GetDefaultVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetDefaultVersionRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetDefaultVersionRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_GetDefaultVersion_Call) Return(defaultVersion *config_center.DefaultVersion, err error) *ConfigCenterServiceServer_GetDefaultVersion_Call {
	_c.Call.Return(defaultVersion, err)
	return _c
}

func (_c *ConfigCenterServiceServer_GetDefaultVersion_Call) RunAndReturn(run func(context1 context.Context, getDefaultVersionRequest *config_center.GetDefaultVersionRequest) (*config_center.DefaultVersion, error)) *ConfigCenterServiceServer_GetDefaultVersion_Call {
	_c.Call.Return(run)
	return _c
}

// GetMetaProfile provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) GetMetaProfile(context1 context.Context, getMetaProfileRequest *config_center.GetMetaProfileRequest) (*config_center.MetaProfile, error) {
	ret := _mock.Called(context1, getMetaProfileRequest)

	if len(ret) == 0 {
		panic("no return value specified for GetMetaProfile")
	}

	var r0 *config_center.MetaProfile
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetMetaProfileRequest) (*config_center.MetaProfile, error)); ok {
		return returnFunc(context1, getMetaProfileRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetMetaProfileRequest) *config_center.MetaProfile); ok {
		r0 = returnFunc(context1, getMetaProfileRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.MetaProfile)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetMetaProfileRequest) error); ok {
		r1 = returnFunc(context1, getMetaProfileRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_GetMetaProfile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMetaProfile'
type ConfigCenterServiceServer_GetMetaProfile_Call struct {
	*mock.Call
}

// GetMetaProfile is a helper method to define mock.On call
//   - context1 context.Context
//   - getMetaProfileRequest *config_center.GetMetaProfileRequest
func (_e *ConfigCenterServiceServer_Expecter) GetMetaProfile(context1 interface{}, getMetaProfileRequest interface{}) *ConfigCenterServiceServer_GetMetaProfile_Call {
	return &ConfigCenterServiceServer_GetMetaProfile_Call{Call: _e.mock.On("GetMetaProfile", context1, getMetaProfileRequest)}
}

func (_c *ConfigCenterServiceServer_GetMetaProfile_Call) Run(run func(context1 context.Context, getMetaProfileRequest *config_center.GetMetaProfileRequest)) *ConfigCenterServiceServer_GetMetaProfile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetMetaProfileRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetMetaProfileRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_GetMetaProfile_Call) Return(metaProfile *config_center.MetaProfile, err error) *ConfigCenterServiceServer_GetMetaProfile_Call {
	_c.Call.Return(metaProfile, err)
	return _c
}

func (_c *ConfigCenterServiceServer_GetMetaProfile_Call) RunAndReturn(run func(context1 context.Context, getMetaProfileRequest *config_center.GetMetaProfileRequest) (*config_center.MetaProfile, error)) *ConfigCenterServiceServer_GetMetaProfile_Call {
	_c.Call.Return(run)
	return _c
}

// GetRegionalServer provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) GetRegionalServer(context1 context.Context, getRegionalServerRequest *config_center.GetRegionalServerRequest) (*config_center.RegionalServer, error) {
	ret := _mock.Called(context1, getRegionalServerRequest)

	if len(ret) == 0 {
		panic("no return value specified for GetRegionalServer")
	}

	var r0 *config_center.RegionalServer
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetRegionalServerRequest) (*config_center.RegionalServer, error)); ok {
		return returnFunc(context1, getRegionalServerRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetRegionalServerRequest) *config_center.RegionalServer); ok {
		r0 = returnFunc(context1, getRegionalServerRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.RegionalServer)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetRegionalServerRequest) error); ok {
		r1 = returnFunc(context1, getRegionalServerRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_GetRegionalServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRegionalServer'
type ConfigCenterServiceServer_GetRegionalServer_Call struct {
	*mock.Call
}

// GetRegionalServer is a helper method to define mock.On call
//   - context1 context.Context
//   - getRegionalServerRequest *config_center.GetRegionalServerRequest
func (_e *ConfigCenterServiceServer_Expecter) GetRegionalServer(context1 interface{}, getRegionalServerRequest interface{}) *ConfigCenterServiceServer_GetRegionalServer_Call {
	return &ConfigCenterServiceServer_GetRegionalServer_Call{Call: _e.mock.On("GetRegionalServer", context1, getRegionalServerRequest)}
}

func (_c *ConfigCenterServiceServer_GetRegionalServer_Call) Run(run func(context1 context.Context, getRegionalServerRequest *config_center.GetRegionalServerRequest)) *ConfigCenterServiceServer_GetRegionalServer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetRegionalServerRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetRegionalServerRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_GetRegionalServer_Call) Return(regionalServer *config_center.RegionalServer, err error) *ConfigCenterServiceServer_GetRegionalServer_Call {
	_c.Call.Return(regionalServer, err)
	return _c
}

func (_c *ConfigCenterServiceServer_GetRegionalServer_Call) RunAndReturn(run func(context1 context.Context, getRegionalServerRequest *config_center.GetRegionalServerRequest) (*config_center.RegionalServer, error)) *ConfigCenterServiceServer_GetRegionalServer_Call {
	_c.Call.Return(run)
	return _c
}

// GetTemplateUsage provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) GetTemplateUsage(context1 context.Context, getTemplateUsageRequest *config_center.GetTemplateUsageRequest) (*config_center.TemplateUsage, error) {
	ret := _mock.Called(context1, getTemplateUsageRequest)

	if len(ret) == 0 {
		panic("no return value specified for GetTemplateUsage")
	}

	var r0 *config_center.TemplateUsage
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetTemplateUsageRequest) (*config_center.TemplateUsage, error)); ok {
		return returnFunc(context1, getTemplateUsageRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetTemplateUsageRequest) *config_center.TemplateUsage); ok {
		r0 = returnFunc(context1, getTemplateUsageRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.TemplateUsage)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetTemplateUsageRequest) error); ok {
		r1 = returnFunc(context1, getTemplateUsageRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_GetTemplateUsage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTemplateUsage'
type ConfigCenterServiceServer_GetTemplateUsage_Call struct {
	*mock.Call
}

// GetTemplateUsage is a helper method to define mock.On call
//   - context1 context.Context
//   - getTemplateUsageRequest *config_center.GetTemplateUsageRequest
func (_e *ConfigCenterServiceServer_Expecter) GetTemplateUsage(context1 interface{}, getTemplateUsageRequest interface{}) *ConfigCenterServiceServer_GetTemplateUsage_Call {
	return &ConfigCenterServiceServer_GetTemplateUsage_Call{Call: _e.mock.On("GetTemplateUsage", context1, getTemplateUsageRequest)}
}

func (_c *ConfigCenterServiceServer_GetTemplateUsage_Call) Run(run func(context1 context.Context, getTemplateUsageRequest *config_center.GetTemplateUsageRequest)) *ConfigCenterServiceServer_GetTemplateUsage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetTemplateUsageRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetTemplateUsageRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_GetTemplateUsage_Call) Return(templateUsage *config_center.TemplateUsage, err error) *ConfigCenterServiceServer_GetTemplateUsage_Call {
	_c.Call.Return(templateUsage, err)
	return _c
}

func (_c *ConfigCenterServiceServer_GetTemplateUsage_Call) RunAndReturn(run func(context1 context.Context, getTemplateUsageRequest *config_center.GetTemplateUsageRequest) (*config_center.TemplateUsage, error)) *ConfigCenterServiceServer_GetTemplateUsage_Call {
	_c.Call.Return(run)
	return _c
}

// GetTenantInitialCustomParams provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) GetTenantInitialCustomParams(context1 context.Context, getTenantInitialCustomParamsRequest *config_center.GetTenantInitialCustomParamsRequest) (*config_center.TenantInitialCustomPatams, error) {
	ret := _mock.Called(context1, getTenantInitialCustomParamsRequest)

	if len(ret) == 0 {
		panic("no return value specified for GetTenantInitialCustomParams")
	}

	var r0 *config_center.TenantInitialCustomPatams
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetTenantInitialCustomParamsRequest) (*config_center.TenantInitialCustomPatams, error)); ok {
		return returnFunc(context1, getTenantInitialCustomParamsRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.GetTenantInitialCustomParamsRequest) *config_center.TenantInitialCustomPatams); ok {
		r0 = returnFunc(context1, getTenantInitialCustomParamsRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.TenantInitialCustomPatams)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.GetTenantInitialCustomParamsRequest) error); ok {
		r1 = returnFunc(context1, getTenantInitialCustomParamsRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_GetTenantInitialCustomParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTenantInitialCustomParams'
type ConfigCenterServiceServer_GetTenantInitialCustomParams_Call struct {
	*mock.Call
}

// GetTenantInitialCustomParams is a helper method to define mock.On call
//   - context1 context.Context
//   - getTenantInitialCustomParamsRequest *config_center.GetTenantInitialCustomParamsRequest
func (_e *ConfigCenterServiceServer_Expecter) GetTenantInitialCustomParams(context1 interface{}, getTenantInitialCustomParamsRequest interface{}) *ConfigCenterServiceServer_GetTenantInitialCustomParams_Call {
	return &ConfigCenterServiceServer_GetTenantInitialCustomParams_Call{Call: _e.mock.On("GetTenantInitialCustomParams", context1, getTenantInitialCustomParamsRequest)}
}

func (_c *ConfigCenterServiceServer_GetTenantInitialCustomParams_Call) Run(run func(context1 context.Context, getTenantInitialCustomParamsRequest *config_center.GetTenantInitialCustomParamsRequest)) *ConfigCenterServiceServer_GetTenantInitialCustomParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.GetTenantInitialCustomParamsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.GetTenantInitialCustomParamsRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_GetTenantInitialCustomParams_Call) Return(tenantInitialCustomPatams *config_center.TenantInitialCustomPatams, err error) *ConfigCenterServiceServer_GetTenantInitialCustomParams_Call {
	_c.Call.Return(tenantInitialCustomPatams, err)
	return _c
}

func (_c *ConfigCenterServiceServer_GetTenantInitialCustomParams_Call) RunAndReturn(run func(context1 context.Context, getTenantInitialCustomParamsRequest *config_center.GetTenantInitialCustomParamsRequest) (*config_center.TenantInitialCustomPatams, error)) *ConfigCenterServiceServer_GetTenantInitialCustomParams_Call {
	_c.Call.Return(run)
	return _c
}

// InitClusterMeta provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) InitClusterMeta(context1 context.Context, initClusterMetaRequest *config_center.InitClusterMetaRequest) (*config_center.ClusterMeta, error) {
	ret := _mock.Called(context1, initClusterMetaRequest)

	if len(ret) == 0 {
		panic("no return value specified for InitClusterMeta")
	}

	var r0 *config_center.ClusterMeta
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.InitClusterMetaRequest) (*config_center.ClusterMeta, error)); ok {
		return returnFunc(context1, initClusterMetaRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.InitClusterMetaRequest) *config_center.ClusterMeta); ok {
		r0 = returnFunc(context1, initClusterMetaRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ClusterMeta)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.InitClusterMetaRequest) error); ok {
		r1 = returnFunc(context1, initClusterMetaRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_InitClusterMeta_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InitClusterMeta'
type ConfigCenterServiceServer_InitClusterMeta_Call struct {
	*mock.Call
}

// InitClusterMeta is a helper method to define mock.On call
//   - context1 context.Context
//   - initClusterMetaRequest *config_center.InitClusterMetaRequest
func (_e *ConfigCenterServiceServer_Expecter) InitClusterMeta(context1 interface{}, initClusterMetaRequest interface{}) *ConfigCenterServiceServer_InitClusterMeta_Call {
	return &ConfigCenterServiceServer_InitClusterMeta_Call{Call: _e.mock.On("InitClusterMeta", context1, initClusterMetaRequest)}
}

func (_c *ConfigCenterServiceServer_InitClusterMeta_Call) Run(run func(context1 context.Context, initClusterMetaRequest *config_center.InitClusterMetaRequest)) *ConfigCenterServiceServer_InitClusterMeta_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.InitClusterMetaRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.InitClusterMetaRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_InitClusterMeta_Call) Return(clusterMeta *config_center.ClusterMeta, err error) *ConfigCenterServiceServer_InitClusterMeta_Call {
	_c.Call.Return(clusterMeta, err)
	return _c
}

func (_c *ConfigCenterServiceServer_InitClusterMeta_Call) RunAndReturn(run func(context1 context.Context, initClusterMetaRequest *config_center.InitClusterMetaRequest) (*config_center.ClusterMeta, error)) *ConfigCenterServiceServer_InitClusterMeta_Call {
	_c.Call.Return(run)
	return _c
}

// ListAvailableInstances provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) ListAvailableInstances(context1 context.Context, listAvailableInstancesRequest *config_center.ListAvailableInstancesRequest) (*config_center.ListAvailableInstancesResponse, error) {
	ret := _mock.Called(context1, listAvailableInstancesRequest)

	if len(ret) == 0 {
		panic("no return value specified for ListAvailableInstances")
	}

	var r0 *config_center.ListAvailableInstancesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListAvailableInstancesRequest) (*config_center.ListAvailableInstancesResponse, error)); ok {
		return returnFunc(context1, listAvailableInstancesRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListAvailableInstancesRequest) *config_center.ListAvailableInstancesResponse); ok {
		r0 = returnFunc(context1, listAvailableInstancesRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListAvailableInstancesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListAvailableInstancesRequest) error); ok {
		r1 = returnFunc(context1, listAvailableInstancesRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_ListAvailableInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAvailableInstances'
type ConfigCenterServiceServer_ListAvailableInstances_Call struct {
	*mock.Call
}

// ListAvailableInstances is a helper method to define mock.On call
//   - context1 context.Context
//   - listAvailableInstancesRequest *config_center.ListAvailableInstancesRequest
func (_e *ConfigCenterServiceServer_Expecter) ListAvailableInstances(context1 interface{}, listAvailableInstancesRequest interface{}) *ConfigCenterServiceServer_ListAvailableInstances_Call {
	return &ConfigCenterServiceServer_ListAvailableInstances_Call{Call: _e.mock.On("ListAvailableInstances", context1, listAvailableInstancesRequest)}
}

func (_c *ConfigCenterServiceServer_ListAvailableInstances_Call) Run(run func(context1 context.Context, listAvailableInstancesRequest *config_center.ListAvailableInstancesRequest)) *ConfigCenterServiceServer_ListAvailableInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListAvailableInstancesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListAvailableInstancesRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_ListAvailableInstances_Call) Return(listAvailableInstancesResponse *config_center.ListAvailableInstancesResponse, err error) *ConfigCenterServiceServer_ListAvailableInstances_Call {
	_c.Call.Return(listAvailableInstancesResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_ListAvailableInstances_Call) RunAndReturn(run func(context1 context.Context, listAvailableInstancesRequest *config_center.ListAvailableInstancesRequest) (*config_center.ListAvailableInstancesResponse, error)) *ConfigCenterServiceServer_ListAvailableInstances_Call {
	_c.Call.Return(run)
	return _c
}

// ListAvailableVersions provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) ListAvailableVersions(context1 context.Context, listAvailableVersionsRequest *config_center.ListAvailableVersionsRequest) (*config_center.ListAvailableVersionsResponse, error) {
	ret := _mock.Called(context1, listAvailableVersionsRequest)

	if len(ret) == 0 {
		panic("no return value specified for ListAvailableVersions")
	}

	var r0 *config_center.ListAvailableVersionsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListAvailableVersionsRequest) (*config_center.ListAvailableVersionsResponse, error)); ok {
		return returnFunc(context1, listAvailableVersionsRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListAvailableVersionsRequest) *config_center.ListAvailableVersionsResponse); ok {
		r0 = returnFunc(context1, listAvailableVersionsRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListAvailableVersionsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListAvailableVersionsRequest) error); ok {
		r1 = returnFunc(context1, listAvailableVersionsRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_ListAvailableVersions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAvailableVersions'
type ConfigCenterServiceServer_ListAvailableVersions_Call struct {
	*mock.Call
}

// ListAvailableVersions is a helper method to define mock.On call
//   - context1 context.Context
//   - listAvailableVersionsRequest *config_center.ListAvailableVersionsRequest
func (_e *ConfigCenterServiceServer_Expecter) ListAvailableVersions(context1 interface{}, listAvailableVersionsRequest interface{}) *ConfigCenterServiceServer_ListAvailableVersions_Call {
	return &ConfigCenterServiceServer_ListAvailableVersions_Call{Call: _e.mock.On("ListAvailableVersions", context1, listAvailableVersionsRequest)}
}

func (_c *ConfigCenterServiceServer_ListAvailableVersions_Call) Run(run func(context1 context.Context, listAvailableVersionsRequest *config_center.ListAvailableVersionsRequest)) *ConfigCenterServiceServer_ListAvailableVersions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListAvailableVersionsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListAvailableVersionsRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_ListAvailableVersions_Call) Return(listAvailableVersionsResponse *config_center.ListAvailableVersionsResponse, err error) *ConfigCenterServiceServer_ListAvailableVersions_Call {
	_c.Call.Return(listAvailableVersionsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_ListAvailableVersions_Call) RunAndReturn(run func(context1 context.Context, listAvailableVersionsRequest *config_center.ListAvailableVersionsRequest) (*config_center.ListAvailableVersionsResponse, error)) *ConfigCenterServiceServer_ListAvailableVersions_Call {
	_c.Call.Return(run)
	return _c
}

// ListClusterComponents provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) ListClusterComponents(context1 context.Context, listClusterComponentsRequest *config_center.ListClusterComponentsRequest) (*config_center.ListClusterComponentsResponse, error) {
	ret := _mock.Called(context1, listClusterComponentsRequest)

	if len(ret) == 0 {
		panic("no return value specified for ListClusterComponents")
	}

	var r0 *config_center.ListClusterComponentsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListClusterComponentsRequest) (*config_center.ListClusterComponentsResponse, error)); ok {
		return returnFunc(context1, listClusterComponentsRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListClusterComponentsRequest) *config_center.ListClusterComponentsResponse); ok {
		r0 = returnFunc(context1, listClusterComponentsRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListClusterComponentsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListClusterComponentsRequest) error); ok {
		r1 = returnFunc(context1, listClusterComponentsRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_ListClusterComponents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClusterComponents'
type ConfigCenterServiceServer_ListClusterComponents_Call struct {
	*mock.Call
}

// ListClusterComponents is a helper method to define mock.On call
//   - context1 context.Context
//   - listClusterComponentsRequest *config_center.ListClusterComponentsRequest
func (_e *ConfigCenterServiceServer_Expecter) ListClusterComponents(context1 interface{}, listClusterComponentsRequest interface{}) *ConfigCenterServiceServer_ListClusterComponents_Call {
	return &ConfigCenterServiceServer_ListClusterComponents_Call{Call: _e.mock.On("ListClusterComponents", context1, listClusterComponentsRequest)}
}

func (_c *ConfigCenterServiceServer_ListClusterComponents_Call) Run(run func(context1 context.Context, listClusterComponentsRequest *config_center.ListClusterComponentsRequest)) *ConfigCenterServiceServer_ListClusterComponents_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListClusterComponentsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListClusterComponentsRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_ListClusterComponents_Call) Return(listClusterComponentsResponse *config_center.ListClusterComponentsResponse, err error) *ConfigCenterServiceServer_ListClusterComponents_Call {
	_c.Call.Return(listClusterComponentsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_ListClusterComponents_Call) RunAndReturn(run func(context1 context.Context, listClusterComponentsRequest *config_center.ListClusterComponentsRequest) (*config_center.ListClusterComponentsResponse, error)) *ConfigCenterServiceServer_ListClusterComponents_Call {
	_c.Call.Return(run)
	return _c
}

// ListClusterConfigurationFiles provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) ListClusterConfigurationFiles(context1 context.Context, listClusterConfigurationFilesRequest *config_center.ListClusterConfigurationFilesRequest) (*config_center.ListClusterConfigurationFilesResponse, error) {
	ret := _mock.Called(context1, listClusterConfigurationFilesRequest)

	if len(ret) == 0 {
		panic("no return value specified for ListClusterConfigurationFiles")
	}

	var r0 *config_center.ListClusterConfigurationFilesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListClusterConfigurationFilesRequest) (*config_center.ListClusterConfigurationFilesResponse, error)); ok {
		return returnFunc(context1, listClusterConfigurationFilesRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListClusterConfigurationFilesRequest) *config_center.ListClusterConfigurationFilesResponse); ok {
		r0 = returnFunc(context1, listClusterConfigurationFilesRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListClusterConfigurationFilesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListClusterConfigurationFilesRequest) error); ok {
		r1 = returnFunc(context1, listClusterConfigurationFilesRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_ListClusterConfigurationFiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClusterConfigurationFiles'
type ConfigCenterServiceServer_ListClusterConfigurationFiles_Call struct {
	*mock.Call
}

// ListClusterConfigurationFiles is a helper method to define mock.On call
//   - context1 context.Context
//   - listClusterConfigurationFilesRequest *config_center.ListClusterConfigurationFilesRequest
func (_e *ConfigCenterServiceServer_Expecter) ListClusterConfigurationFiles(context1 interface{}, listClusterConfigurationFilesRequest interface{}) *ConfigCenterServiceServer_ListClusterConfigurationFiles_Call {
	return &ConfigCenterServiceServer_ListClusterConfigurationFiles_Call{Call: _e.mock.On("ListClusterConfigurationFiles", context1, listClusterConfigurationFilesRequest)}
}

func (_c *ConfigCenterServiceServer_ListClusterConfigurationFiles_Call) Run(run func(context1 context.Context, listClusterConfigurationFilesRequest *config_center.ListClusterConfigurationFilesRequest)) *ConfigCenterServiceServer_ListClusterConfigurationFiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListClusterConfigurationFilesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListClusterConfigurationFilesRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_ListClusterConfigurationFiles_Call) Return(listClusterConfigurationFilesResponse *config_center.ListClusterConfigurationFilesResponse, err error) *ConfigCenterServiceServer_ListClusterConfigurationFiles_Call {
	_c.Call.Return(listClusterConfigurationFilesResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_ListClusterConfigurationFiles_Call) RunAndReturn(run func(context1 context.Context, listClusterConfigurationFilesRequest *config_center.ListClusterConfigurationFilesRequest) (*config_center.ListClusterConfigurationFilesResponse, error)) *ConfigCenterServiceServer_ListClusterConfigurationFiles_Call {
	_c.Call.Return(run)
	return _c
}

// ListComponentImages provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) ListComponentImages(context1 context.Context, listComponentImagesRequest *config_center.ListComponentImagesRequest) (*config_center.ListComponentImagesResponse, error) {
	ret := _mock.Called(context1, listComponentImagesRequest)

	if len(ret) == 0 {
		panic("no return value specified for ListComponentImages")
	}

	var r0 *config_center.ListComponentImagesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListComponentImagesRequest) (*config_center.ListComponentImagesResponse, error)); ok {
		return returnFunc(context1, listComponentImagesRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListComponentImagesRequest) *config_center.ListComponentImagesResponse); ok {
		r0 = returnFunc(context1, listComponentImagesRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListComponentImagesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListComponentImagesRequest) error); ok {
		r1 = returnFunc(context1, listComponentImagesRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_ListComponentImages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListComponentImages'
type ConfigCenterServiceServer_ListComponentImages_Call struct {
	*mock.Call
}

// ListComponentImages is a helper method to define mock.On call
//   - context1 context.Context
//   - listComponentImagesRequest *config_center.ListComponentImagesRequest
func (_e *ConfigCenterServiceServer_Expecter) ListComponentImages(context1 interface{}, listComponentImagesRequest interface{}) *ConfigCenterServiceServer_ListComponentImages_Call {
	return &ConfigCenterServiceServer_ListComponentImages_Call{Call: _e.mock.On("ListComponentImages", context1, listComponentImagesRequest)}
}

func (_c *ConfigCenterServiceServer_ListComponentImages_Call) Run(run func(context1 context.Context, listComponentImagesRequest *config_center.ListComponentImagesRequest)) *ConfigCenterServiceServer_ListComponentImages_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListComponentImagesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListComponentImagesRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_ListComponentImages_Call) Return(listComponentImagesResponse *config_center.ListComponentImagesResponse, err error) *ConfigCenterServiceServer_ListComponentImages_Call {
	_c.Call.Return(listComponentImagesResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_ListComponentImages_Call) RunAndReturn(run func(context1 context.Context, listComponentImagesRequest *config_center.ListComponentImagesRequest) (*config_center.ListComponentImagesResponse, error)) *ConfigCenterServiceServer_ListComponentImages_Call {
	_c.Call.Return(run)
	return _c
}

// ListConfigurationDictItems provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) ListConfigurationDictItems(context1 context.Context, listConfigurationDictItemsRequest *config_center.ListConfigurationDictItemsRequest) (*config_center.ListConfigurationDictItemsResponse, error) {
	ret := _mock.Called(context1, listConfigurationDictItemsRequest)

	if len(ret) == 0 {
		panic("no return value specified for ListConfigurationDictItems")
	}

	var r0 *config_center.ListConfigurationDictItemsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListConfigurationDictItemsRequest) (*config_center.ListConfigurationDictItemsResponse, error)); ok {
		return returnFunc(context1, listConfigurationDictItemsRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListConfigurationDictItemsRequest) *config_center.ListConfigurationDictItemsResponse); ok {
		r0 = returnFunc(context1, listConfigurationDictItemsRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListConfigurationDictItemsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListConfigurationDictItemsRequest) error); ok {
		r1 = returnFunc(context1, listConfigurationDictItemsRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_ListConfigurationDictItems_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListConfigurationDictItems'
type ConfigCenterServiceServer_ListConfigurationDictItems_Call struct {
	*mock.Call
}

// ListConfigurationDictItems is a helper method to define mock.On call
//   - context1 context.Context
//   - listConfigurationDictItemsRequest *config_center.ListConfigurationDictItemsRequest
func (_e *ConfigCenterServiceServer_Expecter) ListConfigurationDictItems(context1 interface{}, listConfigurationDictItemsRequest interface{}) *ConfigCenterServiceServer_ListConfigurationDictItems_Call {
	return &ConfigCenterServiceServer_ListConfigurationDictItems_Call{Call: _e.mock.On("ListConfigurationDictItems", context1, listConfigurationDictItemsRequest)}
}

func (_c *ConfigCenterServiceServer_ListConfigurationDictItems_Call) Run(run func(context1 context.Context, listConfigurationDictItemsRequest *config_center.ListConfigurationDictItemsRequest)) *ConfigCenterServiceServer_ListConfigurationDictItems_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListConfigurationDictItemsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListConfigurationDictItemsRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_ListConfigurationDictItems_Call) Return(listConfigurationDictItemsResponse *config_center.ListConfigurationDictItemsResponse, err error) *ConfigCenterServiceServer_ListConfigurationDictItems_Call {
	_c.Call.Return(listConfigurationDictItemsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_ListConfigurationDictItems_Call) RunAndReturn(run func(context1 context.Context, listConfigurationDictItemsRequest *config_center.ListConfigurationDictItemsRequest) (*config_center.ListConfigurationDictItemsResponse, error)) *ConfigCenterServiceServer_ListConfigurationDictItems_Call {
	_c.Call.Return(run)
	return _c
}

// ListConfigurationDictVersions provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) ListConfigurationDictVersions(context1 context.Context, listConfigurationDictVersionsRequest *config_center.ListConfigurationDictVersionsRequest) (*config_center.ListConfigurationDictVersionsResponse, error) {
	ret := _mock.Called(context1, listConfigurationDictVersionsRequest)

	if len(ret) == 0 {
		panic("no return value specified for ListConfigurationDictVersions")
	}

	var r0 *config_center.ListConfigurationDictVersionsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListConfigurationDictVersionsRequest) (*config_center.ListConfigurationDictVersionsResponse, error)); ok {
		return returnFunc(context1, listConfigurationDictVersionsRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListConfigurationDictVersionsRequest) *config_center.ListConfigurationDictVersionsResponse); ok {
		r0 = returnFunc(context1, listConfigurationDictVersionsRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListConfigurationDictVersionsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListConfigurationDictVersionsRequest) error); ok {
		r1 = returnFunc(context1, listConfigurationDictVersionsRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_ListConfigurationDictVersions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListConfigurationDictVersions'
type ConfigCenterServiceServer_ListConfigurationDictVersions_Call struct {
	*mock.Call
}

// ListConfigurationDictVersions is a helper method to define mock.On call
//   - context1 context.Context
//   - listConfigurationDictVersionsRequest *config_center.ListConfigurationDictVersionsRequest
func (_e *ConfigCenterServiceServer_Expecter) ListConfigurationDictVersions(context1 interface{}, listConfigurationDictVersionsRequest interface{}) *ConfigCenterServiceServer_ListConfigurationDictVersions_Call {
	return &ConfigCenterServiceServer_ListConfigurationDictVersions_Call{Call: _e.mock.On("ListConfigurationDictVersions", context1, listConfigurationDictVersionsRequest)}
}

func (_c *ConfigCenterServiceServer_ListConfigurationDictVersions_Call) Run(run func(context1 context.Context, listConfigurationDictVersionsRequest *config_center.ListConfigurationDictVersionsRequest)) *ConfigCenterServiceServer_ListConfigurationDictVersions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListConfigurationDictVersionsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListConfigurationDictVersionsRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_ListConfigurationDictVersions_Call) Return(listConfigurationDictVersionsResponse *config_center.ListConfigurationDictVersionsResponse, err error) *ConfigCenterServiceServer_ListConfigurationDictVersions_Call {
	_c.Call.Return(listConfigurationDictVersionsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_ListConfigurationDictVersions_Call) RunAndReturn(run func(context1 context.Context, listConfigurationDictVersionsRequest *config_center.ListConfigurationDictVersionsRequest) (*config_center.ListConfigurationDictVersionsResponse, error)) *ConfigCenterServiceServer_ListConfigurationDictVersions_Call {
	_c.Call.Return(run)
	return _c
}

// ListConfigurationTemplateDefaultCaseBindings provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) ListConfigurationTemplateDefaultCaseBindings(context1 context.Context, listConfigurationTemplateDefaultCaseBindingsRequest *config_center.ListConfigurationTemplateDefaultCaseBindingsRequest) (*config_center.ListConfigurationTemplateDefaultCaseBindingsResponse, error) {
	ret := _mock.Called(context1, listConfigurationTemplateDefaultCaseBindingsRequest)

	if len(ret) == 0 {
		panic("no return value specified for ListConfigurationTemplateDefaultCaseBindings")
	}

	var r0 *config_center.ListConfigurationTemplateDefaultCaseBindingsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListConfigurationTemplateDefaultCaseBindingsRequest) (*config_center.ListConfigurationTemplateDefaultCaseBindingsResponse, error)); ok {
		return returnFunc(context1, listConfigurationTemplateDefaultCaseBindingsRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListConfigurationTemplateDefaultCaseBindingsRequest) *config_center.ListConfigurationTemplateDefaultCaseBindingsResponse); ok {
		r0 = returnFunc(context1, listConfigurationTemplateDefaultCaseBindingsRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListConfigurationTemplateDefaultCaseBindingsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListConfigurationTemplateDefaultCaseBindingsRequest) error); ok {
		r1 = returnFunc(context1, listConfigurationTemplateDefaultCaseBindingsRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_ListConfigurationTemplateDefaultCaseBindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListConfigurationTemplateDefaultCaseBindings'
type ConfigCenterServiceServer_ListConfigurationTemplateDefaultCaseBindings_Call struct {
	*mock.Call
}

// ListConfigurationTemplateDefaultCaseBindings is a helper method to define mock.On call
//   - context1 context.Context
//   - listConfigurationTemplateDefaultCaseBindingsRequest *config_center.ListConfigurationTemplateDefaultCaseBindingsRequest
func (_e *ConfigCenterServiceServer_Expecter) ListConfigurationTemplateDefaultCaseBindings(context1 interface{}, listConfigurationTemplateDefaultCaseBindingsRequest interface{}) *ConfigCenterServiceServer_ListConfigurationTemplateDefaultCaseBindings_Call {
	return &ConfigCenterServiceServer_ListConfigurationTemplateDefaultCaseBindings_Call{Call: _e.mock.On("ListConfigurationTemplateDefaultCaseBindings", context1, listConfigurationTemplateDefaultCaseBindingsRequest)}
}

func (_c *ConfigCenterServiceServer_ListConfigurationTemplateDefaultCaseBindings_Call) Run(run func(context1 context.Context, listConfigurationTemplateDefaultCaseBindingsRequest *config_center.ListConfigurationTemplateDefaultCaseBindingsRequest)) *ConfigCenterServiceServer_ListConfigurationTemplateDefaultCaseBindings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListConfigurationTemplateDefaultCaseBindingsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListConfigurationTemplateDefaultCaseBindingsRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_ListConfigurationTemplateDefaultCaseBindings_Call) Return(listConfigurationTemplateDefaultCaseBindingsResponse *config_center.ListConfigurationTemplateDefaultCaseBindingsResponse, err error) *ConfigCenterServiceServer_ListConfigurationTemplateDefaultCaseBindings_Call {
	_c.Call.Return(listConfigurationTemplateDefaultCaseBindingsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_ListConfigurationTemplateDefaultCaseBindings_Call) RunAndReturn(run func(context1 context.Context, listConfigurationTemplateDefaultCaseBindingsRequest *config_center.ListConfigurationTemplateDefaultCaseBindingsRequest) (*config_center.ListConfigurationTemplateDefaultCaseBindingsResponse, error)) *ConfigCenterServiceServer_ListConfigurationTemplateDefaultCaseBindings_Call {
	_c.Call.Return(run)
	return _c
}

// ListConfigurationTemplates provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) ListConfigurationTemplates(context1 context.Context, listConfigurationTemplatesRequest *config_center.ListConfigurationTemplatesRequest) (*config_center.ListConfigurationTemplatesResponse, error) {
	ret := _mock.Called(context1, listConfigurationTemplatesRequest)

	if len(ret) == 0 {
		panic("no return value specified for ListConfigurationTemplates")
	}

	var r0 *config_center.ListConfigurationTemplatesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListConfigurationTemplatesRequest) (*config_center.ListConfigurationTemplatesResponse, error)); ok {
		return returnFunc(context1, listConfigurationTemplatesRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListConfigurationTemplatesRequest) *config_center.ListConfigurationTemplatesResponse); ok {
		r0 = returnFunc(context1, listConfigurationTemplatesRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListConfigurationTemplatesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListConfigurationTemplatesRequest) error); ok {
		r1 = returnFunc(context1, listConfigurationTemplatesRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_ListConfigurationTemplates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListConfigurationTemplates'
type ConfigCenterServiceServer_ListConfigurationTemplates_Call struct {
	*mock.Call
}

// ListConfigurationTemplates is a helper method to define mock.On call
//   - context1 context.Context
//   - listConfigurationTemplatesRequest *config_center.ListConfigurationTemplatesRequest
func (_e *ConfigCenterServiceServer_Expecter) ListConfigurationTemplates(context1 interface{}, listConfigurationTemplatesRequest interface{}) *ConfigCenterServiceServer_ListConfigurationTemplates_Call {
	return &ConfigCenterServiceServer_ListConfigurationTemplates_Call{Call: _e.mock.On("ListConfigurationTemplates", context1, listConfigurationTemplatesRequest)}
}

func (_c *ConfigCenterServiceServer_ListConfigurationTemplates_Call) Run(run func(context1 context.Context, listConfigurationTemplatesRequest *config_center.ListConfigurationTemplatesRequest)) *ConfigCenterServiceServer_ListConfigurationTemplates_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListConfigurationTemplatesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListConfigurationTemplatesRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_ListConfigurationTemplates_Call) Return(listConfigurationTemplatesResponse *config_center.ListConfigurationTemplatesResponse, err error) *ConfigCenterServiceServer_ListConfigurationTemplates_Call {
	_c.Call.Return(listConfigurationTemplatesResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_ListConfigurationTemplates_Call) RunAndReturn(run func(context1 context.Context, listConfigurationTemplatesRequest *config_center.ListConfigurationTemplatesRequest) (*config_center.ListConfigurationTemplatesResponse, error)) *ConfigCenterServiceServer_ListConfigurationTemplates_Call {
	_c.Call.Return(run)
	return _c
}

// ListDefaultVersionRules provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) ListDefaultVersionRules(context1 context.Context, listDefaultVersionRulesRequest *config_center.ListDefaultVersionRulesRequest) (*config_center.ListDefaultVersionRulesResponse, error) {
	ret := _mock.Called(context1, listDefaultVersionRulesRequest)

	if len(ret) == 0 {
		panic("no return value specified for ListDefaultVersionRules")
	}

	var r0 *config_center.ListDefaultVersionRulesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListDefaultVersionRulesRequest) (*config_center.ListDefaultVersionRulesResponse, error)); ok {
		return returnFunc(context1, listDefaultVersionRulesRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListDefaultVersionRulesRequest) *config_center.ListDefaultVersionRulesResponse); ok {
		r0 = returnFunc(context1, listDefaultVersionRulesRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListDefaultVersionRulesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListDefaultVersionRulesRequest) error); ok {
		r1 = returnFunc(context1, listDefaultVersionRulesRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_ListDefaultVersionRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDefaultVersionRules'
type ConfigCenterServiceServer_ListDefaultVersionRules_Call struct {
	*mock.Call
}

// ListDefaultVersionRules is a helper method to define mock.On call
//   - context1 context.Context
//   - listDefaultVersionRulesRequest *config_center.ListDefaultVersionRulesRequest
func (_e *ConfigCenterServiceServer_Expecter) ListDefaultVersionRules(context1 interface{}, listDefaultVersionRulesRequest interface{}) *ConfigCenterServiceServer_ListDefaultVersionRules_Call {
	return &ConfigCenterServiceServer_ListDefaultVersionRules_Call{Call: _e.mock.On("ListDefaultVersionRules", context1, listDefaultVersionRulesRequest)}
}

func (_c *ConfigCenterServiceServer_ListDefaultVersionRules_Call) Run(run func(context1 context.Context, listDefaultVersionRulesRequest *config_center.ListDefaultVersionRulesRequest)) *ConfigCenterServiceServer_ListDefaultVersionRules_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListDefaultVersionRulesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListDefaultVersionRulesRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_ListDefaultVersionRules_Call) Return(listDefaultVersionRulesResponse *config_center.ListDefaultVersionRulesResponse, err error) *ConfigCenterServiceServer_ListDefaultVersionRules_Call {
	_c.Call.Return(listDefaultVersionRulesResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_ListDefaultVersionRules_Call) RunAndReturn(run func(context1 context.Context, listDefaultVersionRulesRequest *config_center.ListDefaultVersionRulesRequest) (*config_center.ListDefaultVersionRulesResponse, error)) *ConfigCenterServiceServer_ListDefaultVersionRules_Call {
	_c.Call.Return(run)
	return _c
}

// ListMetaProfiles provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) ListMetaProfiles(context1 context.Context, listMetaProfilesRequest *config_center.ListMetaProfilesRequest) (*config_center.ListMetaProfilesResponse, error) {
	ret := _mock.Called(context1, listMetaProfilesRequest)

	if len(ret) == 0 {
		panic("no return value specified for ListMetaProfiles")
	}

	var r0 *config_center.ListMetaProfilesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListMetaProfilesRequest) (*config_center.ListMetaProfilesResponse, error)); ok {
		return returnFunc(context1, listMetaProfilesRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListMetaProfilesRequest) *config_center.ListMetaProfilesResponse); ok {
		r0 = returnFunc(context1, listMetaProfilesRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListMetaProfilesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListMetaProfilesRequest) error); ok {
		r1 = returnFunc(context1, listMetaProfilesRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_ListMetaProfiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListMetaProfiles'
type ConfigCenterServiceServer_ListMetaProfiles_Call struct {
	*mock.Call
}

// ListMetaProfiles is a helper method to define mock.On call
//   - context1 context.Context
//   - listMetaProfilesRequest *config_center.ListMetaProfilesRequest
func (_e *ConfigCenterServiceServer_Expecter) ListMetaProfiles(context1 interface{}, listMetaProfilesRequest interface{}) *ConfigCenterServiceServer_ListMetaProfiles_Call {
	return &ConfigCenterServiceServer_ListMetaProfiles_Call{Call: _e.mock.On("ListMetaProfiles", context1, listMetaProfilesRequest)}
}

func (_c *ConfigCenterServiceServer_ListMetaProfiles_Call) Run(run func(context1 context.Context, listMetaProfilesRequest *config_center.ListMetaProfilesRequest)) *ConfigCenterServiceServer_ListMetaProfiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListMetaProfilesRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListMetaProfilesRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_ListMetaProfiles_Call) Return(listMetaProfilesResponse *config_center.ListMetaProfilesResponse, err error) *ConfigCenterServiceServer_ListMetaProfiles_Call {
	_c.Call.Return(listMetaProfilesResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_ListMetaProfiles_Call) RunAndReturn(run func(context1 context.Context, listMetaProfilesRequest *config_center.ListMetaProfilesRequest) (*config_center.ListMetaProfilesResponse, error)) *ConfigCenterServiceServer_ListMetaProfiles_Call {
	_c.Call.Return(run)
	return _c
}

// ListRegionalServers provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) ListRegionalServers(context1 context.Context, listRegionalServersRequest *config_center.ListRegionalServersRequest) (*config_center.ListRegionalServersResponse, error) {
	ret := _mock.Called(context1, listRegionalServersRequest)

	if len(ret) == 0 {
		panic("no return value specified for ListRegionalServers")
	}

	var r0 *config_center.ListRegionalServersResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListRegionalServersRequest) (*config_center.ListRegionalServersResponse, error)); ok {
		return returnFunc(context1, listRegionalServersRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListRegionalServersRequest) *config_center.ListRegionalServersResponse); ok {
		r0 = returnFunc(context1, listRegionalServersRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListRegionalServersResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListRegionalServersRequest) error); ok {
		r1 = returnFunc(context1, listRegionalServersRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_ListRegionalServers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRegionalServers'
type ConfigCenterServiceServer_ListRegionalServers_Call struct {
	*mock.Call
}

// ListRegionalServers is a helper method to define mock.On call
//   - context1 context.Context
//   - listRegionalServersRequest *config_center.ListRegionalServersRequest
func (_e *ConfigCenterServiceServer_Expecter) ListRegionalServers(context1 interface{}, listRegionalServersRequest interface{}) *ConfigCenterServiceServer_ListRegionalServers_Call {
	return &ConfigCenterServiceServer_ListRegionalServers_Call{Call: _e.mock.On("ListRegionalServers", context1, listRegionalServersRequest)}
}

func (_c *ConfigCenterServiceServer_ListRegionalServers_Call) Run(run func(context1 context.Context, listRegionalServersRequest *config_center.ListRegionalServersRequest)) *ConfigCenterServiceServer_ListRegionalServers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListRegionalServersRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListRegionalServersRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_ListRegionalServers_Call) Return(listRegionalServersResponse *config_center.ListRegionalServersResponse, err error) *ConfigCenterServiceServer_ListRegionalServers_Call {
	_c.Call.Return(listRegionalServersResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_ListRegionalServers_Call) RunAndReturn(run func(context1 context.Context, listRegionalServersRequest *config_center.ListRegionalServersRequest) (*config_center.ListRegionalServersResponse, error)) *ConfigCenterServiceServer_ListRegionalServers_Call {
	_c.Call.Return(run)
	return _c
}

// ListTenantInitialCustomParams provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) ListTenantInitialCustomParams(context1 context.Context, listTenantInitialCustomParamsRequest *config_center.ListTenantInitialCustomParamsRequest) (*config_center.ListTenantInitialCustomParamsResponse, error) {
	ret := _mock.Called(context1, listTenantInitialCustomParamsRequest)

	if len(ret) == 0 {
		panic("no return value specified for ListTenantInitialCustomParams")
	}

	var r0 *config_center.ListTenantInitialCustomParamsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListTenantInitialCustomParamsRequest) (*config_center.ListTenantInitialCustomParamsResponse, error)); ok {
		return returnFunc(context1, listTenantInitialCustomParamsRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.ListTenantInitialCustomParamsRequest) *config_center.ListTenantInitialCustomParamsResponse); ok {
		r0 = returnFunc(context1, listTenantInitialCustomParamsRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ListTenantInitialCustomParamsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.ListTenantInitialCustomParamsRequest) error); ok {
		r1 = returnFunc(context1, listTenantInitialCustomParamsRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_ListTenantInitialCustomParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTenantInitialCustomParams'
type ConfigCenterServiceServer_ListTenantInitialCustomParams_Call struct {
	*mock.Call
}

// ListTenantInitialCustomParams is a helper method to define mock.On call
//   - context1 context.Context
//   - listTenantInitialCustomParamsRequest *config_center.ListTenantInitialCustomParamsRequest
func (_e *ConfigCenterServiceServer_Expecter) ListTenantInitialCustomParams(context1 interface{}, listTenantInitialCustomParamsRequest interface{}) *ConfigCenterServiceServer_ListTenantInitialCustomParams_Call {
	return &ConfigCenterServiceServer_ListTenantInitialCustomParams_Call{Call: _e.mock.On("ListTenantInitialCustomParams", context1, listTenantInitialCustomParamsRequest)}
}

func (_c *ConfigCenterServiceServer_ListTenantInitialCustomParams_Call) Run(run func(context1 context.Context, listTenantInitialCustomParamsRequest *config_center.ListTenantInitialCustomParamsRequest)) *ConfigCenterServiceServer_ListTenantInitialCustomParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.ListTenantInitialCustomParamsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.ListTenantInitialCustomParamsRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_ListTenantInitialCustomParams_Call) Return(listTenantInitialCustomParamsResponse *config_center.ListTenantInitialCustomParamsResponse, err error) *ConfigCenterServiceServer_ListTenantInitialCustomParams_Call {
	_c.Call.Return(listTenantInitialCustomParamsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_ListTenantInitialCustomParams_Call) RunAndReturn(run func(context1 context.Context, listTenantInitialCustomParamsRequest *config_center.ListTenantInitialCustomParamsRequest) (*config_center.ListTenantInitialCustomParamsResponse, error)) *ConfigCenterServiceServer_ListTenantInitialCustomParams_Call {
	_c.Call.Return(run)
	return _c
}

// OfflineRegionalServer provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) OfflineRegionalServer(context1 context.Context, offlineRegionalServerRequest *config_center.OfflineRegionalServerRequest) (*emptypb.Empty, error) {
	ret := _mock.Called(context1, offlineRegionalServerRequest)

	if len(ret) == 0 {
		panic("no return value specified for OfflineRegionalServer")
	}

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.OfflineRegionalServerRequest) (*emptypb.Empty, error)); ok {
		return returnFunc(context1, offlineRegionalServerRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.OfflineRegionalServerRequest) *emptypb.Empty); ok {
		r0 = returnFunc(context1, offlineRegionalServerRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.OfflineRegionalServerRequest) error); ok {
		r1 = returnFunc(context1, offlineRegionalServerRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_OfflineRegionalServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OfflineRegionalServer'
type ConfigCenterServiceServer_OfflineRegionalServer_Call struct {
	*mock.Call
}

// OfflineRegionalServer is a helper method to define mock.On call
//   - context1 context.Context
//   - offlineRegionalServerRequest *config_center.OfflineRegionalServerRequest
func (_e *ConfigCenterServiceServer_Expecter) OfflineRegionalServer(context1 interface{}, offlineRegionalServerRequest interface{}) *ConfigCenterServiceServer_OfflineRegionalServer_Call {
	return &ConfigCenterServiceServer_OfflineRegionalServer_Call{Call: _e.mock.On("OfflineRegionalServer", context1, offlineRegionalServerRequest)}
}

func (_c *ConfigCenterServiceServer_OfflineRegionalServer_Call) Run(run func(context1 context.Context, offlineRegionalServerRequest *config_center.OfflineRegionalServerRequest)) *ConfigCenterServiceServer_OfflineRegionalServer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.OfflineRegionalServerRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.OfflineRegionalServerRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_OfflineRegionalServer_Call) Return(empty *emptypb.Empty, err error) *ConfigCenterServiceServer_OfflineRegionalServer_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *ConfigCenterServiceServer_OfflineRegionalServer_Call) RunAndReturn(run func(context1 context.Context, offlineRegionalServerRequest *config_center.OfflineRegionalServerRequest) (*emptypb.Empty, error)) *ConfigCenterServiceServer_OfflineRegionalServer_Call {
	_c.Call.Return(run)
	return _c
}

// PurgeDictItems provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) PurgeDictItems(context1 context.Context, purgeDictItemsRequest *config_center.PurgeDictItemsRequest) (*config_center.PurgeDictItemsResponse, error) {
	ret := _mock.Called(context1, purgeDictItemsRequest)

	if len(ret) == 0 {
		panic("no return value specified for PurgeDictItems")
	}

	var r0 *config_center.PurgeDictItemsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.PurgeDictItemsRequest) (*config_center.PurgeDictItemsResponse, error)); ok {
		return returnFunc(context1, purgeDictItemsRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.PurgeDictItemsRequest) *config_center.PurgeDictItemsResponse); ok {
		r0 = returnFunc(context1, purgeDictItemsRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.PurgeDictItemsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.PurgeDictItemsRequest) error); ok {
		r1 = returnFunc(context1, purgeDictItemsRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_PurgeDictItems_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PurgeDictItems'
type ConfigCenterServiceServer_PurgeDictItems_Call struct {
	*mock.Call
}

// PurgeDictItems is a helper method to define mock.On call
//   - context1 context.Context
//   - purgeDictItemsRequest *config_center.PurgeDictItemsRequest
func (_e *ConfigCenterServiceServer_Expecter) PurgeDictItems(context1 interface{}, purgeDictItemsRequest interface{}) *ConfigCenterServiceServer_PurgeDictItems_Call {
	return &ConfigCenterServiceServer_PurgeDictItems_Call{Call: _e.mock.On("PurgeDictItems", context1, purgeDictItemsRequest)}
}

func (_c *ConfigCenterServiceServer_PurgeDictItems_Call) Run(run func(context1 context.Context, purgeDictItemsRequest *config_center.PurgeDictItemsRequest)) *ConfigCenterServiceServer_PurgeDictItems_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.PurgeDictItemsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.PurgeDictItemsRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_PurgeDictItems_Call) Return(purgeDictItemsResponse *config_center.PurgeDictItemsResponse, err error) *ConfigCenterServiceServer_PurgeDictItems_Call {
	_c.Call.Return(purgeDictItemsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_PurgeDictItems_Call) RunAndReturn(run func(context1 context.Context, purgeDictItemsRequest *config_center.PurgeDictItemsRequest) (*config_center.PurgeDictItemsResponse, error)) *ConfigCenterServiceServer_PurgeDictItems_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterRegionalServer provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) RegisterRegionalServer(context1 context.Context, registerRegionalServerRequest *config_center.RegisterRegionalServerRequest) (*config_center.RegionalServer, error) {
	ret := _mock.Called(context1, registerRegionalServerRequest)

	if len(ret) == 0 {
		panic("no return value specified for RegisterRegionalServer")
	}

	var r0 *config_center.RegionalServer
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.RegisterRegionalServerRequest) (*config_center.RegionalServer, error)); ok {
		return returnFunc(context1, registerRegionalServerRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.RegisterRegionalServerRequest) *config_center.RegionalServer); ok {
		r0 = returnFunc(context1, registerRegionalServerRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.RegionalServer)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.RegisterRegionalServerRequest) error); ok {
		r1 = returnFunc(context1, registerRegionalServerRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_RegisterRegionalServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterRegionalServer'
type ConfigCenterServiceServer_RegisterRegionalServer_Call struct {
	*mock.Call
}

// RegisterRegionalServer is a helper method to define mock.On call
//   - context1 context.Context
//   - registerRegionalServerRequest *config_center.RegisterRegionalServerRequest
func (_e *ConfigCenterServiceServer_Expecter) RegisterRegionalServer(context1 interface{}, registerRegionalServerRequest interface{}) *ConfigCenterServiceServer_RegisterRegionalServer_Call {
	return &ConfigCenterServiceServer_RegisterRegionalServer_Call{Call: _e.mock.On("RegisterRegionalServer", context1, registerRegionalServerRequest)}
}

func (_c *ConfigCenterServiceServer_RegisterRegionalServer_Call) Run(run func(context1 context.Context, registerRegionalServerRequest *config_center.RegisterRegionalServerRequest)) *ConfigCenterServiceServer_RegisterRegionalServer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.RegisterRegionalServerRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.RegisterRegionalServerRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_RegisterRegionalServer_Call) Return(regionalServer *config_center.RegionalServer, err error) *ConfigCenterServiceServer_RegisterRegionalServer_Call {
	_c.Call.Return(regionalServer, err)
	return _c
}

func (_c *ConfigCenterServiceServer_RegisterRegionalServer_Call) RunAndReturn(run func(context1 context.Context, registerRegionalServerRequest *config_center.RegisterRegionalServerRequest) (*config_center.RegionalServer, error)) *ConfigCenterServiceServer_RegisterRegionalServer_Call {
	_c.Call.Return(run)
	return _c
}

// SearchClusterComponents provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) SearchClusterComponents(context1 context.Context, searchClusterComponentsRequest *config_center.SearchClusterComponentsRequest) (*config_center.SearchClusterComponentsResponse, error) {
	ret := _mock.Called(context1, searchClusterComponentsRequest)

	if len(ret) == 0 {
		panic("no return value specified for SearchClusterComponents")
	}

	var r0 *config_center.SearchClusterComponentsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.SearchClusterComponentsRequest) (*config_center.SearchClusterComponentsResponse, error)); ok {
		return returnFunc(context1, searchClusterComponentsRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.SearchClusterComponentsRequest) *config_center.SearchClusterComponentsResponse); ok {
		r0 = returnFunc(context1, searchClusterComponentsRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.SearchClusterComponentsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.SearchClusterComponentsRequest) error); ok {
		r1 = returnFunc(context1, searchClusterComponentsRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_SearchClusterComponents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchClusterComponents'
type ConfigCenterServiceServer_SearchClusterComponents_Call struct {
	*mock.Call
}

// SearchClusterComponents is a helper method to define mock.On call
//   - context1 context.Context
//   - searchClusterComponentsRequest *config_center.SearchClusterComponentsRequest
func (_e *ConfigCenterServiceServer_Expecter) SearchClusterComponents(context1 interface{}, searchClusterComponentsRequest interface{}) *ConfigCenterServiceServer_SearchClusterComponents_Call {
	return &ConfigCenterServiceServer_SearchClusterComponents_Call{Call: _e.mock.On("SearchClusterComponents", context1, searchClusterComponentsRequest)}
}

func (_c *ConfigCenterServiceServer_SearchClusterComponents_Call) Run(run func(context1 context.Context, searchClusterComponentsRequest *config_center.SearchClusterComponentsRequest)) *ConfigCenterServiceServer_SearchClusterComponents_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.SearchClusterComponentsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.SearchClusterComponentsRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_SearchClusterComponents_Call) Return(searchClusterComponentsResponse *config_center.SearchClusterComponentsResponse, err error) *ConfigCenterServiceServer_SearchClusterComponents_Call {
	_c.Call.Return(searchClusterComponentsResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_SearchClusterComponents_Call) RunAndReturn(run func(context1 context.Context, searchClusterComponentsRequest *config_center.SearchClusterComponentsRequest) (*config_center.SearchClusterComponentsResponse, error)) *ConfigCenterServiceServer_SearchClusterComponents_Call {
	_c.Call.Return(run)
	return _c
}

// SearchDefaultConfigurationTemplate provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) SearchDefaultConfigurationTemplate(context1 context.Context, searchDefaultConfigurationTemplateRequest *config_center.SearchDefaultConfigurationTemplateRequest) (*config_center.ConfigurationTemplate, error) {
	ret := _mock.Called(context1, searchDefaultConfigurationTemplateRequest)

	if len(ret) == 0 {
		panic("no return value specified for SearchDefaultConfigurationTemplate")
	}

	var r0 *config_center.ConfigurationTemplate
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.SearchDefaultConfigurationTemplateRequest) (*config_center.ConfigurationTemplate, error)); ok {
		return returnFunc(context1, searchDefaultConfigurationTemplateRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.SearchDefaultConfigurationTemplateRequest) *config_center.ConfigurationTemplate); ok {
		r0 = returnFunc(context1, searchDefaultConfigurationTemplateRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationTemplate)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.SearchDefaultConfigurationTemplateRequest) error); ok {
		r1 = returnFunc(context1, searchDefaultConfigurationTemplateRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_SearchDefaultConfigurationTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchDefaultConfigurationTemplate'
type ConfigCenterServiceServer_SearchDefaultConfigurationTemplate_Call struct {
	*mock.Call
}

// SearchDefaultConfigurationTemplate is a helper method to define mock.On call
//   - context1 context.Context
//   - searchDefaultConfigurationTemplateRequest *config_center.SearchDefaultConfigurationTemplateRequest
func (_e *ConfigCenterServiceServer_Expecter) SearchDefaultConfigurationTemplate(context1 interface{}, searchDefaultConfigurationTemplateRequest interface{}) *ConfigCenterServiceServer_SearchDefaultConfigurationTemplate_Call {
	return &ConfigCenterServiceServer_SearchDefaultConfigurationTemplate_Call{Call: _e.mock.On("SearchDefaultConfigurationTemplate", context1, searchDefaultConfigurationTemplateRequest)}
}

func (_c *ConfigCenterServiceServer_SearchDefaultConfigurationTemplate_Call) Run(run func(context1 context.Context, searchDefaultConfigurationTemplateRequest *config_center.SearchDefaultConfigurationTemplateRequest)) *ConfigCenterServiceServer_SearchDefaultConfigurationTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.SearchDefaultConfigurationTemplateRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.SearchDefaultConfigurationTemplateRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_SearchDefaultConfigurationTemplate_Call) Return(configurationTemplate *config_center.ConfigurationTemplate, err error) *ConfigCenterServiceServer_SearchDefaultConfigurationTemplate_Call {
	_c.Call.Return(configurationTemplate, err)
	return _c
}

func (_c *ConfigCenterServiceServer_SearchDefaultConfigurationTemplate_Call) RunAndReturn(run func(context1 context.Context, searchDefaultConfigurationTemplateRequest *config_center.SearchDefaultConfigurationTemplateRequest) (*config_center.ConfigurationTemplate, error)) *ConfigCenterServiceServer_SearchDefaultConfigurationTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// SyncRegionalServer provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) SyncRegionalServer(context1 context.Context, syncRegionalServerRequest *config_center.SyncRegionalServerRequest) (*config_center.RegionalServer, error) {
	ret := _mock.Called(context1, syncRegionalServerRequest)

	if len(ret) == 0 {
		panic("no return value specified for SyncRegionalServer")
	}

	var r0 *config_center.RegionalServer
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.SyncRegionalServerRequest) (*config_center.RegionalServer, error)); ok {
		return returnFunc(context1, syncRegionalServerRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.SyncRegionalServerRequest) *config_center.RegionalServer); ok {
		r0 = returnFunc(context1, syncRegionalServerRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.RegionalServer)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.SyncRegionalServerRequest) error); ok {
		r1 = returnFunc(context1, syncRegionalServerRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_SyncRegionalServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SyncRegionalServer'
type ConfigCenterServiceServer_SyncRegionalServer_Call struct {
	*mock.Call
}

// SyncRegionalServer is a helper method to define mock.On call
//   - context1 context.Context
//   - syncRegionalServerRequest *config_center.SyncRegionalServerRequest
func (_e *ConfigCenterServiceServer_Expecter) SyncRegionalServer(context1 interface{}, syncRegionalServerRequest interface{}) *ConfigCenterServiceServer_SyncRegionalServer_Call {
	return &ConfigCenterServiceServer_SyncRegionalServer_Call{Call: _e.mock.On("SyncRegionalServer", context1, syncRegionalServerRequest)}
}

func (_c *ConfigCenterServiceServer_SyncRegionalServer_Call) Run(run func(context1 context.Context, syncRegionalServerRequest *config_center.SyncRegionalServerRequest)) *ConfigCenterServiceServer_SyncRegionalServer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.SyncRegionalServerRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.SyncRegionalServerRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_SyncRegionalServer_Call) Return(regionalServer *config_center.RegionalServer, err error) *ConfigCenterServiceServer_SyncRegionalServer_Call {
	_c.Call.Return(regionalServer, err)
	return _c
}

func (_c *ConfigCenterServiceServer_SyncRegionalServer_Call) RunAndReturn(run func(context1 context.Context, syncRegionalServerRequest *config_center.SyncRegionalServerRequest) (*config_center.RegionalServer, error)) *ConfigCenterServiceServer_SyncRegionalServer_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateClusterComponent provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) UpdateClusterComponent(context1 context.Context, updateClusterComponentRequest *config_center.UpdateClusterComponentRequest) (*config_center.ClusterComponent, error) {
	ret := _mock.Called(context1, updateClusterComponentRequest)

	if len(ret) == 0 {
		panic("no return value specified for UpdateClusterComponent")
	}

	var r0 *config_center.ClusterComponent
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateClusterComponentRequest) (*config_center.ClusterComponent, error)); ok {
		return returnFunc(context1, updateClusterComponentRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateClusterComponentRequest) *config_center.ClusterComponent); ok {
		r0 = returnFunc(context1, updateClusterComponentRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ClusterComponent)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.UpdateClusterComponentRequest) error); ok {
		r1 = returnFunc(context1, updateClusterComponentRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_UpdateClusterComponent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateClusterComponent'
type ConfigCenterServiceServer_UpdateClusterComponent_Call struct {
	*mock.Call
}

// UpdateClusterComponent is a helper method to define mock.On call
//   - context1 context.Context
//   - updateClusterComponentRequest *config_center.UpdateClusterComponentRequest
func (_e *ConfigCenterServiceServer_Expecter) UpdateClusterComponent(context1 interface{}, updateClusterComponentRequest interface{}) *ConfigCenterServiceServer_UpdateClusterComponent_Call {
	return &ConfigCenterServiceServer_UpdateClusterComponent_Call{Call: _e.mock.On("UpdateClusterComponent", context1, updateClusterComponentRequest)}
}

func (_c *ConfigCenterServiceServer_UpdateClusterComponent_Call) Run(run func(context1 context.Context, updateClusterComponentRequest *config_center.UpdateClusterComponentRequest)) *ConfigCenterServiceServer_UpdateClusterComponent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.UpdateClusterComponentRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.UpdateClusterComponentRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_UpdateClusterComponent_Call) Return(clusterComponent *config_center.ClusterComponent, err error) *ConfigCenterServiceServer_UpdateClusterComponent_Call {
	_c.Call.Return(clusterComponent, err)
	return _c
}

func (_c *ConfigCenterServiceServer_UpdateClusterComponent_Call) RunAndReturn(run func(context1 context.Context, updateClusterComponentRequest *config_center.UpdateClusterComponentRequest) (*config_center.ClusterComponent, error)) *ConfigCenterServiceServer_UpdateClusterComponent_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateClusterConfigurationFile provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) UpdateClusterConfigurationFile(context1 context.Context, updateClusterConfigurationFileRequest *config_center.UpdateClusterConfigurationFileRequest) (*config_center.ConfigurationFile, error) {
	ret := _mock.Called(context1, updateClusterConfigurationFileRequest)

	if len(ret) == 0 {
		panic("no return value specified for UpdateClusterConfigurationFile")
	}

	var r0 *config_center.ConfigurationFile
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateClusterConfigurationFileRequest) (*config_center.ConfigurationFile, error)); ok {
		return returnFunc(context1, updateClusterConfigurationFileRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateClusterConfigurationFileRequest) *config_center.ConfigurationFile); ok {
		r0 = returnFunc(context1, updateClusterConfigurationFileRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationFile)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.UpdateClusterConfigurationFileRequest) error); ok {
		r1 = returnFunc(context1, updateClusterConfigurationFileRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_UpdateClusterConfigurationFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateClusterConfigurationFile'
type ConfigCenterServiceServer_UpdateClusterConfigurationFile_Call struct {
	*mock.Call
}

// UpdateClusterConfigurationFile is a helper method to define mock.On call
//   - context1 context.Context
//   - updateClusterConfigurationFileRequest *config_center.UpdateClusterConfigurationFileRequest
func (_e *ConfigCenterServiceServer_Expecter) UpdateClusterConfigurationFile(context1 interface{}, updateClusterConfigurationFileRequest interface{}) *ConfigCenterServiceServer_UpdateClusterConfigurationFile_Call {
	return &ConfigCenterServiceServer_UpdateClusterConfigurationFile_Call{Call: _e.mock.On("UpdateClusterConfigurationFile", context1, updateClusterConfigurationFileRequest)}
}

func (_c *ConfigCenterServiceServer_UpdateClusterConfigurationFile_Call) Run(run func(context1 context.Context, updateClusterConfigurationFileRequest *config_center.UpdateClusterConfigurationFileRequest)) *ConfigCenterServiceServer_UpdateClusterConfigurationFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.UpdateClusterConfigurationFileRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.UpdateClusterConfigurationFileRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_UpdateClusterConfigurationFile_Call) Return(configurationFile *config_center.ConfigurationFile, err error) *ConfigCenterServiceServer_UpdateClusterConfigurationFile_Call {
	_c.Call.Return(configurationFile, err)
	return _c
}

func (_c *ConfigCenterServiceServer_UpdateClusterConfigurationFile_Call) RunAndReturn(run func(context1 context.Context, updateClusterConfigurationFileRequest *config_center.UpdateClusterConfigurationFileRequest) (*config_center.ConfigurationFile, error)) *ConfigCenterServiceServer_UpdateClusterConfigurationFile_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateClusterMeta provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) UpdateClusterMeta(context1 context.Context, updateClusterMetaRequest *config_center.UpdateClusterMetaRequest) (*config_center.UpdateClusterMetaResponse, error) {
	ret := _mock.Called(context1, updateClusterMetaRequest)

	if len(ret) == 0 {
		panic("no return value specified for UpdateClusterMeta")
	}

	var r0 *config_center.UpdateClusterMetaResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateClusterMetaRequest) (*config_center.UpdateClusterMetaResponse, error)); ok {
		return returnFunc(context1, updateClusterMetaRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateClusterMetaRequest) *config_center.UpdateClusterMetaResponse); ok {
		r0 = returnFunc(context1, updateClusterMetaRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.UpdateClusterMetaResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.UpdateClusterMetaRequest) error); ok {
		r1 = returnFunc(context1, updateClusterMetaRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_UpdateClusterMeta_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateClusterMeta'
type ConfigCenterServiceServer_UpdateClusterMeta_Call struct {
	*mock.Call
}

// UpdateClusterMeta is a helper method to define mock.On call
//   - context1 context.Context
//   - updateClusterMetaRequest *config_center.UpdateClusterMetaRequest
func (_e *ConfigCenterServiceServer_Expecter) UpdateClusterMeta(context1 interface{}, updateClusterMetaRequest interface{}) *ConfigCenterServiceServer_UpdateClusterMeta_Call {
	return &ConfigCenterServiceServer_UpdateClusterMeta_Call{Call: _e.mock.On("UpdateClusterMeta", context1, updateClusterMetaRequest)}
}

func (_c *ConfigCenterServiceServer_UpdateClusterMeta_Call) Run(run func(context1 context.Context, updateClusterMetaRequest *config_center.UpdateClusterMetaRequest)) *ConfigCenterServiceServer_UpdateClusterMeta_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.UpdateClusterMetaRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.UpdateClusterMetaRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_UpdateClusterMeta_Call) Return(updateClusterMetaResponse *config_center.UpdateClusterMetaResponse, err error) *ConfigCenterServiceServer_UpdateClusterMeta_Call {
	_c.Call.Return(updateClusterMetaResponse, err)
	return _c
}

func (_c *ConfigCenterServiceServer_UpdateClusterMeta_Call) RunAndReturn(run func(context1 context.Context, updateClusterMetaRequest *config_center.UpdateClusterMetaRequest) (*config_center.UpdateClusterMetaResponse, error)) *ConfigCenterServiceServer_UpdateClusterMeta_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateComponentImage provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) UpdateComponentImage(context1 context.Context, updateComponentImageRequest *config_center.UpdateComponentImageRequest) (*config_center.ComponentImage, error) {
	ret := _mock.Called(context1, updateComponentImageRequest)

	if len(ret) == 0 {
		panic("no return value specified for UpdateComponentImage")
	}

	var r0 *config_center.ComponentImage
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateComponentImageRequest) (*config_center.ComponentImage, error)); ok {
		return returnFunc(context1, updateComponentImageRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateComponentImageRequest) *config_center.ComponentImage); ok {
		r0 = returnFunc(context1, updateComponentImageRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ComponentImage)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.UpdateComponentImageRequest) error); ok {
		r1 = returnFunc(context1, updateComponentImageRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_UpdateComponentImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateComponentImage'
type ConfigCenterServiceServer_UpdateComponentImage_Call struct {
	*mock.Call
}

// UpdateComponentImage is a helper method to define mock.On call
//   - context1 context.Context
//   - updateComponentImageRequest *config_center.UpdateComponentImageRequest
func (_e *ConfigCenterServiceServer_Expecter) UpdateComponentImage(context1 interface{}, updateComponentImageRequest interface{}) *ConfigCenterServiceServer_UpdateComponentImage_Call {
	return &ConfigCenterServiceServer_UpdateComponentImage_Call{Call: _e.mock.On("UpdateComponentImage", context1, updateComponentImageRequest)}
}

func (_c *ConfigCenterServiceServer_UpdateComponentImage_Call) Run(run func(context1 context.Context, updateComponentImageRequest *config_center.UpdateComponentImageRequest)) *ConfigCenterServiceServer_UpdateComponentImage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.UpdateComponentImageRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.UpdateComponentImageRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_UpdateComponentImage_Call) Return(componentImage *config_center.ComponentImage, err error) *ConfigCenterServiceServer_UpdateComponentImage_Call {
	_c.Call.Return(componentImage, err)
	return _c
}

func (_c *ConfigCenterServiceServer_UpdateComponentImage_Call) RunAndReturn(run func(context1 context.Context, updateComponentImageRequest *config_center.UpdateComponentImageRequest) (*config_center.ComponentImage, error)) *ConfigCenterServiceServer_UpdateComponentImage_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateConfigurationDictItem provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) UpdateConfigurationDictItem(context1 context.Context, updateConfigurationDictItemReq *config_center.UpdateConfigurationDictItemReq) (*config_center.ConfigurationDictItem, error) {
	ret := _mock.Called(context1, updateConfigurationDictItemReq)

	if len(ret) == 0 {
		panic("no return value specified for UpdateConfigurationDictItem")
	}

	var r0 *config_center.ConfigurationDictItem
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateConfigurationDictItemReq) (*config_center.ConfigurationDictItem, error)); ok {
		return returnFunc(context1, updateConfigurationDictItemReq)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateConfigurationDictItemReq) *config_center.ConfigurationDictItem); ok {
		r0 = returnFunc(context1, updateConfigurationDictItemReq)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationDictItem)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.UpdateConfigurationDictItemReq) error); ok {
		r1 = returnFunc(context1, updateConfigurationDictItemReq)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_UpdateConfigurationDictItem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateConfigurationDictItem'
type ConfigCenterServiceServer_UpdateConfigurationDictItem_Call struct {
	*mock.Call
}

// UpdateConfigurationDictItem is a helper method to define mock.On call
//   - context1 context.Context
//   - updateConfigurationDictItemReq *config_center.UpdateConfigurationDictItemReq
func (_e *ConfigCenterServiceServer_Expecter) UpdateConfigurationDictItem(context1 interface{}, updateConfigurationDictItemReq interface{}) *ConfigCenterServiceServer_UpdateConfigurationDictItem_Call {
	return &ConfigCenterServiceServer_UpdateConfigurationDictItem_Call{Call: _e.mock.On("UpdateConfigurationDictItem", context1, updateConfigurationDictItemReq)}
}

func (_c *ConfigCenterServiceServer_UpdateConfigurationDictItem_Call) Run(run func(context1 context.Context, updateConfigurationDictItemReq *config_center.UpdateConfigurationDictItemReq)) *ConfigCenterServiceServer_UpdateConfigurationDictItem_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.UpdateConfigurationDictItemReq
		if args[1] != nil {
			arg1 = args[1].(*config_center.UpdateConfigurationDictItemReq)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_UpdateConfigurationDictItem_Call) Return(configurationDictItem *config_center.ConfigurationDictItem, err error) *ConfigCenterServiceServer_UpdateConfigurationDictItem_Call {
	_c.Call.Return(configurationDictItem, err)
	return _c
}

func (_c *ConfigCenterServiceServer_UpdateConfigurationDictItem_Call) RunAndReturn(run func(context1 context.Context, updateConfigurationDictItemReq *config_center.UpdateConfigurationDictItemReq) (*config_center.ConfigurationDictItem, error)) *ConfigCenterServiceServer_UpdateConfigurationDictItem_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDefaultConfigurationTemplate provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) UpdateDefaultConfigurationTemplate(context1 context.Context, updateDefaultConfigurationTemplateRequest *config_center.UpdateDefaultConfigurationTemplateRequest) (*config_center.ConfigurationTemplate, error) {
	ret := _mock.Called(context1, updateDefaultConfigurationTemplateRequest)

	if len(ret) == 0 {
		panic("no return value specified for UpdateDefaultConfigurationTemplate")
	}

	var r0 *config_center.ConfigurationTemplate
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateDefaultConfigurationTemplateRequest) (*config_center.ConfigurationTemplate, error)); ok {
		return returnFunc(context1, updateDefaultConfigurationTemplateRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateDefaultConfigurationTemplateRequest) *config_center.ConfigurationTemplate); ok {
		r0 = returnFunc(context1, updateDefaultConfigurationTemplateRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationTemplate)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.UpdateDefaultConfigurationTemplateRequest) error); ok {
		r1 = returnFunc(context1, updateDefaultConfigurationTemplateRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_UpdateDefaultConfigurationTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDefaultConfigurationTemplate'
type ConfigCenterServiceServer_UpdateDefaultConfigurationTemplate_Call struct {
	*mock.Call
}

// UpdateDefaultConfigurationTemplate is a helper method to define mock.On call
//   - context1 context.Context
//   - updateDefaultConfigurationTemplateRequest *config_center.UpdateDefaultConfigurationTemplateRequest
func (_e *ConfigCenterServiceServer_Expecter) UpdateDefaultConfigurationTemplate(context1 interface{}, updateDefaultConfigurationTemplateRequest interface{}) *ConfigCenterServiceServer_UpdateDefaultConfigurationTemplate_Call {
	return &ConfigCenterServiceServer_UpdateDefaultConfigurationTemplate_Call{Call: _e.mock.On("UpdateDefaultConfigurationTemplate", context1, updateDefaultConfigurationTemplateRequest)}
}

func (_c *ConfigCenterServiceServer_UpdateDefaultConfigurationTemplate_Call) Run(run func(context1 context.Context, updateDefaultConfigurationTemplateRequest *config_center.UpdateDefaultConfigurationTemplateRequest)) *ConfigCenterServiceServer_UpdateDefaultConfigurationTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.UpdateDefaultConfigurationTemplateRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.UpdateDefaultConfigurationTemplateRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_UpdateDefaultConfigurationTemplate_Call) Return(configurationTemplate *config_center.ConfigurationTemplate, err error) *ConfigCenterServiceServer_UpdateDefaultConfigurationTemplate_Call {
	_c.Call.Return(configurationTemplate, err)
	return _c
}

func (_c *ConfigCenterServiceServer_UpdateDefaultConfigurationTemplate_Call) RunAndReturn(run func(context1 context.Context, updateDefaultConfigurationTemplateRequest *config_center.UpdateDefaultConfigurationTemplateRequest) (*config_center.ConfigurationTemplate, error)) *ConfigCenterServiceServer_UpdateDefaultConfigurationTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDefaultVersion provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) UpdateDefaultVersion(context1 context.Context, updateDefaultVersionRequest *config_center.UpdateDefaultVersionRequest) (*config_center.DefaultVersion, error) {
	ret := _mock.Called(context1, updateDefaultVersionRequest)

	if len(ret) == 0 {
		panic("no return value specified for UpdateDefaultVersion")
	}

	var r0 *config_center.DefaultVersion
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateDefaultVersionRequest) (*config_center.DefaultVersion, error)); ok {
		return returnFunc(context1, updateDefaultVersionRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateDefaultVersionRequest) *config_center.DefaultVersion); ok {
		r0 = returnFunc(context1, updateDefaultVersionRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.DefaultVersion)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.UpdateDefaultVersionRequest) error); ok {
		r1 = returnFunc(context1, updateDefaultVersionRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_UpdateDefaultVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDefaultVersion'
type ConfigCenterServiceServer_UpdateDefaultVersion_Call struct {
	*mock.Call
}

// UpdateDefaultVersion is a helper method to define mock.On call
//   - context1 context.Context
//   - updateDefaultVersionRequest *config_center.UpdateDefaultVersionRequest
func (_e *ConfigCenterServiceServer_Expecter) UpdateDefaultVersion(context1 interface{}, updateDefaultVersionRequest interface{}) *ConfigCenterServiceServer_UpdateDefaultVersion_Call {
	return &ConfigCenterServiceServer_UpdateDefaultVersion_Call{Call: _e.mock.On("UpdateDefaultVersion", context1, updateDefaultVersionRequest)}
}

func (_c *ConfigCenterServiceServer_UpdateDefaultVersion_Call) Run(run func(context1 context.Context, updateDefaultVersionRequest *config_center.UpdateDefaultVersionRequest)) *ConfigCenterServiceServer_UpdateDefaultVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.UpdateDefaultVersionRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.UpdateDefaultVersionRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_UpdateDefaultVersion_Call) Return(defaultVersion *config_center.DefaultVersion, err error) *ConfigCenterServiceServer_UpdateDefaultVersion_Call {
	_c.Call.Return(defaultVersion, err)
	return _c
}

func (_c *ConfigCenterServiceServer_UpdateDefaultVersion_Call) RunAndReturn(run func(context1 context.Context, updateDefaultVersionRequest *config_center.UpdateDefaultVersionRequest) (*config_center.DefaultVersion, error)) *ConfigCenterServiceServer_UpdateDefaultVersion_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTenantInitialCustomParams provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) UpdateTenantInitialCustomParams(context1 context.Context, updateTenantInitialCustomParamsRequest *config_center.UpdateTenantInitialCustomParamsRequest) (*config_center.TenantInitialCustomPatams, error) {
	ret := _mock.Called(context1, updateTenantInitialCustomParamsRequest)

	if len(ret) == 0 {
		panic("no return value specified for UpdateTenantInitialCustomParams")
	}

	var r0 *config_center.TenantInitialCustomPatams
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateTenantInitialCustomParamsRequest) (*config_center.TenantInitialCustomPatams, error)); ok {
		return returnFunc(context1, updateTenantInitialCustomParamsRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpdateTenantInitialCustomParamsRequest) *config_center.TenantInitialCustomPatams); ok {
		r0 = returnFunc(context1, updateTenantInitialCustomParamsRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.TenantInitialCustomPatams)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.UpdateTenantInitialCustomParamsRequest) error); ok {
		r1 = returnFunc(context1, updateTenantInitialCustomParamsRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_UpdateTenantInitialCustomParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTenantInitialCustomParams'
type ConfigCenterServiceServer_UpdateTenantInitialCustomParams_Call struct {
	*mock.Call
}

// UpdateTenantInitialCustomParams is a helper method to define mock.On call
//   - context1 context.Context
//   - updateTenantInitialCustomParamsRequest *config_center.UpdateTenantInitialCustomParamsRequest
func (_e *ConfigCenterServiceServer_Expecter) UpdateTenantInitialCustomParams(context1 interface{}, updateTenantInitialCustomParamsRequest interface{}) *ConfigCenterServiceServer_UpdateTenantInitialCustomParams_Call {
	return &ConfigCenterServiceServer_UpdateTenantInitialCustomParams_Call{Call: _e.mock.On("UpdateTenantInitialCustomParams", context1, updateTenantInitialCustomParamsRequest)}
}

func (_c *ConfigCenterServiceServer_UpdateTenantInitialCustomParams_Call) Run(run func(context1 context.Context, updateTenantInitialCustomParamsRequest *config_center.UpdateTenantInitialCustomParamsRequest)) *ConfigCenterServiceServer_UpdateTenantInitialCustomParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.UpdateTenantInitialCustomParamsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.UpdateTenantInitialCustomParamsRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_UpdateTenantInitialCustomParams_Call) Return(tenantInitialCustomPatams *config_center.TenantInitialCustomPatams, err error) *ConfigCenterServiceServer_UpdateTenantInitialCustomParams_Call {
	_c.Call.Return(tenantInitialCustomPatams, err)
	return _c
}

func (_c *ConfigCenterServiceServer_UpdateTenantInitialCustomParams_Call) RunAndReturn(run func(context1 context.Context, updateTenantInitialCustomParamsRequest *config_center.UpdateTenantInitialCustomParamsRequest) (*config_center.TenantInitialCustomPatams, error)) *ConfigCenterServiceServer_UpdateTenantInitialCustomParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpsertClusterCustomParams provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) UpsertClusterCustomParams(context1 context.Context, upsertClusterCustomParamsRequest *config_center.UpsertClusterCustomParamsRequest) (*config_center.ConfigurationFile, error) {
	ret := _mock.Called(context1, upsertClusterCustomParamsRequest)

	if len(ret) == 0 {
		panic("no return value specified for UpsertClusterCustomParams")
	}

	var r0 *config_center.ConfigurationFile
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpsertClusterCustomParamsRequest) (*config_center.ConfigurationFile, error)); ok {
		return returnFunc(context1, upsertClusterCustomParamsRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *config_center.UpsertClusterCustomParamsRequest) *config_center.ConfigurationFile); ok {
		r0 = returnFunc(context1, upsertClusterCustomParamsRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config_center.ConfigurationFile)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *config_center.UpsertClusterCustomParamsRequest) error); ok {
		r1 = returnFunc(context1, upsertClusterCustomParamsRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// ConfigCenterServiceServer_UpsertClusterCustomParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpsertClusterCustomParams'
type ConfigCenterServiceServer_UpsertClusterCustomParams_Call struct {
	*mock.Call
}

// UpsertClusterCustomParams is a helper method to define mock.On call
//   - context1 context.Context
//   - upsertClusterCustomParamsRequest *config_center.UpsertClusterCustomParamsRequest
func (_e *ConfigCenterServiceServer_Expecter) UpsertClusterCustomParams(context1 interface{}, upsertClusterCustomParamsRequest interface{}) *ConfigCenterServiceServer_UpsertClusterCustomParams_Call {
	return &ConfigCenterServiceServer_UpsertClusterCustomParams_Call{Call: _e.mock.On("UpsertClusterCustomParams", context1, upsertClusterCustomParamsRequest)}
}

func (_c *ConfigCenterServiceServer_UpsertClusterCustomParams_Call) Run(run func(context1 context.Context, upsertClusterCustomParamsRequest *config_center.UpsertClusterCustomParamsRequest)) *ConfigCenterServiceServer_UpsertClusterCustomParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *config_center.UpsertClusterCustomParamsRequest
		if args[1] != nil {
			arg1 = args[1].(*config_center.UpsertClusterCustomParamsRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *ConfigCenterServiceServer_UpsertClusterCustomParams_Call) Return(configurationFile *config_center.ConfigurationFile, err error) *ConfigCenterServiceServer_UpsertClusterCustomParams_Call {
	_c.Call.Return(configurationFile, err)
	return _c
}

func (_c *ConfigCenterServiceServer_UpsertClusterCustomParams_Call) RunAndReturn(run func(context1 context.Context, upsertClusterCustomParamsRequest *config_center.UpsertClusterCustomParamsRequest) (*config_center.ConfigurationFile, error)) *ConfigCenterServiceServer_UpsertClusterCustomParams_Call {
	_c.Call.Return(run)
	return _c
}

// mustEmbedUnimplementedConfigCenterServiceServer provides a mock function for the type ConfigCenterServiceServer
func (_mock *ConfigCenterServiceServer) mustEmbedUnimplementedConfigCenterServiceServer() {
	_mock.Called()
	return
}

// ConfigCenterServiceServer_mustEmbedUnimplementedConfigCenterServiceServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'mustEmbedUnimplementedConfigCenterServiceServer'
type ConfigCenterServiceServer_mustEmbedUnimplementedConfigCenterServiceServer_Call struct {
	*mock.Call
}

// mustEmbedUnimplementedConfigCenterServiceServer is a helper method to define mock.On call
func (_e *ConfigCenterServiceServer_Expecter) mustEmbedUnimplementedConfigCenterServiceServer() *ConfigCenterServiceServer_mustEmbedUnimplementedConfigCenterServiceServer_Call {
	return &ConfigCenterServiceServer_mustEmbedUnimplementedConfigCenterServiceServer_Call{Call: _e.mock.On("mustEmbedUnimplementedConfigCenterServiceServer")}
}

func (_c *ConfigCenterServiceServer_mustEmbedUnimplementedConfigCenterServiceServer_Call) Run(run func()) *ConfigCenterServiceServer_mustEmbedUnimplementedConfigCenterServiceServer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *ConfigCenterServiceServer_mustEmbedUnimplementedConfigCenterServiceServer_Call) Return() *ConfigCenterServiceServer_mustEmbedUnimplementedConfigCenterServiceServer_Call {
	_c.Call.Return()
	return _c
}

func (_c *ConfigCenterServiceServer_mustEmbedUnimplementedConfigCenterServiceServer_Call) RunAndReturn(run func()) *ConfigCenterServiceServer_mustEmbedUnimplementedConfigCenterServiceServer_Call {
	_c.Run(run)
	return _c
}

// NewUnsafeConfigCenterServiceServer creates a new instance of UnsafeConfigCenterServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewUnsafeConfigCenterServiceServer(t interface {
	mock.TestingT
	Cleanup(func())
}) *UnsafeConfigCenterServiceServer {
	mock := &UnsafeConfigCenterServiceServer{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// UnsafeConfigCenterServiceServer is an autogenerated mock type for the UnsafeConfigCenterServiceServer type
type UnsafeConfigCenterServiceServer struct {
	mock.Mock
}

type UnsafeConfigCenterServiceServer_Expecter struct {
	mock *mock.Mock
}

func (_m *UnsafeConfigCenterServiceServer) EXPECT() *UnsafeConfigCenterServiceServer_Expecter {
	return &UnsafeConfigCenterServiceServer_Expecter{mock: &_m.Mock}
}

// mustEmbedUnimplementedConfigCenterServiceServer provides a mock function for the type UnsafeConfigCenterServiceServer
func (_mock *UnsafeConfigCenterServiceServer) mustEmbedUnimplementedConfigCenterServiceServer() {
	_mock.Called()
	return
}

// UnsafeConfigCenterServiceServer_mustEmbedUnimplementedConfigCenterServiceServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'mustEmbedUnimplementedConfigCenterServiceServer'
type UnsafeConfigCenterServiceServer_mustEmbedUnimplementedConfigCenterServiceServer_Call struct {
	*mock.Call
}

// mustEmbedUnimplementedConfigCenterServiceServer is a helper method to define mock.On call
func (_e *UnsafeConfigCenterServiceServer_Expecter) mustEmbedUnimplementedConfigCenterServiceServer() *UnsafeConfigCenterServiceServer_mustEmbedUnimplementedConfigCenterServiceServer_Call {
	return &UnsafeConfigCenterServiceServer_mustEmbedUnimplementedConfigCenterServiceServer_Call{Call: _e.mock.On("mustEmbedUnimplementedConfigCenterServiceServer")}
}

func (_c *UnsafeConfigCenterServiceServer_mustEmbedUnimplementedConfigCenterServiceServer_Call) Run(run func()) *UnsafeConfigCenterServiceServer_mustEmbedUnimplementedConfigCenterServiceServer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *UnsafeConfigCenterServiceServer_mustEmbedUnimplementedConfigCenterServiceServer_Call) Return() *UnsafeConfigCenterServiceServer_mustEmbedUnimplementedConfigCenterServiceServer_Call {
	_c.Call.Return()
	return _c
}

func (_c *UnsafeConfigCenterServiceServer_mustEmbedUnimplementedConfigCenterServiceServer_Call) RunAndReturn(run func()) *UnsafeConfigCenterServiceServer_mustEmbedUnimplementedConfigCenterServiceServer_Call {
	_c.Run(run)
	return _c
}