chromium/out/Default/gen/modules/audio_processing/debug.pb.h

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_debug_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_debug_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_debug_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_debug_2eproto {};
namespace webrtc {
namespace audioproc {
class Config;
struct ConfigDefaultTypeInternal;
extern ConfigDefaultTypeInternal _Config_default_instance_;
class Event;
struct EventDefaultTypeInternal;
extern EventDefaultTypeInternal _Event_default_instance_;
class Init;
struct InitDefaultTypeInternal;
extern InitDefaultTypeInternal _Init_default_instance_;
class PlayoutAudioDeviceInfo;
struct PlayoutAudioDeviceInfoDefaultTypeInternal;
extern PlayoutAudioDeviceInfoDefaultTypeInternal _PlayoutAudioDeviceInfo_default_instance_;
class ReverseStream;
struct ReverseStreamDefaultTypeInternal;
extern ReverseStreamDefaultTypeInternal _ReverseStream_default_instance_;
class RuntimeSetting;
struct RuntimeSettingDefaultTypeInternal;
extern RuntimeSettingDefaultTypeInternal _RuntimeSetting_default_instance_;
class Stream;
struct StreamDefaultTypeInternal;
extern StreamDefaultTypeInternal _Stream_default_instance_;
}  // namespace audioproc
}  // namespace webrtc
PROTOBUF_NAMESPACE_OPEN
template<> ::webrtc::audioproc::Config* Arena::CreateMaybeMessage<::webrtc::audioproc::Config>(Arena*);
template<> ::webrtc::audioproc::Event* Arena::CreateMaybeMessage<::webrtc::audioproc::Event>(Arena*);
template<> ::webrtc::audioproc::Init* Arena::CreateMaybeMessage<::webrtc::audioproc::Init>(Arena*);
template<> ::webrtc::audioproc::PlayoutAudioDeviceInfo* Arena::CreateMaybeMessage<::webrtc::audioproc::PlayoutAudioDeviceInfo>(Arena*);
template<> ::webrtc::audioproc::ReverseStream* Arena::CreateMaybeMessage<::webrtc::audioproc::ReverseStream>(Arena*);
template<> ::webrtc::audioproc::RuntimeSetting* Arena::CreateMaybeMessage<::webrtc::audioproc::RuntimeSetting>(Arena*);
template<> ::webrtc::audioproc::Stream* Arena::CreateMaybeMessage<::webrtc::audioproc::Stream>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace webrtc {
namespace audioproc {

enum Event_Type : int {};
bool Event_Type_IsValid(int value);
constexpr Event_Type Event_Type_Type_MIN =;
constexpr Event_Type Event_Type_Type_MAX =;
constexpr int Event_Type_Type_ARRAYSIZE =;

const std::string& Event_Type_Name(Event_Type value);
template<typename T>
inline const std::string& Event_Type_Name(T enum_t_value) {}
bool Event_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Event_Type* value);
// ===================================================================

class Init final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:webrtc.audioproc.Init) */ {};
// -------------------------------------------------------------------

class ReverseStream final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:webrtc.audioproc.ReverseStream) */ {};
// -------------------------------------------------------------------

class Stream final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:webrtc.audioproc.Stream) */ {};
// -------------------------------------------------------------------

class Config final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:webrtc.audioproc.Config) */ {};
// -------------------------------------------------------------------

class PlayoutAudioDeviceInfo final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:webrtc.audioproc.PlayoutAudioDeviceInfo) */ {};
// -------------------------------------------------------------------

class RuntimeSetting final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:webrtc.audioproc.RuntimeSetting) */ {};
// -------------------------------------------------------------------

class Event final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:webrtc.audioproc.Event) */ {};
// ===================================================================


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

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// Init

// optional int32 sample_rate = 1;
inline bool Init::_internal_has_sample_rate() const {}
inline bool Init::has_sample_rate() const {}
inline void Init::clear_sample_rate() {}
inline int32_t Init::_internal_sample_rate() const {}
inline int32_t Init::sample_rate() const {}
inline void Init::_internal_set_sample_rate(int32_t value) {}
inline void Init::set_sample_rate(int32_t value) {}

// optional int32 device_sample_rate = 2 [deprecated = true];
inline bool Init::_internal_has_device_sample_rate() const {}
inline bool Init::has_device_sample_rate() const {}
inline void Init::clear_device_sample_rate() {}
inline int32_t Init::_internal_device_sample_rate() const {}
inline int32_t Init::device_sample_rate() const {}
inline void Init::_internal_set_device_sample_rate(int32_t value) {}
inline void Init::set_device_sample_rate(int32_t value) {}

// optional int32 num_input_channels = 3;
inline bool Init::_internal_has_num_input_channels() const {}
inline bool Init::has_num_input_channels() const {}
inline void Init::clear_num_input_channels() {}
inline int32_t Init::_internal_num_input_channels() const {}
inline int32_t Init::num_input_channels() const {}
inline void Init::_internal_set_num_input_channels(int32_t value) {}
inline void Init::set_num_input_channels(int32_t value) {}

// optional int32 num_output_channels = 4;
inline bool Init::_internal_has_num_output_channels() const {}
inline bool Init::has_num_output_channels() const {}
inline void Init::clear_num_output_channels() {}
inline int32_t Init::_internal_num_output_channels() const {}
inline int32_t Init::num_output_channels() const {}
inline void Init::_internal_set_num_output_channels(int32_t value) {}
inline void Init::set_num_output_channels(int32_t value) {}

// optional int32 num_reverse_channels = 5;
inline bool Init::_internal_has_num_reverse_channels() const {}
inline bool Init::has_num_reverse_channels() const {}
inline void Init::clear_num_reverse_channels() {}
inline int32_t Init::_internal_num_reverse_channels() const {}
inline int32_t Init::num_reverse_channels() const {}
inline void Init::_internal_set_num_reverse_channels(int32_t value) {}
inline void Init::set_num_reverse_channels(int32_t value) {}

// optional int32 reverse_sample_rate = 6;
inline bool Init::_internal_has_reverse_sample_rate() const {}
inline bool Init::has_reverse_sample_rate() const {}
inline void Init::clear_reverse_sample_rate() {}
inline int32_t Init::_internal_reverse_sample_rate() const {}
inline int32_t Init::reverse_sample_rate() const {}
inline void Init::_internal_set_reverse_sample_rate(int32_t value) {}
inline void Init::set_reverse_sample_rate(int32_t value) {}

// optional int32 output_sample_rate = 7;
inline bool Init::_internal_has_output_sample_rate() const {}
inline bool Init::has_output_sample_rate() const {}
inline void Init::clear_output_sample_rate() {}
inline int32_t Init::_internal_output_sample_rate() const {}
inline int32_t Init::output_sample_rate() const {}
inline void Init::_internal_set_output_sample_rate(int32_t value) {}
inline void Init::set_output_sample_rate(int32_t value) {}

// optional int32 reverse_output_sample_rate = 8;
inline bool Init::_internal_has_reverse_output_sample_rate() const {}
inline bool Init::has_reverse_output_sample_rate() const {}
inline void Init::clear_reverse_output_sample_rate() {}
inline int32_t Init::_internal_reverse_output_sample_rate() const {}
inline int32_t Init::reverse_output_sample_rate() const {}
inline void Init::_internal_set_reverse_output_sample_rate(int32_t value) {}
inline void Init::set_reverse_output_sample_rate(int32_t value) {}

// optional int32 num_reverse_output_channels = 9;
inline bool Init::_internal_has_num_reverse_output_channels() const {}
inline bool Init::has_num_reverse_output_channels() const {}
inline void Init::clear_num_reverse_output_channels() {}
inline int32_t Init::_internal_num_reverse_output_channels() const {}
inline int32_t Init::num_reverse_output_channels() const {}
inline void Init::_internal_set_num_reverse_output_channels(int32_t value) {}
inline void Init::set_num_reverse_output_channels(int32_t value) {}

// optional int64 timestamp_ms = 10;
inline bool Init::_internal_has_timestamp_ms() const {}
inline bool Init::has_timestamp_ms() const {}
inline void Init::clear_timestamp_ms() {}
inline int64_t Init::_internal_timestamp_ms() const {}
inline int64_t Init::timestamp_ms() const {}
inline void Init::_internal_set_timestamp_ms(int64_t value) {}
inline void Init::set_timestamp_ms(int64_t value) {}

// -------------------------------------------------------------------

// ReverseStream

// optional bytes data = 1;
inline bool ReverseStream::_internal_has_data() const {}
inline bool ReverseStream::has_data() const {}
inline void ReverseStream::clear_data() {}
inline const std::string& ReverseStream::data() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReverseStream::set_data(ArgT0&& arg0, ArgT... args) {}
inline std::string* ReverseStream::mutable_data() {}
inline const std::string& ReverseStream::_internal_data() const {}
inline void ReverseStream::_internal_set_data(const std::string& value) {}
inline std::string* ReverseStream::_internal_mutable_data() {}
inline std::string* ReverseStream::release_data() {}
inline void ReverseStream::set_allocated_data(std::string* data) {}

// repeated bytes channel = 2;
inline int ReverseStream::_internal_channel_size() const {}
inline int ReverseStream::channel_size() const {}
inline void ReverseStream::clear_channel() {}
inline std::string* ReverseStream::add_channel() {}
inline const std::string& ReverseStream::_internal_channel(int index) const {}
inline const std::string& ReverseStream::channel(int index) const {}
inline std::string* ReverseStream::mutable_channel(int index) {}
inline void ReverseStream::set_channel(int index, const std::string& value) {}
inline void ReverseStream::set_channel(int index, std::string&& value) {}
inline void ReverseStream::set_channel(int index, const char* value) {}
inline void ReverseStream::set_channel(int index, const void* value, size_t size) {}
inline std::string* ReverseStream::_internal_add_channel() {}
inline void ReverseStream::add_channel(const std::string& value) {}
inline void ReverseStream::add_channel(std::string&& value) {}
inline void ReverseStream::add_channel(const char* value) {}
inline void ReverseStream::add_channel(const void* value, size_t size) {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
ReverseStream::channel() const {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
ReverseStream::mutable_channel() {}

// -------------------------------------------------------------------

// Stream

// optional bytes input_data = 1;
inline bool Stream::_internal_has_input_data() const {}
inline bool Stream::has_input_data() const {}
inline void Stream::clear_input_data() {}
inline const std::string& Stream::input_data() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Stream::set_input_data(ArgT0&& arg0, ArgT... args) {}
inline std::string* Stream::mutable_input_data() {}
inline const std::string& Stream::_internal_input_data() const {}
inline void Stream::_internal_set_input_data(const std::string& value) {}
inline std::string* Stream::_internal_mutable_input_data() {}
inline std::string* Stream::release_input_data() {}
inline void Stream::set_allocated_input_data(std::string* input_data) {}

// optional bytes output_data = 2;
inline bool Stream::_internal_has_output_data() const {}
inline bool Stream::has_output_data() const {}
inline void Stream::clear_output_data() {}
inline const std::string& Stream::output_data() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Stream::set_output_data(ArgT0&& arg0, ArgT... args) {}
inline std::string* Stream::mutable_output_data() {}
inline const std::string& Stream::_internal_output_data() const {}
inline void Stream::_internal_set_output_data(const std::string& value) {}
inline std::string* Stream::_internal_mutable_output_data() {}
inline std::string* Stream::release_output_data() {}
inline void Stream::set_allocated_output_data(std::string* output_data) {}

// optional int32 delay = 3;
inline bool Stream::_internal_has_delay() const {}
inline bool Stream::has_delay() const {}
inline void Stream::clear_delay() {}
inline int32_t Stream::_internal_delay() const {}
inline int32_t Stream::delay() const {}
inline void Stream::_internal_set_delay(int32_t value) {}
inline void Stream::set_delay(int32_t value) {}

// optional sint32 drift = 4;
inline bool Stream::_internal_has_drift() const {}
inline bool Stream::has_drift() const {}
inline void Stream::clear_drift() {}
inline int32_t Stream::_internal_drift() const {}
inline int32_t Stream::drift() const {}
inline void Stream::_internal_set_drift(int32_t value) {}
inline void Stream::set_drift(int32_t value) {}

// optional int32 applied_input_volume = 5;
inline bool Stream::_internal_has_applied_input_volume() const {}
inline bool Stream::has_applied_input_volume() const {}
inline void Stream::clear_applied_input_volume() {}
inline int32_t Stream::_internal_applied_input_volume() const {}
inline int32_t Stream::applied_input_volume() const {}
inline void Stream::_internal_set_applied_input_volume(int32_t value) {}
inline void Stream::set_applied_input_volume(int32_t value) {}

// optional bool keypress = 6;
inline bool Stream::_internal_has_keypress() const {}
inline bool Stream::has_keypress() const {}
inline void Stream::clear_keypress() {}
inline bool Stream::_internal_keypress() const {}
inline bool Stream::keypress() const {}
inline void Stream::_internal_set_keypress(bool value) {}
inline void Stream::set_keypress(bool value) {}

// repeated bytes input_channel = 7;
inline int Stream::_internal_input_channel_size() const {}
inline int Stream::input_channel_size() const {}
inline void Stream::clear_input_channel() {}
inline std::string* Stream::add_input_channel() {}
inline const std::string& Stream::_internal_input_channel(int index) const {}
inline const std::string& Stream::input_channel(int index) const {}
inline std::string* Stream::mutable_input_channel(int index) {}
inline void Stream::set_input_channel(int index, const std::string& value) {}
inline void Stream::set_input_channel(int index, std::string&& value) {}
inline void Stream::set_input_channel(int index, const char* value) {}
inline void Stream::set_input_channel(int index, const void* value, size_t size) {}
inline std::string* Stream::_internal_add_input_channel() {}
inline void Stream::add_input_channel(const std::string& value) {}
inline void Stream::add_input_channel(std::string&& value) {}
inline void Stream::add_input_channel(const char* value) {}
inline void Stream::add_input_channel(const void* value, size_t size) {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Stream::input_channel() const {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Stream::mutable_input_channel() {}

// repeated bytes output_channel = 8;
inline int Stream::_internal_output_channel_size() const {}
inline int Stream::output_channel_size() const {}
inline void Stream::clear_output_channel() {}
inline std::string* Stream::add_output_channel() {}
inline const std::string& Stream::_internal_output_channel(int index) const {}
inline const std::string& Stream::output_channel(int index) const {}
inline std::string* Stream::mutable_output_channel(int index) {}
inline void Stream::set_output_channel(int index, const std::string& value) {}
inline void Stream::set_output_channel(int index, std::string&& value) {}
inline void Stream::set_output_channel(int index, const char* value) {}
inline void Stream::set_output_channel(int index, const void* value, size_t size) {}
inline std::string* Stream::_internal_add_output_channel() {}
inline void Stream::add_output_channel(const std::string& value) {}
inline void Stream::add_output_channel(std::string&& value) {}
inline void Stream::add_output_channel(const char* value) {}
inline void Stream::add_output_channel(const void* value, size_t size) {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Stream::output_channel() const {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Stream::mutable_output_channel() {}

// -------------------------------------------------------------------

// Config

// optional bool aec_enabled = 1;
inline bool Config::_internal_has_aec_enabled() const {}
inline bool Config::has_aec_enabled() const {}
inline void Config::clear_aec_enabled() {}
inline bool Config::_internal_aec_enabled() const {}
inline bool Config::aec_enabled() const {}
inline void Config::_internal_set_aec_enabled(bool value) {}
inline void Config::set_aec_enabled(bool value) {}

// optional bool aec_delay_agnostic_enabled = 2;
inline bool Config::_internal_has_aec_delay_agnostic_enabled() const {}
inline bool Config::has_aec_delay_agnostic_enabled() const {}
inline void Config::clear_aec_delay_agnostic_enabled() {}
inline bool Config::_internal_aec_delay_agnostic_enabled() const {}
inline bool Config::aec_delay_agnostic_enabled() const {}
inline void Config::_internal_set_aec_delay_agnostic_enabled(bool value) {}
inline void Config::set_aec_delay_agnostic_enabled(bool value) {}

// optional bool aec_drift_compensation_enabled = 3;
inline bool Config::_internal_has_aec_drift_compensation_enabled() const {}
inline bool Config::has_aec_drift_compensation_enabled() const {}
inline void Config::clear_aec_drift_compensation_enabled() {}
inline bool Config::_internal_aec_drift_compensation_enabled() const {}
inline bool Config::aec_drift_compensation_enabled() const {}
inline void Config::_internal_set_aec_drift_compensation_enabled(bool value) {}
inline void Config::set_aec_drift_compensation_enabled(bool value) {}

// optional bool aec_extended_filter_enabled = 4;
inline bool Config::_internal_has_aec_extended_filter_enabled() const {}
inline bool Config::has_aec_extended_filter_enabled() const {}
inline void Config::clear_aec_extended_filter_enabled() {}
inline bool Config::_internal_aec_extended_filter_enabled() const {}
inline bool Config::aec_extended_filter_enabled() const {}
inline void Config::_internal_set_aec_extended_filter_enabled(bool value) {}
inline void Config::set_aec_extended_filter_enabled(bool value) {}

// optional int32 aec_suppression_level = 5;
inline bool Config::_internal_has_aec_suppression_level() const {}
inline bool Config::has_aec_suppression_level() const {}
inline void Config::clear_aec_suppression_level() {}
inline int32_t Config::_internal_aec_suppression_level() const {}
inline int32_t Config::aec_suppression_level() const {}
inline void Config::_internal_set_aec_suppression_level(int32_t value) {}
inline void Config::set_aec_suppression_level(int32_t value) {}

// optional bool aecm_enabled = 6;
inline bool Config::_internal_has_aecm_enabled() const {}
inline bool Config::has_aecm_enabled() const {}
inline void Config::clear_aecm_enabled() {}
inline bool Config::_internal_aecm_enabled() const {}
inline bool Config::aecm_enabled() const {}
inline void Config::_internal_set_aecm_enabled(bool value) {}
inline void Config::set_aecm_enabled(bool value) {}

// optional bool aecm_comfort_noise_enabled = 7 [deprecated = true];
inline bool Config::_internal_has_aecm_comfort_noise_enabled() const {}
inline bool Config::has_aecm_comfort_noise_enabled() const {}
inline void Config::clear_aecm_comfort_noise_enabled() {}
inline bool Config::_internal_aecm_comfort_noise_enabled() const {}
inline bool Config::aecm_comfort_noise_enabled() const {}
inline void Config::_internal_set_aecm_comfort_noise_enabled(bool value) {}
inline void Config::set_aecm_comfort_noise_enabled(bool value) {}

// optional int32 aecm_routing_mode = 8 [deprecated = true];
inline bool Config::_internal_has_aecm_routing_mode() const {}
inline bool Config::has_aecm_routing_mode() const {}
inline void Config::clear_aecm_routing_mode() {}
inline int32_t Config::_internal_aecm_routing_mode() const {}
inline int32_t Config::aecm_routing_mode() const {}
inline void Config::_internal_set_aecm_routing_mode(int32_t value) {}
inline void Config::set_aecm_routing_mode(int32_t value) {}

// optional bool agc_enabled = 9;
inline bool Config::_internal_has_agc_enabled() const {}
inline bool Config::has_agc_enabled() const {}
inline void Config::clear_agc_enabled() {}
inline bool Config::_internal_agc_enabled() const {}
inline bool Config::agc_enabled() const {}
inline void Config::_internal_set_agc_enabled(bool value) {}
inline void Config::set_agc_enabled(bool value) {}

// optional int32 agc_mode = 10;
inline bool Config::_internal_has_agc_mode() const {}
inline bool Config::has_agc_mode() const {}
inline void Config::clear_agc_mode() {}
inline int32_t Config::_internal_agc_mode() const {}
inline int32_t Config::agc_mode() const {}
inline void Config::_internal_set_agc_mode(int32_t value) {}
inline void Config::set_agc_mode(int32_t value) {}

// optional bool agc_limiter_enabled = 11;
inline bool Config::_internal_has_agc_limiter_enabled() const {}
inline bool Config::has_agc_limiter_enabled() const {}
inline void Config::clear_agc_limiter_enabled() {}
inline bool Config::_internal_agc_limiter_enabled() const {}
inline bool Config::agc_limiter_enabled() const {}
inline void Config::_internal_set_agc_limiter_enabled(bool value) {}
inline void Config::set_agc_limiter_enabled(bool value) {}

// optional bool noise_robust_agc_enabled = 12;
inline bool Config::_internal_has_noise_robust_agc_enabled() const {}
inline bool Config::has_noise_robust_agc_enabled() const {}
inline void Config::clear_noise_robust_agc_enabled() {}
inline bool Config::_internal_noise_robust_agc_enabled() const {}
inline bool Config::noise_robust_agc_enabled() const {}
inline void Config::_internal_set_noise_robust_agc_enabled(bool value) {}
inline void Config::set_noise_robust_agc_enabled(bool value) {}

// optional bool hpf_enabled = 13;
inline bool Config::_internal_has_hpf_enabled() const {}
inline bool Config::has_hpf_enabled() const {}
inline void Config::clear_hpf_enabled() {}
inline bool Config::_internal_hpf_enabled() const {}
inline bool Config::hpf_enabled() const {}
inline void Config::_internal_set_hpf_enabled(bool value) {}
inline void Config::set_hpf_enabled(bool value) {}

// optional bool ns_enabled = 14;
inline bool Config::_internal_has_ns_enabled() const {}
inline bool Config::has_ns_enabled() const {}
inline void Config::clear_ns_enabled() {}
inline bool Config::_internal_ns_enabled() const {}
inline bool Config::ns_enabled() const {}
inline void Config::_internal_set_ns_enabled(bool value) {}
inline void Config::set_ns_enabled(bool value) {}

// optional int32 ns_level = 15;
inline bool Config::_internal_has_ns_level() const {}
inline bool Config::has_ns_level() const {}
inline void Config::clear_ns_level() {}
inline int32_t Config::_internal_ns_level() const {}
inline int32_t Config::ns_level() const {}
inline void Config::_internal_set_ns_level(int32_t value) {}
inline void Config::set_ns_level(int32_t value) {}

// optional bool transient_suppression_enabled = 16;
inline bool Config::_internal_has_transient_suppression_enabled() const {}
inline bool Config::has_transient_suppression_enabled() const {}
inline void Config::clear_transient_suppression_enabled() {}
inline bool Config::_internal_transient_suppression_enabled() const {}
inline bool Config::transient_suppression_enabled() const {}
inline void Config::_internal_set_transient_suppression_enabled(bool value) {}
inline void Config::set_transient_suppression_enabled(bool value) {}

// optional string experiments_description = 17;
inline bool Config::_internal_has_experiments_description() const {}
inline bool Config::has_experiments_description() const {}
inline void Config::clear_experiments_description() {}
inline const std::string& Config::experiments_description() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Config::set_experiments_description(ArgT0&& arg0, ArgT... args) {}
inline std::string* Config::mutable_experiments_description() {}
inline const std::string& Config::_internal_experiments_description() const {}
inline void Config::_internal_set_experiments_description(const std::string& value) {}
inline std::string* Config::_internal_mutable_experiments_description() {}
inline std::string* Config::release_experiments_description() {}
inline void Config::set_allocated_experiments_description(std::string* experiments_description) {}

// optional bool pre_amplifier_enabled = 19;
inline bool Config::_internal_has_pre_amplifier_enabled() const {}
inline bool Config::has_pre_amplifier_enabled() const {}
inline void Config::clear_pre_amplifier_enabled() {}
inline bool Config::_internal_pre_amplifier_enabled() const {}
inline bool Config::pre_amplifier_enabled() const {}
inline void Config::_internal_set_pre_amplifier_enabled(bool value) {}
inline void Config::set_pre_amplifier_enabled(bool value) {}

// optional float pre_amplifier_fixed_gain_factor = 20;
inline bool Config::_internal_has_pre_amplifier_fixed_gain_factor() const {}
inline bool Config::has_pre_amplifier_fixed_gain_factor() const {}
inline void Config::clear_pre_amplifier_fixed_gain_factor() {}
inline float Config::_internal_pre_amplifier_fixed_gain_factor() const {}
inline float Config::pre_amplifier_fixed_gain_factor() const {}
inline void Config::_internal_set_pre_amplifier_fixed_gain_factor(float value) {}
inline void Config::set_pre_amplifier_fixed_gain_factor(float value) {}

// -------------------------------------------------------------------

// PlayoutAudioDeviceInfo

// optional int32 id = 1;
inline bool PlayoutAudioDeviceInfo::_internal_has_id() const {}
inline bool PlayoutAudioDeviceInfo::has_id() const {}
inline void PlayoutAudioDeviceInfo::clear_id() {}
inline int32_t PlayoutAudioDeviceInfo::_internal_id() const {}
inline int32_t PlayoutAudioDeviceInfo::id() const {}
inline void PlayoutAudioDeviceInfo::_internal_set_id(int32_t value) {}
inline void PlayoutAudioDeviceInfo::set_id(int32_t value) {}

// optional int32 max_volume = 2;
inline bool PlayoutAudioDeviceInfo::_internal_has_max_volume() const {}
inline bool PlayoutAudioDeviceInfo::has_max_volume() const {}
inline void PlayoutAudioDeviceInfo::clear_max_volume() {}
inline int32_t PlayoutAudioDeviceInfo::_internal_max_volume() const {}
inline int32_t PlayoutAudioDeviceInfo::max_volume() const {}
inline void PlayoutAudioDeviceInfo::_internal_set_max_volume(int32_t value) {}
inline void PlayoutAudioDeviceInfo::set_max_volume(int32_t value) {}

// -------------------------------------------------------------------

// RuntimeSetting

// optional float capture_pre_gain = 1;
inline bool RuntimeSetting::_internal_has_capture_pre_gain() const {}
inline bool RuntimeSetting::has_capture_pre_gain() const {}
inline void RuntimeSetting::clear_capture_pre_gain() {}
inline float RuntimeSetting::_internal_capture_pre_gain() const {}
inline float RuntimeSetting::capture_pre_gain() const {}
inline void RuntimeSetting::_internal_set_capture_pre_gain(float value) {}
inline void RuntimeSetting::set_capture_pre_gain(float value) {}

// optional float custom_render_processing_setting = 2;
inline bool RuntimeSetting::_internal_has_custom_render_processing_setting() const {}
inline bool RuntimeSetting::has_custom_render_processing_setting() const {}
inline void RuntimeSetting::clear_custom_render_processing_setting() {}
inline float RuntimeSetting::_internal_custom_render_processing_setting() const {}
inline float RuntimeSetting::custom_render_processing_setting() const {}
inline void RuntimeSetting::_internal_set_custom_render_processing_setting(float value) {}
inline void RuntimeSetting::set_custom_render_processing_setting(float value) {}

// optional float capture_fixed_post_gain = 3;
inline bool RuntimeSetting::_internal_has_capture_fixed_post_gain() const {}
inline bool RuntimeSetting::has_capture_fixed_post_gain() const {}
inline void RuntimeSetting::clear_capture_fixed_post_gain() {}
inline float RuntimeSetting::_internal_capture_fixed_post_gain() const {}
inline float RuntimeSetting::capture_fixed_post_gain() const {}
inline void RuntimeSetting::_internal_set_capture_fixed_post_gain(float value) {}
inline void RuntimeSetting::set_capture_fixed_post_gain(float value) {}

// optional int32 playout_volume_change = 4;
inline bool RuntimeSetting::_internal_has_playout_volume_change() const {}
inline bool RuntimeSetting::has_playout_volume_change() const {}
inline void RuntimeSetting::clear_playout_volume_change() {}
inline int32_t RuntimeSetting::_internal_playout_volume_change() const {}
inline int32_t RuntimeSetting::playout_volume_change() const {}
inline void RuntimeSetting::_internal_set_playout_volume_change(int32_t value) {}
inline void RuntimeSetting::set_playout_volume_change(int32_t value) {}

// optional .webrtc.audioproc.PlayoutAudioDeviceInfo playout_audio_device_change = 5;
inline bool RuntimeSetting::_internal_has_playout_audio_device_change() const {}
inline bool RuntimeSetting::has_playout_audio_device_change() const {}
inline void RuntimeSetting::clear_playout_audio_device_change() {}
inline const ::webrtc::audioproc::PlayoutAudioDeviceInfo& RuntimeSetting::_internal_playout_audio_device_change() const {}
inline const ::webrtc::audioproc::PlayoutAudioDeviceInfo& RuntimeSetting::playout_audio_device_change() const {}
inline void RuntimeSetting::unsafe_arena_set_allocated_playout_audio_device_change(
    ::webrtc::audioproc::PlayoutAudioDeviceInfo* playout_audio_device_change) {}
inline ::webrtc::audioproc::PlayoutAudioDeviceInfo* RuntimeSetting::release_playout_audio_device_change() {}
inline ::webrtc::audioproc::PlayoutAudioDeviceInfo* RuntimeSetting::unsafe_arena_release_playout_audio_device_change() {}
inline ::webrtc::audioproc::PlayoutAudioDeviceInfo* RuntimeSetting::_internal_mutable_playout_audio_device_change() {}
inline ::webrtc::audioproc::PlayoutAudioDeviceInfo* RuntimeSetting::mutable_playout_audio_device_change() {}
inline void RuntimeSetting::set_allocated_playout_audio_device_change(::webrtc::audioproc::PlayoutAudioDeviceInfo* playout_audio_device_change) {}

// optional bool capture_output_used = 6;
inline bool RuntimeSetting::_internal_has_capture_output_used() const {}
inline bool RuntimeSetting::has_capture_output_used() const {}
inline void RuntimeSetting::clear_capture_output_used() {}
inline bool RuntimeSetting::_internal_capture_output_used() const {}
inline bool RuntimeSetting::capture_output_used() const {}
inline void RuntimeSetting::_internal_set_capture_output_used(bool value) {}
inline void RuntimeSetting::set_capture_output_used(bool value) {}

// optional float capture_post_gain = 7;
inline bool RuntimeSetting::_internal_has_capture_post_gain() const {}
inline bool RuntimeSetting::has_capture_post_gain() const {}
inline void RuntimeSetting::clear_capture_post_gain() {}
inline float RuntimeSetting::_internal_capture_post_gain() const {}
inline float RuntimeSetting::capture_post_gain() const {}
inline void RuntimeSetting::_internal_set_capture_post_gain(float value) {}
inline void RuntimeSetting::set_capture_post_gain(float value) {}

// -------------------------------------------------------------------

// Event

// required .webrtc.audioproc.Event.Type type = 1;
inline bool Event::_internal_has_type() const {}
inline bool Event::has_type() const {}
inline void Event::clear_type() {}
inline ::webrtc::audioproc::Event_Type Event::_internal_type() const {}
inline ::webrtc::audioproc::Event_Type Event::type() const {}
inline void Event::_internal_set_type(::webrtc::audioproc::Event_Type value) {}
inline void Event::set_type(::webrtc::audioproc::Event_Type value) {}

// optional .webrtc.audioproc.Init init = 2;
inline bool Event::_internal_has_init() const {}
inline bool Event::has_init() const {}
inline void Event::clear_init() {}
inline const ::webrtc::audioproc::Init& Event::_internal_init() const {}
inline const ::webrtc::audioproc::Init& Event::init() const {}
inline void Event::unsafe_arena_set_allocated_init(
    ::webrtc::audioproc::Init* init) {}
inline ::webrtc::audioproc::Init* Event::release_init() {}
inline ::webrtc::audioproc::Init* Event::unsafe_arena_release_init() {}
inline ::webrtc::audioproc::Init* Event::_internal_mutable_init() {}
inline ::webrtc::audioproc::Init* Event::mutable_init() {}
inline void Event::set_allocated_init(::webrtc::audioproc::Init* init) {}

// optional .webrtc.audioproc.ReverseStream reverse_stream = 3;
inline bool Event::_internal_has_reverse_stream() const {}
inline bool Event::has_reverse_stream() const {}
inline void Event::clear_reverse_stream() {}
inline const ::webrtc::audioproc::ReverseStream& Event::_internal_reverse_stream() const {}
inline const ::webrtc::audioproc::ReverseStream& Event::reverse_stream() const {}
inline void Event::unsafe_arena_set_allocated_reverse_stream(
    ::webrtc::audioproc::ReverseStream* reverse_stream) {}
inline ::webrtc::audioproc::ReverseStream* Event::release_reverse_stream() {}
inline ::webrtc::audioproc::ReverseStream* Event::unsafe_arena_release_reverse_stream() {}
inline ::webrtc::audioproc::ReverseStream* Event::_internal_mutable_reverse_stream() {}
inline ::webrtc::audioproc::ReverseStream* Event::mutable_reverse_stream() {}
inline void Event::set_allocated_reverse_stream(::webrtc::audioproc::ReverseStream* reverse_stream) {}

// optional .webrtc.audioproc.Stream stream = 4;
inline bool Event::_internal_has_stream() const {}
inline bool Event::has_stream() const {}
inline void Event::clear_stream() {}
inline const ::webrtc::audioproc::Stream& Event::_internal_stream() const {}
inline const ::webrtc::audioproc::Stream& Event::stream() const {}
inline void Event::unsafe_arena_set_allocated_stream(
    ::webrtc::audioproc::Stream* stream) {}
inline ::webrtc::audioproc::Stream* Event::release_stream() {}
inline ::webrtc::audioproc::Stream* Event::unsafe_arena_release_stream() {}
inline ::webrtc::audioproc::Stream* Event::_internal_mutable_stream() {}
inline ::webrtc::audioproc::Stream* Event::mutable_stream() {}
inline void Event::set_allocated_stream(::webrtc::audioproc::Stream* stream) {}

// optional .webrtc.audioproc.Config config = 5;
inline bool Event::_internal_has_config() const {}
inline bool Event::has_config() const {}
inline void Event::clear_config() {}
inline const ::webrtc::audioproc::Config& Event::_internal_config() const {}
inline const ::webrtc::audioproc::Config& Event::config() const {}
inline void Event::unsafe_arena_set_allocated_config(
    ::webrtc::audioproc::Config* config) {}
inline ::webrtc::audioproc::Config* Event::release_config() {}
inline ::webrtc::audioproc::Config* Event::unsafe_arena_release_config() {}
inline ::webrtc::audioproc::Config* Event::_internal_mutable_config() {}
inline ::webrtc::audioproc::Config* Event::mutable_config() {}
inline void Event::set_allocated_config(::webrtc::audioproc::Config* config) {}

// optional .webrtc.audioproc.RuntimeSetting runtime_setting = 6;
inline bool Event::_internal_has_runtime_setting() const {}
inline bool Event::has_runtime_setting() const {}
inline void Event::clear_runtime_setting() {}
inline const ::webrtc::audioproc::RuntimeSetting& Event::_internal_runtime_setting() const {}
inline const ::webrtc::audioproc::RuntimeSetting& Event::runtime_setting() const {}
inline void Event::unsafe_arena_set_allocated_runtime_setting(
    ::webrtc::audioproc::RuntimeSetting* runtime_setting) {}
inline ::webrtc::audioproc::RuntimeSetting* Event::release_runtime_setting() {}
inline ::webrtc::audioproc::RuntimeSetting* Event::unsafe_arena_release_runtime_setting() {}
inline ::webrtc::audioproc::RuntimeSetting* Event::_internal_mutable_runtime_setting() {}
inline ::webrtc::audioproc::RuntimeSetting* Event::mutable_runtime_setting() {}
inline void Event::set_allocated_runtime_setting(::webrtc::audioproc::RuntimeSetting* runtime_setting) {}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace audioproc
}  // namespace webrtc

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::webrtc::audioproc::Event_Type> : ::std::true_type {};

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_debug_2eproto