chromium/out/Default/gen/logging/rtc_event_log/rtc_event_log2.pb.cc

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: rtc_event_log2.proto

#include "rtc_event_log2.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG

_pb;
_pbi;

namespace webrtc {
namespace rtclog2 {
PROTOBUF_CONSTEXPR EventStream::EventStream(
    ::_pbi::ConstantInitialized):{}
struct EventStreamDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EventStreamDefaultTypeInternal _EventStream_default_instance_;
PROTOBUF_CONSTEXPR Event::Event(
    ::_pbi::ConstantInitialized):{}
struct EventDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EventDefaultTypeInternal _Event_default_instance_;
PROTOBUF_CONSTEXPR GenericPacketReceived::GenericPacketReceived(
    ::_pbi::ConstantInitialized):{}
struct GenericPacketReceivedDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GenericPacketReceivedDefaultTypeInternal _GenericPacketReceived_default_instance_;
PROTOBUF_CONSTEXPR GenericPacketSent::GenericPacketSent(
    ::_pbi::ConstantInitialized):{}
struct GenericPacketSentDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GenericPacketSentDefaultTypeInternal _GenericPacketSent_default_instance_;
PROTOBUF_CONSTEXPR GenericAckReceived::GenericAckReceived(
    ::_pbi::ConstantInitialized):{}
struct GenericAckReceivedDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GenericAckReceivedDefaultTypeInternal _GenericAckReceived_default_instance_;
PROTOBUF_CONSTEXPR DependencyDescriptorsWireInfo::DependencyDescriptorsWireInfo(
    ::_pbi::ConstantInitialized):{}
struct DependencyDescriptorsWireInfoDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DependencyDescriptorsWireInfoDefaultTypeInternal _DependencyDescriptorsWireInfo_default_instance_;
PROTOBUF_CONSTEXPR IncomingRtpPackets::IncomingRtpPackets(
    ::_pbi::ConstantInitialized):{}
struct IncomingRtpPacketsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IncomingRtpPacketsDefaultTypeInternal _IncomingRtpPackets_default_instance_;
PROTOBUF_CONSTEXPR OutgoingRtpPackets::OutgoingRtpPackets(
    ::_pbi::ConstantInitialized):{}
struct OutgoingRtpPacketsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OutgoingRtpPacketsDefaultTypeInternal _OutgoingRtpPackets_default_instance_;
PROTOBUF_CONSTEXPR IncomingRtcpPackets::IncomingRtcpPackets(
    ::_pbi::ConstantInitialized):{}
struct IncomingRtcpPacketsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IncomingRtcpPacketsDefaultTypeInternal _IncomingRtcpPackets_default_instance_;
PROTOBUF_CONSTEXPR OutgoingRtcpPackets::OutgoingRtcpPackets(
    ::_pbi::ConstantInitialized):{}
struct OutgoingRtcpPacketsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OutgoingRtcpPacketsDefaultTypeInternal _OutgoingRtcpPackets_default_instance_;
PROTOBUF_CONSTEXPR AudioPlayoutEvents::AudioPlayoutEvents(
    ::_pbi::ConstantInitialized):{}
struct AudioPlayoutEventsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AudioPlayoutEventsDefaultTypeInternal _AudioPlayoutEvents_default_instance_;
PROTOBUF_CONSTEXPR NetEqSetMinimumDelay::NetEqSetMinimumDelay(
    ::_pbi::ConstantInitialized):{}
struct NetEqSetMinimumDelayDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NetEqSetMinimumDelayDefaultTypeInternal _NetEqSetMinimumDelay_default_instance_;
PROTOBUF_CONSTEXPR FrameDecodedEvents::FrameDecodedEvents(
    ::_pbi::ConstantInitialized):{}
struct FrameDecodedEventsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FrameDecodedEventsDefaultTypeInternal _FrameDecodedEvents_default_instance_;
PROTOBUF_CONSTEXPR BeginLogEvent::BeginLogEvent(
    ::_pbi::ConstantInitialized):{}
struct BeginLogEventDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BeginLogEventDefaultTypeInternal _BeginLogEvent_default_instance_;
PROTOBUF_CONSTEXPR EndLogEvent::EndLogEvent(
    ::_pbi::ConstantInitialized):{}
struct EndLogEventDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EndLogEventDefaultTypeInternal _EndLogEvent_default_instance_;
PROTOBUF_CONSTEXPR LossBasedBweUpdates::LossBasedBweUpdates(
    ::_pbi::ConstantInitialized):{}
struct LossBasedBweUpdatesDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LossBasedBweUpdatesDefaultTypeInternal _LossBasedBweUpdates_default_instance_;
PROTOBUF_CONSTEXPR DelayBasedBweUpdates::DelayBasedBweUpdates(
    ::_pbi::ConstantInitialized):{}
struct DelayBasedBweUpdatesDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DelayBasedBweUpdatesDefaultTypeInternal _DelayBasedBweUpdates_default_instance_;
PROTOBUF_CONSTEXPR RtpHeaderExtensionConfig::RtpHeaderExtensionConfig(
    ::_pbi::ConstantInitialized):{}
struct RtpHeaderExtensionConfigDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RtpHeaderExtensionConfigDefaultTypeInternal _RtpHeaderExtensionConfig_default_instance_;
PROTOBUF_CONSTEXPR VideoRecvStreamConfig::VideoRecvStreamConfig(
    ::_pbi::ConstantInitialized):{}
struct VideoRecvStreamConfigDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VideoRecvStreamConfigDefaultTypeInternal _VideoRecvStreamConfig_default_instance_;
PROTOBUF_CONSTEXPR VideoSendStreamConfig::VideoSendStreamConfig(
    ::_pbi::ConstantInitialized):{}
struct VideoSendStreamConfigDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VideoSendStreamConfigDefaultTypeInternal _VideoSendStreamConfig_default_instance_;
PROTOBUF_CONSTEXPR AudioRecvStreamConfig::AudioRecvStreamConfig(
    ::_pbi::ConstantInitialized):{}
struct AudioRecvStreamConfigDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AudioRecvStreamConfigDefaultTypeInternal _AudioRecvStreamConfig_default_instance_;
PROTOBUF_CONSTEXPR AudioSendStreamConfig::AudioSendStreamConfig(
    ::_pbi::ConstantInitialized):{}
struct AudioSendStreamConfigDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AudioSendStreamConfigDefaultTypeInternal _AudioSendStreamConfig_default_instance_;
PROTOBUF_CONSTEXPR AudioNetworkAdaptations::AudioNetworkAdaptations(
    ::_pbi::ConstantInitialized):{}
struct AudioNetworkAdaptationsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AudioNetworkAdaptationsDefaultTypeInternal _AudioNetworkAdaptations_default_instance_;
PROTOBUF_CONSTEXPR BweProbeCluster::BweProbeCluster(
    ::_pbi::ConstantInitialized):{}
struct BweProbeClusterDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BweProbeClusterDefaultTypeInternal _BweProbeCluster_default_instance_;
PROTOBUF_CONSTEXPR BweProbeResultSuccess::BweProbeResultSuccess(
    ::_pbi::ConstantInitialized):{}
struct BweProbeResultSuccessDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BweProbeResultSuccessDefaultTypeInternal _BweProbeResultSuccess_default_instance_;
PROTOBUF_CONSTEXPR BweProbeResultFailure::BweProbeResultFailure(
    ::_pbi::ConstantInitialized):{}
struct BweProbeResultFailureDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BweProbeResultFailureDefaultTypeInternal _BweProbeResultFailure_default_instance_;
PROTOBUF_CONSTEXPR AlrState::AlrState(
    ::_pbi::ConstantInitialized):{}
struct AlrStateDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AlrStateDefaultTypeInternal _AlrState_default_instance_;
PROTOBUF_CONSTEXPR IceCandidatePairConfig::IceCandidatePairConfig(
    ::_pbi::ConstantInitialized):{}
struct IceCandidatePairConfigDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IceCandidatePairConfigDefaultTypeInternal _IceCandidatePairConfig_default_instance_;
PROTOBUF_CONSTEXPR IceCandidatePairEvent::IceCandidatePairEvent(
    ::_pbi::ConstantInitialized):{}
struct IceCandidatePairEventDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IceCandidatePairEventDefaultTypeInternal _IceCandidatePairEvent_default_instance_;
PROTOBUF_CONSTEXPR DtlsTransportStateEvent::DtlsTransportStateEvent(
    ::_pbi::ConstantInitialized):{}
struct DtlsTransportStateEventDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DtlsTransportStateEventDefaultTypeInternal _DtlsTransportStateEvent_default_instance_;
PROTOBUF_CONSTEXPR DtlsWritableState::DtlsWritableState(
    ::_pbi::ConstantInitialized):{}
struct DtlsWritableStateDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DtlsWritableStateDefaultTypeInternal _DtlsWritableState_default_instance_;
PROTOBUF_CONSTEXPR RouteChange::RouteChange(
    ::_pbi::ConstantInitialized):{}
struct RouteChangeDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RouteChangeDefaultTypeInternal _RouteChange_default_instance_;
PROTOBUF_CONSTEXPR RemoteEstimates::RemoteEstimates(
    ::_pbi::ConstantInitialized):{}
struct RemoteEstimatesDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RemoteEstimatesDefaultTypeInternal _RemoteEstimates_default_instance_;
}  // namespace rtclog2
}  // namespace webrtc
namespace webrtc {
namespace rtclog2 {
bool FrameDecodedEvents_Codec_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> FrameDecodedEvents_Codec_strings[7] =;

static const char FrameDecodedEvents_Codec_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry FrameDecodedEvents_Codec_entries[] =;

static const int FrameDecodedEvents_Codec_entries_by_number[] =;

const std::string& FrameDecodedEvents_Codec_Name(
    FrameDecodedEvents_Codec value) {}
bool FrameDecodedEvents_Codec_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FrameDecodedEvents_Codec* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr FrameDecodedEvents_Codec FrameDecodedEvents::CODEC_UNKNOWN;
constexpr FrameDecodedEvents_Codec FrameDecodedEvents::CODEC_GENERIC;
constexpr FrameDecodedEvents_Codec FrameDecodedEvents::CODEC_VP8;
constexpr FrameDecodedEvents_Codec FrameDecodedEvents::CODEC_VP9;
constexpr FrameDecodedEvents_Codec FrameDecodedEvents::CODEC_AV1;
constexpr FrameDecodedEvents_Codec FrameDecodedEvents::CODEC_H264;
constexpr FrameDecodedEvents_Codec FrameDecodedEvents::CODEC_H265;
constexpr FrameDecodedEvents_Codec FrameDecodedEvents::Codec_MIN;
constexpr FrameDecodedEvents_Codec FrameDecodedEvents::Codec_MAX;
constexpr int FrameDecodedEvents::Codec_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool DelayBasedBweUpdates_DetectorState_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> DelayBasedBweUpdates_DetectorState_strings[4] =;

static const char DelayBasedBweUpdates_DetectorState_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DelayBasedBweUpdates_DetectorState_entries[] =;

static const int DelayBasedBweUpdates_DetectorState_entries_by_number[] =;

const std::string& DelayBasedBweUpdates_DetectorState_Name(
    DelayBasedBweUpdates_DetectorState value) {}
bool DelayBasedBweUpdates_DetectorState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DelayBasedBweUpdates_DetectorState* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr DelayBasedBweUpdates_DetectorState DelayBasedBweUpdates::BWE_UNKNOWN_STATE;
constexpr DelayBasedBweUpdates_DetectorState DelayBasedBweUpdates::BWE_NORMAL;
constexpr DelayBasedBweUpdates_DetectorState DelayBasedBweUpdates::BWE_UNDERUSING;
constexpr DelayBasedBweUpdates_DetectorState DelayBasedBweUpdates::BWE_OVERUSING;
constexpr DelayBasedBweUpdates_DetectorState DelayBasedBweUpdates::DetectorState_MIN;
constexpr DelayBasedBweUpdates_DetectorState DelayBasedBweUpdates::DetectorState_MAX;
constexpr int DelayBasedBweUpdates::DetectorState_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool BweProbeResultFailure_FailureReason_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> BweProbeResultFailure_FailureReason_strings[4] =;

static const char BweProbeResultFailure_FailureReason_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry BweProbeResultFailure_FailureReason_entries[] =;

static const int BweProbeResultFailure_FailureReason_entries_by_number[] =;

const std::string& BweProbeResultFailure_FailureReason_Name(
    BweProbeResultFailure_FailureReason value) {}
bool BweProbeResultFailure_FailureReason_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BweProbeResultFailure_FailureReason* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr BweProbeResultFailure_FailureReason BweProbeResultFailure::UNKNOWN;
constexpr BweProbeResultFailure_FailureReason BweProbeResultFailure::INVALID_SEND_RECEIVE_INTERVAL;
constexpr BweProbeResultFailure_FailureReason BweProbeResultFailure::INVALID_SEND_RECEIVE_RATIO;
constexpr BweProbeResultFailure_FailureReason BweProbeResultFailure::TIMEOUT;
constexpr BweProbeResultFailure_FailureReason BweProbeResultFailure::FailureReason_MIN;
constexpr BweProbeResultFailure_FailureReason BweProbeResultFailure::FailureReason_MAX;
constexpr int BweProbeResultFailure::FailureReason_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool IceCandidatePairConfig_IceCandidatePairConfigType_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> IceCandidatePairConfig_IceCandidatePairConfigType_strings[5] =;

static const char IceCandidatePairConfig_IceCandidatePairConfigType_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry IceCandidatePairConfig_IceCandidatePairConfigType_entries[] =;

static const int IceCandidatePairConfig_IceCandidatePairConfigType_entries_by_number[] =;

const std::string& IceCandidatePairConfig_IceCandidatePairConfigType_Name(
    IceCandidatePairConfig_IceCandidatePairConfigType value) {}
bool IceCandidatePairConfig_IceCandidatePairConfigType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IceCandidatePairConfig_IceCandidatePairConfigType* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr IceCandidatePairConfig_IceCandidatePairConfigType IceCandidatePairConfig::UNKNOWN_CONFIG_TYPE;
constexpr IceCandidatePairConfig_IceCandidatePairConfigType IceCandidatePairConfig::ADDED;
constexpr IceCandidatePairConfig_IceCandidatePairConfigType IceCandidatePairConfig::UPDATED;
constexpr IceCandidatePairConfig_IceCandidatePairConfigType IceCandidatePairConfig::DESTROYED;
constexpr IceCandidatePairConfig_IceCandidatePairConfigType IceCandidatePairConfig::SELECTED;
constexpr IceCandidatePairConfig_IceCandidatePairConfigType IceCandidatePairConfig::IceCandidatePairConfigType_MIN;
constexpr IceCandidatePairConfig_IceCandidatePairConfigType IceCandidatePairConfig::IceCandidatePairConfigType_MAX;
constexpr int IceCandidatePairConfig::IceCandidatePairConfigType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool IceCandidatePairConfig_IceCandidateType_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> IceCandidatePairConfig_IceCandidateType_strings[5] =;

static const char IceCandidatePairConfig_IceCandidateType_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry IceCandidatePairConfig_IceCandidateType_entries[] =;

static const int IceCandidatePairConfig_IceCandidateType_entries_by_number[] =;

const std::string& IceCandidatePairConfig_IceCandidateType_Name(
    IceCandidatePairConfig_IceCandidateType value) {}
bool IceCandidatePairConfig_IceCandidateType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IceCandidatePairConfig_IceCandidateType* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr IceCandidatePairConfig_IceCandidateType IceCandidatePairConfig::UNKNOWN_CANDIDATE_TYPE;
constexpr IceCandidatePairConfig_IceCandidateType IceCandidatePairConfig::LOCAL;
constexpr IceCandidatePairConfig_IceCandidateType IceCandidatePairConfig::STUN;
constexpr IceCandidatePairConfig_IceCandidateType IceCandidatePairConfig::PRFLX;
constexpr IceCandidatePairConfig_IceCandidateType IceCandidatePairConfig::RELAY;
constexpr IceCandidatePairConfig_IceCandidateType IceCandidatePairConfig::IceCandidateType_MIN;
constexpr IceCandidatePairConfig_IceCandidateType IceCandidatePairConfig::IceCandidateType_MAX;
constexpr int IceCandidatePairConfig::IceCandidateType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool IceCandidatePairConfig_Protocol_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> IceCandidatePairConfig_Protocol_strings[5] =;

static const char IceCandidatePairConfig_Protocol_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry IceCandidatePairConfig_Protocol_entries[] =;

static const int IceCandidatePairConfig_Protocol_entries_by_number[] =;

const std::string& IceCandidatePairConfig_Protocol_Name(
    IceCandidatePairConfig_Protocol value) {}
bool IceCandidatePairConfig_Protocol_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IceCandidatePairConfig_Protocol* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr IceCandidatePairConfig_Protocol IceCandidatePairConfig::UNKNOWN_PROTOCOL;
constexpr IceCandidatePairConfig_Protocol IceCandidatePairConfig::UDP;
constexpr IceCandidatePairConfig_Protocol IceCandidatePairConfig::TCP;
constexpr IceCandidatePairConfig_Protocol IceCandidatePairConfig::SSLTCP;
constexpr IceCandidatePairConfig_Protocol IceCandidatePairConfig::TLS;
constexpr IceCandidatePairConfig_Protocol IceCandidatePairConfig::Protocol_MIN;
constexpr IceCandidatePairConfig_Protocol IceCandidatePairConfig::Protocol_MAX;
constexpr int IceCandidatePairConfig::Protocol_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool IceCandidatePairConfig_AddressFamily_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> IceCandidatePairConfig_AddressFamily_strings[3] =;

static const char IceCandidatePairConfig_AddressFamily_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry IceCandidatePairConfig_AddressFamily_entries[] =;

static const int IceCandidatePairConfig_AddressFamily_entries_by_number[] =;

const std::string& IceCandidatePairConfig_AddressFamily_Name(
    IceCandidatePairConfig_AddressFamily value) {}
bool IceCandidatePairConfig_AddressFamily_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IceCandidatePairConfig_AddressFamily* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr IceCandidatePairConfig_AddressFamily IceCandidatePairConfig::UNKNOWN_ADDRESS_FAMILY;
constexpr IceCandidatePairConfig_AddressFamily IceCandidatePairConfig::IPV4;
constexpr IceCandidatePairConfig_AddressFamily IceCandidatePairConfig::IPV6;
constexpr IceCandidatePairConfig_AddressFamily IceCandidatePairConfig::AddressFamily_MIN;
constexpr IceCandidatePairConfig_AddressFamily IceCandidatePairConfig::AddressFamily_MAX;
constexpr int IceCandidatePairConfig::AddressFamily_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool IceCandidatePairConfig_NetworkType_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> IceCandidatePairConfig_NetworkType_strings[6] =;

static const char IceCandidatePairConfig_NetworkType_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry IceCandidatePairConfig_NetworkType_entries[] =;

static const int IceCandidatePairConfig_NetworkType_entries_by_number[] =;

const std::string& IceCandidatePairConfig_NetworkType_Name(
    IceCandidatePairConfig_NetworkType value) {}
bool IceCandidatePairConfig_NetworkType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IceCandidatePairConfig_NetworkType* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::UNKNOWN_NETWORK_TYPE;
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::ETHERNET;
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::WIFI;
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::CELLULAR;
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::VPN;
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::LOOPBACK;
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::NetworkType_MIN;
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::NetworkType_MAX;
constexpr int IceCandidatePairConfig::NetworkType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool IceCandidatePairEvent_IceCandidatePairEventType_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> IceCandidatePairEvent_IceCandidatePairEventType_strings[5] =;

static const char IceCandidatePairEvent_IceCandidatePairEventType_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry IceCandidatePairEvent_IceCandidatePairEventType_entries[] =;

static const int IceCandidatePairEvent_IceCandidatePairEventType_entries_by_number[] =;

const std::string& IceCandidatePairEvent_IceCandidatePairEventType_Name(
    IceCandidatePairEvent_IceCandidatePairEventType value) {}
bool IceCandidatePairEvent_IceCandidatePairEventType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IceCandidatePairEvent_IceCandidatePairEventType* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr IceCandidatePairEvent_IceCandidatePairEventType IceCandidatePairEvent::UNKNOWN_CHECK_TYPE;
constexpr IceCandidatePairEvent_IceCandidatePairEventType IceCandidatePairEvent::CHECK_SENT;
constexpr IceCandidatePairEvent_IceCandidatePairEventType IceCandidatePairEvent::CHECK_RECEIVED;
constexpr IceCandidatePairEvent_IceCandidatePairEventType IceCandidatePairEvent::CHECK_RESPONSE_SENT;
constexpr IceCandidatePairEvent_IceCandidatePairEventType IceCandidatePairEvent::CHECK_RESPONSE_RECEIVED;
constexpr IceCandidatePairEvent_IceCandidatePairEventType IceCandidatePairEvent::IceCandidatePairEventType_MIN;
constexpr IceCandidatePairEvent_IceCandidatePairEventType IceCandidatePairEvent::IceCandidatePairEventType_MAX;
constexpr int IceCandidatePairEvent::IceCandidatePairEventType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool DtlsTransportStateEvent_DtlsTransportState_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> DtlsTransportStateEvent_DtlsTransportState_strings[6] =;

static const char DtlsTransportStateEvent_DtlsTransportState_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DtlsTransportStateEvent_DtlsTransportState_entries[] =;

static const int DtlsTransportStateEvent_DtlsTransportState_entries_by_number[] =;

const std::string& DtlsTransportStateEvent_DtlsTransportState_Name(
    DtlsTransportStateEvent_DtlsTransportState value) {}
bool DtlsTransportStateEvent_DtlsTransportState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DtlsTransportStateEvent_DtlsTransportState* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr DtlsTransportStateEvent_DtlsTransportState DtlsTransportStateEvent::UNKNOWN_DTLS_TRANSPORT_STATE;
constexpr DtlsTransportStateEvent_DtlsTransportState DtlsTransportStateEvent::DTLS_TRANSPORT_NEW;
constexpr DtlsTransportStateEvent_DtlsTransportState DtlsTransportStateEvent::DTLS_TRANSPORT_CONNECTING;
constexpr DtlsTransportStateEvent_DtlsTransportState DtlsTransportStateEvent::DTLS_TRANSPORT_CONNECTED;
constexpr DtlsTransportStateEvent_DtlsTransportState DtlsTransportStateEvent::DTLS_TRANSPORT_CLOSED;
constexpr DtlsTransportStateEvent_DtlsTransportState DtlsTransportStateEvent::DTLS_TRANSPORT_FAILED;
constexpr DtlsTransportStateEvent_DtlsTransportState DtlsTransportStateEvent::DtlsTransportState_MIN;
constexpr DtlsTransportStateEvent_DtlsTransportState DtlsTransportStateEvent::DtlsTransportState_MAX;
constexpr int DtlsTransportStateEvent::DtlsTransportState_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

// ===================================================================

class EventStream::_Internal {};

EventStream::EventStream(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
EventStream::EventStream(const EventStream& from)
  :{}

inline void EventStream::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

EventStream::~EventStream() {}

inline void EventStream::SharedDtor() {}

void EventStream::SetCachedSize(int size) const {}

void EventStream::Clear() {}

const char* EventStream::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* EventStream::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t EventStream::ByteSizeLong() const {}

void EventStream::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void EventStream::MergeFrom(const EventStream& from) {}

void EventStream::CopyFrom(const EventStream& from) {}

bool EventStream::IsInitialized() const {}

void EventStream::InternalSwap(EventStream* other) {}

std::string EventStream::GetTypeName() const {}


// ===================================================================

class Event::_Internal {};

Event::Event(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
Event::Event(const Event& from)
  :{}

inline void Event::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

Event::~Event() {}

inline void Event::SharedDtor() {}

void Event::SetCachedSize(int size) const {}

void Event::Clear() {}

const char* Event::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* Event::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t Event::ByteSizeLong() const {}

void Event::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void Event::MergeFrom(const Event& from) {}

void Event::CopyFrom(const Event& from) {}

bool Event::IsInitialized() const {}

void Event::InternalSwap(Event* other) {}

std::string Event::GetTypeName() const {}


// ===================================================================

class GenericPacketReceived::_Internal {};

GenericPacketReceived::GenericPacketReceived(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
GenericPacketReceived::GenericPacketReceived(const GenericPacketReceived& from)
  :{}

inline void GenericPacketReceived::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

GenericPacketReceived::~GenericPacketReceived() {}

inline void GenericPacketReceived::SharedDtor() {}

void GenericPacketReceived::SetCachedSize(int size) const {}

void GenericPacketReceived::Clear() {}

const char* GenericPacketReceived::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* GenericPacketReceived::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t GenericPacketReceived::ByteSizeLong() const {}

void GenericPacketReceived::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void GenericPacketReceived::MergeFrom(const GenericPacketReceived& from) {}

void GenericPacketReceived::CopyFrom(const GenericPacketReceived& from) {}

bool GenericPacketReceived::IsInitialized() const {}

void GenericPacketReceived::InternalSwap(GenericPacketReceived* other) {}

std::string GenericPacketReceived::GetTypeName() const {}


// ===================================================================

class GenericPacketSent::_Internal {};

GenericPacketSent::GenericPacketSent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
GenericPacketSent::GenericPacketSent(const GenericPacketSent& from)
  :{}

inline void GenericPacketSent::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

GenericPacketSent::~GenericPacketSent() {}

inline void GenericPacketSent::SharedDtor() {}

void GenericPacketSent::SetCachedSize(int size) const {}

void GenericPacketSent::Clear() {}

const char* GenericPacketSent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* GenericPacketSent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t GenericPacketSent::ByteSizeLong() const {}

void GenericPacketSent::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void GenericPacketSent::MergeFrom(const GenericPacketSent& from) {}

void GenericPacketSent::CopyFrom(const GenericPacketSent& from) {}

bool GenericPacketSent::IsInitialized() const {}

void GenericPacketSent::InternalSwap(GenericPacketSent* other) {}

std::string GenericPacketSent::GetTypeName() const {}


// ===================================================================

class GenericAckReceived::_Internal {};

GenericAckReceived::GenericAckReceived(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
GenericAckReceived::GenericAckReceived(const GenericAckReceived& from)
  :{}

inline void GenericAckReceived::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

GenericAckReceived::~GenericAckReceived() {}

inline void GenericAckReceived::SharedDtor() {}

void GenericAckReceived::SetCachedSize(int size) const {}

void GenericAckReceived::Clear() {}

const char* GenericAckReceived::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* GenericAckReceived::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t GenericAckReceived::ByteSizeLong() const {}

void GenericAckReceived::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void GenericAckReceived::MergeFrom(const GenericAckReceived& from) {}

void GenericAckReceived::CopyFrom(const GenericAckReceived& from) {}

bool GenericAckReceived::IsInitialized() const {}

void GenericAckReceived::InternalSwap(GenericAckReceived* other) {}

std::string GenericAckReceived::GetTypeName() const {}


// ===================================================================

class DependencyDescriptorsWireInfo::_Internal {};

DependencyDescriptorsWireInfo::DependencyDescriptorsWireInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
DependencyDescriptorsWireInfo::DependencyDescriptorsWireInfo(const DependencyDescriptorsWireInfo& from)
  :{}

inline void DependencyDescriptorsWireInfo::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

DependencyDescriptorsWireInfo::~DependencyDescriptorsWireInfo() {}

inline void DependencyDescriptorsWireInfo::SharedDtor() {}

void DependencyDescriptorsWireInfo::SetCachedSize(int size) const {}

void DependencyDescriptorsWireInfo::Clear() {}

const char* DependencyDescriptorsWireInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* DependencyDescriptorsWireInfo::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t DependencyDescriptorsWireInfo::ByteSizeLong() const {}

void DependencyDescriptorsWireInfo::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void DependencyDescriptorsWireInfo::MergeFrom(const DependencyDescriptorsWireInfo& from) {}

void DependencyDescriptorsWireInfo::CopyFrom(const DependencyDescriptorsWireInfo& from) {}

bool DependencyDescriptorsWireInfo::IsInitialized() const {}

void DependencyDescriptorsWireInfo::InternalSwap(DependencyDescriptorsWireInfo* other) {}

std::string DependencyDescriptorsWireInfo::GetTypeName() const {}


// ===================================================================

class IncomingRtpPackets::_Internal {};

const ::webrtc::rtclog2::DependencyDescriptorsWireInfo&
IncomingRtpPackets::_Internal::dependency_descriptor(const IncomingRtpPackets* msg) {}
IncomingRtpPackets::IncomingRtpPackets(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
IncomingRtpPackets::IncomingRtpPackets(const IncomingRtpPackets& from)
  :{}

inline void IncomingRtpPackets::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

IncomingRtpPackets::~IncomingRtpPackets() {}

inline void IncomingRtpPackets::SharedDtor() {}

void IncomingRtpPackets::SetCachedSize(int size) const {}

void IncomingRtpPackets::Clear() {}

const char* IncomingRtpPackets::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* IncomingRtpPackets::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t IncomingRtpPackets::ByteSizeLong() const {}

void IncomingRtpPackets::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void IncomingRtpPackets::MergeFrom(const IncomingRtpPackets& from) {}

void IncomingRtpPackets::CopyFrom(const IncomingRtpPackets& from) {}

bool IncomingRtpPackets::IsInitialized() const {}

void IncomingRtpPackets::InternalSwap(IncomingRtpPackets* other) {}

std::string IncomingRtpPackets::GetTypeName() const {}


// ===================================================================

class OutgoingRtpPackets::_Internal {};

const ::webrtc::rtclog2::DependencyDescriptorsWireInfo&
OutgoingRtpPackets::_Internal::dependency_descriptor(const OutgoingRtpPackets* msg) {}
OutgoingRtpPackets::OutgoingRtpPackets(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
OutgoingRtpPackets::OutgoingRtpPackets(const OutgoingRtpPackets& from)
  :{}

inline void OutgoingRtpPackets::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

OutgoingRtpPackets::~OutgoingRtpPackets() {}

inline void OutgoingRtpPackets::SharedDtor() {}

void OutgoingRtpPackets::SetCachedSize(int size) const {}

void OutgoingRtpPackets::Clear() {}

const char* OutgoingRtpPackets::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* OutgoingRtpPackets::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t OutgoingRtpPackets::ByteSizeLong() const {}

void OutgoingRtpPackets::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void OutgoingRtpPackets::MergeFrom(const OutgoingRtpPackets& from) {}

void OutgoingRtpPackets::CopyFrom(const OutgoingRtpPackets& from) {}

bool OutgoingRtpPackets::IsInitialized() const {}

void OutgoingRtpPackets::InternalSwap(OutgoingRtpPackets* other) {}

std::string OutgoingRtpPackets::GetTypeName() const {}


// ===================================================================

class IncomingRtcpPackets::_Internal {};

IncomingRtcpPackets::IncomingRtcpPackets(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
IncomingRtcpPackets::IncomingRtcpPackets(const IncomingRtcpPackets& from)
  :{}

inline void IncomingRtcpPackets::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

IncomingRtcpPackets::~IncomingRtcpPackets() {}

inline void IncomingRtcpPackets::SharedDtor() {}

void IncomingRtcpPackets::SetCachedSize(int size) const {}

void IncomingRtcpPackets::Clear() {}

const char* IncomingRtcpPackets::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* IncomingRtcpPackets::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t IncomingRtcpPackets::ByteSizeLong() const {}

void IncomingRtcpPackets::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void IncomingRtcpPackets::MergeFrom(const IncomingRtcpPackets& from) {}

void IncomingRtcpPackets::CopyFrom(const IncomingRtcpPackets& from) {}

bool IncomingRtcpPackets::IsInitialized() const {}

void IncomingRtcpPackets::InternalSwap(IncomingRtcpPackets* other) {}

std::string IncomingRtcpPackets::GetTypeName() const {}


// ===================================================================

class OutgoingRtcpPackets::_Internal {};

OutgoingRtcpPackets::OutgoingRtcpPackets(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
OutgoingRtcpPackets::OutgoingRtcpPackets(const OutgoingRtcpPackets& from)
  :{}

inline void OutgoingRtcpPackets::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

OutgoingRtcpPackets::~OutgoingRtcpPackets() {}

inline void OutgoingRtcpPackets::SharedDtor() {}

void OutgoingRtcpPackets::SetCachedSize(int size) const {}

void OutgoingRtcpPackets::Clear() {}

const char* OutgoingRtcpPackets::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* OutgoingRtcpPackets::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t OutgoingRtcpPackets::ByteSizeLong() const {}

void OutgoingRtcpPackets::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void OutgoingRtcpPackets::MergeFrom(const OutgoingRtcpPackets& from) {}

void OutgoingRtcpPackets::CopyFrom(const OutgoingRtcpPackets& from) {}

bool OutgoingRtcpPackets::IsInitialized() const {}

void OutgoingRtcpPackets::InternalSwap(OutgoingRtcpPackets* other) {}

std::string OutgoingRtcpPackets::GetTypeName() const {}


// ===================================================================

class AudioPlayoutEvents::_Internal {};

AudioPlayoutEvents::AudioPlayoutEvents(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
AudioPlayoutEvents::AudioPlayoutEvents(const AudioPlayoutEvents& from)
  :{}

inline void AudioPlayoutEvents::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

AudioPlayoutEvents::~AudioPlayoutEvents() {}

inline void AudioPlayoutEvents::SharedDtor() {}

void AudioPlayoutEvents::SetCachedSize(int size) const {}

void AudioPlayoutEvents::Clear() {}

const char* AudioPlayoutEvents::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* AudioPlayoutEvents::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t AudioPlayoutEvents::ByteSizeLong() const {}

void AudioPlayoutEvents::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void AudioPlayoutEvents::MergeFrom(const AudioPlayoutEvents& from) {}

void AudioPlayoutEvents::CopyFrom(const AudioPlayoutEvents& from) {}

bool AudioPlayoutEvents::IsInitialized() const {}

void AudioPlayoutEvents::InternalSwap(AudioPlayoutEvents* other) {}

std::string AudioPlayoutEvents::GetTypeName() const {}


// ===================================================================

class NetEqSetMinimumDelay::_Internal {};

NetEqSetMinimumDelay::NetEqSetMinimumDelay(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
NetEqSetMinimumDelay::NetEqSetMinimumDelay(const NetEqSetMinimumDelay& from)
  :{}

inline void NetEqSetMinimumDelay::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

NetEqSetMinimumDelay::~NetEqSetMinimumDelay() {}

inline void NetEqSetMinimumDelay::SharedDtor() {}

void NetEqSetMinimumDelay::SetCachedSize(int size) const {}

void NetEqSetMinimumDelay::Clear() {}

const char* NetEqSetMinimumDelay::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* NetEqSetMinimumDelay::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t NetEqSetMinimumDelay::ByteSizeLong() const {}

void NetEqSetMinimumDelay::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void NetEqSetMinimumDelay::MergeFrom(const NetEqSetMinimumDelay& from) {}

void NetEqSetMinimumDelay::CopyFrom(const NetEqSetMinimumDelay& from) {}

bool NetEqSetMinimumDelay::IsInitialized() const {}

void NetEqSetMinimumDelay::InternalSwap(NetEqSetMinimumDelay* other) {}

std::string NetEqSetMinimumDelay::GetTypeName() const {}


// ===================================================================

class FrameDecodedEvents::_Internal {};

FrameDecodedEvents::FrameDecodedEvents(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
FrameDecodedEvents::FrameDecodedEvents(const FrameDecodedEvents& from)
  :{}

inline void FrameDecodedEvents::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

FrameDecodedEvents::~FrameDecodedEvents() {}

inline void FrameDecodedEvents::SharedDtor() {}

void FrameDecodedEvents::SetCachedSize(int size) const {}

void FrameDecodedEvents::Clear() {}

const char* FrameDecodedEvents::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* FrameDecodedEvents::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t FrameDecodedEvents::ByteSizeLong() const {}

void FrameDecodedEvents::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void FrameDecodedEvents::MergeFrom(const FrameDecodedEvents& from) {}

void FrameDecodedEvents::CopyFrom(const FrameDecodedEvents& from) {}

bool FrameDecodedEvents::IsInitialized() const {}

void FrameDecodedEvents::InternalSwap(FrameDecodedEvents* other) {}

std::string FrameDecodedEvents::GetTypeName() const {}


// ===================================================================

class BeginLogEvent::_Internal {};

BeginLogEvent::BeginLogEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
BeginLogEvent::BeginLogEvent(const BeginLogEvent& from)
  :{}

inline void BeginLogEvent::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

BeginLogEvent::~BeginLogEvent() {}

inline void BeginLogEvent::SharedDtor() {}

void BeginLogEvent::SetCachedSize(int size) const {}

void BeginLogEvent::Clear() {}

const char* BeginLogEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* BeginLogEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t BeginLogEvent::ByteSizeLong() const {}

void BeginLogEvent::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void BeginLogEvent::MergeFrom(const BeginLogEvent& from) {}

void BeginLogEvent::CopyFrom(const BeginLogEvent& from) {}

bool BeginLogEvent::IsInitialized() const {}

void BeginLogEvent::InternalSwap(BeginLogEvent* other) {}

std::string BeginLogEvent::GetTypeName() const {}


// ===================================================================

class EndLogEvent::_Internal {};

EndLogEvent::EndLogEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
EndLogEvent::EndLogEvent(const EndLogEvent& from)
  :{}

inline void EndLogEvent::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

EndLogEvent::~EndLogEvent() {}

inline void EndLogEvent::SharedDtor() {}

void EndLogEvent::SetCachedSize(int size) const {}

void EndLogEvent::Clear() {}

const char* EndLogEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* EndLogEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t EndLogEvent::ByteSizeLong() const {}

void EndLogEvent::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void EndLogEvent::MergeFrom(const EndLogEvent& from) {}

void EndLogEvent::CopyFrom(const EndLogEvent& from) {}

bool EndLogEvent::IsInitialized() const {}

void EndLogEvent::InternalSwap(EndLogEvent* other) {}

std::string EndLogEvent::GetTypeName() const {}


// ===================================================================

class LossBasedBweUpdates::_Internal {};

LossBasedBweUpdates::LossBasedBweUpdates(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
LossBasedBweUpdates::LossBasedBweUpdates(const LossBasedBweUpdates& from)
  :{}

inline void LossBasedBweUpdates::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

LossBasedBweUpdates::~LossBasedBweUpdates() {}

inline void LossBasedBweUpdates::SharedDtor() {}

void LossBasedBweUpdates::SetCachedSize(int size) const {}

void LossBasedBweUpdates::Clear() {}

const char* LossBasedBweUpdates::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* LossBasedBweUpdates::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t LossBasedBweUpdates::ByteSizeLong() const {}

void LossBasedBweUpdates::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void LossBasedBweUpdates::MergeFrom(const LossBasedBweUpdates& from) {}

void LossBasedBweUpdates::CopyFrom(const LossBasedBweUpdates& from) {}

bool LossBasedBweUpdates::IsInitialized() const {}

void LossBasedBweUpdates::InternalSwap(LossBasedBweUpdates* other) {}

std::string LossBasedBweUpdates::GetTypeName() const {}


// ===================================================================

class DelayBasedBweUpdates::_Internal {};

DelayBasedBweUpdates::DelayBasedBweUpdates(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
DelayBasedBweUpdates::DelayBasedBweUpdates(const DelayBasedBweUpdates& from)
  :{}

inline void DelayBasedBweUpdates::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

DelayBasedBweUpdates::~DelayBasedBweUpdates() {}

inline void DelayBasedBweUpdates::SharedDtor() {}

void DelayBasedBweUpdates::SetCachedSize(int size) const {}

void DelayBasedBweUpdates::Clear() {}

const char* DelayBasedBweUpdates::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* DelayBasedBweUpdates::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t DelayBasedBweUpdates::ByteSizeLong() const {}

void DelayBasedBweUpdates::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void DelayBasedBweUpdates::MergeFrom(const DelayBasedBweUpdates& from) {}

void DelayBasedBweUpdates::CopyFrom(const DelayBasedBweUpdates& from) {}

bool DelayBasedBweUpdates::IsInitialized() const {}

void DelayBasedBweUpdates::InternalSwap(DelayBasedBweUpdates* other) {}

std::string DelayBasedBweUpdates::GetTypeName() const {}


// ===================================================================

class RtpHeaderExtensionConfig::_Internal {};

RtpHeaderExtensionConfig::RtpHeaderExtensionConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
RtpHeaderExtensionConfig::RtpHeaderExtensionConfig(const RtpHeaderExtensionConfig& from)
  :{}

inline void RtpHeaderExtensionConfig::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

RtpHeaderExtensionConfig::~RtpHeaderExtensionConfig() {}

inline void RtpHeaderExtensionConfig::SharedDtor() {}

void RtpHeaderExtensionConfig::SetCachedSize(int size) const {}

void RtpHeaderExtensionConfig::Clear() {}

const char* RtpHeaderExtensionConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* RtpHeaderExtensionConfig::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t RtpHeaderExtensionConfig::ByteSizeLong() const {}

void RtpHeaderExtensionConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void RtpHeaderExtensionConfig::MergeFrom(const RtpHeaderExtensionConfig& from) {}

void RtpHeaderExtensionConfig::CopyFrom(const RtpHeaderExtensionConfig& from) {}

bool RtpHeaderExtensionConfig::IsInitialized() const {}

void RtpHeaderExtensionConfig::InternalSwap(RtpHeaderExtensionConfig* other) {}

std::string RtpHeaderExtensionConfig::GetTypeName() const {}


// ===================================================================

class VideoRecvStreamConfig::_Internal {};

const ::webrtc::rtclog2::RtpHeaderExtensionConfig&
VideoRecvStreamConfig::_Internal::header_extensions(const VideoRecvStreamConfig* msg) {}
VideoRecvStreamConfig::VideoRecvStreamConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
VideoRecvStreamConfig::VideoRecvStreamConfig(const VideoRecvStreamConfig& from)
  :{}

inline void VideoRecvStreamConfig::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

VideoRecvStreamConfig::~VideoRecvStreamConfig() {}

inline void VideoRecvStreamConfig::SharedDtor() {}

void VideoRecvStreamConfig::SetCachedSize(int size) const {}

void VideoRecvStreamConfig::Clear() {}

const char* VideoRecvStreamConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* VideoRecvStreamConfig::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t VideoRecvStreamConfig::ByteSizeLong() const {}

void VideoRecvStreamConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void VideoRecvStreamConfig::MergeFrom(const VideoRecvStreamConfig& from) {}

void VideoRecvStreamConfig::CopyFrom(const VideoRecvStreamConfig& from) {}

bool VideoRecvStreamConfig::IsInitialized() const {}

void VideoRecvStreamConfig::InternalSwap(VideoRecvStreamConfig* other) {}

std::string VideoRecvStreamConfig::GetTypeName() const {}


// ===================================================================

class VideoSendStreamConfig::_Internal {};

const ::webrtc::rtclog2::RtpHeaderExtensionConfig&
VideoSendStreamConfig::_Internal::header_extensions(const VideoSendStreamConfig* msg) {}
VideoSendStreamConfig::VideoSendStreamConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
VideoSendStreamConfig::VideoSendStreamConfig(const VideoSendStreamConfig& from)
  :{}

inline void VideoSendStreamConfig::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

VideoSendStreamConfig::~VideoSendStreamConfig() {}

inline void VideoSendStreamConfig::SharedDtor() {}

void VideoSendStreamConfig::SetCachedSize(int size) const {}

void VideoSendStreamConfig::Clear() {}

const char* VideoSendStreamConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* VideoSendStreamConfig::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t VideoSendStreamConfig::ByteSizeLong() const {}

void VideoSendStreamConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void VideoSendStreamConfig::MergeFrom(const VideoSendStreamConfig& from) {}

void VideoSendStreamConfig::CopyFrom(const VideoSendStreamConfig& from) {}

bool VideoSendStreamConfig::IsInitialized() const {}

void VideoSendStreamConfig::InternalSwap(VideoSendStreamConfig* other) {}

std::string VideoSendStreamConfig::GetTypeName() const {}


// ===================================================================

class AudioRecvStreamConfig::_Internal {};

const ::webrtc::rtclog2::RtpHeaderExtensionConfig&
AudioRecvStreamConfig::_Internal::header_extensions(const AudioRecvStreamConfig* msg) {}
AudioRecvStreamConfig::AudioRecvStreamConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
AudioRecvStreamConfig::AudioRecvStreamConfig(const AudioRecvStreamConfig& from)
  :{}

inline void AudioRecvStreamConfig::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

AudioRecvStreamConfig::~AudioRecvStreamConfig() {}

inline void AudioRecvStreamConfig::SharedDtor() {}

void AudioRecvStreamConfig::SetCachedSize(int size) const {}

void AudioRecvStreamConfig::Clear() {}

const char* AudioRecvStreamConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* AudioRecvStreamConfig::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t AudioRecvStreamConfig::ByteSizeLong() const {}

void AudioRecvStreamConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void AudioRecvStreamConfig::MergeFrom(const AudioRecvStreamConfig& from) {}

void AudioRecvStreamConfig::CopyFrom(const AudioRecvStreamConfig& from) {}

bool AudioRecvStreamConfig::IsInitialized() const {}

void AudioRecvStreamConfig::InternalSwap(AudioRecvStreamConfig* other) {}

std::string AudioRecvStreamConfig::GetTypeName() const {}


// ===================================================================

class AudioSendStreamConfig::_Internal {};

const ::webrtc::rtclog2::RtpHeaderExtensionConfig&
AudioSendStreamConfig::_Internal::header_extensions(const AudioSendStreamConfig* msg) {}
AudioSendStreamConfig::AudioSendStreamConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
AudioSendStreamConfig::AudioSendStreamConfig(const AudioSendStreamConfig& from)
  :{}

inline void AudioSendStreamConfig::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

AudioSendStreamConfig::~AudioSendStreamConfig() {}

inline void AudioSendStreamConfig::SharedDtor() {}

void AudioSendStreamConfig::SetCachedSize(int size) const {}

void AudioSendStreamConfig::Clear() {}

const char* AudioSendStreamConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* AudioSendStreamConfig::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t AudioSendStreamConfig::ByteSizeLong() const {}

void AudioSendStreamConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void AudioSendStreamConfig::MergeFrom(const AudioSendStreamConfig& from) {}

void AudioSendStreamConfig::CopyFrom(const AudioSendStreamConfig& from) {}

bool AudioSendStreamConfig::IsInitialized() const {}

void AudioSendStreamConfig::InternalSwap(AudioSendStreamConfig* other) {}

std::string AudioSendStreamConfig::GetTypeName() const {}


// ===================================================================

class AudioNetworkAdaptations::_Internal {};

AudioNetworkAdaptations::AudioNetworkAdaptations(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
AudioNetworkAdaptations::AudioNetworkAdaptations(const AudioNetworkAdaptations& from)
  :{}

inline void AudioNetworkAdaptations::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

AudioNetworkAdaptations::~AudioNetworkAdaptations() {}

inline void AudioNetworkAdaptations::SharedDtor() {}

void AudioNetworkAdaptations::SetCachedSize(int size) const {}

void AudioNetworkAdaptations::Clear() {}

const char* AudioNetworkAdaptations::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* AudioNetworkAdaptations::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t AudioNetworkAdaptations::ByteSizeLong() const {}

void AudioNetworkAdaptations::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void AudioNetworkAdaptations::MergeFrom(const AudioNetworkAdaptations& from) {}

void AudioNetworkAdaptations::CopyFrom(const AudioNetworkAdaptations& from) {}

bool AudioNetworkAdaptations::IsInitialized() const {}

void AudioNetworkAdaptations::InternalSwap(AudioNetworkAdaptations* other) {}

std::string AudioNetworkAdaptations::GetTypeName() const {}


// ===================================================================

class BweProbeCluster::_Internal {};

BweProbeCluster::BweProbeCluster(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
BweProbeCluster::BweProbeCluster(const BweProbeCluster& from)
  :{}

inline void BweProbeCluster::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

BweProbeCluster::~BweProbeCluster() {}

inline void BweProbeCluster::SharedDtor() {}

void BweProbeCluster::SetCachedSize(int size) const {}

void BweProbeCluster::Clear() {}

const char* BweProbeCluster::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* BweProbeCluster::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t BweProbeCluster::ByteSizeLong() const {}

void BweProbeCluster::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void BweProbeCluster::MergeFrom(const BweProbeCluster& from) {}

void BweProbeCluster::CopyFrom(const BweProbeCluster& from) {}

bool BweProbeCluster::IsInitialized() const {}

void BweProbeCluster::InternalSwap(BweProbeCluster* other) {}

std::string BweProbeCluster::GetTypeName() const {}


// ===================================================================

class BweProbeResultSuccess::_Internal {};

BweProbeResultSuccess::BweProbeResultSuccess(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
BweProbeResultSuccess::BweProbeResultSuccess(const BweProbeResultSuccess& from)
  :{}

inline void BweProbeResultSuccess::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

BweProbeResultSuccess::~BweProbeResultSuccess() {}

inline void BweProbeResultSuccess::SharedDtor() {}

void BweProbeResultSuccess::SetCachedSize(int size) const {}

void BweProbeResultSuccess::Clear() {}

const char* BweProbeResultSuccess::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* BweProbeResultSuccess::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t BweProbeResultSuccess::ByteSizeLong() const {}

void BweProbeResultSuccess::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void BweProbeResultSuccess::MergeFrom(const BweProbeResultSuccess& from) {}

void BweProbeResultSuccess::CopyFrom(const BweProbeResultSuccess& from) {}

bool BweProbeResultSuccess::IsInitialized() const {}

void BweProbeResultSuccess::InternalSwap(BweProbeResultSuccess* other) {}

std::string BweProbeResultSuccess::GetTypeName() const {}


// ===================================================================

class BweProbeResultFailure::_Internal {};

BweProbeResultFailure::BweProbeResultFailure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
BweProbeResultFailure::BweProbeResultFailure(const BweProbeResultFailure& from)
  :{}

inline void BweProbeResultFailure::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

BweProbeResultFailure::~BweProbeResultFailure() {}

inline void BweProbeResultFailure::SharedDtor() {}

void BweProbeResultFailure::SetCachedSize(int size) const {}

void BweProbeResultFailure::Clear() {}

const char* BweProbeResultFailure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* BweProbeResultFailure::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t BweProbeResultFailure::ByteSizeLong() const {}

void BweProbeResultFailure::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void BweProbeResultFailure::MergeFrom(const BweProbeResultFailure& from) {}

void BweProbeResultFailure::CopyFrom(const BweProbeResultFailure& from) {}

bool BweProbeResultFailure::IsInitialized() const {}

void BweProbeResultFailure::InternalSwap(BweProbeResultFailure* other) {}

std::string BweProbeResultFailure::GetTypeName() const {}


// ===================================================================

class AlrState::_Internal {};

AlrState::AlrState(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
AlrState::AlrState(const AlrState& from)
  :{}

inline void AlrState::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

AlrState::~AlrState() {}

inline void AlrState::SharedDtor() {}

void AlrState::SetCachedSize(int size) const {}

void AlrState::Clear() {}

const char* AlrState::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* AlrState::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t AlrState::ByteSizeLong() const {}

void AlrState::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void AlrState::MergeFrom(const AlrState& from) {}

void AlrState::CopyFrom(const AlrState& from) {}

bool AlrState::IsInitialized() const {}

void AlrState::InternalSwap(AlrState* other) {}

std::string AlrState::GetTypeName() const {}


// ===================================================================

class IceCandidatePairConfig::_Internal {};

IceCandidatePairConfig::IceCandidatePairConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
IceCandidatePairConfig::IceCandidatePairConfig(const IceCandidatePairConfig& from)
  :{}

inline void IceCandidatePairConfig::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

IceCandidatePairConfig::~IceCandidatePairConfig() {}

inline void IceCandidatePairConfig::SharedDtor() {}

void IceCandidatePairConfig::SetCachedSize(int size) const {}

void IceCandidatePairConfig::Clear() {}

const char* IceCandidatePairConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* IceCandidatePairConfig::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t IceCandidatePairConfig::ByteSizeLong() const {}

void IceCandidatePairConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void IceCandidatePairConfig::MergeFrom(const IceCandidatePairConfig& from) {}

void IceCandidatePairConfig::CopyFrom(const IceCandidatePairConfig& from) {}

bool IceCandidatePairConfig::IsInitialized() const {}

void IceCandidatePairConfig::InternalSwap(IceCandidatePairConfig* other) {}

std::string IceCandidatePairConfig::GetTypeName() const {}


// ===================================================================

class IceCandidatePairEvent::_Internal {};

IceCandidatePairEvent::IceCandidatePairEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
IceCandidatePairEvent::IceCandidatePairEvent(const IceCandidatePairEvent& from)
  :{}

inline void IceCandidatePairEvent::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

IceCandidatePairEvent::~IceCandidatePairEvent() {}

inline void IceCandidatePairEvent::SharedDtor() {}

void IceCandidatePairEvent::SetCachedSize(int size) const {}

void IceCandidatePairEvent::Clear() {}

const char* IceCandidatePairEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* IceCandidatePairEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t IceCandidatePairEvent::ByteSizeLong() const {}

void IceCandidatePairEvent::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void IceCandidatePairEvent::MergeFrom(const IceCandidatePairEvent& from) {}

void IceCandidatePairEvent::CopyFrom(const IceCandidatePairEvent& from) {}

bool IceCandidatePairEvent::IsInitialized() const {}

void IceCandidatePairEvent::InternalSwap(IceCandidatePairEvent* other) {}

std::string IceCandidatePairEvent::GetTypeName() const {}


// ===================================================================

class DtlsTransportStateEvent::_Internal {};

DtlsTransportStateEvent::DtlsTransportStateEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
DtlsTransportStateEvent::DtlsTransportStateEvent(const DtlsTransportStateEvent& from)
  :{}

inline void DtlsTransportStateEvent::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

DtlsTransportStateEvent::~DtlsTransportStateEvent() {}

inline void DtlsTransportStateEvent::SharedDtor() {}

void DtlsTransportStateEvent::SetCachedSize(int size) const {}

void DtlsTransportStateEvent::Clear() {}

const char* DtlsTransportStateEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* DtlsTransportStateEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t DtlsTransportStateEvent::ByteSizeLong() const {}

void DtlsTransportStateEvent::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void DtlsTransportStateEvent::MergeFrom(const DtlsTransportStateEvent& from) {}

void DtlsTransportStateEvent::CopyFrom(const DtlsTransportStateEvent& from) {}

bool DtlsTransportStateEvent::IsInitialized() const {}

void DtlsTransportStateEvent::InternalSwap(DtlsTransportStateEvent* other) {}

std::string DtlsTransportStateEvent::GetTypeName() const {}


// ===================================================================

class DtlsWritableState::_Internal {};

DtlsWritableState::DtlsWritableState(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
DtlsWritableState::DtlsWritableState(const DtlsWritableState& from)
  :{}

inline void DtlsWritableState::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

DtlsWritableState::~DtlsWritableState() {}

inline void DtlsWritableState::SharedDtor() {}

void DtlsWritableState::SetCachedSize(int size) const {}

void DtlsWritableState::Clear() {}

const char* DtlsWritableState::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* DtlsWritableState::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t DtlsWritableState::ByteSizeLong() const {}

void DtlsWritableState::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void DtlsWritableState::MergeFrom(const DtlsWritableState& from) {}void DtlsWritableState::CopyFrom(const DtlsWritableState& from) {}bool DtlsWritableState::IsInitialized() const {}void DtlsWritableState::InternalSwap(DtlsWritableState* other) {}std::string DtlsWritableState::GetTypeName() const {}class RouteChange::_Internal {}RouteChange::RouteChange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}RouteChange::RouteChange(const RouteChange& from)
  :{}inline void RouteChange::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}RouteChange::~RouteChange() {}inline void RouteChange::SharedDtor() {}void RouteChange::SetCachedSize(int size) const {}void RouteChange::Clear() {}const char* RouteChange::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}uint8_t* RouteChange::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}size_t RouteChange::ByteSizeLong() const {}void RouteChange::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}void RouteChange::MergeFrom(const RouteChange& from) {}void RouteChange::CopyFrom(const RouteChange& from) {}bool RouteChange::IsInitialized() const {}void RouteChange::InternalSwap(RouteChange* other) {}std::string RouteChange::GetTypeName() const {}class RemoteEstimates::_Internal {}RemoteEstimates::RemoteEstimates(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}RemoteEstimates::RemoteEstimates(const RemoteEstimates& from)
  :{}inline void RemoteEstimates::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}RemoteEstimates::~RemoteEstimates() {}inline void RemoteEstimates::SharedDtor() {}void RemoteEstimates::SetCachedSize(int size) const {}void RemoteEstimates::Clear() {}const char* RemoteEstimates::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}uint8_t* RemoteEstimates::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}size_t RemoteEstimates::ByteSizeLong() const {}void RemoteEstimates::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}void RemoteEstimates::MergeFrom(const RemoteEstimates& from) {}void RemoteEstimates::CopyFrom(const RemoteEstimates& from) {}bool RemoteEstimates::IsInitialized() const {}void RemoteEstimates::InternalSwap(RemoteEstimates* other) {}std::string RemoteEstimates::GetTypeName() const {}PROTOBUF_NAMESPACE_OPENtemplate<> PROTOBUF_NOINLINE ::webrtc::rtclog2::EventStream*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::EventStream >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::Event*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::Event >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::GenericPacketReceived*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::GenericPacketReceived >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::GenericPacketSent*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::GenericPacketSent >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::GenericAckReceived*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::GenericAckReceived >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::DependencyDescriptorsWireInfo*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::DependencyDescriptorsWireInfo >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::IncomingRtpPackets*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::IncomingRtpPackets >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::OutgoingRtpPackets*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::OutgoingRtpPackets >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::IncomingRtcpPackets*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::IncomingRtcpPackets >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::OutgoingRtcpPackets*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::OutgoingRtcpPackets >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::AudioPlayoutEvents*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::AudioPlayoutEvents >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::NetEqSetMinimumDelay*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::NetEqSetMinimumDelay >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::FrameDecodedEvents*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::FrameDecodedEvents >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::BeginLogEvent*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::BeginLogEvent >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::EndLogEvent*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::EndLogEvent >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::LossBasedBweUpdates*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::LossBasedBweUpdates >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::DelayBasedBweUpdates*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::DelayBasedBweUpdates >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::RtpHeaderExtensionConfig*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::RtpHeaderExtensionConfig >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::VideoRecvStreamConfig*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::VideoRecvStreamConfig >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::VideoSendStreamConfig*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::VideoSendStreamConfig >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::AudioRecvStreamConfig*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::AudioRecvStreamConfig >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::AudioSendStreamConfig*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::AudioSendStreamConfig >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::AudioNetworkAdaptations*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::AudioNetworkAdaptations >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::BweProbeCluster*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::BweProbeCluster >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::BweProbeResultSuccess*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::BweProbeResultSuccess >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::BweProbeResultFailure*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::BweProbeResultFailure >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::AlrState*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::AlrState >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::IceCandidatePairConfig*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::IceCandidatePairConfig >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::IceCandidatePairEvent*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::IceCandidatePairEvent >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::DtlsTransportStateEvent*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::DtlsTransportStateEvent >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::DtlsWritableState*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::DtlsWritableState >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::RouteChange*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::RouteChange >(Arena* arena) {}template<> PROTOBUF_NOINLINE ::webrtc::rtclog2::RemoteEstimates*
Arena::CreateMaybeMessage< ::webrtc::rtclog2::RemoteEstimates >(Arena* arena) {}PROTOBUF_NAMESPACE_CLOSE#include <google/protobuf/port_undef.inc>