admin_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/kakao/varlog/proto/admpb (interfaces: ClusterManagerClient,ClusterManagerServer)

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

import (
	context "context"
	reflect "reflect"

	types "github.com/gogo/protobuf/types"
	gomock "github.com/golang/mock/gomock"
	grpc "google.golang.org/grpc"
)

// MockClusterManagerClient is a mock of ClusterManagerClient interface.
type MockClusterManagerClient struct {
	ctrl     *gomock.Controller
	recorder *MockClusterManagerClientMockRecorder
}

// MockClusterManagerClientMockRecorder is the mock recorder for MockClusterManagerClient.
type MockClusterManagerClientMockRecorder struct {
	mock *MockClusterManagerClient
}

// NewMockClusterManagerClient creates a new mock instance.
func NewMockClusterManagerClient(ctrl *gomock.Controller) *MockClusterManagerClient {
	mock := &MockClusterManagerClient{ctrl: ctrl}
	mock.recorder = &MockClusterManagerClientMockRecorder{mock}
	return mock
}

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

// AddLogStream mocks base method.
func (m *MockClusterManagerClient) AddLogStream(arg0 context.Context, arg1 *AddLogStreamRequest, arg2 ...grpc.CallOption) (*AddLogStreamResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddLogStream", varargs...)
	ret0, _ := ret[0].(*AddLogStreamResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddLogStream indicates an expected call of AddLogStream.
func (mr *MockClusterManagerClientMockRecorder) AddLogStream(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLogStream", reflect.TypeOf((*MockClusterManagerClient)(nil).AddLogStream), varargs...)
}

// AddMRPeer mocks base method.
func (m *MockClusterManagerClient) AddMRPeer(arg0 context.Context, arg1 *AddMRPeerRequest, arg2 ...grpc.CallOption) (*AddMRPeerResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddMRPeer", varargs...)
	ret0, _ := ret[0].(*AddMRPeerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddMRPeer indicates an expected call of AddMRPeer.
func (mr *MockClusterManagerClientMockRecorder) AddMRPeer(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddMRPeer", reflect.TypeOf((*MockClusterManagerClient)(nil).AddMRPeer), varargs...)
}

// AddMetadataRepositoryNode mocks base method.
func (m *MockClusterManagerClient) AddMetadataRepositoryNode(arg0 context.Context, arg1 *AddMetadataRepositoryNodeRequest, arg2 ...grpc.CallOption) (*AddMetadataRepositoryNodeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddMetadataRepositoryNode", varargs...)
	ret0, _ := ret[0].(*AddMetadataRepositoryNodeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddMetadataRepositoryNode indicates an expected call of AddMetadataRepositoryNode.
func (mr *MockClusterManagerClientMockRecorder) AddMetadataRepositoryNode(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddMetadataRepositoryNode", reflect.TypeOf((*MockClusterManagerClient)(nil).AddMetadataRepositoryNode), varargs...)
}

// AddStorageNode mocks base method.
func (m *MockClusterManagerClient) AddStorageNode(arg0 context.Context, arg1 *AddStorageNodeRequest, arg2 ...grpc.CallOption) (*AddStorageNodeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddStorageNode", varargs...)
	ret0, _ := ret[0].(*AddStorageNodeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddStorageNode indicates an expected call of AddStorageNode.
func (mr *MockClusterManagerClientMockRecorder) AddStorageNode(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddStorageNode", reflect.TypeOf((*MockClusterManagerClient)(nil).AddStorageNode), varargs...)
}

// AddTopic mocks base method.
func (m *MockClusterManagerClient) AddTopic(arg0 context.Context, arg1 *AddTopicRequest, arg2 ...grpc.CallOption) (*AddTopicResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddTopic", varargs...)
	ret0, _ := ret[0].(*AddTopicResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddTopic indicates an expected call of AddTopic.
func (mr *MockClusterManagerClientMockRecorder) AddTopic(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTopic", reflect.TypeOf((*MockClusterManagerClient)(nil).AddTopic), varargs...)
}

// DeleteMetadataRepositoryNode mocks base method.
func (m *MockClusterManagerClient) DeleteMetadataRepositoryNode(arg0 context.Context, arg1 *DeleteMetadataRepositoryNodeRequest, arg2 ...grpc.CallOption) (*DeleteMetadataRepositoryNodeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteMetadataRepositoryNode", varargs...)
	ret0, _ := ret[0].(*DeleteMetadataRepositoryNodeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteMetadataRepositoryNode indicates an expected call of DeleteMetadataRepositoryNode.
func (mr *MockClusterManagerClientMockRecorder) DeleteMetadataRepositoryNode(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMetadataRepositoryNode", reflect.TypeOf((*MockClusterManagerClient)(nil).DeleteMetadataRepositoryNode), varargs...)
}

// DescribeTopic mocks base method.
func (m *MockClusterManagerClient) DescribeTopic(arg0 context.Context, arg1 *DescribeTopicRequest, arg2 ...grpc.CallOption) (*DescribeTopicResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTopic", varargs...)
	ret0, _ := ret[0].(*DescribeTopicResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTopic indicates an expected call of DescribeTopic.
func (mr *MockClusterManagerClientMockRecorder) DescribeTopic(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTopic", reflect.TypeOf((*MockClusterManagerClient)(nil).DescribeTopic), varargs...)
}

// GetLogStream mocks base method.
func (m *MockClusterManagerClient) GetLogStream(arg0 context.Context, arg1 *GetLogStreamRequest, arg2 ...grpc.CallOption) (*GetLogStreamResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLogStream", varargs...)
	ret0, _ := ret[0].(*GetLogStreamResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLogStream indicates an expected call of GetLogStream.
func (mr *MockClusterManagerClientMockRecorder) GetLogStream(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogStream", reflect.TypeOf((*MockClusterManagerClient)(nil).GetLogStream), varargs...)
}

// GetMRMembers mocks base method.
func (m *MockClusterManagerClient) GetMRMembers(arg0 context.Context, arg1 *types.Empty, arg2 ...grpc.CallOption) (*GetMRMembersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMRMembers", varargs...)
	ret0, _ := ret[0].(*GetMRMembersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMRMembers indicates an expected call of GetMRMembers.
func (mr *MockClusterManagerClientMockRecorder) GetMRMembers(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMRMembers", reflect.TypeOf((*MockClusterManagerClient)(nil).GetMRMembers), varargs...)
}

// GetMetadataRepositoryNode mocks base method.
func (m *MockClusterManagerClient) GetMetadataRepositoryNode(arg0 context.Context, arg1 *GetMetadataRepositoryNodeRequest, arg2 ...grpc.CallOption) (*GetMetadataRepositoryNodeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMetadataRepositoryNode", varargs...)
	ret0, _ := ret[0].(*GetMetadataRepositoryNodeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMetadataRepositoryNode indicates an expected call of GetMetadataRepositoryNode.
func (mr *MockClusterManagerClientMockRecorder) GetMetadataRepositoryNode(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadataRepositoryNode", reflect.TypeOf((*MockClusterManagerClient)(nil).GetMetadataRepositoryNode), varargs...)
}

// GetStorageNode mocks base method.
func (m *MockClusterManagerClient) GetStorageNode(arg0 context.Context, arg1 *GetStorageNodeRequest, arg2 ...grpc.CallOption) (*GetStorageNodeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetStorageNode", varargs...)
	ret0, _ := ret[0].(*GetStorageNodeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStorageNode indicates an expected call of GetStorageNode.
func (mr *MockClusterManagerClientMockRecorder) GetStorageNode(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageNode", reflect.TypeOf((*MockClusterManagerClient)(nil).GetStorageNode), varargs...)
}

// GetTopic mocks base method.
func (m *MockClusterManagerClient) GetTopic(arg0 context.Context, arg1 *GetTopicRequest, arg2 ...grpc.CallOption) (*GetTopicResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTopic", varargs...)
	ret0, _ := ret[0].(*GetTopicResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTopic indicates an expected call of GetTopic.
func (mr *MockClusterManagerClientMockRecorder) GetTopic(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTopic", reflect.TypeOf((*MockClusterManagerClient)(nil).GetTopic), varargs...)
}

// ListLogStreams mocks base method.
func (m *MockClusterManagerClient) ListLogStreams(arg0 context.Context, arg1 *ListLogStreamsRequest, arg2 ...grpc.CallOption) (*ListLogStreamsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListLogStreams", varargs...)
	ret0, _ := ret[0].(*ListLogStreamsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLogStreams indicates an expected call of ListLogStreams.
func (mr *MockClusterManagerClientMockRecorder) ListLogStreams(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLogStreams", reflect.TypeOf((*MockClusterManagerClient)(nil).ListLogStreams), varargs...)
}

// ListMetadataRepositoryNodes mocks base method.
func (m *MockClusterManagerClient) ListMetadataRepositoryNodes(arg0 context.Context, arg1 *ListMetadataRepositoryNodesRequest, arg2 ...grpc.CallOption) (*ListMetadataRepositoryNodesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListMetadataRepositoryNodes", varargs...)
	ret0, _ := ret[0].(*ListMetadataRepositoryNodesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMetadataRepositoryNodes indicates an expected call of ListMetadataRepositoryNodes.
func (mr *MockClusterManagerClientMockRecorder) ListMetadataRepositoryNodes(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMetadataRepositoryNodes", reflect.TypeOf((*MockClusterManagerClient)(nil).ListMetadataRepositoryNodes), varargs...)
}

// ListStorageNodes mocks base method.
func (m *MockClusterManagerClient) ListStorageNodes(arg0 context.Context, arg1 *ListStorageNodesRequest, arg2 ...grpc.CallOption) (*ListStorageNodesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListStorageNodes", varargs...)
	ret0, _ := ret[0].(*ListStorageNodesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListStorageNodes indicates an expected call of ListStorageNodes.
func (mr *MockClusterManagerClientMockRecorder) ListStorageNodes(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStorageNodes", reflect.TypeOf((*MockClusterManagerClient)(nil).ListStorageNodes), varargs...)
}

// ListTopics mocks base method.
func (m *MockClusterManagerClient) ListTopics(arg0 context.Context, arg1 *ListTopicsRequest, arg2 ...grpc.CallOption) (*ListTopicsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTopics", varargs...)
	ret0, _ := ret[0].(*ListTopicsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTopics indicates an expected call of ListTopics.
func (mr *MockClusterManagerClientMockRecorder) ListTopics(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTopics", reflect.TypeOf((*MockClusterManagerClient)(nil).ListTopics), varargs...)
}

// RemoveLogStreamReplica mocks base method.
func (m *MockClusterManagerClient) RemoveLogStreamReplica(arg0 context.Context, arg1 *RemoveLogStreamReplicaRequest, arg2 ...grpc.CallOption) (*RemoveLogStreamReplicaResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemoveLogStreamReplica", varargs...)
	ret0, _ := ret[0].(*RemoveLogStreamReplicaResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveLogStreamReplica indicates an expected call of RemoveLogStreamReplica.
func (mr *MockClusterManagerClientMockRecorder) RemoveLogStreamReplica(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveLogStreamReplica", reflect.TypeOf((*MockClusterManagerClient)(nil).RemoveLogStreamReplica), varargs...)
}

// RemoveMRPeer mocks base method.
func (m *MockClusterManagerClient) RemoveMRPeer(arg0 context.Context, arg1 *RemoveMRPeerRequest, arg2 ...grpc.CallOption) (*RemoveMRPeerResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemoveMRPeer", varargs...)
	ret0, _ := ret[0].(*RemoveMRPeerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveMRPeer indicates an expected call of RemoveMRPeer.
func (mr *MockClusterManagerClientMockRecorder) RemoveMRPeer(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveMRPeer", reflect.TypeOf((*MockClusterManagerClient)(nil).RemoveMRPeer), varargs...)
}

// Seal mocks base method.
func (m *MockClusterManagerClient) Seal(arg0 context.Context, arg1 *SealRequest, arg2 ...grpc.CallOption) (*SealResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Seal", varargs...)
	ret0, _ := ret[0].(*SealResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Seal indicates an expected call of Seal.
func (mr *MockClusterManagerClientMockRecorder) Seal(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seal", reflect.TypeOf((*MockClusterManagerClient)(nil).Seal), varargs...)
}

// Sync mocks base method.
func (m *MockClusterManagerClient) Sync(arg0 context.Context, arg1 *SyncRequest, arg2 ...grpc.CallOption) (*SyncResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Sync", varargs...)
	ret0, _ := ret[0].(*SyncResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Sync indicates an expected call of Sync.
func (mr *MockClusterManagerClientMockRecorder) Sync(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sync", reflect.TypeOf((*MockClusterManagerClient)(nil).Sync), varargs...)
}

// Trim mocks base method.
func (m *MockClusterManagerClient) Trim(arg0 context.Context, arg1 *TrimRequest, arg2 ...grpc.CallOption) (*TrimResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Trim", varargs...)
	ret0, _ := ret[0].(*TrimResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Trim indicates an expected call of Trim.
func (mr *MockClusterManagerClientMockRecorder) Trim(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trim", reflect.TypeOf((*MockClusterManagerClient)(nil).Trim), varargs...)
}

// UnregisterLogStream mocks base method.
func (m *MockClusterManagerClient) UnregisterLogStream(arg0 context.Context, arg1 *UnregisterLogStreamRequest, arg2 ...grpc.CallOption) (*UnregisterLogStreamResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UnregisterLogStream", varargs...)
	ret0, _ := ret[0].(*UnregisterLogStreamResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnregisterLogStream indicates an expected call of UnregisterLogStream.
func (mr *MockClusterManagerClientMockRecorder) UnregisterLogStream(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterLogStream", reflect.TypeOf((*MockClusterManagerClient)(nil).UnregisterLogStream), varargs...)
}

// UnregisterStorageNode mocks base method.
func (m *MockClusterManagerClient) UnregisterStorageNode(arg0 context.Context, arg1 *UnregisterStorageNodeRequest, arg2 ...grpc.CallOption) (*UnregisterStorageNodeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UnregisterStorageNode", varargs...)
	ret0, _ := ret[0].(*UnregisterStorageNodeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnregisterStorageNode indicates an expected call of UnregisterStorageNode.
func (mr *MockClusterManagerClientMockRecorder) UnregisterStorageNode(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterStorageNode", reflect.TypeOf((*MockClusterManagerClient)(nil).UnregisterStorageNode), varargs...)
}

// UnregisterTopic mocks base method.
func (m *MockClusterManagerClient) UnregisterTopic(arg0 context.Context, arg1 *UnregisterTopicRequest, arg2 ...grpc.CallOption) (*UnregisterTopicResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UnregisterTopic", varargs...)
	ret0, _ := ret[0].(*UnregisterTopicResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnregisterTopic indicates an expected call of UnregisterTopic.
func (mr *MockClusterManagerClientMockRecorder) UnregisterTopic(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterTopic", reflect.TypeOf((*MockClusterManagerClient)(nil).UnregisterTopic), varargs...)
}

// Unseal mocks base method.
func (m *MockClusterManagerClient) Unseal(arg0 context.Context, arg1 *UnsealRequest, arg2 ...grpc.CallOption) (*UnsealResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Unseal", varargs...)
	ret0, _ := ret[0].(*UnsealResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Unseal indicates an expected call of Unseal.
func (mr *MockClusterManagerClientMockRecorder) Unseal(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unseal", reflect.TypeOf((*MockClusterManagerClient)(nil).Unseal), varargs...)
}

// UpdateLogStream mocks base method.
func (m *MockClusterManagerClient) UpdateLogStream(arg0 context.Context, arg1 *UpdateLogStreamRequest, arg2 ...grpc.CallOption) (*UpdateLogStreamResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateLogStream", varargs...)
	ret0, _ := ret[0].(*UpdateLogStreamResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateLogStream indicates an expected call of UpdateLogStream.
func (mr *MockClusterManagerClientMockRecorder) UpdateLogStream(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLogStream", reflect.TypeOf((*MockClusterManagerClient)(nil).UpdateLogStream), varargs...)
}

// MockClusterManagerServer is a mock of ClusterManagerServer interface.
type MockClusterManagerServer struct {
	ctrl     *gomock.Controller
	recorder *MockClusterManagerServerMockRecorder
}

// MockClusterManagerServerMockRecorder is the mock recorder for MockClusterManagerServer.
type MockClusterManagerServerMockRecorder struct {
	mock *MockClusterManagerServer
}

// NewMockClusterManagerServer creates a new mock instance.
func NewMockClusterManagerServer(ctrl *gomock.Controller) *MockClusterManagerServer {
	mock := &MockClusterManagerServer{ctrl: ctrl}
	mock.recorder = &MockClusterManagerServerMockRecorder{mock}
	return mock
}

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

// AddLogStream mocks base method.
func (m *MockClusterManagerServer) AddLogStream(arg0 context.Context, arg1 *AddLogStreamRequest) (*AddLogStreamResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddLogStream", arg0, arg1)
	ret0, _ := ret[0].(*AddLogStreamResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddLogStream indicates an expected call of AddLogStream.
func (mr *MockClusterManagerServerMockRecorder) AddLogStream(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLogStream", reflect.TypeOf((*MockClusterManagerServer)(nil).AddLogStream), arg0, arg1)
}

// AddMRPeer mocks base method.
func (m *MockClusterManagerServer) AddMRPeer(arg0 context.Context, arg1 *AddMRPeerRequest) (*AddMRPeerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddMRPeer", arg0, arg1)
	ret0, _ := ret[0].(*AddMRPeerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddMRPeer indicates an expected call of AddMRPeer.
func (mr *MockClusterManagerServerMockRecorder) AddMRPeer(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddMRPeer", reflect.TypeOf((*MockClusterManagerServer)(nil).AddMRPeer), arg0, arg1)
}

// AddMetadataRepositoryNode mocks base method.
func (m *MockClusterManagerServer) AddMetadataRepositoryNode(arg0 context.Context, arg1 *AddMetadataRepositoryNodeRequest) (*AddMetadataRepositoryNodeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddMetadataRepositoryNode", arg0, arg1)
	ret0, _ := ret[0].(*AddMetadataRepositoryNodeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddMetadataRepositoryNode indicates an expected call of AddMetadataRepositoryNode.
func (mr *MockClusterManagerServerMockRecorder) AddMetadataRepositoryNode(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddMetadataRepositoryNode", reflect.TypeOf((*MockClusterManagerServer)(nil).AddMetadataRepositoryNode), arg0, arg1)
}

// AddStorageNode mocks base method.
func (m *MockClusterManagerServer) AddStorageNode(arg0 context.Context, arg1 *AddStorageNodeRequest) (*AddStorageNodeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddStorageNode", arg0, arg1)
	ret0, _ := ret[0].(*AddStorageNodeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddStorageNode indicates an expected call of AddStorageNode.
func (mr *MockClusterManagerServerMockRecorder) AddStorageNode(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddStorageNode", reflect.TypeOf((*MockClusterManagerServer)(nil).AddStorageNode), arg0, arg1)
}

// AddTopic mocks base method.
func (m *MockClusterManagerServer) AddTopic(arg0 context.Context, arg1 *AddTopicRequest) (*AddTopicResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddTopic", arg0, arg1)
	ret0, _ := ret[0].(*AddTopicResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddTopic indicates an expected call of AddTopic.
func (mr *MockClusterManagerServerMockRecorder) AddTopic(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTopic", reflect.TypeOf((*MockClusterManagerServer)(nil).AddTopic), arg0, arg1)
}

// DeleteMetadataRepositoryNode mocks base method.
func (m *MockClusterManagerServer) DeleteMetadataRepositoryNode(arg0 context.Context, arg1 *DeleteMetadataRepositoryNodeRequest) (*DeleteMetadataRepositoryNodeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMetadataRepositoryNode", arg0, arg1)
	ret0, _ := ret[0].(*DeleteMetadataRepositoryNodeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteMetadataRepositoryNode indicates an expected call of DeleteMetadataRepositoryNode.
func (mr *MockClusterManagerServerMockRecorder) DeleteMetadataRepositoryNode(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMetadataRepositoryNode", reflect.TypeOf((*MockClusterManagerServer)(nil).DeleteMetadataRepositoryNode), arg0, arg1)
}

// DescribeTopic mocks base method.
func (m *MockClusterManagerServer) DescribeTopic(arg0 context.Context, arg1 *DescribeTopicRequest) (*DescribeTopicResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTopic", arg0, arg1)
	ret0, _ := ret[0].(*DescribeTopicResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTopic indicates an expected call of DescribeTopic.
func (mr *MockClusterManagerServerMockRecorder) DescribeTopic(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTopic", reflect.TypeOf((*MockClusterManagerServer)(nil).DescribeTopic), arg0, arg1)
}

// GetLogStream mocks base method.
func (m *MockClusterManagerServer) GetLogStream(arg0 context.Context, arg1 *GetLogStreamRequest) (*GetLogStreamResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogStream", arg0, arg1)
	ret0, _ := ret[0].(*GetLogStreamResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLogStream indicates an expected call of GetLogStream.
func (mr *MockClusterManagerServerMockRecorder) GetLogStream(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogStream", reflect.TypeOf((*MockClusterManagerServer)(nil).GetLogStream), arg0, arg1)
}

// GetMRMembers mocks base method.
func (m *MockClusterManagerServer) GetMRMembers(arg0 context.Context, arg1 *types.Empty) (*GetMRMembersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMRMembers", arg0, arg1)
	ret0, _ := ret[0].(*GetMRMembersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMRMembers indicates an expected call of GetMRMembers.
func (mr *MockClusterManagerServerMockRecorder) GetMRMembers(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMRMembers", reflect.TypeOf((*MockClusterManagerServer)(nil).GetMRMembers), arg0, arg1)
}

// GetMetadataRepositoryNode mocks base method.
func (m *MockClusterManagerServer) GetMetadataRepositoryNode(arg0 context.Context, arg1 *GetMetadataRepositoryNodeRequest) (*GetMetadataRepositoryNodeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetadataRepositoryNode", arg0, arg1)
	ret0, _ := ret[0].(*GetMetadataRepositoryNodeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMetadataRepositoryNode indicates an expected call of GetMetadataRepositoryNode.
func (mr *MockClusterManagerServerMockRecorder) GetMetadataRepositoryNode(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadataRepositoryNode", reflect.TypeOf((*MockClusterManagerServer)(nil).GetMetadataRepositoryNode), arg0, arg1)
}

// GetStorageNode mocks base method.
func (m *MockClusterManagerServer) GetStorageNode(arg0 context.Context, arg1 *GetStorageNodeRequest) (*GetStorageNodeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStorageNode", arg0, arg1)
	ret0, _ := ret[0].(*GetStorageNodeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStorageNode indicates an expected call of GetStorageNode.
func (mr *MockClusterManagerServerMockRecorder) GetStorageNode(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageNode", reflect.TypeOf((*MockClusterManagerServer)(nil).GetStorageNode), arg0, arg1)
}

// GetTopic mocks base method.
func (m *MockClusterManagerServer) GetTopic(arg0 context.Context, arg1 *GetTopicRequest) (*GetTopicResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTopic", arg0, arg1)
	ret0, _ := ret[0].(*GetTopicResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTopic indicates an expected call of GetTopic.
func (mr *MockClusterManagerServerMockRecorder) GetTopic(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTopic", reflect.TypeOf((*MockClusterManagerServer)(nil).GetTopic), arg0, arg1)
}

// ListLogStreams mocks base method.
func (m *MockClusterManagerServer) ListLogStreams(arg0 context.Context, arg1 *ListLogStreamsRequest) (*ListLogStreamsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLogStreams", arg0, arg1)
	ret0, _ := ret[0].(*ListLogStreamsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLogStreams indicates an expected call of ListLogStreams.
func (mr *MockClusterManagerServerMockRecorder) ListLogStreams(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLogStreams", reflect.TypeOf((*MockClusterManagerServer)(nil).ListLogStreams), arg0, arg1)
}

// ListMetadataRepositoryNodes mocks base method.
func (m *MockClusterManagerServer) ListMetadataRepositoryNodes(arg0 context.Context, arg1 *ListMetadataRepositoryNodesRequest) (*ListMetadataRepositoryNodesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMetadataRepositoryNodes", arg0, arg1)
	ret0, _ := ret[0].(*ListMetadataRepositoryNodesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMetadataRepositoryNodes indicates an expected call of ListMetadataRepositoryNodes.
func (mr *MockClusterManagerServerMockRecorder) ListMetadataRepositoryNodes(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMetadataRepositoryNodes", reflect.TypeOf((*MockClusterManagerServer)(nil).ListMetadataRepositoryNodes), arg0, arg1)
}

// ListStorageNodes mocks base method.
func (m *MockClusterManagerServer) ListStorageNodes(arg0 context.Context, arg1 *ListStorageNodesRequest) (*ListStorageNodesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListStorageNodes", arg0, arg1)
	ret0, _ := ret[0].(*ListStorageNodesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListStorageNodes indicates an expected call of ListStorageNodes.
func (mr *MockClusterManagerServerMockRecorder) ListStorageNodes(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStorageNodes", reflect.TypeOf((*MockClusterManagerServer)(nil).ListStorageNodes), arg0, arg1)
}

// ListTopics mocks base method.
func (m *MockClusterManagerServer) ListTopics(arg0 context.Context, arg1 *ListTopicsRequest) (*ListTopicsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTopics", arg0, arg1)
	ret0, _ := ret[0].(*ListTopicsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTopics indicates an expected call of ListTopics.
func (mr *MockClusterManagerServerMockRecorder) ListTopics(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTopics", reflect.TypeOf((*MockClusterManagerServer)(nil).ListTopics), arg0, arg1)
}

// RemoveLogStreamReplica mocks base method.
func (m *MockClusterManagerServer) RemoveLogStreamReplica(arg0 context.Context, arg1 *RemoveLogStreamReplicaRequest) (*RemoveLogStreamReplicaResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveLogStreamReplica", arg0, arg1)
	ret0, _ := ret[0].(*RemoveLogStreamReplicaResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveLogStreamReplica indicates an expected call of RemoveLogStreamReplica.
func (mr *MockClusterManagerServerMockRecorder) RemoveLogStreamReplica(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveLogStreamReplica", reflect.TypeOf((*MockClusterManagerServer)(nil).RemoveLogStreamReplica), arg0, arg1)
}

// RemoveMRPeer mocks base method.
func (m *MockClusterManagerServer) RemoveMRPeer(arg0 context.Context, arg1 *RemoveMRPeerRequest) (*RemoveMRPeerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveMRPeer", arg0, arg1)
	ret0, _ := ret[0].(*RemoveMRPeerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveMRPeer indicates an expected call of RemoveMRPeer.
func (mr *MockClusterManagerServerMockRecorder) RemoveMRPeer(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveMRPeer", reflect.TypeOf((*MockClusterManagerServer)(nil).RemoveMRPeer), arg0, arg1)
}

// Seal mocks base method.
func (m *MockClusterManagerServer) Seal(arg0 context.Context, arg1 *SealRequest) (*SealResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Seal", arg0, arg1)
	ret0, _ := ret[0].(*SealResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Seal indicates an expected call of Seal.
func (mr *MockClusterManagerServerMockRecorder) Seal(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seal", reflect.TypeOf((*MockClusterManagerServer)(nil).Seal), arg0, arg1)
}

// Sync mocks base method.
func (m *MockClusterManagerServer) Sync(arg0 context.Context, arg1 *SyncRequest) (*SyncResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Sync", arg0, arg1)
	ret0, _ := ret[0].(*SyncResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Sync indicates an expected call of Sync.
func (mr *MockClusterManagerServerMockRecorder) Sync(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sync", reflect.TypeOf((*MockClusterManagerServer)(nil).Sync), arg0, arg1)
}

// Trim mocks base method.
func (m *MockClusterManagerServer) Trim(arg0 context.Context, arg1 *TrimRequest) (*TrimResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trim", arg0, arg1)
	ret0, _ := ret[0].(*TrimResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Trim indicates an expected call of Trim.
func (mr *MockClusterManagerServerMockRecorder) Trim(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trim", reflect.TypeOf((*MockClusterManagerServer)(nil).Trim), arg0, arg1)
}

// UnregisterLogStream mocks base method.
func (m *MockClusterManagerServer) UnregisterLogStream(arg0 context.Context, arg1 *UnregisterLogStreamRequest) (*UnregisterLogStreamResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnregisterLogStream", arg0, arg1)
	ret0, _ := ret[0].(*UnregisterLogStreamResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnregisterLogStream indicates an expected call of UnregisterLogStream.
func (mr *MockClusterManagerServerMockRecorder) UnregisterLogStream(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterLogStream", reflect.TypeOf((*MockClusterManagerServer)(nil).UnregisterLogStream), arg0, arg1)
}

// UnregisterStorageNode mocks base method.
func (m *MockClusterManagerServer) UnregisterStorageNode(arg0 context.Context, arg1 *UnregisterStorageNodeRequest) (*UnregisterStorageNodeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnregisterStorageNode", arg0, arg1)
	ret0, _ := ret[0].(*UnregisterStorageNodeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnregisterStorageNode indicates an expected call of UnregisterStorageNode.
func (mr *MockClusterManagerServerMockRecorder) UnregisterStorageNode(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterStorageNode", reflect.TypeOf((*MockClusterManagerServer)(nil).UnregisterStorageNode), arg0, arg1)
}

// UnregisterTopic mocks base method.
func (m *MockClusterManagerServer) UnregisterTopic(arg0 context.Context, arg1 *UnregisterTopicRequest) (*UnregisterTopicResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnregisterTopic", arg0, arg1)
	ret0, _ := ret[0].(*UnregisterTopicResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnregisterTopic indicates an expected call of UnregisterTopic.
func (mr *MockClusterManagerServerMockRecorder) UnregisterTopic(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterTopic", reflect.TypeOf((*MockClusterManagerServer)(nil).UnregisterTopic), arg0, arg1)
}

// Unseal mocks base method.
func (m *MockClusterManagerServer) Unseal(arg0 context.Context, arg1 *UnsealRequest) (*UnsealResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Unseal", arg0, arg1)
	ret0, _ := ret[0].(*UnsealResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Unseal indicates an expected call of Unseal.
func (mr *MockClusterManagerServerMockRecorder) Unseal(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unseal", reflect.TypeOf((*MockClusterManagerServer)(nil).Unseal), arg0, arg1)
}

// UpdateLogStream mocks base method.
func (m *MockClusterManagerServer) UpdateLogStream(arg0 context.Context, arg1 *UpdateLogStreamRequest) (*UpdateLogStreamResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateLogStream", arg0, arg1)
	ret0, _ := ret[0].(*UpdateLogStreamResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateLogStream indicates an expected call of UpdateLogStream.
func (mr *MockClusterManagerServerMockRecorder) UpdateLogStream(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLogStream", reflect.TypeOf((*MockClusterManagerServer)(nil).UpdateLogStream), arg0, arg1)
}