chromium/out/Default/gen/third_party/openscreen/src/cast/common/channel/proto/cast_channel.pb.h

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_cast_5fchannel_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_cast_5fchannel_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_cast_5fchannel_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_cast_5fchannel_2eproto {};
namespace openscreen {
namespace cast {
namespace proto {
class AuthChallenge;
struct AuthChallengeDefaultTypeInternal;
extern AuthChallengeDefaultTypeInternal _AuthChallenge_default_instance_;
class AuthError;
struct AuthErrorDefaultTypeInternal;
extern AuthErrorDefaultTypeInternal _AuthError_default_instance_;
class AuthResponse;
struct AuthResponseDefaultTypeInternal;
extern AuthResponseDefaultTypeInternal _AuthResponse_default_instance_;
class CastMessage;
struct CastMessageDefaultTypeInternal;
extern CastMessageDefaultTypeInternal _CastMessage_default_instance_;
class DeviceAuthMessage;
struct DeviceAuthMessageDefaultTypeInternal;
extern DeviceAuthMessageDefaultTypeInternal _DeviceAuthMessage_default_instance_;
}  // namespace proto
}  // namespace cast
}  // namespace openscreen
PROTOBUF_NAMESPACE_OPEN
template<> ::openscreen::cast::proto::AuthChallenge* Arena::CreateMaybeMessage<::openscreen::cast::proto::AuthChallenge>(Arena*);
template<> ::openscreen::cast::proto::AuthError* Arena::CreateMaybeMessage<::openscreen::cast::proto::AuthError>(Arena*);
template<> ::openscreen::cast::proto::AuthResponse* Arena::CreateMaybeMessage<::openscreen::cast::proto::AuthResponse>(Arena*);
template<> ::openscreen::cast::proto::CastMessage* Arena::CreateMaybeMessage<::openscreen::cast::proto::CastMessage>(Arena*);
template<> ::openscreen::cast::proto::DeviceAuthMessage* Arena::CreateMaybeMessage<::openscreen::cast::proto::DeviceAuthMessage>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace openscreen {
namespace cast {
namespace proto {

enum CastMessage_ProtocolVersion : int {};
bool CastMessage_ProtocolVersion_IsValid(int value);
constexpr CastMessage_ProtocolVersion CastMessage_ProtocolVersion_ProtocolVersion_MIN =;
constexpr CastMessage_ProtocolVersion CastMessage_ProtocolVersion_ProtocolVersion_MAX =;
constexpr int CastMessage_ProtocolVersion_ProtocolVersion_ARRAYSIZE =;

const std::string& CastMessage_ProtocolVersion_Name(CastMessage_ProtocolVersion value);
template<typename T>
inline const std::string& CastMessage_ProtocolVersion_Name(T enum_t_value) {}
bool CastMessage_ProtocolVersion_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CastMessage_ProtocolVersion* value);
enum CastMessage_PayloadType : int {};
bool CastMessage_PayloadType_IsValid(int value);
constexpr CastMessage_PayloadType CastMessage_PayloadType_PayloadType_MIN =;
constexpr CastMessage_PayloadType CastMessage_PayloadType_PayloadType_MAX =;
constexpr int CastMessage_PayloadType_PayloadType_ARRAYSIZE =;

const std::string& CastMessage_PayloadType_Name(CastMessage_PayloadType value);
template<typename T>
inline const std::string& CastMessage_PayloadType_Name(T enum_t_value) {}
bool CastMessage_PayloadType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CastMessage_PayloadType* value);
enum AuthError_ErrorType : int {};
bool AuthError_ErrorType_IsValid(int value);
constexpr AuthError_ErrorType AuthError_ErrorType_ErrorType_MIN =;
constexpr AuthError_ErrorType AuthError_ErrorType_ErrorType_MAX =;
constexpr int AuthError_ErrorType_ErrorType_ARRAYSIZE =;

const std::string& AuthError_ErrorType_Name(AuthError_ErrorType value);
template<typename T>
inline const std::string& AuthError_ErrorType_Name(T enum_t_value) {}
bool AuthError_ErrorType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AuthError_ErrorType* value);
enum SignatureAlgorithm : int {};
bool SignatureAlgorithm_IsValid(int value);
constexpr SignatureAlgorithm SignatureAlgorithm_MIN =;
constexpr SignatureAlgorithm SignatureAlgorithm_MAX =;
constexpr int SignatureAlgorithm_ARRAYSIZE =;

const std::string& SignatureAlgorithm_Name(SignatureAlgorithm value);
template<typename T>
inline const std::string& SignatureAlgorithm_Name(T enum_t_value) {}
bool SignatureAlgorithm_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SignatureAlgorithm* value);
enum HashAlgorithm : int {};
bool HashAlgorithm_IsValid(int value);
constexpr HashAlgorithm HashAlgorithm_MIN =;
constexpr HashAlgorithm HashAlgorithm_MAX =;
constexpr int HashAlgorithm_ARRAYSIZE =;

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

class CastMessage final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:openscreen.cast.proto.CastMessage) */ {};
// -------------------------------------------------------------------

class AuthChallenge final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:openscreen.cast.proto.AuthChallenge) */ {};
// -------------------------------------------------------------------

class AuthResponse final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:openscreen.cast.proto.AuthResponse) */ {};
// -------------------------------------------------------------------

class AuthError final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:openscreen.cast.proto.AuthError) */ {};
// -------------------------------------------------------------------

class DeviceAuthMessage final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:openscreen.cast.proto.DeviceAuthMessage) */ {};
// ===================================================================


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

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

// required .openscreen.cast.proto.CastMessage.ProtocolVersion protocol_version = 1;
inline bool CastMessage::_internal_has_protocol_version() const {}
inline bool CastMessage::has_protocol_version() const {}
inline void CastMessage::clear_protocol_version() {}
inline ::openscreen::cast::proto::CastMessage_ProtocolVersion CastMessage::_internal_protocol_version() const {}
inline ::openscreen::cast::proto::CastMessage_ProtocolVersion CastMessage::protocol_version() const {}
inline void CastMessage::_internal_set_protocol_version(::openscreen::cast::proto::CastMessage_ProtocolVersion value) {}
inline void CastMessage::set_protocol_version(::openscreen::cast::proto::CastMessage_ProtocolVersion value) {}

// required string source_id = 2;
inline bool CastMessage::_internal_has_source_id() const {}
inline bool CastMessage::has_source_id() const {}
inline void CastMessage::clear_source_id() {}
inline const std::string& CastMessage::source_id() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CastMessage::set_source_id(ArgT0&& arg0, ArgT... args) {}
inline std::string* CastMessage::mutable_source_id() {}
inline const std::string& CastMessage::_internal_source_id() const {}
inline void CastMessage::_internal_set_source_id(const std::string& value) {}
inline std::string* CastMessage::_internal_mutable_source_id() {}
inline std::string* CastMessage::release_source_id() {}
inline void CastMessage::set_allocated_source_id(std::string* source_id) {}

// required string destination_id = 3;
inline bool CastMessage::_internal_has_destination_id() const {}
inline bool CastMessage::has_destination_id() const {}
inline void CastMessage::clear_destination_id() {}
inline const std::string& CastMessage::destination_id() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CastMessage::set_destination_id(ArgT0&& arg0, ArgT... args) {}
inline std::string* CastMessage::mutable_destination_id() {}
inline const std::string& CastMessage::_internal_destination_id() const {}
inline void CastMessage::_internal_set_destination_id(const std::string& value) {}
inline std::string* CastMessage::_internal_mutable_destination_id() {}
inline std::string* CastMessage::release_destination_id() {}
inline void CastMessage::set_allocated_destination_id(std::string* destination_id) {}

// required string namespace = 4;
inline bool CastMessage::_internal_has_namespace_() const {}
inline bool CastMessage::has_namespace_() const {}
inline void CastMessage::clear_namespace_() {}
inline const std::string& CastMessage::namespace_() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CastMessage::set_namespace_(ArgT0&& arg0, ArgT... args) {}
inline std::string* CastMessage::mutable_namespace_() {}
inline const std::string& CastMessage::_internal_namespace_() const {}
inline void CastMessage::_internal_set_namespace_(const std::string& value) {}
inline std::string* CastMessage::_internal_mutable_namespace_() {}
inline std::string* CastMessage::release_namespace_() {}
inline void CastMessage::set_allocated_namespace_(std::string* namespace_) {}

// required .openscreen.cast.proto.CastMessage.PayloadType payload_type = 5;
inline bool CastMessage::_internal_has_payload_type() const {}
inline bool CastMessage::has_payload_type() const {}
inline void CastMessage::clear_payload_type() {}
inline ::openscreen::cast::proto::CastMessage_PayloadType CastMessage::_internal_payload_type() const {}
inline ::openscreen::cast::proto::CastMessage_PayloadType CastMessage::payload_type() const {}
inline void CastMessage::_internal_set_payload_type(::openscreen::cast::proto::CastMessage_PayloadType value) {}
inline void CastMessage::set_payload_type(::openscreen::cast::proto::CastMessage_PayloadType value) {}

// optional string payload_utf8 = 6;
inline bool CastMessage::_internal_has_payload_utf8() const {}
inline bool CastMessage::has_payload_utf8() const {}
inline void CastMessage::clear_payload_utf8() {}
inline const std::string& CastMessage::payload_utf8() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CastMessage::set_payload_utf8(ArgT0&& arg0, ArgT... args) {}
inline std::string* CastMessage::mutable_payload_utf8() {}
inline const std::string& CastMessage::_internal_payload_utf8() const {}
inline void CastMessage::_internal_set_payload_utf8(const std::string& value) {}
inline std::string* CastMessage::_internal_mutable_payload_utf8() {}
inline std::string* CastMessage::release_payload_utf8() {}
inline void CastMessage::set_allocated_payload_utf8(std::string* payload_utf8) {}

// optional bytes payload_binary = 7;
inline bool CastMessage::_internal_has_payload_binary() const {}
inline bool CastMessage::has_payload_binary() const {}
inline void CastMessage::clear_payload_binary() {}
inline const std::string& CastMessage::payload_binary() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CastMessage::set_payload_binary(ArgT0&& arg0, ArgT... args) {}
inline std::string* CastMessage::mutable_payload_binary() {}
inline const std::string& CastMessage::_internal_payload_binary() const {}
inline void CastMessage::_internal_set_payload_binary(const std::string& value) {}
inline std::string* CastMessage::_internal_mutable_payload_binary() {}
inline std::string* CastMessage::release_payload_binary() {}
inline void CastMessage::set_allocated_payload_binary(std::string* payload_binary) {}

// optional bool continued = 8;
inline bool CastMessage::_internal_has_continued() const {}
inline bool CastMessage::has_continued() const {}
inline void CastMessage::clear_continued() {}
inline bool CastMessage::_internal_continued() const {}
inline bool CastMessage::continued() const {}
inline void CastMessage::_internal_set_continued(bool value) {}
inline void CastMessage::set_continued(bool value) {}

// optional uint32 remaining_length = 9;
inline bool CastMessage::_internal_has_remaining_length() const {}
inline bool CastMessage::has_remaining_length() const {}
inline void CastMessage::clear_remaining_length() {}
inline uint32_t CastMessage::_internal_remaining_length() const {}
inline uint32_t CastMessage::remaining_length() const {}
inline void CastMessage::_internal_set_remaining_length(uint32_t value) {}
inline void CastMessage::set_remaining_length(uint32_t value) {}

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

// AuthChallenge

// optional .openscreen.cast.proto.SignatureAlgorithm signature_algorithm = 1 [default = RSASSA_PKCS1v15];
inline bool AuthChallenge::_internal_has_signature_algorithm() const {}
inline bool AuthChallenge::has_signature_algorithm() const {}
inline void AuthChallenge::clear_signature_algorithm() {}
inline ::openscreen::cast::proto::SignatureAlgorithm AuthChallenge::_internal_signature_algorithm() const {}
inline ::openscreen::cast::proto::SignatureAlgorithm AuthChallenge::signature_algorithm() const {}
inline void AuthChallenge::_internal_set_signature_algorithm(::openscreen::cast::proto::SignatureAlgorithm value) {}
inline void AuthChallenge::set_signature_algorithm(::openscreen::cast::proto::SignatureAlgorithm value) {}

// optional bytes sender_nonce = 2;
inline bool AuthChallenge::_internal_has_sender_nonce() const {}
inline bool AuthChallenge::has_sender_nonce() const {}
inline void AuthChallenge::clear_sender_nonce() {}
inline const std::string& AuthChallenge::sender_nonce() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AuthChallenge::set_sender_nonce(ArgT0&& arg0, ArgT... args) {}
inline std::string* AuthChallenge::mutable_sender_nonce() {}
inline const std::string& AuthChallenge::_internal_sender_nonce() const {}
inline void AuthChallenge::_internal_set_sender_nonce(const std::string& value) {}
inline std::string* AuthChallenge::_internal_mutable_sender_nonce() {}
inline std::string* AuthChallenge::release_sender_nonce() {}
inline void AuthChallenge::set_allocated_sender_nonce(std::string* sender_nonce) {}

// optional .openscreen.cast.proto.HashAlgorithm hash_algorithm = 3 [default = SHA1];
inline bool AuthChallenge::_internal_has_hash_algorithm() const {}
inline bool AuthChallenge::has_hash_algorithm() const {}
inline void AuthChallenge::clear_hash_algorithm() {}
inline ::openscreen::cast::proto::HashAlgorithm AuthChallenge::_internal_hash_algorithm() const {}
inline ::openscreen::cast::proto::HashAlgorithm AuthChallenge::hash_algorithm() const {}
inline void AuthChallenge::_internal_set_hash_algorithm(::openscreen::cast::proto::HashAlgorithm value) {}
inline void AuthChallenge::set_hash_algorithm(::openscreen::cast::proto::HashAlgorithm value) {}

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

// AuthResponse

// required bytes signature = 1;
inline bool AuthResponse::_internal_has_signature() const {}
inline bool AuthResponse::has_signature() const {}
inline void AuthResponse::clear_signature() {}
inline const std::string& AuthResponse::signature() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AuthResponse::set_signature(ArgT0&& arg0, ArgT... args) {}
inline std::string* AuthResponse::mutable_signature() {}
inline const std::string& AuthResponse::_internal_signature() const {}
inline void AuthResponse::_internal_set_signature(const std::string& value) {}
inline std::string* AuthResponse::_internal_mutable_signature() {}
inline std::string* AuthResponse::release_signature() {}
inline void AuthResponse::set_allocated_signature(std::string* signature) {}

// required bytes client_auth_certificate = 2;
inline bool AuthResponse::_internal_has_client_auth_certificate() const {}
inline bool AuthResponse::has_client_auth_certificate() const {}
inline void AuthResponse::clear_client_auth_certificate() {}
inline const std::string& AuthResponse::client_auth_certificate() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AuthResponse::set_client_auth_certificate(ArgT0&& arg0, ArgT... args) {}
inline std::string* AuthResponse::mutable_client_auth_certificate() {}
inline const std::string& AuthResponse::_internal_client_auth_certificate() const {}
inline void AuthResponse::_internal_set_client_auth_certificate(const std::string& value) {}
inline std::string* AuthResponse::_internal_mutable_client_auth_certificate() {}
inline std::string* AuthResponse::release_client_auth_certificate() {}
inline void AuthResponse::set_allocated_client_auth_certificate(std::string* client_auth_certificate) {}

// repeated bytes intermediate_certificate = 3;
inline int AuthResponse::_internal_intermediate_certificate_size() const {}
inline int AuthResponse::intermediate_certificate_size() const {}
inline void AuthResponse::clear_intermediate_certificate() {}
inline std::string* AuthResponse::add_intermediate_certificate() {}
inline const std::string& AuthResponse::_internal_intermediate_certificate(int index) const {}
inline const std::string& AuthResponse::intermediate_certificate(int index) const {}
inline std::string* AuthResponse::mutable_intermediate_certificate(int index) {}
inline void AuthResponse::set_intermediate_certificate(int index, const std::string& value) {}
inline void AuthResponse::set_intermediate_certificate(int index, std::string&& value) {}
inline void AuthResponse::set_intermediate_certificate(int index, const char* value) {}
inline void AuthResponse::set_intermediate_certificate(int index, const void* value, size_t size) {}
inline std::string* AuthResponse::_internal_add_intermediate_certificate() {}
inline void AuthResponse::add_intermediate_certificate(const std::string& value) {}
inline void AuthResponse::add_intermediate_certificate(std::string&& value) {}
inline void AuthResponse::add_intermediate_certificate(const char* value) {}
inline void AuthResponse::add_intermediate_certificate(const void* value, size_t size) {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
AuthResponse::intermediate_certificate() const {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
AuthResponse::mutable_intermediate_certificate() {}

// optional .openscreen.cast.proto.SignatureAlgorithm signature_algorithm = 4 [default = RSASSA_PKCS1v15];
inline bool AuthResponse::_internal_has_signature_algorithm() const {}
inline bool AuthResponse::has_signature_algorithm() const {}
inline void AuthResponse::clear_signature_algorithm() {}
inline ::openscreen::cast::proto::SignatureAlgorithm AuthResponse::_internal_signature_algorithm() const {}
inline ::openscreen::cast::proto::SignatureAlgorithm AuthResponse::signature_algorithm() const {}
inline void AuthResponse::_internal_set_signature_algorithm(::openscreen::cast::proto::SignatureAlgorithm value) {}
inline void AuthResponse::set_signature_algorithm(::openscreen::cast::proto::SignatureAlgorithm value) {}

// optional bytes sender_nonce = 5;
inline bool AuthResponse::_internal_has_sender_nonce() const {}
inline bool AuthResponse::has_sender_nonce() const {}
inline void AuthResponse::clear_sender_nonce() {}
inline const std::string& AuthResponse::sender_nonce() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AuthResponse::set_sender_nonce(ArgT0&& arg0, ArgT... args) {}
inline std::string* AuthResponse::mutable_sender_nonce() {}
inline const std::string& AuthResponse::_internal_sender_nonce() const {}
inline void AuthResponse::_internal_set_sender_nonce(const std::string& value) {}
inline std::string* AuthResponse::_internal_mutable_sender_nonce() {}
inline std::string* AuthResponse::release_sender_nonce() {}
inline void AuthResponse::set_allocated_sender_nonce(std::string* sender_nonce) {}

// optional .openscreen.cast.proto.HashAlgorithm hash_algorithm = 6 [default = SHA1];
inline bool AuthResponse::_internal_has_hash_algorithm() const {}
inline bool AuthResponse::has_hash_algorithm() const {}
inline void AuthResponse::clear_hash_algorithm() {}
inline ::openscreen::cast::proto::HashAlgorithm AuthResponse::_internal_hash_algorithm() const {}
inline ::openscreen::cast::proto::HashAlgorithm AuthResponse::hash_algorithm() const {}
inline void AuthResponse::_internal_set_hash_algorithm(::openscreen::cast::proto::HashAlgorithm value) {}
inline void AuthResponse::set_hash_algorithm(::openscreen::cast::proto::HashAlgorithm value) {}

// optional bytes crl = 7;
inline bool AuthResponse::_internal_has_crl() const {}
inline bool AuthResponse::has_crl() const {}
inline void AuthResponse::clear_crl() {}
inline const std::string& AuthResponse::crl() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AuthResponse::set_crl(ArgT0&& arg0, ArgT... args) {}
inline std::string* AuthResponse::mutable_crl() {}
inline const std::string& AuthResponse::_internal_crl() const {}
inline void AuthResponse::_internal_set_crl(const std::string& value) {}
inline std::string* AuthResponse::_internal_mutable_crl() {}
inline std::string* AuthResponse::release_crl() {}
inline void AuthResponse::set_allocated_crl(std::string* crl) {}

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

// AuthError

// required .openscreen.cast.proto.AuthError.ErrorType error_type = 1;
inline bool AuthError::_internal_has_error_type() const {}
inline bool AuthError::has_error_type() const {}
inline void AuthError::clear_error_type() {}
inline ::openscreen::cast::proto::AuthError_ErrorType AuthError::_internal_error_type() const {}
inline ::openscreen::cast::proto::AuthError_ErrorType AuthError::error_type() const {}
inline void AuthError::_internal_set_error_type(::openscreen::cast::proto::AuthError_ErrorType value) {}
inline void AuthError::set_error_type(::openscreen::cast::proto::AuthError_ErrorType value) {}

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

// DeviceAuthMessage

// optional .openscreen.cast.proto.AuthChallenge challenge = 1;
inline bool DeviceAuthMessage::_internal_has_challenge() const {}
inline bool DeviceAuthMessage::has_challenge() const {}
inline void DeviceAuthMessage::clear_challenge() {}
inline const ::openscreen::cast::proto::AuthChallenge& DeviceAuthMessage::_internal_challenge() const {}
inline const ::openscreen::cast::proto::AuthChallenge& DeviceAuthMessage::challenge() const {}
inline void DeviceAuthMessage::unsafe_arena_set_allocated_challenge(
    ::openscreen::cast::proto::AuthChallenge* challenge) {}
inline ::openscreen::cast::proto::AuthChallenge* DeviceAuthMessage::release_challenge() {}
inline ::openscreen::cast::proto::AuthChallenge* DeviceAuthMessage::unsafe_arena_release_challenge() {}
inline ::openscreen::cast::proto::AuthChallenge* DeviceAuthMessage::_internal_mutable_challenge() {}
inline ::openscreen::cast::proto::AuthChallenge* DeviceAuthMessage::mutable_challenge() {}
inline void DeviceAuthMessage::set_allocated_challenge(::openscreen::cast::proto::AuthChallenge* challenge) {}

// optional .openscreen.cast.proto.AuthResponse response = 2;
inline bool DeviceAuthMessage::_internal_has_response() const {}
inline bool DeviceAuthMessage::has_response() const {}
inline void DeviceAuthMessage::clear_response() {}
inline const ::openscreen::cast::proto::AuthResponse& DeviceAuthMessage::_internal_response() const {}
inline const ::openscreen::cast::proto::AuthResponse& DeviceAuthMessage::response() const {}
inline void DeviceAuthMessage::unsafe_arena_set_allocated_response(
    ::openscreen::cast::proto::AuthResponse* response) {}
inline ::openscreen::cast::proto::AuthResponse* DeviceAuthMessage::release_response() {}
inline ::openscreen::cast::proto::AuthResponse* DeviceAuthMessage::unsafe_arena_release_response() {}
inline ::openscreen::cast::proto::AuthResponse* DeviceAuthMessage::_internal_mutable_response() {}
inline ::openscreen::cast::proto::AuthResponse* DeviceAuthMessage::mutable_response() {}
inline void DeviceAuthMessage::set_allocated_response(::openscreen::cast::proto::AuthResponse* response) {}

// optional .openscreen.cast.proto.AuthError error = 3;
inline bool DeviceAuthMessage::_internal_has_error() const {}
inline bool DeviceAuthMessage::has_error() const {}
inline void DeviceAuthMessage::clear_error() {}
inline const ::openscreen::cast::proto::AuthError& DeviceAuthMessage::_internal_error() const {}
inline const ::openscreen::cast::proto::AuthError& DeviceAuthMessage::error() const {}
inline void DeviceAuthMessage::unsafe_arena_set_allocated_error(
    ::openscreen::cast::proto::AuthError* error) {}
inline ::openscreen::cast::proto::AuthError* DeviceAuthMessage::release_error() {}
inline ::openscreen::cast::proto::AuthError* DeviceAuthMessage::unsafe_arena_release_error() {}
inline ::openscreen::cast::proto::AuthError* DeviceAuthMessage::_internal_mutable_error() {}
inline ::openscreen::cast::proto::AuthError* DeviceAuthMessage::mutable_error() {}
inline void DeviceAuthMessage::set_allocated_error(::openscreen::cast::proto::AuthError* error) {}

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace proto
}  // namespace cast
}  // namespace openscreen

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::openscreen::cast::proto::CastMessage_ProtocolVersion> : ::std::true_type {};
template <> struct is_proto_enum< ::openscreen::cast::proto::CastMessage_PayloadType> : ::std::true_type {};
template <> struct is_proto_enum< ::openscreen::cast::proto::AuthError_ErrorType> : ::std::true_type {};
template <> struct is_proto_enum< ::openscreen::cast::proto::SignatureAlgorithm> : ::std::true_type {};
template <> struct is_proto_enum< ::openscreen::cast::proto::HashAlgorithm> : ::std::true_type {};

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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