// Code generated by MockGen. DO NOT EDIT.
// Source: protocol.go
//
// Generated by this command:
//
//	mockgen -write_generate_directive -package protocol -destination protocol_mock_test.go -source protocol.go
//

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

import (
	reflect "reflect"
	time "time"

	gomock "go.uber.org/mock/gomock"
)

//go:generate mockgen -write_generate_directive -package protocol -destination protocol_mock_test.go -source protocol.go

// MockFederable is a mock of Federable interface.
type MockFederable struct {
	ctrl     *gomock.Controller
	recorder *MockFederableMockRecorder
	isgomock struct{}
}

// MockFederableMockRecorder is the mock recorder for MockFederable.
type MockFederableMockRecorder struct {
	mock *MockFederable
}

// NewMockFederable creates a new mock instance.
func NewMockFederable(ctrl *gomock.Controller) *MockFederable {
	mock := &MockFederable{ctrl: ctrl}
	mock.recorder = &MockFederableMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

// NetworkHops mocks base method.
func (m *MockFederable) NetworkHops() [][3]string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NetworkHops")
	ret0, _ := ret[0].([][3]string)
	return ret0
}

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

// RecordNetworkHop mocks base method.
func (m *MockFederable) RecordNetworkHop(in, processor, out string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RecordNetworkHop", in, processor, out)
}

// RecordNetworkHop indicates an expected call of RecordNetworkHop.
func (mr *MockFederableMockRecorder) RecordNetworkHop(in, processor, out any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordNetworkHop", reflect.TypeOf((*MockFederable)(nil).RecordNetworkHop), in, processor, out)
}

// SetFederationReplyTo mocks base method.
func (m *MockFederable) SetFederationReplyTo(reply string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFederationReplyTo", reply)
}

// SetFederationReplyTo indicates an expected call of SetFederationReplyTo.
func (mr *MockFederableMockRecorder) SetFederationReplyTo(reply any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFederationReplyTo", reflect.TypeOf((*MockFederable)(nil).SetFederationReplyTo), reply)
}

// SetFederationRequestID mocks base method.
func (m *MockFederable) SetFederationRequestID(id string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFederationRequestID", id)
}

// SetFederationRequestID indicates an expected call of SetFederationRequestID.
func (mr *MockFederableMockRecorder) SetFederationRequestID(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFederationRequestID", reflect.TypeOf((*MockFederable)(nil).SetFederationRequestID), id)
}

// SetFederationTargets mocks base method.
func (m *MockFederable) SetFederationTargets(targets []string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFederationTargets", targets)
}

// SetFederationTargets indicates an expected call of SetFederationTargets.
func (mr *MockFederableMockRecorder) SetFederationTargets(targets any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFederationTargets", reflect.TypeOf((*MockFederable)(nil).SetFederationTargets), targets)
}

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

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

// MockRequest is a mock of Request interface.
type MockRequest struct {
	ctrl     *gomock.Controller
	recorder *MockRequestMockRecorder
	isgomock struct{}
}

// MockRequestMockRecorder is the mock recorder for MockRequest.
type MockRequestMockRecorder struct {
	mock *MockRequest
}

// NewMockRequest creates a new mock instance.
func NewMockRequest(ctrl *gomock.Controller) *MockRequest {
	mock := &MockRequest{ctrl: ctrl}
	mock.recorder = &MockRequestMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// IsValidJSON indicates an expected call of IsValidJSON.
func (mr *MockRequestMockRecorder) IsValidJSON(data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsValidJSON", reflect.TypeOf((*MockRequest)(nil).IsValidJSON), data)
}

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

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

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

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

// NetworkHops mocks base method.
func (m *MockRequest) NetworkHops() [][3]string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NetworkHops")
	ret0, _ := ret[0].([][3]string)
	return ret0
}

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

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

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

// RecordNetworkHop mocks base method.
func (m *MockRequest) RecordNetworkHop(in, processor, out string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RecordNetworkHop", in, processor, out)
}

// RecordNetworkHop indicates an expected call of RecordNetworkHop.
func (mr *MockRequestMockRecorder) RecordNetworkHop(in, processor, out any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordNetworkHop", reflect.TypeOf((*MockRequest)(nil).RecordNetworkHop), in, processor, out)
}

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

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

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

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

// SetAgent mocks base method.
func (m *MockRequest) SetAgent(agent string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAgent", agent)
}

// SetAgent indicates an expected call of SetAgent.
func (mr *MockRequestMockRecorder) SetAgent(agent any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAgent", reflect.TypeOf((*MockRequest)(nil).SetAgent), agent)
}

// SetCallerID mocks base method.
func (m *MockRequest) SetCallerID(id string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCallerID", id)
}

// SetCallerID indicates an expected call of SetCallerID.
func (mr *MockRequestMockRecorder) SetCallerID(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCallerID", reflect.TypeOf((*MockRequest)(nil).SetCallerID), id)
}

// SetCollective mocks base method.
func (m *MockRequest) SetCollective(collective string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCollective", collective)
}

// SetCollective indicates an expected call of SetCollective.
func (mr *MockRequestMockRecorder) SetCollective(collective any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCollective", reflect.TypeOf((*MockRequest)(nil).SetCollective), collective)
}

// SetFederationReplyTo mocks base method.
func (m *MockRequest) SetFederationReplyTo(reply string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFederationReplyTo", reply)
}

// SetFederationReplyTo indicates an expected call of SetFederationReplyTo.
func (mr *MockRequestMockRecorder) SetFederationReplyTo(reply any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFederationReplyTo", reflect.TypeOf((*MockRequest)(nil).SetFederationReplyTo), reply)
}

// SetFederationRequestID mocks base method.
func (m *MockRequest) SetFederationRequestID(id string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFederationRequestID", id)
}

// SetFederationRequestID indicates an expected call of SetFederationRequestID.
func (mr *MockRequestMockRecorder) SetFederationRequestID(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFederationRequestID", reflect.TypeOf((*MockRequest)(nil).SetFederationRequestID), id)
}

// SetFederationTargets mocks base method.
func (m *MockRequest) SetFederationTargets(targets []string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFederationTargets", targets)
}

// SetFederationTargets indicates an expected call of SetFederationTargets.
func (mr *MockRequestMockRecorder) SetFederationTargets(targets any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFederationTargets", reflect.TypeOf((*MockRequest)(nil).SetFederationTargets), targets)
}

// SetFilter mocks base method.
func (m *MockRequest) SetFilter(arg0 *Filter) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFilter", arg0)
}

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

// SetMessage mocks base method.
func (m *MockRequest) SetMessage(message []byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMessage", message)
}

// SetMessage indicates an expected call of SetMessage.
func (mr *MockRequestMockRecorder) SetMessage(message any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMessage", reflect.TypeOf((*MockRequest)(nil).SetMessage), message)
}

// SetRequestID mocks base method.
func (m *MockRequest) SetRequestID(id string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRequestID", id)
}

// SetRequestID indicates an expected call of SetRequestID.
func (mr *MockRequestMockRecorder) SetRequestID(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRequestID", reflect.TypeOf((*MockRequest)(nil).SetRequestID), id)
}

// SetTTL mocks base method.
func (m *MockRequest) SetTTL(ttl int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTTL", ttl)
}

// SetTTL indicates an expected call of SetTTL.
func (mr *MockRequestMockRecorder) SetTTL(ttl any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTTL", reflect.TypeOf((*MockRequest)(nil).SetTTL), ttl)
}

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

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

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

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

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

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

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

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

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

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

// MockReply is a mock of Reply interface.
type MockReply struct {
	ctrl     *gomock.Controller
	recorder *MockReplyMockRecorder
	isgomock struct{}
}

// MockReplyMockRecorder is the mock recorder for MockReply.
type MockReplyMockRecorder struct {
	mock *MockReply
}

// NewMockReply creates a new mock instance.
func NewMockReply(ctrl *gomock.Controller) *MockReply {
	mock := &MockReply{ctrl: ctrl}
	mock.recorder = &MockReplyMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

// IsValidJSON indicates an expected call of IsValidJSON.
func (mr *MockReplyMockRecorder) IsValidJSON(data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsValidJSON", reflect.TypeOf((*MockReply)(nil).IsValidJSON), data)
}

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

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

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

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

// NetworkHops mocks base method.
func (m *MockReply) NetworkHops() [][3]string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NetworkHops")
	ret0, _ := ret[0].([][3]string)
	return ret0
}

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

// RecordNetworkHop mocks base method.
func (m *MockReply) RecordNetworkHop(in, processor, out string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RecordNetworkHop", in, processor, out)
}

// RecordNetworkHop indicates an expected call of RecordNetworkHop.
func (mr *MockReplyMockRecorder) RecordNetworkHop(in, processor, out any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordNetworkHop", reflect.TypeOf((*MockReply)(nil).RecordNetworkHop), in, processor, out)
}

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

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

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

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

// SetFederationReplyTo mocks base method.
func (m *MockReply) SetFederationReplyTo(reply string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFederationReplyTo", reply)
}

// SetFederationReplyTo indicates an expected call of SetFederationReplyTo.
func (mr *MockReplyMockRecorder) SetFederationReplyTo(reply any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFederationReplyTo", reflect.TypeOf((*MockReply)(nil).SetFederationReplyTo), reply)
}

// SetFederationRequestID mocks base method.
func (m *MockReply) SetFederationRequestID(id string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFederationRequestID", id)
}

// SetFederationRequestID indicates an expected call of SetFederationRequestID.
func (mr *MockReplyMockRecorder) SetFederationRequestID(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFederationRequestID", reflect.TypeOf((*MockReply)(nil).SetFederationRequestID), id)
}

// SetFederationTargets mocks base method.
func (m *MockReply) SetFederationTargets(targets []string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFederationTargets", targets)
}

// SetFederationTargets indicates an expected call of SetFederationTargets.
func (mr *MockReplyMockRecorder) SetFederationTargets(targets any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFederationTargets", reflect.TypeOf((*MockReply)(nil).SetFederationTargets), targets)
}

// SetMessage mocks base method.
func (m *MockReply) SetMessage(message []byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMessage", message)
}

// SetMessage indicates an expected call of SetMessage.
func (mr *MockReplyMockRecorder) SetMessage(message any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMessage", reflect.TypeOf((*MockReply)(nil).SetMessage), message)
}

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

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

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

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

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

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

// MockSecureRequest is a mock of SecureRequest interface.
type MockSecureRequest struct {
	ctrl     *gomock.Controller
	recorder *MockSecureRequestMockRecorder
	isgomock struct{}
}

// MockSecureRequestMockRecorder is the mock recorder for MockSecureRequest.
type MockSecureRequestMockRecorder struct {
	mock *MockSecureRequest
}

// NewMockSecureRequest creates a new mock instance.
func NewMockSecureRequest(ctrl *gomock.Controller) *MockSecureRequest {
	mock := &MockSecureRequest{ctrl: ctrl}
	mock.recorder = &MockSecureRequestMockRecorder{mock}
	return mock
}

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

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

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

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

// IsValidJSON indicates an expected call of IsValidJSON.
func (mr *MockSecureRequestMockRecorder) IsValidJSON(data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsValidJSON", reflect.TypeOf((*MockSecureRequest)(nil).IsValidJSON), data)
}

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

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

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

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

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

// SetMessage indicates an expected call of SetMessage.
func (mr *MockSecureRequestMockRecorder) SetMessage(request any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMessage", reflect.TypeOf((*MockSecureRequest)(nil).SetMessage), request)
}

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

// SetSigner indicates an expected call of SetSigner.
func (mr *MockSecureRequestMockRecorder) SetSigner(signer any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSigner", reflect.TypeOf((*MockSecureRequest)(nil).SetSigner), signer)
}

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

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

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

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

// MockSecureReply is a mock of SecureReply interface.
type MockSecureReply struct {
	ctrl     *gomock.Controller
	recorder *MockSecureReplyMockRecorder
	isgomock struct{}
}

// MockSecureReplyMockRecorder is the mock recorder for MockSecureReply.
type MockSecureReplyMockRecorder struct {
	mock *MockSecureReply
}

// NewMockSecureReply creates a new mock instance.
func NewMockSecureReply(ctrl *gomock.Controller) *MockSecureReply {
	mock := &MockSecureReply{ctrl: ctrl}
	mock.recorder = &MockSecureReplyMockRecorder{mock}
	return mock
}

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

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

// IsValidJSON indicates an expected call of IsValidJSON.
func (mr *MockSecureReplyMockRecorder) IsValidJSON(data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsValidJSON", reflect.TypeOf((*MockSecureReply)(nil).IsValidJSON), data)
}

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

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

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

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

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

// SetMessage indicates an expected call of SetMessage.
func (mr *MockSecureReplyMockRecorder) SetMessage(reply any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMessage", reflect.TypeOf((*MockSecureReply)(nil).SetMessage), reply)
}

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

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

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

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

// MockTransportMessage is a mock of TransportMessage interface.
type MockTransportMessage struct {
	ctrl     *gomock.Controller
	recorder *MockTransportMessageMockRecorder
	isgomock struct{}
}

// MockTransportMessageMockRecorder is the mock recorder for MockTransportMessage.
type MockTransportMessageMockRecorder struct {
	mock *MockTransportMessage
}

// NewMockTransportMessage creates a new mock instance.
func NewMockTransportMessage(ctrl *gomock.Controller) *MockTransportMessage {
	mock := &MockTransportMessage{ctrl: ctrl}
	mock.recorder = &MockTransportMessageMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

// IsValidJSON indicates an expected call of IsValidJSON.
func (mr *MockTransportMessageMockRecorder) IsValidJSON(data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsValidJSON", reflect.TypeOf((*MockTransportMessage)(nil).IsValidJSON), data)
}

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

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

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

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

// NetworkHops mocks base method.
func (m *MockTransportMessage) NetworkHops() [][3]string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NetworkHops")
	ret0, _ := ret[0].([][3]string)
	return ret0
}

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

// RecordNetworkHop mocks base method.
func (m *MockTransportMessage) RecordNetworkHop(in, processor, out string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RecordNetworkHop", in, processor, out)
}

// RecordNetworkHop indicates an expected call of RecordNetworkHop.
func (mr *MockTransportMessageMockRecorder) RecordNetworkHop(in, processor, out any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordNetworkHop", reflect.TypeOf((*MockTransportMessage)(nil).RecordNetworkHop), in, processor, out)
}

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

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

// SeenBy mocks base method.
func (m *MockTransportMessage) SeenBy() [][3]string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SeenBy")
	ret0, _ := ret[0].([][3]string)
	return ret0
}

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

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

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

// SetFederationReplyTo mocks base method.
func (m *MockTransportMessage) SetFederationReplyTo(reply string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFederationReplyTo", reply)
}

// SetFederationReplyTo indicates an expected call of SetFederationReplyTo.
func (mr *MockTransportMessageMockRecorder) SetFederationReplyTo(reply any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFederationReplyTo", reflect.TypeOf((*MockTransportMessage)(nil).SetFederationReplyTo), reply)
}

// SetFederationRequestID mocks base method.
func (m *MockTransportMessage) SetFederationRequestID(id string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFederationRequestID", id)
}

// SetFederationRequestID indicates an expected call of SetFederationRequestID.
func (mr *MockTransportMessageMockRecorder) SetFederationRequestID(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFederationRequestID", reflect.TypeOf((*MockTransportMessage)(nil).SetFederationRequestID), id)
}

// SetFederationTargets mocks base method.
func (m *MockTransportMessage) SetFederationTargets(targets []string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFederationTargets", targets)
}

// SetFederationTargets indicates an expected call of SetFederationTargets.
func (mr *MockTransportMessageMockRecorder) SetFederationTargets(targets any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFederationTargets", reflect.TypeOf((*MockTransportMessage)(nil).SetFederationTargets), targets)
}

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

// SetReplyData indicates an expected call of SetReplyData.
func (mr *MockTransportMessageMockRecorder) SetReplyData(reply any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReplyData", reflect.TypeOf((*MockTransportMessage)(nil).SetReplyData), reply)
}

// SetReplyTo mocks base method.
func (m *MockTransportMessage) SetReplyTo(reply string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetReplyTo", reply)
}

// SetReplyTo indicates an expected call of SetReplyTo.
func (mr *MockTransportMessageMockRecorder) SetReplyTo(reply any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReplyTo", reflect.TypeOf((*MockTransportMessage)(nil).SetReplyTo), reply)
}

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

// SetRequestData indicates an expected call of SetRequestData.
func (mr *MockTransportMessageMockRecorder) SetRequestData(request any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRequestData", reflect.TypeOf((*MockTransportMessage)(nil).SetRequestData), request)
}

// SetSender mocks base method.
func (m *MockTransportMessage) SetSender(sender string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetSender", sender)
}

// SetSender indicates an expected call of SetSender.
func (mr *MockTransportMessageMockRecorder) SetSender(sender any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSender", reflect.TypeOf((*MockTransportMessage)(nil).SetSender), sender)
}

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

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

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

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