// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/luxfi/consensus/core (interfaces: Sender)
//
// Generated by this command:
//
//	mockgen -package=commonmock -destination=commonmock/sender.go -mock_names=Sender=Sender . Sender
//

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

import (
	context "context"
	reflect "reflect"

	ids "github.com/luxfi/ids"
	set "github.com/luxfi/math/set"
	warp "github.com/luxfi/warp"
	gomock "go.uber.org/mock/gomock"
)

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

// SenderMockRecorder is the mock recorder for Sender.
type SenderMockRecorder struct {
	mock *Sender
}

// NewSender creates a new mock instance.
func NewSender(ctrl *gomock.Controller) *Sender {
	mock := &Sender{ctrl: ctrl}
	mock.recorder = &SenderMockRecorder{mock}
	return mock
}

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

// SendAccepted mocks base method.
func (m *Sender) SendAccepted(ctx context.Context, nodeID ids.NodeID, requestID uint32, containerIDs []ids.ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendAccepted", ctx, nodeID, requestID, containerIDs)
}

// SendAccepted indicates an expected call of SendAccepted.
func (mr *SenderMockRecorder) SendAccepted(ctx, nodeID, requestID, containerIDs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAccepted", reflect.TypeOf((*Sender)(nil).SendAccepted), ctx, nodeID, requestID, containerIDs)
}

// SendAcceptedFrontier mocks base method.
func (m *Sender) SendAcceptedFrontier(ctx context.Context, nodeID ids.NodeID, requestID uint32, containerID ids.ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendAcceptedFrontier", ctx, nodeID, requestID, containerID)
}

// SendAcceptedFrontier indicates an expected call of SendAcceptedFrontier.
func (mr *SenderMockRecorder) SendAcceptedFrontier(ctx, nodeID, requestID, containerID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAcceptedFrontier", reflect.TypeOf((*Sender)(nil).SendAcceptedFrontier), ctx, nodeID, requestID, containerID)
}

// SendAcceptedStateSummary mocks base method.
func (m *Sender) SendAcceptedStateSummary(ctx context.Context, nodeID ids.NodeID, requestID uint32, summaryIDs []ids.ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendAcceptedStateSummary", ctx, nodeID, requestID, summaryIDs)
}

// SendAcceptedStateSummary indicates an expected call of SendAcceptedStateSummary.
func (mr *SenderMockRecorder) SendAcceptedStateSummary(ctx, nodeID, requestID, summaryIDs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAcceptedStateSummary", reflect.TypeOf((*Sender)(nil).SendAcceptedStateSummary), ctx, nodeID, requestID, summaryIDs)
}

// SendAncestors mocks base method.
func (m *Sender) SendAncestors(ctx context.Context, nodeID ids.NodeID, requestID uint32, containers [][]byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendAncestors", ctx, nodeID, requestID, containers)
}

// SendAncestors indicates an expected call of SendAncestors.
func (mr *SenderMockRecorder) SendAncestors(ctx, nodeID, requestID, containers any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAncestors", reflect.TypeOf((*Sender)(nil).SendAncestors), ctx, nodeID, requestID, containers)
}

// SendError mocks base method.
func (m *Sender) SendError(ctx context.Context, nodeID ids.NodeID, requestID uint32, errorCode int32, errorMessage string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendError", ctx, nodeID, requestID, errorCode, errorMessage)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendError indicates an expected call of SendError.
func (mr *SenderMockRecorder) SendError(ctx, nodeID, requestID, errorCode, errorMessage any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendError", reflect.TypeOf((*Sender)(nil).SendError), ctx, nodeID, requestID, errorCode, errorMessage)
}

// SendGossip mocks base method.
func (m *Sender) SendGossip(ctx context.Context, config warp.SendConfig, appGossipBytes []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendGossip", ctx, config, appGossipBytes)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendGossip indicates an expected call of SendGossip.
func (mr *SenderMockRecorder) SendGossip(ctx, config, appGossipBytes any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendGossip", reflect.TypeOf((*Sender)(nil).SendGossip), ctx, config, appGossipBytes)
}

// SendRequest mocks base method.
func (m *Sender) SendRequest(ctx context.Context, nodeIDs set.Set[ids.NodeID], requestID uint32, appRequestBytes []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendRequest", ctx, nodeIDs, requestID, appRequestBytes)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendRequest indicates an expected call of SendRequest.
func (mr *SenderMockRecorder) SendRequest(ctx, nodeIDs, requestID, appRequestBytes any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendRequest", reflect.TypeOf((*Sender)(nil).SendRequest), ctx, nodeIDs, requestID, appRequestBytes)
}

// SendResponse mocks base method.
func (m *Sender) SendResponse(ctx context.Context, nodeID ids.NodeID, requestID uint32, appResponseBytes []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendResponse", ctx, nodeID, requestID, appResponseBytes)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendResponse indicates an expected call of SendResponse.
func (mr *SenderMockRecorder) SendResponse(ctx, nodeID, requestID, appResponseBytes any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendResponse", reflect.TypeOf((*Sender)(nil).SendResponse), ctx, nodeID, requestID, appResponseBytes)
}

// SendChits mocks base method.
func (m *Sender) SendChits(ctx context.Context, nodeID ids.NodeID, requestID uint32, preferredID, preferredIDAtHeight, acceptedID ids.ID, acceptedHeight uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendChits", ctx, nodeID, requestID, preferredID, preferredIDAtHeight, acceptedID, acceptedHeight)
}

// SendChits indicates an expected call of SendChits.
func (mr *SenderMockRecorder) SendChits(ctx, nodeID, requestID, preferredID, preferredIDAtHeight, acceptedID, acceptedHeight any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendChits", reflect.TypeOf((*Sender)(nil).SendChits), ctx, nodeID, requestID, preferredID, preferredIDAtHeight, acceptedID, acceptedHeight)
}

// SendGet mocks base method.
func (m *Sender) SendGet(ctx context.Context, nodeID ids.NodeID, requestID uint32, containerID ids.ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendGet", ctx, nodeID, requestID, containerID)
}

// SendGet indicates an expected call of SendGet.
func (mr *SenderMockRecorder) SendGet(ctx, nodeID, requestID, containerID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendGet", reflect.TypeOf((*Sender)(nil).SendGet), ctx, nodeID, requestID, containerID)
}

// SendGetAccepted mocks base method.
func (m *Sender) SendGetAccepted(ctx context.Context, nodeIDs set.Set[ids.NodeID], requestID uint32, containerIDs []ids.ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendGetAccepted", ctx, nodeIDs, requestID, containerIDs)
}

// SendGetAccepted indicates an expected call of SendGetAccepted.
func (mr *SenderMockRecorder) SendGetAccepted(ctx, nodeIDs, requestID, containerIDs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendGetAccepted", reflect.TypeOf((*Sender)(nil).SendGetAccepted), ctx, nodeIDs, requestID, containerIDs)
}

// SendGetAcceptedFrontier mocks base method.
func (m *Sender) SendGetAcceptedFrontier(ctx context.Context, nodeIDs set.Set[ids.NodeID], requestID uint32) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendGetAcceptedFrontier", ctx, nodeIDs, requestID)
}

// SendGetAcceptedFrontier indicates an expected call of SendGetAcceptedFrontier.
func (mr *SenderMockRecorder) SendGetAcceptedFrontier(ctx, nodeIDs, requestID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendGetAcceptedFrontier", reflect.TypeOf((*Sender)(nil).SendGetAcceptedFrontier), ctx, nodeIDs, requestID)
}

// SendGetAcceptedStateSummary mocks base method.
func (m *Sender) SendGetAcceptedStateSummary(ctx context.Context, nodeIDs set.Set[ids.NodeID], requestID uint32, heights []uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendGetAcceptedStateSummary", ctx, nodeIDs, requestID, heights)
}

// SendGetAcceptedStateSummary indicates an expected call of SendGetAcceptedStateSummary.
func (mr *SenderMockRecorder) SendGetAcceptedStateSummary(ctx, nodeIDs, requestID, heights any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendGetAcceptedStateSummary", reflect.TypeOf((*Sender)(nil).SendGetAcceptedStateSummary), ctx, nodeIDs, requestID, heights)
}

// SendGetAncestors mocks base method.
func (m *Sender) SendGetAncestors(ctx context.Context, nodeID ids.NodeID, requestID uint32, containerID ids.ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendGetAncestors", ctx, nodeID, requestID, containerID)
}

// SendGetAncestors indicates an expected call of SendGetAncestors.
func (mr *SenderMockRecorder) SendGetAncestors(ctx, nodeID, requestID, containerID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendGetAncestors", reflect.TypeOf((*Sender)(nil).SendGetAncestors), ctx, nodeID, requestID, containerID)
}

// SendGetStateSummaryFrontier mocks base method.
func (m *Sender) SendGetStateSummaryFrontier(ctx context.Context, nodeIDs set.Set[ids.NodeID], requestID uint32) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendGetStateSummaryFrontier", ctx, nodeIDs, requestID)
}

// SendGetStateSummaryFrontier indicates an expected call of SendGetStateSummaryFrontier.
func (mr *SenderMockRecorder) SendGetStateSummaryFrontier(ctx, nodeIDs, requestID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendGetStateSummaryFrontier", reflect.TypeOf((*Sender)(nil).SendGetStateSummaryFrontier), ctx, nodeIDs, requestID)
}

// SendPullQuery mocks base method.
func (m *Sender) SendPullQuery(ctx context.Context, nodeIDs set.Set[ids.NodeID], requestID uint32, containerID ids.ID, requestedHeight uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendPullQuery", ctx, nodeIDs, requestID, containerID, requestedHeight)
}

// SendPullQuery indicates an expected call of SendPullQuery.
func (mr *SenderMockRecorder) SendPullQuery(ctx, nodeIDs, requestID, containerID, requestedHeight any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendPullQuery", reflect.TypeOf((*Sender)(nil).SendPullQuery), ctx, nodeIDs, requestID, containerID, requestedHeight)
}

// SendPushQuery mocks base method.
func (m *Sender) SendPushQuery(ctx context.Context, nodeIDs set.Set[ids.NodeID], requestID uint32, container []byte, requestedHeight uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendPushQuery", ctx, nodeIDs, requestID, container, requestedHeight)
}

// SendPushQuery indicates an expected call of SendPushQuery.
func (mr *SenderMockRecorder) SendPushQuery(ctx, nodeIDs, requestID, container, requestedHeight any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendPushQuery", reflect.TypeOf((*Sender)(nil).SendPushQuery), ctx, nodeIDs, requestID, container, requestedHeight)
}

// SendPut mocks base method.
func (m *Sender) SendPut(ctx context.Context, nodeID ids.NodeID, requestID uint32, container []byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendPut", ctx, nodeID, requestID, container)
}

// SendPut indicates an expected call of SendPut.
func (mr *SenderMockRecorder) SendPut(ctx, nodeID, requestID, container any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendPut", reflect.TypeOf((*Sender)(nil).SendPut), ctx, nodeID, requestID, container)
}

// SendStateSummaryFrontier mocks base method.
func (m *Sender) SendStateSummaryFrontier(ctx context.Context, nodeID ids.NodeID, requestID uint32, summary []byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendStateSummaryFrontier", ctx, nodeID, requestID, summary)
}

// SendStateSummaryFrontier indicates an expected call of SendStateSummaryFrontier.
func (mr *SenderMockRecorder) SendStateSummaryFrontier(ctx, nodeID, requestID, summary any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendStateSummaryFrontier", reflect.TypeOf((*Sender)(nil).SendStateSummaryFrontier), ctx, nodeID, requestID, summary)
}
