// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/erigontech/erigon/node/direct (interfaces: SentryClient)
//
// Generated by this command:
//
//	mockgen -typed=true -destination=./sentry_client_mock.go -package=direct . SentryClient
//

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

import (
	context "context"
	reflect "reflect"

	sentryproto "github.com/erigontech/erigon/node/gointerfaces/sentryproto"
	typesproto "github.com/erigontech/erigon/node/gointerfaces/typesproto"
	gomock "go.uber.org/mock/gomock"
	grpc "google.golang.org/grpc"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// MockSentryClient is a mock of SentryClient interface.
type MockSentryClient struct {
	ctrl     *gomock.Controller
	recorder *MockSentryClientMockRecorder
	isgomock struct{}
}

// MockSentryClientMockRecorder is the mock recorder for MockSentryClient.
type MockSentryClientMockRecorder struct {
	mock *MockSentryClient
}

// NewMockSentryClient creates a new mock instance.
func NewMockSentryClient(ctrl *gomock.Controller) *MockSentryClient {
	mock := &MockSentryClient{ctrl: ctrl}
	mock.recorder = &MockSentryClientMockRecorder{mock}
	return mock
}

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

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

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

// MockSentryClientAddPeerCall wrap *gomock.Call
type MockSentryClientAddPeerCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientAddPeerCall) Return(arg0 *sentryproto.AddPeerReply, arg1 error) *MockSentryClientAddPeerCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientAddPeerCall) Do(f func(context.Context, *sentryproto.AddPeerRequest, ...grpc.CallOption) (*sentryproto.AddPeerReply, error)) *MockSentryClientAddPeerCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientAddPeerCall) DoAndReturn(f func(context.Context, *sentryproto.AddPeerRequest, ...grpc.CallOption) (*sentryproto.AddPeerReply, error)) *MockSentryClientAddPeerCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

// MockSentryClientAddTrustedPeerCall wrap *gomock.Call
type MockSentryClientAddTrustedPeerCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientAddTrustedPeerCall) Return(arg0 *sentryproto.AddPeerReply, arg1 error) *MockSentryClientAddTrustedPeerCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientAddTrustedPeerCall) Do(f func(context.Context, *sentryproto.AddPeerRequest, ...grpc.CallOption) (*sentryproto.AddPeerReply, error)) *MockSentryClientAddTrustedPeerCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientAddTrustedPeerCall) DoAndReturn(f func(context.Context, *sentryproto.AddPeerRequest, ...grpc.CallOption) (*sentryproto.AddPeerReply, error)) *MockSentryClientAddTrustedPeerCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

// MockSentryClientHandShakeCall wrap *gomock.Call
type MockSentryClientHandShakeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientHandShakeCall) Return(arg0 *sentryproto.HandShakeReply, arg1 error) *MockSentryClientHandShakeCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientHandShakeCall) Do(f func(context.Context, *emptypb.Empty, ...grpc.CallOption) (*sentryproto.HandShakeReply, error)) *MockSentryClientHandShakeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientHandShakeCall) DoAndReturn(f func(context.Context, *emptypb.Empty, ...grpc.CallOption) (*sentryproto.HandShakeReply, error)) *MockSentryClientHandShakeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MarkDisconnected mocks base method.
func (m *MockSentryClient) MarkDisconnected() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "MarkDisconnected")
}

// MarkDisconnected indicates an expected call of MarkDisconnected.
func (mr *MockSentryClientMockRecorder) MarkDisconnected() *MockSentryClientMarkDisconnectedCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkDisconnected", reflect.TypeOf((*MockSentryClient)(nil).MarkDisconnected))
	return &MockSentryClientMarkDisconnectedCall{Call: call}
}

// MockSentryClientMarkDisconnectedCall wrap *gomock.Call
type MockSentryClientMarkDisconnectedCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientMarkDisconnectedCall) Return() *MockSentryClientMarkDisconnectedCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientMarkDisconnectedCall) Do(f func()) *MockSentryClientMarkDisconnectedCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientMarkDisconnectedCall) DoAndReturn(f func()) *MockSentryClientMarkDisconnectedCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Messages mocks base method.
func (m *MockSentryClient) Messages(ctx context.Context, in *sentryproto.MessagesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[sentryproto.InboundMessage], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Messages", varargs...)
	ret0, _ := ret[0].(grpc.ServerStreamingClient[sentryproto.InboundMessage])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockSentryClientMessagesCall wrap *gomock.Call
type MockSentryClientMessagesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientMessagesCall) Return(arg0 grpc.ServerStreamingClient[sentryproto.InboundMessage], arg1 error) *MockSentryClientMessagesCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientMessagesCall) Do(f func(context.Context, *sentryproto.MessagesRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[sentryproto.InboundMessage], error)) *MockSentryClientMessagesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientMessagesCall) DoAndReturn(f func(context.Context, *sentryproto.MessagesRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[sentryproto.InboundMessage], error)) *MockSentryClientMessagesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

// MockSentryClientNodeInfoCall wrap *gomock.Call
type MockSentryClientNodeInfoCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientNodeInfoCall) Return(arg0 *typesproto.NodeInfoReply, arg1 error) *MockSentryClientNodeInfoCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientNodeInfoCall) Do(f func(context.Context, *emptypb.Empty, ...grpc.CallOption) (*typesproto.NodeInfoReply, error)) *MockSentryClientNodeInfoCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientNodeInfoCall) DoAndReturn(f func(context.Context, *emptypb.Empty, ...grpc.CallOption) (*typesproto.NodeInfoReply, error)) *MockSentryClientNodeInfoCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

// MockSentryClientPeerByIdCall wrap *gomock.Call
type MockSentryClientPeerByIdCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientPeerByIdCall) Return(arg0 *sentryproto.PeerByIdReply, arg1 error) *MockSentryClientPeerByIdCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientPeerByIdCall) Do(f func(context.Context, *sentryproto.PeerByIdRequest, ...grpc.CallOption) (*sentryproto.PeerByIdReply, error)) *MockSentryClientPeerByIdCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientPeerByIdCall) DoAndReturn(f func(context.Context, *sentryproto.PeerByIdRequest, ...grpc.CallOption) (*sentryproto.PeerByIdReply, error)) *MockSentryClientPeerByIdCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

// MockSentryClientPeerCountCall wrap *gomock.Call
type MockSentryClientPeerCountCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientPeerCountCall) Return(arg0 *sentryproto.PeerCountReply, arg1 error) *MockSentryClientPeerCountCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientPeerCountCall) Do(f func(context.Context, *sentryproto.PeerCountRequest, ...grpc.CallOption) (*sentryproto.PeerCountReply, error)) *MockSentryClientPeerCountCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientPeerCountCall) DoAndReturn(f func(context.Context, *sentryproto.PeerCountRequest, ...grpc.CallOption) (*sentryproto.PeerCountReply, error)) *MockSentryClientPeerCountCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PeerEvents mocks base method.
func (m *MockSentryClient) PeerEvents(ctx context.Context, in *sentryproto.PeerEventsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[sentryproto.PeerEvent], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PeerEvents", varargs...)
	ret0, _ := ret[0].(grpc.ServerStreamingClient[sentryproto.PeerEvent])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockSentryClientPeerEventsCall wrap *gomock.Call
type MockSentryClientPeerEventsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientPeerEventsCall) Return(arg0 grpc.ServerStreamingClient[sentryproto.PeerEvent], arg1 error) *MockSentryClientPeerEventsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientPeerEventsCall) Do(f func(context.Context, *sentryproto.PeerEventsRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[sentryproto.PeerEvent], error)) *MockSentryClientPeerEventsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientPeerEventsCall) DoAndReturn(f func(context.Context, *sentryproto.PeerEventsRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[sentryproto.PeerEvent], error)) *MockSentryClientPeerEventsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

// MockSentryClientPeersCall wrap *gomock.Call
type MockSentryClientPeersCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientPeersCall) Return(arg0 *sentryproto.PeersReply, arg1 error) *MockSentryClientPeersCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientPeersCall) Do(f func(context.Context, *emptypb.Empty, ...grpc.CallOption) (*sentryproto.PeersReply, error)) *MockSentryClientPeersCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientPeersCall) DoAndReturn(f func(context.Context, *emptypb.Empty, ...grpc.CallOption) (*sentryproto.PeersReply, error)) *MockSentryClientPeersCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

// MockSentryClientPenalizePeerCall wrap *gomock.Call
type MockSentryClientPenalizePeerCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientPenalizePeerCall) Return(arg0 *emptypb.Empty, arg1 error) *MockSentryClientPenalizePeerCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientPenalizePeerCall) Do(f func(context.Context, *sentryproto.PenalizePeerRequest, ...grpc.CallOption) (*emptypb.Empty, error)) *MockSentryClientPenalizePeerCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientPenalizePeerCall) DoAndReturn(f func(context.Context, *sentryproto.PenalizePeerRequest, ...grpc.CallOption) (*emptypb.Empty, error)) *MockSentryClientPenalizePeerCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Protocol indicates an expected call of Protocol.
func (mr *MockSentryClientMockRecorder) Protocol() *MockSentryClientProtocolCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Protocol", reflect.TypeOf((*MockSentryClient)(nil).Protocol))
	return &MockSentryClientProtocolCall{Call: call}
}

// MockSentryClientProtocolCall wrap *gomock.Call
type MockSentryClientProtocolCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientProtocolCall) Return(arg0 uint) *MockSentryClientProtocolCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientProtocolCall) Do(f func() uint) *MockSentryClientProtocolCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientProtocolCall) DoAndReturn(f func() uint) *MockSentryClientProtocolCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Ready indicates an expected call of Ready.
func (mr *MockSentryClientMockRecorder) Ready() *MockSentryClientReadyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ready", reflect.TypeOf((*MockSentryClient)(nil).Ready))
	return &MockSentryClientReadyCall{Call: call}
}

// MockSentryClientReadyCall wrap *gomock.Call
type MockSentryClientReadyCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientReadyCall) Return(arg0 bool) *MockSentryClientReadyCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientReadyCall) Do(f func() bool) *MockSentryClientReadyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientReadyCall) DoAndReturn(f func() bool) *MockSentryClientReadyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

// MockSentryClientRemovePeerCall wrap *gomock.Call
type MockSentryClientRemovePeerCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientRemovePeerCall) Return(arg0 *sentryproto.RemovePeerReply, arg1 error) *MockSentryClientRemovePeerCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientRemovePeerCall) Do(f func(context.Context, *sentryproto.RemovePeerRequest, ...grpc.CallOption) (*sentryproto.RemovePeerReply, error)) *MockSentryClientRemovePeerCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientRemovePeerCall) DoAndReturn(f func(context.Context, *sentryproto.RemovePeerRequest, ...grpc.CallOption) (*sentryproto.RemovePeerReply, error)) *MockSentryClientRemovePeerCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

// MockSentryClientRemoveTrustedPeerCall wrap *gomock.Call
type MockSentryClientRemoveTrustedPeerCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientRemoveTrustedPeerCall) Return(arg0 *sentryproto.RemovePeerReply, arg1 error) *MockSentryClientRemoveTrustedPeerCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientRemoveTrustedPeerCall) Do(f func(context.Context, *sentryproto.RemovePeerRequest, ...grpc.CallOption) (*sentryproto.RemovePeerReply, error)) *MockSentryClientRemoveTrustedPeerCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientRemoveTrustedPeerCall) DoAndReturn(f func(context.Context, *sentryproto.RemovePeerRequest, ...grpc.CallOption) (*sentryproto.RemovePeerReply, error)) *MockSentryClientRemoveTrustedPeerCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

// MockSentryClientSendMessageByIdCall wrap *gomock.Call
type MockSentryClientSendMessageByIdCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientSendMessageByIdCall) Return(arg0 *sentryproto.SentPeers, arg1 error) *MockSentryClientSendMessageByIdCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientSendMessageByIdCall) Do(f func(context.Context, *sentryproto.SendMessageByIdRequest, ...grpc.CallOption) (*sentryproto.SentPeers, error)) *MockSentryClientSendMessageByIdCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientSendMessageByIdCall) DoAndReturn(f func(context.Context, *sentryproto.SendMessageByIdRequest, ...grpc.CallOption) (*sentryproto.SentPeers, error)) *MockSentryClientSendMessageByIdCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

// MockSentryClientSendMessageByMinBlockCall wrap *gomock.Call
type MockSentryClientSendMessageByMinBlockCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientSendMessageByMinBlockCall) Return(arg0 *sentryproto.SentPeers, arg1 error) *MockSentryClientSendMessageByMinBlockCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientSendMessageByMinBlockCall) Do(f func(context.Context, *sentryproto.SendMessageByMinBlockRequest, ...grpc.CallOption) (*sentryproto.SentPeers, error)) *MockSentryClientSendMessageByMinBlockCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientSendMessageByMinBlockCall) DoAndReturn(f func(context.Context, *sentryproto.SendMessageByMinBlockRequest, ...grpc.CallOption) (*sentryproto.SentPeers, error)) *MockSentryClientSendMessageByMinBlockCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

// MockSentryClientSendMessageToAllCall wrap *gomock.Call
type MockSentryClientSendMessageToAllCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientSendMessageToAllCall) Return(arg0 *sentryproto.SentPeers, arg1 error) *MockSentryClientSendMessageToAllCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientSendMessageToAllCall) Do(f func(context.Context, *sentryproto.OutboundMessageData, ...grpc.CallOption) (*sentryproto.SentPeers, error)) *MockSentryClientSendMessageToAllCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientSendMessageToAllCall) DoAndReturn(f func(context.Context, *sentryproto.OutboundMessageData, ...grpc.CallOption) (*sentryproto.SentPeers, error)) *MockSentryClientSendMessageToAllCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

// MockSentryClientSendMessageToRandomPeersCall wrap *gomock.Call
type MockSentryClientSendMessageToRandomPeersCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientSendMessageToRandomPeersCall) Return(arg0 *sentryproto.SentPeers, arg1 error) *MockSentryClientSendMessageToRandomPeersCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientSendMessageToRandomPeersCall) Do(f func(context.Context, *sentryproto.SendMessageToRandomPeersRequest, ...grpc.CallOption) (*sentryproto.SentPeers, error)) *MockSentryClientSendMessageToRandomPeersCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientSendMessageToRandomPeersCall) DoAndReturn(f func(context.Context, *sentryproto.SendMessageToRandomPeersRequest, ...grpc.CallOption) (*sentryproto.SentPeers, error)) *MockSentryClientSendMessageToRandomPeersCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

// MockSentryClientSetPeerBlockRangeCall wrap *gomock.Call
type MockSentryClientSetPeerBlockRangeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientSetPeerBlockRangeCall) Return(arg0 *emptypb.Empty, arg1 error) *MockSentryClientSetPeerBlockRangeCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientSetPeerBlockRangeCall) Do(f func(context.Context, *sentryproto.SetPeerBlockRangeRequest, ...grpc.CallOption) (*emptypb.Empty, error)) *MockSentryClientSetPeerBlockRangeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientSetPeerBlockRangeCall) DoAndReturn(f func(context.Context, *sentryproto.SetPeerBlockRangeRequest, ...grpc.CallOption) (*emptypb.Empty, error)) *MockSentryClientSetPeerBlockRangeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

// MockSentryClientSetPeerLatestBlockCall wrap *gomock.Call
type MockSentryClientSetPeerLatestBlockCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientSetPeerLatestBlockCall) Return(arg0 *emptypb.Empty, arg1 error) *MockSentryClientSetPeerLatestBlockCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientSetPeerLatestBlockCall) Do(f func(context.Context, *sentryproto.SetPeerLatestBlockRequest, ...grpc.CallOption) (*emptypb.Empty, error)) *MockSentryClientSetPeerLatestBlockCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientSetPeerLatestBlockCall) DoAndReturn(f func(context.Context, *sentryproto.SetPeerLatestBlockRequest, ...grpc.CallOption) (*emptypb.Empty, error)) *MockSentryClientSetPeerLatestBlockCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

// MockSentryClientSetPeerMinimumBlockCall wrap *gomock.Call
type MockSentryClientSetPeerMinimumBlockCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientSetPeerMinimumBlockCall) Return(arg0 *emptypb.Empty, arg1 error) *MockSentryClientSetPeerMinimumBlockCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientSetPeerMinimumBlockCall) Do(f func(context.Context, *sentryproto.SetPeerMinimumBlockRequest, ...grpc.CallOption) (*emptypb.Empty, error)) *MockSentryClientSetPeerMinimumBlockCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientSetPeerMinimumBlockCall) DoAndReturn(f func(context.Context, *sentryproto.SetPeerMinimumBlockRequest, ...grpc.CallOption) (*emptypb.Empty, error)) *MockSentryClientSetPeerMinimumBlockCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

// MockSentryClientSetStatusCall wrap *gomock.Call
type MockSentryClientSetStatusCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSentryClientSetStatusCall) Return(arg0 *sentryproto.SetStatusReply, arg1 error) *MockSentryClientSetStatusCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSentryClientSetStatusCall) Do(f func(context.Context, *sentryproto.StatusData, ...grpc.CallOption) (*sentryproto.SetStatusReply, error)) *MockSentryClientSetStatusCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSentryClientSetStatusCall) DoAndReturn(f func(context.Context, *sentryproto.StatusData, ...grpc.CallOption) (*sentryproto.SetStatusReply, error)) *MockSentryClientSetStatusCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
