snpb_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/kakao/varlog/proto/snpb (interfaces: ReplicatorClient,ReplicatorServer,Replicator_ReplicateClient,LogIOClient,LogIOServer,LogIO_AppendClient,LogIO_SubscribeClient,LogIO_SubscribeServer,LogStreamReporterClient,LogStreamReporterServer,ManagementClient,ManagementServer)
//
// Generated by this command:
//
//	mockgen -build_flags -mod=vendor -package mock -destination mock/snpb_mock.go . ReplicatorClient,ReplicatorServer,Replicator_ReplicateClient,LogIOClient,LogIOServer,LogIO_AppendClient,LogIO_SubscribeClient,LogIO_SubscribeServer,LogStreamReporterClient,LogStreamReporterServer,ManagementClient,ManagementServer
//

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

import (
	context "context"
	reflect "reflect"

	types "github.com/gogo/protobuf/types"
	gomock "go.uber.org/mock/gomock"
	grpc "google.golang.org/grpc"
	metadata "google.golang.org/grpc/metadata"

	snpb "github.com/kakao/varlog/proto/snpb"
)

// MockReplicatorClient is a mock of ReplicatorClient interface.
type MockReplicatorClient struct {
	ctrl     *gomock.Controller
	recorder *MockReplicatorClientMockRecorder
}

// MockReplicatorClientMockRecorder is the mock recorder for MockReplicatorClient.
type MockReplicatorClientMockRecorder struct {
	mock *MockReplicatorClient
}

// NewMockReplicatorClient creates a new mock instance.
func NewMockReplicatorClient(ctrl *gomock.Controller) *MockReplicatorClient {
	mock := &MockReplicatorClient{ctrl: ctrl}
	mock.recorder = &MockReplicatorClientMockRecorder{mock}
	return mock
}

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

// Replicate mocks base method.
func (m *MockReplicatorClient) Replicate(arg0 context.Context, arg1 ...grpc.CallOption) (snpb.Replicator_ReplicateClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Replicate", varargs...)
	ret0, _ := ret[0].(snpb.Replicator_ReplicateClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Replicate indicates an expected call of Replicate.
func (mr *MockReplicatorClientMockRecorder) Replicate(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Replicate", reflect.TypeOf((*MockReplicatorClient)(nil).Replicate), varargs...)
}

// SyncInit mocks base method.
func (m *MockReplicatorClient) SyncInit(arg0 context.Context, arg1 *snpb.SyncInitRequest, arg2 ...grpc.CallOption) (*snpb.SyncInitResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SyncInit", varargs...)
	ret0, _ := ret[0].(*snpb.SyncInitResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SyncReplicate mocks base method.
func (m *MockReplicatorClient) SyncReplicate(arg0 context.Context, arg1 *snpb.SyncReplicateRequest, arg2 ...grpc.CallOption) (*snpb.SyncReplicateResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SyncReplicate", varargs...)
	ret0, _ := ret[0].(*snpb.SyncReplicateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SyncReplicateStream mocks base method.
func (m *MockReplicatorClient) SyncReplicateStream(arg0 context.Context, arg1 ...grpc.CallOption) (snpb.Replicator_SyncReplicateStreamClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SyncReplicateStream", varargs...)
	ret0, _ := ret[0].(snpb.Replicator_SyncReplicateStreamClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SyncReplicateStream indicates an expected call of SyncReplicateStream.
func (mr *MockReplicatorClientMockRecorder) SyncReplicateStream(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncReplicateStream", reflect.TypeOf((*MockReplicatorClient)(nil).SyncReplicateStream), varargs...)
}

// MockReplicatorServer is a mock of ReplicatorServer interface.
type MockReplicatorServer struct {
	ctrl     *gomock.Controller
	recorder *MockReplicatorServerMockRecorder
}

// MockReplicatorServerMockRecorder is the mock recorder for MockReplicatorServer.
type MockReplicatorServerMockRecorder struct {
	mock *MockReplicatorServer
}

// NewMockReplicatorServer creates a new mock instance.
func NewMockReplicatorServer(ctrl *gomock.Controller) *MockReplicatorServer {
	mock := &MockReplicatorServer{ctrl: ctrl}
	mock.recorder = &MockReplicatorServerMockRecorder{mock}
	return mock
}

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

// Replicate mocks base method.
func (m *MockReplicatorServer) Replicate(arg0 snpb.Replicator_ReplicateServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Replicate", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Replicate indicates an expected call of Replicate.
func (mr *MockReplicatorServerMockRecorder) Replicate(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Replicate", reflect.TypeOf((*MockReplicatorServer)(nil).Replicate), arg0)
}

// SyncInit mocks base method.
func (m *MockReplicatorServer) SyncInit(arg0 context.Context, arg1 *snpb.SyncInitRequest) (*snpb.SyncInitResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SyncInit", arg0, arg1)
	ret0, _ := ret[0].(*snpb.SyncInitResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SyncInit indicates an expected call of SyncInit.
func (mr *MockReplicatorServerMockRecorder) SyncInit(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncInit", reflect.TypeOf((*MockReplicatorServer)(nil).SyncInit), arg0, arg1)
}

// SyncReplicate mocks base method.
func (m *MockReplicatorServer) SyncReplicate(arg0 context.Context, arg1 *snpb.SyncReplicateRequest) (*snpb.SyncReplicateResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SyncReplicate", arg0, arg1)
	ret0, _ := ret[0].(*snpb.SyncReplicateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SyncReplicate indicates an expected call of SyncReplicate.
func (mr *MockReplicatorServerMockRecorder) SyncReplicate(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncReplicate", reflect.TypeOf((*MockReplicatorServer)(nil).SyncReplicate), arg0, arg1)
}

// SyncReplicateStream mocks base method.
func (m *MockReplicatorServer) SyncReplicateStream(arg0 snpb.Replicator_SyncReplicateStreamServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SyncReplicateStream", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SyncReplicateStream indicates an expected call of SyncReplicateStream.
func (mr *MockReplicatorServerMockRecorder) SyncReplicateStream(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncReplicateStream", reflect.TypeOf((*MockReplicatorServer)(nil).SyncReplicateStream), arg0)
}

// MockReplicator_ReplicateClient is a mock of Replicator_ReplicateClient interface.
type MockReplicator_ReplicateClient struct {
	ctrl     *gomock.Controller
	recorder *MockReplicator_ReplicateClientMockRecorder
}

// MockReplicator_ReplicateClientMockRecorder is the mock recorder for MockReplicator_ReplicateClient.
type MockReplicator_ReplicateClientMockRecorder struct {
	mock *MockReplicator_ReplicateClient
}

// NewMockReplicator_ReplicateClient creates a new mock instance.
func NewMockReplicator_ReplicateClient(ctrl *gomock.Controller) *MockReplicator_ReplicateClient {
	mock := &MockReplicator_ReplicateClient{ctrl: ctrl}
	mock.recorder = &MockReplicator_ReplicateClientMockRecorder{mock}
	return mock
}

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

// CloseAndRecv mocks base method.
func (m *MockReplicator_ReplicateClient) CloseAndRecv() (*snpb.ReplicateResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseAndRecv")
	ret0, _ := ret[0].(*snpb.ReplicateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CloseAndRecv indicates an expected call of CloseAndRecv.
func (mr *MockReplicator_ReplicateClientMockRecorder) CloseAndRecv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseAndRecv", reflect.TypeOf((*MockReplicator_ReplicateClient)(nil).CloseAndRecv))
}

// CloseSend mocks base method.
func (m *MockReplicator_ReplicateClient) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockReplicator_ReplicateClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockReplicator_ReplicateClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockReplicator_ReplicateClient) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockReplicator_ReplicateClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockReplicator_ReplicateClient)(nil).Context))
}

// Header mocks base method.
func (m *MockReplicator_ReplicateClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockReplicator_ReplicateClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockReplicator_ReplicateClient)(nil).Header))
}

// RecvMsg mocks base method.
func (m *MockReplicator_ReplicateClient) RecvMsg(arg0 any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RecvMsg", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockReplicator_ReplicateClientMockRecorder) RecvMsg(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockReplicator_ReplicateClient)(nil).RecvMsg), arg0)
}

// Send mocks base method.
func (m *MockReplicator_ReplicateClient) Send(arg0 *snpb.ReplicateRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockReplicator_ReplicateClientMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockReplicator_ReplicateClient)(nil).Send), arg0)
}

// SendMsg mocks base method.
func (m *MockReplicator_ReplicateClient) SendMsg(arg0 any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendMsg", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockReplicator_ReplicateClientMockRecorder) SendMsg(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockReplicator_ReplicateClient)(nil).SendMsg), arg0)
}

// Trailer mocks base method.
func (m *MockReplicator_ReplicateClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockReplicator_ReplicateClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockReplicator_ReplicateClient)(nil).Trailer))
}

// MockLogIOClient is a mock of LogIOClient interface.
type MockLogIOClient struct {
	ctrl     *gomock.Controller
	recorder *MockLogIOClientMockRecorder
}

// MockLogIOClientMockRecorder is the mock recorder for MockLogIOClient.
type MockLogIOClientMockRecorder struct {
	mock *MockLogIOClient
}

// NewMockLogIOClient creates a new mock instance.
func NewMockLogIOClient(ctrl *gomock.Controller) *MockLogIOClient {
	mock := &MockLogIOClient{ctrl: ctrl}
	mock.recorder = &MockLogIOClientMockRecorder{mock}
	return mock
}

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

// Append mocks base method.
func (m *MockLogIOClient) Append(arg0 context.Context, arg1 ...grpc.CallOption) (snpb.LogIO_AppendClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Append", varargs...)
	ret0, _ := ret[0].(snpb.LogIO_AppendClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Append indicates an expected call of Append.
func (mr *MockLogIOClientMockRecorder) Append(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Append", reflect.TypeOf((*MockLogIOClient)(nil).Append), varargs...)
}

// LogStreamReplicaMetadata mocks base method.
func (m *MockLogIOClient) LogStreamReplicaMetadata(arg0 context.Context, arg1 *snpb.LogStreamReplicaMetadataRequest, arg2 ...grpc.CallOption) (*snpb.LogStreamReplicaMetadataResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LogStreamReplicaMetadata", varargs...)
	ret0, _ := ret[0].(*snpb.LogStreamReplicaMetadataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Read mocks base method.
func (m *MockLogIOClient) Read(arg0 context.Context, arg1 *snpb.ReadRequest, arg2 ...grpc.CallOption) (*snpb.ReadResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Read", varargs...)
	ret0, _ := ret[0].(*snpb.ReadResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Subscribe mocks base method.
func (m *MockLogIOClient) Subscribe(arg0 context.Context, arg1 *snpb.SubscribeRequest, arg2 ...grpc.CallOption) (snpb.LogIO_SubscribeClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Subscribe", varargs...)
	ret0, _ := ret[0].(snpb.LogIO_SubscribeClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SubscribeTo mocks base method.
func (m *MockLogIOClient) SubscribeTo(arg0 context.Context, arg1 *snpb.SubscribeToRequest, arg2 ...grpc.CallOption) (snpb.LogIO_SubscribeToClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SubscribeTo", varargs...)
	ret0, _ := ret[0].(snpb.LogIO_SubscribeToClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// MockLogIOServer is a mock of LogIOServer interface.
type MockLogIOServer struct {
	ctrl     *gomock.Controller
	recorder *MockLogIOServerMockRecorder
}

// MockLogIOServerMockRecorder is the mock recorder for MockLogIOServer.
type MockLogIOServerMockRecorder struct {
	mock *MockLogIOServer
}

// NewMockLogIOServer creates a new mock instance.
func NewMockLogIOServer(ctrl *gomock.Controller) *MockLogIOServer {
	mock := &MockLogIOServer{ctrl: ctrl}
	mock.recorder = &MockLogIOServerMockRecorder{mock}
	return mock
}

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

// Append mocks base method.
func (m *MockLogIOServer) Append(arg0 snpb.LogIO_AppendServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Append", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Append indicates an expected call of Append.
func (mr *MockLogIOServerMockRecorder) Append(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Append", reflect.TypeOf((*MockLogIOServer)(nil).Append), arg0)
}

// LogStreamReplicaMetadata mocks base method.
func (m *MockLogIOServer) LogStreamReplicaMetadata(arg0 context.Context, arg1 *snpb.LogStreamReplicaMetadataRequest) (*snpb.LogStreamReplicaMetadataResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LogStreamReplicaMetadata", arg0, arg1)
	ret0, _ := ret[0].(*snpb.LogStreamReplicaMetadataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LogStreamReplicaMetadata indicates an expected call of LogStreamReplicaMetadata.
func (mr *MockLogIOServerMockRecorder) LogStreamReplicaMetadata(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogStreamReplicaMetadata", reflect.TypeOf((*MockLogIOServer)(nil).LogStreamReplicaMetadata), arg0, arg1)
}

// Read mocks base method.
func (m *MockLogIOServer) Read(arg0 context.Context, arg1 *snpb.ReadRequest) (*snpb.ReadResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", arg0, arg1)
	ret0, _ := ret[0].(*snpb.ReadResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Read indicates an expected call of Read.
func (mr *MockLogIOServerMockRecorder) Read(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockLogIOServer)(nil).Read), arg0, arg1)
}

// Subscribe mocks base method.
func (m *MockLogIOServer) Subscribe(arg0 *snpb.SubscribeRequest, arg1 snpb.LogIO_SubscribeServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Subscribe", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Subscribe indicates an expected call of Subscribe.
func (mr *MockLogIOServerMockRecorder) Subscribe(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Subscribe", reflect.TypeOf((*MockLogIOServer)(nil).Subscribe), arg0, arg1)
}

// SubscribeTo mocks base method.
func (m *MockLogIOServer) SubscribeTo(arg0 *snpb.SubscribeToRequest, arg1 snpb.LogIO_SubscribeToServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribeTo", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// SubscribeTo indicates an expected call of SubscribeTo.
func (mr *MockLogIOServerMockRecorder) SubscribeTo(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeTo", reflect.TypeOf((*MockLogIOServer)(nil).SubscribeTo), arg0, arg1)
}

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

// TrimDeprecated indicates an expected call of TrimDeprecated.
func (mr *MockLogIOServerMockRecorder) TrimDeprecated(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TrimDeprecated", reflect.TypeOf((*MockLogIOServer)(nil).TrimDeprecated), arg0, arg1)
}

// MockLogIO_AppendClient is a mock of LogIO_AppendClient interface.
type MockLogIO_AppendClient struct {
	ctrl     *gomock.Controller
	recorder *MockLogIO_AppendClientMockRecorder
}

// MockLogIO_AppendClientMockRecorder is the mock recorder for MockLogIO_AppendClient.
type MockLogIO_AppendClientMockRecorder struct {
	mock *MockLogIO_AppendClient
}

// NewMockLogIO_AppendClient creates a new mock instance.
func NewMockLogIO_AppendClient(ctrl *gomock.Controller) *MockLogIO_AppendClient {
	mock := &MockLogIO_AppendClient{ctrl: ctrl}
	mock.recorder = &MockLogIO_AppendClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockLogIO_AppendClient) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockLogIO_AppendClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockLogIO_AppendClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockLogIO_AppendClient) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLogIO_AppendClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLogIO_AppendClient)(nil).Context))
}

// Header mocks base method.
func (m *MockLogIO_AppendClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockLogIO_AppendClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockLogIO_AppendClient)(nil).Header))
}

// Recv mocks base method.
func (m *MockLogIO_AppendClient) Recv() (*snpb.AppendResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*snpb.AppendResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockLogIO_AppendClientMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockLogIO_AppendClient)(nil).Recv))
}

// RecvMsg mocks base method.
func (m *MockLogIO_AppendClient) RecvMsg(arg0 any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RecvMsg", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLogIO_AppendClientMockRecorder) RecvMsg(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLogIO_AppendClient)(nil).RecvMsg), arg0)
}

// Send mocks base method.
func (m *MockLogIO_AppendClient) Send(arg0 *snpb.AppendRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockLogIO_AppendClientMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockLogIO_AppendClient)(nil).Send), arg0)
}

// SendMsg mocks base method.
func (m *MockLogIO_AppendClient) SendMsg(arg0 any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendMsg", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLogIO_AppendClientMockRecorder) SendMsg(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLogIO_AppendClient)(nil).SendMsg), arg0)
}

// Trailer mocks base method.
func (m *MockLogIO_AppendClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockLogIO_AppendClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockLogIO_AppendClient)(nil).Trailer))
}

// MockLogIO_SubscribeClient is a mock of LogIO_SubscribeClient interface.
type MockLogIO_SubscribeClient struct {
	ctrl     *gomock.Controller
	recorder *MockLogIO_SubscribeClientMockRecorder
}

// MockLogIO_SubscribeClientMockRecorder is the mock recorder for MockLogIO_SubscribeClient.
type MockLogIO_SubscribeClientMockRecorder struct {
	mock *MockLogIO_SubscribeClient
}

// NewMockLogIO_SubscribeClient creates a new mock instance.
func NewMockLogIO_SubscribeClient(ctrl *gomock.Controller) *MockLogIO_SubscribeClient {
	mock := &MockLogIO_SubscribeClient{ctrl: ctrl}
	mock.recorder = &MockLogIO_SubscribeClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockLogIO_SubscribeClient) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockLogIO_SubscribeClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockLogIO_SubscribeClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockLogIO_SubscribeClient) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLogIO_SubscribeClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLogIO_SubscribeClient)(nil).Context))
}

// Header mocks base method.
func (m *MockLogIO_SubscribeClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockLogIO_SubscribeClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockLogIO_SubscribeClient)(nil).Header))
}

// Recv mocks base method.
func (m *MockLogIO_SubscribeClient) Recv() (*snpb.SubscribeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*snpb.SubscribeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockLogIO_SubscribeClientMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockLogIO_SubscribeClient)(nil).Recv))
}

// RecvMsg mocks base method.
func (m *MockLogIO_SubscribeClient) RecvMsg(arg0 any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RecvMsg", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLogIO_SubscribeClientMockRecorder) RecvMsg(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLogIO_SubscribeClient)(nil).RecvMsg), arg0)
}

// SendMsg mocks base method.
func (m *MockLogIO_SubscribeClient) SendMsg(arg0 any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendMsg", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLogIO_SubscribeClientMockRecorder) SendMsg(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLogIO_SubscribeClient)(nil).SendMsg), arg0)
}

// Trailer mocks base method.
func (m *MockLogIO_SubscribeClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockLogIO_SubscribeClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockLogIO_SubscribeClient)(nil).Trailer))
}

// MockLogIO_SubscribeServer is a mock of LogIO_SubscribeServer interface.
type MockLogIO_SubscribeServer struct {
	ctrl     *gomock.Controller
	recorder *MockLogIO_SubscribeServerMockRecorder
}

// MockLogIO_SubscribeServerMockRecorder is the mock recorder for MockLogIO_SubscribeServer.
type MockLogIO_SubscribeServerMockRecorder struct {
	mock *MockLogIO_SubscribeServer
}

// NewMockLogIO_SubscribeServer creates a new mock instance.
func NewMockLogIO_SubscribeServer(ctrl *gomock.Controller) *MockLogIO_SubscribeServer {
	mock := &MockLogIO_SubscribeServer{ctrl: ctrl}
	mock.recorder = &MockLogIO_SubscribeServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockLogIO_SubscribeServer) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLogIO_SubscribeServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLogIO_SubscribeServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m *MockLogIO_SubscribeServer) RecvMsg(arg0 any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RecvMsg", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLogIO_SubscribeServerMockRecorder) RecvMsg(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLogIO_SubscribeServer)(nil).RecvMsg), arg0)
}

// Send mocks base method.
func (m *MockLogIO_SubscribeServer) Send(arg0 *snpb.SubscribeResponse) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockLogIO_SubscribeServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockLogIO_SubscribeServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockLogIO_SubscribeServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockLogIO_SubscribeServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockLogIO_SubscribeServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m *MockLogIO_SubscribeServer) SendMsg(arg0 any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendMsg", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLogIO_SubscribeServerMockRecorder) SendMsg(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLogIO_SubscribeServer)(nil).SendMsg), arg0)
}

// SetHeader mocks base method.
func (m *MockLogIO_SubscribeServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockLogIO_SubscribeServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockLogIO_SubscribeServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockLogIO_SubscribeServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockLogIO_SubscribeServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockLogIO_SubscribeServer)(nil).SetTrailer), arg0)
}

// MockLogStreamReporterClient is a mock of LogStreamReporterClient interface.
type MockLogStreamReporterClient struct {
	ctrl     *gomock.Controller
	recorder *MockLogStreamReporterClientMockRecorder
}

// MockLogStreamReporterClientMockRecorder is the mock recorder for MockLogStreamReporterClient.
type MockLogStreamReporterClientMockRecorder struct {
	mock *MockLogStreamReporterClient
}

// NewMockLogStreamReporterClient creates a new mock instance.
func NewMockLogStreamReporterClient(ctrl *gomock.Controller) *MockLogStreamReporterClient {
	mock := &MockLogStreamReporterClient{ctrl: ctrl}
	mock.recorder = &MockLogStreamReporterClientMockRecorder{mock}
	return mock
}

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

// Commit mocks base method.
func (m *MockLogStreamReporterClient) Commit(arg0 context.Context, arg1 ...grpc.CallOption) (snpb.LogStreamReporter_CommitClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Commit", varargs...)
	ret0, _ := ret[0].(snpb.LogStreamReporter_CommitClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Commit indicates an expected call of Commit.
func (mr *MockLogStreamReporterClientMockRecorder) Commit(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockLogStreamReporterClient)(nil).Commit), varargs...)
}

// CommitBatch mocks base method.
func (m *MockLogStreamReporterClient) CommitBatch(arg0 context.Context, arg1 ...grpc.CallOption) (snpb.LogStreamReporter_CommitBatchClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CommitBatch", varargs...)
	ret0, _ := ret[0].(snpb.LogStreamReporter_CommitBatchClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CommitBatch indicates an expected call of CommitBatch.
func (mr *MockLogStreamReporterClientMockRecorder) CommitBatch(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommitBatch", reflect.TypeOf((*MockLogStreamReporterClient)(nil).CommitBatch), varargs...)
}

// GetReport mocks base method.
func (m *MockLogStreamReporterClient) GetReport(arg0 context.Context, arg1 ...grpc.CallOption) (snpb.LogStreamReporter_GetReportClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetReport", varargs...)
	ret0, _ := ret[0].(snpb.LogStreamReporter_GetReportClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReport indicates an expected call of GetReport.
func (mr *MockLogStreamReporterClientMockRecorder) GetReport(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReport", reflect.TypeOf((*MockLogStreamReporterClient)(nil).GetReport), varargs...)
}

// MockLogStreamReporterServer is a mock of LogStreamReporterServer interface.
type MockLogStreamReporterServer struct {
	ctrl     *gomock.Controller
	recorder *MockLogStreamReporterServerMockRecorder
}

// MockLogStreamReporterServerMockRecorder is the mock recorder for MockLogStreamReporterServer.
type MockLogStreamReporterServerMockRecorder struct {
	mock *MockLogStreamReporterServer
}

// NewMockLogStreamReporterServer creates a new mock instance.
func NewMockLogStreamReporterServer(ctrl *gomock.Controller) *MockLogStreamReporterServer {
	mock := &MockLogStreamReporterServer{ctrl: ctrl}
	mock.recorder = &MockLogStreamReporterServerMockRecorder{mock}
	return mock
}

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

// Commit mocks base method.
func (m *MockLogStreamReporterServer) Commit(arg0 snpb.LogStreamReporter_CommitServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Commit", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Commit indicates an expected call of Commit.
func (mr *MockLogStreamReporterServerMockRecorder) Commit(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockLogStreamReporterServer)(nil).Commit), arg0)
}

// CommitBatch mocks base method.
func (m *MockLogStreamReporterServer) CommitBatch(arg0 snpb.LogStreamReporter_CommitBatchServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CommitBatch", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// CommitBatch indicates an expected call of CommitBatch.
func (mr *MockLogStreamReporterServerMockRecorder) CommitBatch(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommitBatch", reflect.TypeOf((*MockLogStreamReporterServer)(nil).CommitBatch), arg0)
}

// GetReport mocks base method.
func (m *MockLogStreamReporterServer) GetReport(arg0 snpb.LogStreamReporter_GetReportServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReport", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetReport indicates an expected call of GetReport.
func (mr *MockLogStreamReporterServerMockRecorder) GetReport(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReport", reflect.TypeOf((*MockLogStreamReporterServer)(nil).GetReport), arg0)
}

// MockManagementClient is a mock of ManagementClient interface.
type MockManagementClient struct {
	ctrl     *gomock.Controller
	recorder *MockManagementClientMockRecorder
}

// MockManagementClientMockRecorder is the mock recorder for MockManagementClient.
type MockManagementClientMockRecorder struct {
	mock *MockManagementClient
}

// NewMockManagementClient creates a new mock instance.
func NewMockManagementClient(ctrl *gomock.Controller) *MockManagementClient {
	mock := &MockManagementClient{ctrl: ctrl}
	mock.recorder = &MockManagementClientMockRecorder{mock}
	return mock
}

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

// AddLogStreamReplica mocks base method.
func (m *MockManagementClient) AddLogStreamReplica(arg0 context.Context, arg1 *snpb.AddLogStreamReplicaRequest, arg2 ...grpc.CallOption) (*snpb.AddLogStreamReplicaResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddLogStreamReplica", varargs...)
	ret0, _ := ret[0].(*snpb.AddLogStreamReplicaResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetMetadata mocks base method.
func (m *MockManagementClient) GetMetadata(arg0 context.Context, arg1 *snpb.GetMetadataRequest, arg2 ...grpc.CallOption) (*snpb.GetMetadataResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMetadata", varargs...)
	ret0, _ := ret[0].(*snpb.GetMetadataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

// MockManagementServer is a mock of ManagementServer interface.
type MockManagementServer struct {
	ctrl     *gomock.Controller
	recorder *MockManagementServerMockRecorder
}

// MockManagementServerMockRecorder is the mock recorder for MockManagementServer.
type MockManagementServerMockRecorder struct {
	mock *MockManagementServer
}

// NewMockManagementServer creates a new mock instance.
func NewMockManagementServer(ctrl *gomock.Controller) *MockManagementServer {
	mock := &MockManagementServer{ctrl: ctrl}
	mock.recorder = &MockManagementServerMockRecorder{mock}
	return mock
}

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

// AddLogStreamReplica mocks base method.
func (m *MockManagementServer) AddLogStreamReplica(arg0 context.Context, arg1 *snpb.AddLogStreamReplicaRequest) (*snpb.AddLogStreamReplicaResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddLogStreamReplica", arg0, arg1)
	ret0, _ := ret[0].(*snpb.AddLogStreamReplicaResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddLogStreamReplica indicates an expected call of AddLogStreamReplica.
func (mr *MockManagementServerMockRecorder) AddLogStreamReplica(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLogStreamReplica", reflect.TypeOf((*MockManagementServer)(nil).AddLogStreamReplica), arg0, arg1)
}

// GetMetadata mocks base method.
func (m *MockManagementServer) GetMetadata(arg0 context.Context, arg1 *snpb.GetMetadataRequest) (*snpb.GetMetadataResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetadata", arg0, arg1)
	ret0, _ := ret[0].(*snpb.GetMetadataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMetadata indicates an expected call of GetMetadata.
func (mr *MockManagementServerMockRecorder) GetMetadata(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadata", reflect.TypeOf((*MockManagementServer)(nil).GetMetadata), arg0, arg1)
}

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

// RemoveLogStream indicates an expected call of RemoveLogStream.
func (mr *MockManagementServerMockRecorder) RemoveLogStream(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveLogStream", reflect.TypeOf((*MockManagementServer)(nil).RemoveLogStream), arg0, arg1)
}

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

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

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

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

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

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

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

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