// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/quic-go/quic-go/internal/mocks/logging (interfaces: ConnectionTracer)
//
// Generated by this command:
//
//	mockgen -typed -build_flags=-tags=gomock -package internal -destination internal/connection_tracer.go github.com/quic-go/quic-go/internal/mocks/logging ConnectionTracer
//

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

import (
	net "net"
	reflect "reflect"
	time "time"

	logging "github.com/quic-go/quic-go/logging"
	gomock "go.uber.org/mock/gomock"
)

// MockConnectionTracer is a mock of ConnectionTracer interface.
type MockConnectionTracer struct {
	ctrl     *gomock.Controller
	recorder *MockConnectionTracerMockRecorder
	isgomock struct{}
}

// MockConnectionTracerMockRecorder is the mock recorder for MockConnectionTracer.
type MockConnectionTracerMockRecorder struct {
	mock *MockConnectionTracer
}

// NewMockConnectionTracer creates a new mock instance.
func NewMockConnectionTracer(ctrl *gomock.Controller) *MockConnectionTracer {
	mock := &MockConnectionTracer{ctrl: ctrl}
	mock.recorder = &MockConnectionTracerMockRecorder{mock}
	return mock
}

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

// AcknowledgedPacket mocks base method.
func (m *MockConnectionTracer) AcknowledgedPacket(arg0 logging.EncryptionLevel, arg1 logging.PacketNumber) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AcknowledgedPacket", arg0, arg1)
}

// AcknowledgedPacket indicates an expected call of AcknowledgedPacket.
func (mr *MockConnectionTracerMockRecorder) AcknowledgedPacket(arg0, arg1 any) *MockConnectionTracerAcknowledgedPacketCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcknowledgedPacket", reflect.TypeOf((*MockConnectionTracer)(nil).AcknowledgedPacket), arg0, arg1)
	return &MockConnectionTracerAcknowledgedPacketCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerAcknowledgedPacketCall) Do(f func(logging.EncryptionLevel, logging.PacketNumber)) *MockConnectionTracerAcknowledgedPacketCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerAcknowledgedPacketCall) DoAndReturn(f func(logging.EncryptionLevel, logging.PacketNumber)) *MockConnectionTracerAcknowledgedPacketCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// BufferedPacket mocks base method.
func (m *MockConnectionTracer) BufferedPacket(arg0 logging.PacketType, arg1 logging.ByteCount) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "BufferedPacket", arg0, arg1)
}

// BufferedPacket indicates an expected call of BufferedPacket.
func (mr *MockConnectionTracerMockRecorder) BufferedPacket(arg0, arg1 any) *MockConnectionTracerBufferedPacketCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BufferedPacket", reflect.TypeOf((*MockConnectionTracer)(nil).BufferedPacket), arg0, arg1)
	return &MockConnectionTracerBufferedPacketCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerBufferedPacketCall) Do(f func(logging.PacketType, logging.ByteCount)) *MockConnectionTracerBufferedPacketCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerBufferedPacketCall) DoAndReturn(f func(logging.PacketType, logging.ByteCount)) *MockConnectionTracerBufferedPacketCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ChoseALPN mocks base method.
func (m *MockConnectionTracer) ChoseALPN(protocol string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ChoseALPN", protocol)
}

// ChoseALPN indicates an expected call of ChoseALPN.
func (mr *MockConnectionTracerMockRecorder) ChoseALPN(protocol any) *MockConnectionTracerChoseALPNCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChoseALPN", reflect.TypeOf((*MockConnectionTracer)(nil).ChoseALPN), protocol)
	return &MockConnectionTracerChoseALPNCall{Call: call}
}

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

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

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

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

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

// Close indicates an expected call of Close.
func (mr *MockConnectionTracerMockRecorder) Close() *MockConnectionTracerCloseCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockConnectionTracer)(nil).Close))
	return &MockConnectionTracerCloseCall{Call: call}
}

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

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

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

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

// ClosedConnection mocks base method.
func (m *MockConnectionTracer) ClosedConnection(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ClosedConnection", arg0)
}

// ClosedConnection indicates an expected call of ClosedConnection.
func (mr *MockConnectionTracerMockRecorder) ClosedConnection(arg0 any) *MockConnectionTracerClosedConnectionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClosedConnection", reflect.TypeOf((*MockConnectionTracer)(nil).ClosedConnection), arg0)
	return &MockConnectionTracerClosedConnectionCall{Call: call}
}

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

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

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

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

// Debug mocks base method.
func (m *MockConnectionTracer) Debug(name, msg string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Debug", name, msg)
}

// Debug indicates an expected call of Debug.
func (mr *MockConnectionTracerMockRecorder) Debug(name, msg any) *MockConnectionTracerDebugCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockConnectionTracer)(nil).Debug), name, msg)
	return &MockConnectionTracerDebugCall{Call: call}
}

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

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

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

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

// DroppedEncryptionLevel mocks base method.
func (m *MockConnectionTracer) DroppedEncryptionLevel(arg0 logging.EncryptionLevel) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "DroppedEncryptionLevel", arg0)
}

// DroppedEncryptionLevel indicates an expected call of DroppedEncryptionLevel.
func (mr *MockConnectionTracerMockRecorder) DroppedEncryptionLevel(arg0 any) *MockConnectionTracerDroppedEncryptionLevelCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DroppedEncryptionLevel", reflect.TypeOf((*MockConnectionTracer)(nil).DroppedEncryptionLevel), arg0)
	return &MockConnectionTracerDroppedEncryptionLevelCall{Call: call}
}

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

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

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

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

// DroppedKey mocks base method.
func (m *MockConnectionTracer) DroppedKey(generation logging.KeyPhase) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "DroppedKey", generation)
}

// DroppedKey indicates an expected call of DroppedKey.
func (mr *MockConnectionTracerMockRecorder) DroppedKey(generation any) *MockConnectionTracerDroppedKeyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DroppedKey", reflect.TypeOf((*MockConnectionTracer)(nil).DroppedKey), generation)
	return &MockConnectionTracerDroppedKeyCall{Call: call}
}

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

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

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

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

// DroppedPacket mocks base method.
func (m *MockConnectionTracer) DroppedPacket(arg0 logging.PacketType, arg1 logging.PacketNumber, arg2 logging.ByteCount, arg3 logging.PacketDropReason) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "DroppedPacket", arg0, arg1, arg2, arg3)
}

// DroppedPacket indicates an expected call of DroppedPacket.
func (mr *MockConnectionTracerMockRecorder) DroppedPacket(arg0, arg1, arg2, arg3 any) *MockConnectionTracerDroppedPacketCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DroppedPacket", reflect.TypeOf((*MockConnectionTracer)(nil).DroppedPacket), arg0, arg1, arg2, arg3)
	return &MockConnectionTracerDroppedPacketCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerDroppedPacketCall) Do(f func(logging.PacketType, logging.PacketNumber, logging.ByteCount, logging.PacketDropReason)) *MockConnectionTracerDroppedPacketCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerDroppedPacketCall) DoAndReturn(f func(logging.PacketType, logging.PacketNumber, logging.ByteCount, logging.PacketDropReason)) *MockConnectionTracerDroppedPacketCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ECNStateUpdated mocks base method.
func (m *MockConnectionTracer) ECNStateUpdated(state logging.ECNState, trigger logging.ECNStateTrigger) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ECNStateUpdated", state, trigger)
}

// ECNStateUpdated indicates an expected call of ECNStateUpdated.
func (mr *MockConnectionTracerMockRecorder) ECNStateUpdated(state, trigger any) *MockConnectionTracerECNStateUpdatedCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ECNStateUpdated", reflect.TypeOf((*MockConnectionTracer)(nil).ECNStateUpdated), state, trigger)
	return &MockConnectionTracerECNStateUpdatedCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerECNStateUpdatedCall) Do(f func(logging.ECNState, logging.ECNStateTrigger)) *MockConnectionTracerECNStateUpdatedCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerECNStateUpdatedCall) DoAndReturn(f func(logging.ECNState, logging.ECNStateTrigger)) *MockConnectionTracerECNStateUpdatedCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// LossTimerCanceled indicates an expected call of LossTimerCanceled.
func (mr *MockConnectionTracerMockRecorder) LossTimerCanceled() *MockConnectionTracerLossTimerCanceledCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LossTimerCanceled", reflect.TypeOf((*MockConnectionTracer)(nil).LossTimerCanceled))
	return &MockConnectionTracerLossTimerCanceledCall{Call: call}
}

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

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

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

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

// LossTimerExpired mocks base method.
func (m *MockConnectionTracer) LossTimerExpired(arg0 logging.TimerType, arg1 logging.EncryptionLevel) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "LossTimerExpired", arg0, arg1)
}

// LossTimerExpired indicates an expected call of LossTimerExpired.
func (mr *MockConnectionTracerMockRecorder) LossTimerExpired(arg0, arg1 any) *MockConnectionTracerLossTimerExpiredCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LossTimerExpired", reflect.TypeOf((*MockConnectionTracer)(nil).LossTimerExpired), arg0, arg1)
	return &MockConnectionTracerLossTimerExpiredCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerLossTimerExpiredCall) Do(f func(logging.TimerType, logging.EncryptionLevel)) *MockConnectionTracerLossTimerExpiredCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerLossTimerExpiredCall) DoAndReturn(f func(logging.TimerType, logging.EncryptionLevel)) *MockConnectionTracerLossTimerExpiredCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// LostPacket mocks base method.
func (m *MockConnectionTracer) LostPacket(arg0 logging.EncryptionLevel, arg1 logging.PacketNumber, arg2 logging.PacketLossReason) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "LostPacket", arg0, arg1, arg2)
}

// LostPacket indicates an expected call of LostPacket.
func (mr *MockConnectionTracerMockRecorder) LostPacket(arg0, arg1, arg2 any) *MockConnectionTracerLostPacketCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LostPacket", reflect.TypeOf((*MockConnectionTracer)(nil).LostPacket), arg0, arg1, arg2)
	return &MockConnectionTracerLostPacketCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerLostPacketCall) Do(f func(logging.EncryptionLevel, logging.PacketNumber, logging.PacketLossReason)) *MockConnectionTracerLostPacketCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerLostPacketCall) DoAndReturn(f func(logging.EncryptionLevel, logging.PacketNumber, logging.PacketLossReason)) *MockConnectionTracerLostPacketCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// NegotiatedVersion mocks base method.
func (m *MockConnectionTracer) NegotiatedVersion(chosen logging.Version, clientVersions, serverVersions []logging.Version) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "NegotiatedVersion", chosen, clientVersions, serverVersions)
}

// NegotiatedVersion indicates an expected call of NegotiatedVersion.
func (mr *MockConnectionTracerMockRecorder) NegotiatedVersion(chosen, clientVersions, serverVersions any) *MockConnectionTracerNegotiatedVersionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NegotiatedVersion", reflect.TypeOf((*MockConnectionTracer)(nil).NegotiatedVersion), chosen, clientVersions, serverVersions)
	return &MockConnectionTracerNegotiatedVersionCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerNegotiatedVersionCall) Do(f func(logging.Version, []logging.Version, []logging.Version)) *MockConnectionTracerNegotiatedVersionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerNegotiatedVersionCall) DoAndReturn(f func(logging.Version, []logging.Version, []logging.Version)) *MockConnectionTracerNegotiatedVersionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ReceivedLongHeaderPacket mocks base method.
func (m *MockConnectionTracer) ReceivedLongHeaderPacket(arg0 *logging.ExtendedHeader, arg1 logging.ByteCount, arg2 logging.ECN, arg3 []logging.Frame) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReceivedLongHeaderPacket", arg0, arg1, arg2, arg3)
}

// ReceivedLongHeaderPacket indicates an expected call of ReceivedLongHeaderPacket.
func (mr *MockConnectionTracerMockRecorder) ReceivedLongHeaderPacket(arg0, arg1, arg2, arg3 any) *MockConnectionTracerReceivedLongHeaderPacketCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedLongHeaderPacket", reflect.TypeOf((*MockConnectionTracer)(nil).ReceivedLongHeaderPacket), arg0, arg1, arg2, arg3)
	return &MockConnectionTracerReceivedLongHeaderPacketCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerReceivedLongHeaderPacketCall) Do(f func(*logging.ExtendedHeader, logging.ByteCount, logging.ECN, []logging.Frame)) *MockConnectionTracerReceivedLongHeaderPacketCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerReceivedLongHeaderPacketCall) DoAndReturn(f func(*logging.ExtendedHeader, logging.ByteCount, logging.ECN, []logging.Frame)) *MockConnectionTracerReceivedLongHeaderPacketCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ReceivedRetry mocks base method.
func (m *MockConnectionTracer) ReceivedRetry(arg0 *logging.Header) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReceivedRetry", arg0)
}

// ReceivedRetry indicates an expected call of ReceivedRetry.
func (mr *MockConnectionTracerMockRecorder) ReceivedRetry(arg0 any) *MockConnectionTracerReceivedRetryCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedRetry", reflect.TypeOf((*MockConnectionTracer)(nil).ReceivedRetry), arg0)
	return &MockConnectionTracerReceivedRetryCall{Call: call}
}

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

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

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

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

// ReceivedShortHeaderPacket mocks base method.
func (m *MockConnectionTracer) ReceivedShortHeaderPacket(arg0 *logging.ShortHeader, arg1 logging.ByteCount, arg2 logging.ECN, arg3 []logging.Frame) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReceivedShortHeaderPacket", arg0, arg1, arg2, arg3)
}

// ReceivedShortHeaderPacket indicates an expected call of ReceivedShortHeaderPacket.
func (mr *MockConnectionTracerMockRecorder) ReceivedShortHeaderPacket(arg0, arg1, arg2, arg3 any) *MockConnectionTracerReceivedShortHeaderPacketCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedShortHeaderPacket", reflect.TypeOf((*MockConnectionTracer)(nil).ReceivedShortHeaderPacket), arg0, arg1, arg2, arg3)
	return &MockConnectionTracerReceivedShortHeaderPacketCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerReceivedShortHeaderPacketCall) Do(f func(*logging.ShortHeader, logging.ByteCount, logging.ECN, []logging.Frame)) *MockConnectionTracerReceivedShortHeaderPacketCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerReceivedShortHeaderPacketCall) DoAndReturn(f func(*logging.ShortHeader, logging.ByteCount, logging.ECN, []logging.Frame)) *MockConnectionTracerReceivedShortHeaderPacketCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ReceivedTransportParameters mocks base method.
func (m *MockConnectionTracer) ReceivedTransportParameters(arg0 *logging.TransportParameters) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReceivedTransportParameters", arg0)
}

// ReceivedTransportParameters indicates an expected call of ReceivedTransportParameters.
func (mr *MockConnectionTracerMockRecorder) ReceivedTransportParameters(arg0 any) *MockConnectionTracerReceivedTransportParametersCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedTransportParameters", reflect.TypeOf((*MockConnectionTracer)(nil).ReceivedTransportParameters), arg0)
	return &MockConnectionTracerReceivedTransportParametersCall{Call: call}
}

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

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

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

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

// ReceivedVersionNegotiationPacket mocks base method.
func (m *MockConnectionTracer) ReceivedVersionNegotiationPacket(dest, src logging.ArbitraryLenConnectionID, arg2 []logging.Version) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReceivedVersionNegotiationPacket", dest, src, arg2)
}

// ReceivedVersionNegotiationPacket indicates an expected call of ReceivedVersionNegotiationPacket.
func (mr *MockConnectionTracerMockRecorder) ReceivedVersionNegotiationPacket(dest, src, arg2 any) *MockConnectionTracerReceivedVersionNegotiationPacketCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedVersionNegotiationPacket", reflect.TypeOf((*MockConnectionTracer)(nil).ReceivedVersionNegotiationPacket), dest, src, arg2)
	return &MockConnectionTracerReceivedVersionNegotiationPacketCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerReceivedVersionNegotiationPacketCall) Do(f func(logging.ArbitraryLenConnectionID, logging.ArbitraryLenConnectionID, []logging.Version)) *MockConnectionTracerReceivedVersionNegotiationPacketCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerReceivedVersionNegotiationPacketCall) DoAndReturn(f func(logging.ArbitraryLenConnectionID, logging.ArbitraryLenConnectionID, []logging.Version)) *MockConnectionTracerReceivedVersionNegotiationPacketCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RestoredTransportParameters mocks base method.
func (m *MockConnectionTracer) RestoredTransportParameters(parameters *logging.TransportParameters) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RestoredTransportParameters", parameters)
}

// RestoredTransportParameters indicates an expected call of RestoredTransportParameters.
func (mr *MockConnectionTracerMockRecorder) RestoredTransportParameters(parameters any) *MockConnectionTracerRestoredTransportParametersCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoredTransportParameters", reflect.TypeOf((*MockConnectionTracer)(nil).RestoredTransportParameters), parameters)
	return &MockConnectionTracerRestoredTransportParametersCall{Call: call}
}

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

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

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

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

// SentLongHeaderPacket mocks base method.
func (m *MockConnectionTracer) SentLongHeaderPacket(arg0 *logging.ExtendedHeader, arg1 logging.ByteCount, arg2 logging.ECN, arg3 *logging.AckFrame, arg4 []logging.Frame) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SentLongHeaderPacket", arg0, arg1, arg2, arg3, arg4)
}

// SentLongHeaderPacket indicates an expected call of SentLongHeaderPacket.
func (mr *MockConnectionTracerMockRecorder) SentLongHeaderPacket(arg0, arg1, arg2, arg3, arg4 any) *MockConnectionTracerSentLongHeaderPacketCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SentLongHeaderPacket", reflect.TypeOf((*MockConnectionTracer)(nil).SentLongHeaderPacket), arg0, arg1, arg2, arg3, arg4)
	return &MockConnectionTracerSentLongHeaderPacketCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerSentLongHeaderPacketCall) Do(f func(*logging.ExtendedHeader, logging.ByteCount, logging.ECN, *logging.AckFrame, []logging.Frame)) *MockConnectionTracerSentLongHeaderPacketCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerSentLongHeaderPacketCall) DoAndReturn(f func(*logging.ExtendedHeader, logging.ByteCount, logging.ECN, *logging.AckFrame, []logging.Frame)) *MockConnectionTracerSentLongHeaderPacketCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SentShortHeaderPacket mocks base method.
func (m *MockConnectionTracer) SentShortHeaderPacket(arg0 *logging.ShortHeader, arg1 logging.ByteCount, arg2 logging.ECN, arg3 *logging.AckFrame, arg4 []logging.Frame) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SentShortHeaderPacket", arg0, arg1, arg2, arg3, arg4)
}

// SentShortHeaderPacket indicates an expected call of SentShortHeaderPacket.
func (mr *MockConnectionTracerMockRecorder) SentShortHeaderPacket(arg0, arg1, arg2, arg3, arg4 any) *MockConnectionTracerSentShortHeaderPacketCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SentShortHeaderPacket", reflect.TypeOf((*MockConnectionTracer)(nil).SentShortHeaderPacket), arg0, arg1, arg2, arg3, arg4)
	return &MockConnectionTracerSentShortHeaderPacketCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerSentShortHeaderPacketCall) Do(f func(*logging.ShortHeader, logging.ByteCount, logging.ECN, *logging.AckFrame, []logging.Frame)) *MockConnectionTracerSentShortHeaderPacketCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerSentShortHeaderPacketCall) DoAndReturn(f func(*logging.ShortHeader, logging.ByteCount, logging.ECN, *logging.AckFrame, []logging.Frame)) *MockConnectionTracerSentShortHeaderPacketCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SentTransportParameters mocks base method.
func (m *MockConnectionTracer) SentTransportParameters(arg0 *logging.TransportParameters) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SentTransportParameters", arg0)
}

// SentTransportParameters indicates an expected call of SentTransportParameters.
func (mr *MockConnectionTracerMockRecorder) SentTransportParameters(arg0 any) *MockConnectionTracerSentTransportParametersCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SentTransportParameters", reflect.TypeOf((*MockConnectionTracer)(nil).SentTransportParameters), arg0)
	return &MockConnectionTracerSentTransportParametersCall{Call: call}
}

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

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

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

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

// SetLossTimer mocks base method.
func (m *MockConnectionTracer) SetLossTimer(arg0 logging.TimerType, arg1 logging.EncryptionLevel, arg2 time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLossTimer", arg0, arg1, arg2)
}

// SetLossTimer indicates an expected call of SetLossTimer.
func (mr *MockConnectionTracerMockRecorder) SetLossTimer(arg0, arg1, arg2 any) *MockConnectionTracerSetLossTimerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLossTimer", reflect.TypeOf((*MockConnectionTracer)(nil).SetLossTimer), arg0, arg1, arg2)
	return &MockConnectionTracerSetLossTimerCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerSetLossTimerCall) Do(f func(logging.TimerType, logging.EncryptionLevel, time.Time)) *MockConnectionTracerSetLossTimerCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerSetLossTimerCall) DoAndReturn(f func(logging.TimerType, logging.EncryptionLevel, time.Time)) *MockConnectionTracerSetLossTimerCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// StartedConnection mocks base method.
func (m *MockConnectionTracer) StartedConnection(local, remote net.Addr, srcConnID, destConnID logging.ConnectionID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "StartedConnection", local, remote, srcConnID, destConnID)
}

// StartedConnection indicates an expected call of StartedConnection.
func (mr *MockConnectionTracerMockRecorder) StartedConnection(local, remote, srcConnID, destConnID any) *MockConnectionTracerStartedConnectionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartedConnection", reflect.TypeOf((*MockConnectionTracer)(nil).StartedConnection), local, remote, srcConnID, destConnID)
	return &MockConnectionTracerStartedConnectionCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerStartedConnectionCall) Do(f func(net.Addr, net.Addr, logging.ConnectionID, logging.ConnectionID)) *MockConnectionTracerStartedConnectionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerStartedConnectionCall) DoAndReturn(f func(net.Addr, net.Addr, logging.ConnectionID, logging.ConnectionID)) *MockConnectionTracerStartedConnectionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UpdatedCongestionState mocks base method.
func (m *MockConnectionTracer) UpdatedCongestionState(arg0 logging.CongestionState) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdatedCongestionState", arg0)
}

// UpdatedCongestionState indicates an expected call of UpdatedCongestionState.
func (mr *MockConnectionTracerMockRecorder) UpdatedCongestionState(arg0 any) *MockConnectionTracerUpdatedCongestionStateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedCongestionState", reflect.TypeOf((*MockConnectionTracer)(nil).UpdatedCongestionState), arg0)
	return &MockConnectionTracerUpdatedCongestionStateCall{Call: call}
}

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

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

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

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

// UpdatedKey mocks base method.
func (m *MockConnectionTracer) UpdatedKey(generation logging.KeyPhase, remote bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdatedKey", generation, remote)
}

// UpdatedKey indicates an expected call of UpdatedKey.
func (mr *MockConnectionTracerMockRecorder) UpdatedKey(generation, remote any) *MockConnectionTracerUpdatedKeyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedKey", reflect.TypeOf((*MockConnectionTracer)(nil).UpdatedKey), generation, remote)
	return &MockConnectionTracerUpdatedKeyCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerUpdatedKeyCall) Do(f func(logging.KeyPhase, bool)) *MockConnectionTracerUpdatedKeyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerUpdatedKeyCall) DoAndReturn(f func(logging.KeyPhase, bool)) *MockConnectionTracerUpdatedKeyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UpdatedKeyFromTLS mocks base method.
func (m *MockConnectionTracer) UpdatedKeyFromTLS(arg0 logging.EncryptionLevel, arg1 logging.Perspective) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdatedKeyFromTLS", arg0, arg1)
}

// UpdatedKeyFromTLS indicates an expected call of UpdatedKeyFromTLS.
func (mr *MockConnectionTracerMockRecorder) UpdatedKeyFromTLS(arg0, arg1 any) *MockConnectionTracerUpdatedKeyFromTLSCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedKeyFromTLS", reflect.TypeOf((*MockConnectionTracer)(nil).UpdatedKeyFromTLS), arg0, arg1)
	return &MockConnectionTracerUpdatedKeyFromTLSCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerUpdatedKeyFromTLSCall) Do(f func(logging.EncryptionLevel, logging.Perspective)) *MockConnectionTracerUpdatedKeyFromTLSCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerUpdatedKeyFromTLSCall) DoAndReturn(f func(logging.EncryptionLevel, logging.Perspective)) *MockConnectionTracerUpdatedKeyFromTLSCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UpdatedMTU mocks base method.
func (m *MockConnectionTracer) UpdatedMTU(mtu logging.ByteCount, done bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdatedMTU", mtu, done)
}

// UpdatedMTU indicates an expected call of UpdatedMTU.
func (mr *MockConnectionTracerMockRecorder) UpdatedMTU(mtu, done any) *MockConnectionTracerUpdatedMTUCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedMTU", reflect.TypeOf((*MockConnectionTracer)(nil).UpdatedMTU), mtu, done)
	return &MockConnectionTracerUpdatedMTUCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerUpdatedMTUCall) Do(f func(logging.ByteCount, bool)) *MockConnectionTracerUpdatedMTUCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerUpdatedMTUCall) DoAndReturn(f func(logging.ByteCount, bool)) *MockConnectionTracerUpdatedMTUCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UpdatedMetrics mocks base method.
func (m *MockConnectionTracer) UpdatedMetrics(rttStats *logging.RTTStats, cwnd, bytesInFlight logging.ByteCount, packetsInFlight int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdatedMetrics", rttStats, cwnd, bytesInFlight, packetsInFlight)
}

// UpdatedMetrics indicates an expected call of UpdatedMetrics.
func (mr *MockConnectionTracerMockRecorder) UpdatedMetrics(rttStats, cwnd, bytesInFlight, packetsInFlight any) *MockConnectionTracerUpdatedMetricsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedMetrics", reflect.TypeOf((*MockConnectionTracer)(nil).UpdatedMetrics), rttStats, cwnd, bytesInFlight, packetsInFlight)
	return &MockConnectionTracerUpdatedMetricsCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockConnectionTracerUpdatedMetricsCall) Do(f func(*logging.RTTStats, logging.ByteCount, logging.ByteCount, int)) *MockConnectionTracerUpdatedMetricsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConnectionTracerUpdatedMetricsCall) DoAndReturn(f func(*logging.RTTStats, logging.ByteCount, logging.ByteCount, int)) *MockConnectionTracerUpdatedMetricsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UpdatedPTOCount mocks base method.
func (m *MockConnectionTracer) UpdatedPTOCount(value uint32) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdatedPTOCount", value)
}

// UpdatedPTOCount indicates an expected call of UpdatedPTOCount.
func (mr *MockConnectionTracerMockRecorder) UpdatedPTOCount(value any) *MockConnectionTracerUpdatedPTOCountCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedPTOCount", reflect.TypeOf((*MockConnectionTracer)(nil).UpdatedPTOCount), value)
	return &MockConnectionTracerUpdatedPTOCountCall{Call: call}
}

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

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

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

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