// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/luxfi/node/message (interfaces: OutboundMsgBuilder)
//
// Generated by this command:
//
//	mockgen -package=messagemock -destination=messagemock/outbound_message_builder.go -mock_names=OutboundMsgBuilder=OutboundMsgBuilder . OutboundMsgBuilder
//

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

import (
	netip "net/netip"
	reflect "reflect"
	time "time"

	ids "github.com/luxfi/ids"
	"github.com/luxfi/net/endpoints"
	message "github.com/luxfi/node/message"
	p2p "github.com/luxfi/node/proto/p2p"
	gomock "go.uber.org/mock/gomock"
)

// OutboundMsgBuilder is a mock of OutboundMsgBuilder interface.
type OutboundMsgBuilder struct {
	ctrl     *gomock.Controller
	recorder *OutboundMsgBuilderMockRecorder
	isgomock struct{}
}

// OutboundMsgBuilderMockRecorder is the mock recorder for OutboundMsgBuilder.
type OutboundMsgBuilderMockRecorder struct {
	mock *OutboundMsgBuilder
}

// NewOutboundMsgBuilder creates a new mock instance.
func NewOutboundMsgBuilder(ctrl *gomock.Controller) *OutboundMsgBuilder {
	mock := &OutboundMsgBuilder{ctrl: ctrl}
	mock.recorder = &OutboundMsgBuilderMockRecorder{mock}
	return mock
}

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

// Accepted mocks base method.
func (m *OutboundMsgBuilder) Accepted(chainID ids.ID, requestID uint32, containerIDs []ids.ID) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Accepted", chainID, requestID, containerIDs)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Accepted indicates an expected call of Accepted.
func (mr *OutboundMsgBuilderMockRecorder) Accepted(chainID, requestID, containerIDs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Accepted", reflect.TypeOf((*OutboundMsgBuilder)(nil).Accepted), chainID, requestID, containerIDs)
}

// AcceptedFrontier mocks base method.
func (m *OutboundMsgBuilder) AcceptedFrontier(chainID ids.ID, requestID uint32, containerID ids.ID) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptedFrontier", chainID, requestID, containerID)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AcceptedFrontier indicates an expected call of AcceptedFrontier.
func (mr *OutboundMsgBuilderMockRecorder) AcceptedFrontier(chainID, requestID, containerID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptedFrontier", reflect.TypeOf((*OutboundMsgBuilder)(nil).AcceptedFrontier), chainID, requestID, containerID)
}

// AcceptedStateSummary mocks base method.
func (m *OutboundMsgBuilder) AcceptedStateSummary(chainID ids.ID, requestID uint32, summaryIDs []ids.ID) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptedStateSummary", chainID, requestID, summaryIDs)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AcceptedStateSummary indicates an expected call of AcceptedStateSummary.
func (mr *OutboundMsgBuilderMockRecorder) AcceptedStateSummary(chainID, requestID, summaryIDs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptedStateSummary", reflect.TypeOf((*OutboundMsgBuilder)(nil).AcceptedStateSummary), chainID, requestID, summaryIDs)
}

// Ancestors mocks base method.
func (m *OutboundMsgBuilder) Ancestors(chainID ids.ID, requestID uint32, containers [][]byte) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Ancestors", chainID, requestID, containers)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Ancestors indicates an expected call of Ancestors.
func (mr *OutboundMsgBuilderMockRecorder) Ancestors(chainID, requestID, containers any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ancestors", reflect.TypeOf((*OutboundMsgBuilder)(nil).Ancestors), chainID, requestID, containers)
}

// Error mocks base method.
func (m *OutboundMsgBuilder) Error(chainID ids.ID, requestID uint32, errorCode int32, errorMessage string) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Error", chainID, requestID, errorCode, errorMessage)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Error indicates an expected call of Error.
func (mr *OutboundMsgBuilderMockRecorder) Error(chainID, requestID, errorCode, errorMessage any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*OutboundMsgBuilder)(nil).Error), chainID, requestID, errorCode, errorMessage)
}

// Gossip mocks base method.
func (m *OutboundMsgBuilder) Gossip(chainID ids.ID, msg []byte) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Gossip", chainID, msg)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Gossip indicates an expected call of Gossip.
func (mr *OutboundMsgBuilderMockRecorder) Gossip(chainID, msg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Gossip", reflect.TypeOf((*OutboundMsgBuilder)(nil).Gossip), chainID, msg)
}

// Request mocks base method.
func (m *OutboundMsgBuilder) Request(chainID ids.ID, requestID uint32, deadline time.Duration, msg []byte) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Request", chainID, requestID, deadline, msg)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Request indicates an expected call of Request.
func (mr *OutboundMsgBuilderMockRecorder) Request(chainID, requestID, deadline, msg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Request", reflect.TypeOf((*OutboundMsgBuilder)(nil).Request), chainID, requestID, deadline, msg)
}

// Response mocks base method.
func (m *OutboundMsgBuilder) Response(chainID ids.ID, requestID uint32, msg []byte) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Response", chainID, requestID, msg)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Response indicates an expected call of Response.
func (mr *OutboundMsgBuilderMockRecorder) Response(chainID, requestID, msg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Response", reflect.TypeOf((*OutboundMsgBuilder)(nil).Response), chainID, requestID, msg)
}

// Chits mocks base method.
func (m *OutboundMsgBuilder) Chits(chainID ids.ID, requestID uint32, preferredID, preferredIDAtHeight, acceptedID ids.ID, acceptedHeight uint64) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Chits", chainID, requestID, preferredID, preferredIDAtHeight, acceptedID, acceptedHeight)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Chits indicates an expected call of Chits.
func (mr *OutboundMsgBuilderMockRecorder) Chits(chainID, requestID, preferredID, preferredIDAtHeight, acceptedID, acceptedHeight any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Chits", reflect.TypeOf((*OutboundMsgBuilder)(nil).Chits), chainID, requestID, preferredID, preferredIDAtHeight, acceptedID, acceptedHeight)
}

// Get mocks base method.
func (m *OutboundMsgBuilder) Get(chainID ids.ID, requestID uint32, deadline time.Duration, containerID ids.ID) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", chainID, requestID, deadline, containerID)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *OutboundMsgBuilderMockRecorder) Get(chainID, requestID, deadline, containerID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*OutboundMsgBuilder)(nil).Get), chainID, requestID, deadline, containerID)
}

// GetAccepted mocks base method.
func (m *OutboundMsgBuilder) GetAccepted(chainID ids.ID, requestID uint32, deadline time.Duration, containerIDs []ids.ID) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccepted", chainID, requestID, deadline, containerIDs)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAccepted indicates an expected call of GetAccepted.
func (mr *OutboundMsgBuilderMockRecorder) GetAccepted(chainID, requestID, deadline, containerIDs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccepted", reflect.TypeOf((*OutboundMsgBuilder)(nil).GetAccepted), chainID, requestID, deadline, containerIDs)
}

// GetAcceptedFrontier mocks base method.
func (m *OutboundMsgBuilder) GetAcceptedFrontier(chainID ids.ID, requestID uint32, deadline time.Duration) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAcceptedFrontier", chainID, requestID, deadline)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAcceptedFrontier indicates an expected call of GetAcceptedFrontier.
func (mr *OutboundMsgBuilderMockRecorder) GetAcceptedFrontier(chainID, requestID, deadline any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAcceptedFrontier", reflect.TypeOf((*OutboundMsgBuilder)(nil).GetAcceptedFrontier), chainID, requestID, deadline)
}

// GetAcceptedStateSummary mocks base method.
func (m *OutboundMsgBuilder) GetAcceptedStateSummary(chainID ids.ID, requestID uint32, deadline time.Duration, heights []uint64) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAcceptedStateSummary", chainID, requestID, deadline, heights)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAcceptedStateSummary indicates an expected call of GetAcceptedStateSummary.
func (mr *OutboundMsgBuilderMockRecorder) GetAcceptedStateSummary(chainID, requestID, deadline, heights any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAcceptedStateSummary", reflect.TypeOf((*OutboundMsgBuilder)(nil).GetAcceptedStateSummary), chainID, requestID, deadline, heights)
}

// GetAncestors mocks base method.
func (m *OutboundMsgBuilder) GetAncestors(chainID ids.ID, requestID uint32, deadline time.Duration, containerID ids.ID, engineType p2p.EngineType) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAncestors", chainID, requestID, deadline, containerID, engineType)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAncestors indicates an expected call of GetAncestors.
func (mr *OutboundMsgBuilderMockRecorder) GetAncestors(chainID, requestID, deadline, containerID, engineType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAncestors", reflect.TypeOf((*OutboundMsgBuilder)(nil).GetAncestors), chainID, requestID, deadline, containerID, engineType)
}

// GetPeerList mocks base method.
func (m *OutboundMsgBuilder) GetPeerList(knownPeersFilter, knownPeersSalt []byte, requestAllNetIPs bool) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPeerList", knownPeersFilter, knownPeersSalt, requestAllNetIPs)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPeerList indicates an expected call of GetPeerList.
func (mr *OutboundMsgBuilderMockRecorder) GetPeerList(knownPeersFilter, knownPeersSalt, requestAllNetIPs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPeerList", reflect.TypeOf((*OutboundMsgBuilder)(nil).GetPeerList), knownPeersFilter, knownPeersSalt, requestAllNetIPs)
}

// GetStateSummaryFrontier mocks base method.
func (m *OutboundMsgBuilder) GetStateSummaryFrontier(chainID ids.ID, requestID uint32, deadline time.Duration) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStateSummaryFrontier", chainID, requestID, deadline)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStateSummaryFrontier indicates an expected call of GetStateSummaryFrontier.
func (mr *OutboundMsgBuilderMockRecorder) GetStateSummaryFrontier(chainID, requestID, deadline any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStateSummaryFrontier", reflect.TypeOf((*OutboundMsgBuilder)(nil).GetStateSummaryFrontier), chainID, requestID, deadline)
}

// Handshake mocks base method.
func (m *OutboundMsgBuilder) Handshake(networkID uint32, myTime uint64, ip netip.AddrPort, client string, major, minor, patch uint32, ipSigningTime uint64, ipNodeIDSig, ipBLSSig []byte, trackedNets []ids.ID, supportedLPs, objectedLPs []uint32, knownPeersFilter, knownPeersSalt []byte, requestAllNetIPs bool, ipMLDSASig []byte) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Handshake", networkID, myTime, ip, client, major, minor, patch, ipSigningTime, ipNodeIDSig, ipBLSSig, trackedNets, supportedLPs, objectedLPs, knownPeersFilter, knownPeersSalt, requestAllNetIPs, ipMLDSASig)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Handshake indicates an expected call of Handshake.
func (mr *OutboundMsgBuilderMockRecorder) Handshake(networkID, myTime, ip, client, major, minor, patch, ipSigningTime, ipNodeIDSig, ipBLSSig, trackedNets, supportedLPs, objectedLPs, knownPeersFilter, knownPeersSalt, requestAllNetIPs, ipMLDSASig any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Handshake", reflect.TypeOf((*OutboundMsgBuilder)(nil).Handshake), networkID, myTime, ip, client, major, minor, patch, ipSigningTime, ipNodeIDSig, ipBLSSig, trackedNets, supportedLPs, objectedLPs, knownPeersFilter, knownPeersSalt, requestAllNetIPs, ipMLDSASig)
}

// PeerList mocks base method.
func (m *OutboundMsgBuilder) PeerList(peers []*endpoints.ClaimedIPPort, bypassThrottling bool) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PeerList", peers, bypassThrottling)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PeerList indicates an expected call of PeerList.
func (mr *OutboundMsgBuilderMockRecorder) PeerList(peers, bypassThrottling any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeerList", reflect.TypeOf((*OutboundMsgBuilder)(nil).PeerList), peers, bypassThrottling)
}

// Ping mocks base method.
func (m *OutboundMsgBuilder) Ping(primaryUptime uint32) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Ping", primaryUptime)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Ping indicates an expected call of Ping.
func (mr *OutboundMsgBuilderMockRecorder) Ping(primaryUptime any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*OutboundMsgBuilder)(nil).Ping), primaryUptime)
}

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

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

// PullQuery mocks base method.
func (m *OutboundMsgBuilder) PullQuery(chainID ids.ID, requestID uint32, deadline time.Duration, containerID ids.ID, requestedHeight uint64) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PullQuery", chainID, requestID, deadline, containerID, requestedHeight)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PullQuery indicates an expected call of PullQuery.
func (mr *OutboundMsgBuilderMockRecorder) PullQuery(chainID, requestID, deadline, containerID, requestedHeight any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PullQuery", reflect.TypeOf((*OutboundMsgBuilder)(nil).PullQuery), chainID, requestID, deadline, containerID, requestedHeight)
}

// PushQuery mocks base method.
func (m *OutboundMsgBuilder) PushQuery(chainID ids.ID, requestID uint32, deadline time.Duration, container []byte, requestedHeight uint64) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PushQuery", chainID, requestID, deadline, container, requestedHeight)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PushQuery indicates an expected call of PushQuery.
func (mr *OutboundMsgBuilderMockRecorder) PushQuery(chainID, requestID, deadline, container, requestedHeight any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PushQuery", reflect.TypeOf((*OutboundMsgBuilder)(nil).PushQuery), chainID, requestID, deadline, container, requestedHeight)
}

// Put mocks base method.
func (m *OutboundMsgBuilder) Put(chainID ids.ID, requestID uint32, container []byte) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Put", chainID, requestID, container)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Put indicates an expected call of Put.
func (mr *OutboundMsgBuilderMockRecorder) Put(chainID, requestID, container any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*OutboundMsgBuilder)(nil).Put), chainID, requestID, container)
}

// BFTMessage mocks base method.
func (m *OutboundMsgBuilder) BFTMessage(msg *p2p.BFT) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFTMessage", msg)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BFTMessage indicates an expected call of BFTMessage.
func (mr *OutboundMsgBuilderMockRecorder) BFTMessage(msg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFTMessage", reflect.TypeOf((*OutboundMsgBuilder)(nil).BFTMessage), msg)
}

// StateSummaryFrontier mocks base method.
func (m *OutboundMsgBuilder) StateSummaryFrontier(chainID ids.ID, requestID uint32, summary []byte) (message.OutboundMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StateSummaryFrontier", chainID, requestID, summary)
	ret0, _ := ret[0].(message.OutboundMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StateSummaryFrontier indicates an expected call of StateSummaryFrontier.
func (mr *OutboundMsgBuilderMockRecorder) StateSummaryFrontier(chainID, requestID, summary any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateSummaryFrontier", reflect.TypeOf((*OutboundMsgBuilder)(nil).StateSummaryFrontier), chainID, requestID, summary)
}
