// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: stream_out/chromecast/cast_channel.proto
// Protobuf C++ Version: 7.34.0

#ifndef stream_5fout_2fchromecast_2fcast_5fchannel_2eproto_2epb_2eh
#define stream_5fout_2fchromecast_2fcast_5fchannel_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>
#include <utility>

// clang-format off
#include "google/protobuf/runtime_version.h"
#if PROTOBUF_VERSION != 7034000
#error "Protobuf C++ gencode is built with an incompatible version of"
#error "Protobuf C++ headers/runtime. See"
#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
#endif
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_tctable_decl.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)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_stream_5fout_2fchromecast_2fcast_5fchannel_2eproto

namespace google {
namespace protobuf {
namespace internal {
template <typename T>
::absl::string_view GetAnyMessageName();
}  // namespace internal
}  // namespace protobuf
}  // namespace google

// Internal implementation detail -- do not use these members.
struct TableStruct_stream_5fout_2fchromecast_2fcast_5fchannel_2eproto {
  static const ::uint32_t offsets[];
};
namespace castchannel {
enum AuthError_ErrorType : int;
extern const uint32_t AuthError_ErrorType_internal_data_[];
enum CastMessage_PayloadType : int;
extern const uint32_t CastMessage_PayloadType_internal_data_[];
enum CastMessage_ProtocolVersion : int;
extern const uint32_t CastMessage_ProtocolVersion_internal_data_[];
class AuthChallenge;
struct AuthChallengeDefaultTypeInternal;
extern AuthChallengeDefaultTypeInternal _AuthChallenge_default_instance_;
extern const ::google::protobuf::internal::ClassDataLite<26> AuthChallenge_class_data_;
class AuthError;
struct AuthErrorDefaultTypeInternal;
extern AuthErrorDefaultTypeInternal _AuthError_default_instance_;
extern const ::google::protobuf::internal::ClassDataLite<22> AuthError_class_data_;
class AuthResponse;
struct AuthResponseDefaultTypeInternal;
extern AuthResponseDefaultTypeInternal _AuthResponse_default_instance_;
extern const ::google::protobuf::internal::ClassDataLite<25> AuthResponse_class_data_;
class CastMessage;
struct CastMessageDefaultTypeInternal;
extern CastMessageDefaultTypeInternal _CastMessage_default_instance_;
extern const ::google::protobuf::internal::ClassDataLite<24> CastMessage_class_data_;
class DeviceAuthMessage;
struct DeviceAuthMessageDefaultTypeInternal;
extern DeviceAuthMessageDefaultTypeInternal _DeviceAuthMessage_default_instance_;
extern const ::google::protobuf::internal::ClassDataLite<30> DeviceAuthMessage_class_data_;
}  // namespace castchannel
namespace google {
namespace protobuf {
template <>
internal::EnumTraitsT<::castchannel::AuthError_ErrorType_internal_data_>
    internal::EnumTraitsImpl::value<::castchannel::AuthError_ErrorType>;
template <>
internal::EnumTraitsT<::castchannel::CastMessage_PayloadType_internal_data_>
    internal::EnumTraitsImpl::value<::castchannel::CastMessage_PayloadType>;
template <>
internal::EnumTraitsT<::castchannel::CastMessage_ProtocolVersion_internal_data_>
    internal::EnumTraitsImpl::value<::castchannel::CastMessage_ProtocolVersion>;
}  // namespace protobuf
}  // namespace google

namespace castchannel {
enum CastMessage_ProtocolVersion : int {
  CastMessage_ProtocolVersion_CASTV2_1_0 = 0,
};

extern const uint32_t CastMessage_ProtocolVersion_internal_data_[];
inline constexpr CastMessage_ProtocolVersion CastMessage_ProtocolVersion_ProtocolVersion_MIN =
    static_cast<CastMessage_ProtocolVersion>(0);
inline constexpr CastMessage_ProtocolVersion CastMessage_ProtocolVersion_ProtocolVersion_MAX =
    static_cast<CastMessage_ProtocolVersion>(0);
[[nodiscard]] inline bool CastMessage_ProtocolVersion_IsValid(int value) {
  return 0 <= value && value <= 0;
}
inline constexpr int CastMessage_ProtocolVersion_ProtocolVersion_ARRAYSIZE = 0 + 1;
[[nodiscard]] const ::std::string& CastMessage_ProtocolVersion_Name(CastMessage_ProtocolVersion value);
template <typename T>
[[nodiscard]] const ::std::string& CastMessage_ProtocolVersion_Name(T value) {
  static_assert(::std::is_same<T, CastMessage_ProtocolVersion>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to ProtocolVersion_Name().");
  return CastMessage_ProtocolVersion_Name(static_cast<CastMessage_ProtocolVersion>(value));
}
[[nodiscard]] bool CastMessage_ProtocolVersion_Parse(
    ::absl::string_view name, CastMessage_ProtocolVersion* PROTOBUF_NONNULL value);
enum CastMessage_PayloadType : int {
  CastMessage_PayloadType_STRING = 0,
  CastMessage_PayloadType_BINARY = 1,
};

extern const uint32_t CastMessage_PayloadType_internal_data_[];
inline constexpr CastMessage_PayloadType CastMessage_PayloadType_PayloadType_MIN =
    static_cast<CastMessage_PayloadType>(0);
inline constexpr CastMessage_PayloadType CastMessage_PayloadType_PayloadType_MAX =
    static_cast<CastMessage_PayloadType>(1);
[[nodiscard]] inline bool CastMessage_PayloadType_IsValid(int value) {
  return 0 <= value && value <= 1;
}
inline constexpr int CastMessage_PayloadType_PayloadType_ARRAYSIZE = 1 + 1;
[[nodiscard]] const ::std::string& CastMessage_PayloadType_Name(CastMessage_PayloadType value);
template <typename T>
[[nodiscard]] const ::std::string& CastMessage_PayloadType_Name(T value) {
  static_assert(::std::is_same<T, CastMessage_PayloadType>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to PayloadType_Name().");
  return CastMessage_PayloadType_Name(static_cast<CastMessage_PayloadType>(value));
}
[[nodiscard]] bool CastMessage_PayloadType_Parse(
    ::absl::string_view name, CastMessage_PayloadType* PROTOBUF_NONNULL value);
enum AuthError_ErrorType : int {
  AuthError_ErrorType_INTERNAL_ERROR = 0,
  AuthError_ErrorType_NO_TLS = 1,
};

extern const uint32_t AuthError_ErrorType_internal_data_[];
inline constexpr AuthError_ErrorType AuthError_ErrorType_ErrorType_MIN =
    static_cast<AuthError_ErrorType>(0);
inline constexpr AuthError_ErrorType AuthError_ErrorType_ErrorType_MAX =
    static_cast<AuthError_ErrorType>(1);
[[nodiscard]] inline bool AuthError_ErrorType_IsValid(int value) {
  return 0 <= value && value <= 1;
}
inline constexpr int AuthError_ErrorType_ErrorType_ARRAYSIZE = 1 + 1;
[[nodiscard]] const ::std::string& AuthError_ErrorType_Name(AuthError_ErrorType value);
template <typename T>
[[nodiscard]] const ::std::string& AuthError_ErrorType_Name(T value) {
  static_assert(::std::is_same<T, AuthError_ErrorType>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to ErrorType_Name().");
  return AuthError_ErrorType_Name(static_cast<AuthError_ErrorType>(value));
}
[[nodiscard]] bool AuthError_ErrorType_Parse(
    ::absl::string_view name, AuthError_ErrorType* PROTOBUF_NONNULL value);

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


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

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED CastMessage final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:castchannel.CastMessage) */ {
 public:
  inline CastMessage() : CastMessage(nullptr) {}
  ~CastMessage() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(CastMessage* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(CastMessage));
  }
#endif

  template <typename = void>
  explicit constexpr CastMessage(::google::protobuf::internal::ConstantInitialized);

  inline CastMessage(const CastMessage& from) : CastMessage(nullptr, from) {}
  inline CastMessage(CastMessage&& from) noexcept
      : CastMessage(nullptr, ::std::move(from)) {}
  inline CastMessage& operator=(const CastMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline CastMessage& operator=(CastMessage&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString);
  }
  [[nodiscard]] inline ::std::string* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::std::string>();
  }

  [[nodiscard]] static const CastMessage& default_instance() {
    return *reinterpret_cast<const CastMessage*>(
        &_CastMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(CastMessage& a, CastMessage& b) { a.Swap(&b); }
  inline void Swap(CastMessage* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CastMessage* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  [[nodiscard]] CastMessage* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::MessageLite::DefaultConstruct<CastMessage>(arena);
  }
  void CopyFrom(const CastMessage& from);
  void MergeFrom(const CastMessage& from) { CastMessage::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(CastMessage* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "castchannel.CastMessage"; }

  explicit CastMessage(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  CastMessage(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const CastMessage& from);
  CastMessage(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, CastMessage&& from) noexcept
      : CastMessage(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  // nested types ----------------------------------------------------
  using ProtocolVersion = CastMessage_ProtocolVersion;
  static constexpr ProtocolVersion CASTV2_1_0 = CastMessage_ProtocolVersion_CASTV2_1_0;
  [[nodiscard]] static inline bool ProtocolVersion_IsValid(int value) {
    return CastMessage_ProtocolVersion_IsValid(value);
  }
  static constexpr ProtocolVersion ProtocolVersion_MIN = CastMessage_ProtocolVersion_ProtocolVersion_MIN;
  static constexpr ProtocolVersion ProtocolVersion_MAX = CastMessage_ProtocolVersion_ProtocolVersion_MAX;
  static constexpr int ProtocolVersion_ARRAYSIZE = CastMessage_ProtocolVersion_ProtocolVersion_ARRAYSIZE;
  template <typename T>
  [[nodiscard]] static inline const ::std::string& ProtocolVersion_Name(T value) {
    return CastMessage_ProtocolVersion_Name(value);
  }
  [[nodiscard]] static inline bool ProtocolVersion_Parse(
      ::absl::string_view name, ProtocolVersion* PROTOBUF_NONNULL value) {
    return CastMessage_ProtocolVersion_Parse(name, value);
  }
  using PayloadType = CastMessage_PayloadType;
  static constexpr PayloadType STRING = CastMessage_PayloadType_STRING;
  static constexpr PayloadType BINARY = CastMessage_PayloadType_BINARY;
  [[nodiscard]] static inline bool PayloadType_IsValid(int value) {
    return CastMessage_PayloadType_IsValid(value);
  }
  static constexpr PayloadType PayloadType_MIN = CastMessage_PayloadType_PayloadType_MIN;
  static constexpr PayloadType PayloadType_MAX = CastMessage_PayloadType_PayloadType_MAX;
  static constexpr int PayloadType_ARRAYSIZE = CastMessage_PayloadType_PayloadType_ARRAYSIZE;
  template <typename T>
  [[nodiscard]] static inline const ::std::string& PayloadType_Name(T value) {
    return CastMessage_PayloadType_Name(value);
  }
  [[nodiscard]] static inline bool PayloadType_Parse(
      ::absl::string_view name, PayloadType* PROTOBUF_NONNULL value) {
    return CastMessage_PayloadType_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kSourceIdFieldNumber = 2,
    kDestinationIdFieldNumber = 3,
    kNamespaceFieldNumber = 4,
    kPayloadUtf8FieldNumber = 6,
    kPayloadBinaryFieldNumber = 7,
    kProtocolVersionFieldNumber = 1,
    kPayloadTypeFieldNumber = 5,
  };
  // required string source_id = 2;
  [[nodiscard]] bool has_source_id()
      const;
  void clear_source_id() ;
  [[nodiscard]] const ::std::string& source_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_source_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_source_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_source_id();
  void set_allocated_source_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_source_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_source_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_source_id();

  public:
  // required string destination_id = 3;
  [[nodiscard]] bool has_destination_id()
      const;
  void clear_destination_id() ;
  [[nodiscard]] const ::std::string& destination_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_destination_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_destination_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_destination_id();
  void set_allocated_destination_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_destination_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_destination_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_destination_id();

  public:
  // required string namespace = 4;
  [[nodiscard]] bool has_namespace_()
      const;
  void clear_namespace_() ;
  [[nodiscard]] const ::std::string& namespace_() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_namespace_(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_namespace_();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_namespace_();
  void set_allocated_namespace_(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_namespace_() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_namespace_(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_namespace_();

  public:
  // optional string payload_utf8 = 6;
  [[nodiscard]] bool has_payload_utf8()
      const;
  void clear_payload_utf8() ;
  [[nodiscard]] const ::std::string& payload_utf8() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_payload_utf8(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_payload_utf8();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_payload_utf8();
  void set_allocated_payload_utf8(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_payload_utf8() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_payload_utf8(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_payload_utf8();

  public:
  // optional bytes payload_binary = 7;
  [[nodiscard]] bool has_payload_binary()
      const;
  void clear_payload_binary() ;
  [[nodiscard]] const ::std::string& payload_binary() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_payload_binary(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_payload_binary();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_payload_binary();
  void set_allocated_payload_binary(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_payload_binary() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_payload_binary(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_payload_binary();

  public:
  // required .castchannel.CastMessage.ProtocolVersion protocol_version = 1;
  [[nodiscard]] bool has_protocol_version()
      const;
  void clear_protocol_version() ;
  [[nodiscard]] ::castchannel::CastMessage_ProtocolVersion protocol_version() const;
  void set_protocol_version(::castchannel::CastMessage_ProtocolVersion value);

  private:
  ::castchannel::CastMessage_ProtocolVersion _internal_protocol_version() const;
  void _internal_set_protocol_version(::castchannel::CastMessage_ProtocolVersion value);

  public:
  // required .castchannel.CastMessage.PayloadType payload_type = 5;
  [[nodiscard]] bool has_payload_type()
      const;
  void clear_payload_type() ;
  [[nodiscard]] ::castchannel::CastMessage_PayloadType payload_type() const;
  void set_payload_type(::castchannel::CastMessage_PayloadType value);

  private:
  ::castchannel::CastMessage_PayloadType _internal_payload_type() const;
  void _internal_set_payload_type(::castchannel::CastMessage_PayloadType value);

  public:
  // @@protoc_insertion_point(class_scope:castchannel.CastMessage)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<3, 7,
                                   2, 0,
                                   2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const CastMessage& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr source_id_;
    ::google::protobuf::internal::ArenaStringPtr destination_id_;
    ::google::protobuf::internal::ArenaStringPtr namespace__;
    ::google::protobuf::internal::ArenaStringPtr payload_utf8_;
    ::google::protobuf::internal::ArenaStringPtr payload_binary_;
    int protocol_version_;
    int payload_type_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_stream_5fout_2fchromecast_2fcast_5fchannel_2eproto;
};

extern const ::google::protobuf::internal::ClassDataLite<24> CastMessage_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED AuthResponse final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:castchannel.AuthResponse) */ {
 public:
  inline AuthResponse() : AuthResponse(nullptr) {}
  ~AuthResponse() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(AuthResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(AuthResponse));
  }
#endif

  template <typename = void>
  explicit constexpr AuthResponse(::google::protobuf::internal::ConstantInitialized);

  inline AuthResponse(const AuthResponse& from) : AuthResponse(nullptr, from) {}
  inline AuthResponse(AuthResponse&& from) noexcept
      : AuthResponse(nullptr, ::std::move(from)) {}
  inline AuthResponse& operator=(const AuthResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline AuthResponse& operator=(AuthResponse&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString);
  }
  [[nodiscard]] inline ::std::string* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::std::string>();
  }

  [[nodiscard]] static const AuthResponse& default_instance() {
    return *reinterpret_cast<const AuthResponse*>(
        &_AuthResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(AuthResponse& a, AuthResponse& b) { a.Swap(&b); }
  inline void Swap(AuthResponse* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AuthResponse* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  [[nodiscard]] AuthResponse* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::MessageLite::DefaultConstruct<AuthResponse>(arena);
  }
  void CopyFrom(const AuthResponse& from);
  void MergeFrom(const AuthResponse& from) { AuthResponse::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(AuthResponse* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "castchannel.AuthResponse"; }

  explicit AuthResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  AuthResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const AuthResponse& from);
  AuthResponse(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, AuthResponse&& from) noexcept
      : AuthResponse(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kSignatureFieldNumber = 1,
    kClientAuthCertificateFieldNumber = 2,
  };
  // required bytes signature = 1;
  [[nodiscard]] bool has_signature()
      const;
  void clear_signature() ;
  [[nodiscard]] const ::std::string& signature() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_signature(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_signature();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_signature();
  void set_allocated_signature(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_signature() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_signature();

  public:
  // required bytes client_auth_certificate = 2;
  [[nodiscard]] bool has_client_auth_certificate()
      const;
  void clear_client_auth_certificate() ;
  [[nodiscard]] const ::std::string& client_auth_certificate() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_client_auth_certificate(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_client_auth_certificate();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_client_auth_certificate();
  void set_allocated_client_auth_certificate(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_client_auth_certificate() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_client_auth_certificate(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_client_auth_certificate();

  public:
  // @@protoc_insertion_point(class_scope:castchannel.AuthResponse)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<1, 2,
                                   0, 0,
                                   2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const AuthResponse& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr signature_;
    ::google::protobuf::internal::ArenaStringPtr client_auth_certificate_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_stream_5fout_2fchromecast_2fcast_5fchannel_2eproto;
};

extern const ::google::protobuf::internal::ClassDataLite<25> AuthResponse_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED AuthError final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:castchannel.AuthError) */ {
 public:
  inline AuthError() : AuthError(nullptr) {}
  ~AuthError() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(AuthError* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(AuthError));
  }
#endif

  template <typename = void>
  explicit constexpr AuthError(::google::protobuf::internal::ConstantInitialized);

  inline AuthError(const AuthError& from) : AuthError(nullptr, from) {}
  inline AuthError(AuthError&& from) noexcept
      : AuthError(nullptr, ::std::move(from)) {}
  inline AuthError& operator=(const AuthError& from) {
    CopyFrom(from);
    return *this;
  }
  inline AuthError& operator=(AuthError&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString);
  }
  [[nodiscard]] inline ::std::string* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::std::string>();
  }

  [[nodiscard]] static const AuthError& default_instance() {
    return *reinterpret_cast<const AuthError*>(
        &_AuthError_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 3;
  friend void swap(AuthError& a, AuthError& b) { a.Swap(&b); }
  inline void Swap(AuthError* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AuthError* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  [[nodiscard]] AuthError* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::MessageLite::DefaultConstruct<AuthError>(arena);
  }
  void CopyFrom(const AuthError& from);
  void MergeFrom(const AuthError& from) { AuthError::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(AuthError* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "castchannel.AuthError"; }

  explicit AuthError(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  AuthError(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const AuthError& from);
  AuthError(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, AuthError&& from) noexcept
      : AuthError(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  // nested types ----------------------------------------------------
  using ErrorType = AuthError_ErrorType;
  static constexpr ErrorType INTERNAL_ERROR = AuthError_ErrorType_INTERNAL_ERROR;
  static constexpr ErrorType NO_TLS = AuthError_ErrorType_NO_TLS;
  [[nodiscard]] static inline bool ErrorType_IsValid(int value) {
    return AuthError_ErrorType_IsValid(value);
  }
  static constexpr ErrorType ErrorType_MIN = AuthError_ErrorType_ErrorType_MIN;
  static constexpr ErrorType ErrorType_MAX = AuthError_ErrorType_ErrorType_MAX;
  static constexpr int ErrorType_ARRAYSIZE = AuthError_ErrorType_ErrorType_ARRAYSIZE;
  template <typename T>
  [[nodiscard]] static inline const ::std::string& ErrorType_Name(T value) {
    return AuthError_ErrorType_Name(value);
  }
  [[nodiscard]] static inline bool ErrorType_Parse(
      ::absl::string_view name, ErrorType* PROTOBUF_NONNULL value) {
    return AuthError_ErrorType_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kErrorTypeFieldNumber = 1,
  };
  // required .castchannel.AuthError.ErrorType error_type = 1;
  [[nodiscard]] bool has_error_type()
      const;
  void clear_error_type() ;
  [[nodiscard]] ::castchannel::AuthError_ErrorType error_type() const;
  void set_error_type(::castchannel::AuthError_ErrorType value);

  private:
  ::castchannel::AuthError_ErrorType _internal_error_type() const;
  void _internal_set_error_type(::castchannel::AuthError_ErrorType value);

  public:
  // @@protoc_insertion_point(class_scope:castchannel.AuthError)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<0, 1,
                                   1, 0,
                                   2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const AuthError& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    int error_type_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_stream_5fout_2fchromecast_2fcast_5fchannel_2eproto;
};

extern const ::google::protobuf::internal::ClassDataLite<22> AuthError_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED AuthChallenge final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:castchannel.AuthChallenge) */ {
 public:
  inline AuthChallenge() : AuthChallenge(nullptr) {}
  ~AuthChallenge() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(AuthChallenge* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(AuthChallenge));
  }
#endif

  template <typename = void>
  explicit constexpr AuthChallenge(::google::protobuf::internal::ConstantInitialized);

  inline AuthChallenge(const AuthChallenge& from) : AuthChallenge(nullptr, from) {}
  inline AuthChallenge(AuthChallenge&& from) noexcept
      : AuthChallenge(nullptr, ::std::move(from)) {}
  inline AuthChallenge& operator=(const AuthChallenge& from) {
    CopyFrom(from);
    return *this;
  }
  inline AuthChallenge& operator=(AuthChallenge&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString);
  }
  [[nodiscard]] inline ::std::string* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::std::string>();
  }

  [[nodiscard]] static const AuthChallenge& default_instance() {
    return *reinterpret_cast<const AuthChallenge*>(
        &_AuthChallenge_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 1;
  friend void swap(AuthChallenge& a, AuthChallenge& b) { a.Swap(&b); }
  inline void Swap(AuthChallenge* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AuthChallenge* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  [[nodiscard]] AuthChallenge* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::MessageLite::DefaultConstruct<AuthChallenge>(arena);
  }
  void CopyFrom(const AuthChallenge& from);
  void MergeFrom(const AuthChallenge& from) { AuthChallenge::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(AuthChallenge* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "castchannel.AuthChallenge"; }

  explicit AuthChallenge(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  AuthChallenge(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const AuthChallenge& from);
  AuthChallenge(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, AuthChallenge&& from) noexcept
      : AuthChallenge(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  // @@protoc_insertion_point(class_scope:castchannel.AuthChallenge)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<0, 0,
                                   0, 0,
                                   2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const AuthChallenge& from_msg);
    ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_stream_5fout_2fchromecast_2fcast_5fchannel_2eproto;
};

extern const ::google::protobuf::internal::ClassDataLite<26> AuthChallenge_class_data_;
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED DeviceAuthMessage final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:castchannel.DeviceAuthMessage) */ {
 public:
  inline DeviceAuthMessage() : DeviceAuthMessage(nullptr) {}
  ~DeviceAuthMessage() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(DeviceAuthMessage* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(DeviceAuthMessage));
  }
#endif

  template <typename = void>
  explicit constexpr DeviceAuthMessage(::google::protobuf::internal::ConstantInitialized);

  inline DeviceAuthMessage(const DeviceAuthMessage& from) : DeviceAuthMessage(nullptr, from) {}
  inline DeviceAuthMessage(DeviceAuthMessage&& from) noexcept
      : DeviceAuthMessage(nullptr, ::std::move(from)) {}
  inline DeviceAuthMessage& operator=(const DeviceAuthMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline DeviceAuthMessage& operator=(DeviceAuthMessage&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString);
  }
  [[nodiscard]] inline ::std::string* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::std::string>();
  }

  [[nodiscard]] static const DeviceAuthMessage& default_instance() {
    return *reinterpret_cast<const DeviceAuthMessage*>(
        &_DeviceAuthMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 4;
  friend void swap(DeviceAuthMessage& a, DeviceAuthMessage& b) { a.Swap(&b); }
  inline void Swap(DeviceAuthMessage* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DeviceAuthMessage* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  [[nodiscard]] DeviceAuthMessage* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::MessageLite::DefaultConstruct<DeviceAuthMessage>(arena);
  }
  void CopyFrom(const DeviceAuthMessage& from);
  void MergeFrom(const DeviceAuthMessage& from) { DeviceAuthMessage::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(DeviceAuthMessage* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "castchannel.DeviceAuthMessage"; }

  explicit DeviceAuthMessage(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  DeviceAuthMessage(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const DeviceAuthMessage& from);
  DeviceAuthMessage(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, DeviceAuthMessage&& from) noexcept
      : DeviceAuthMessage(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_();

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kChallengeFieldNumber = 1,
    kResponseFieldNumber = 2,
    kErrorFieldNumber = 3,
  };
  // optional .castchannel.AuthChallenge challenge = 1;
  [[nodiscard]] bool has_challenge()
      const;
  void clear_challenge() ;
  [[nodiscard]] const ::castchannel::AuthChallenge& challenge() const;
  [[nodiscard]] ::castchannel::AuthChallenge* PROTOBUF_NULLABLE release_challenge();
  ::castchannel::AuthChallenge* PROTOBUF_NONNULL mutable_challenge();
  void set_allocated_challenge(::castchannel::AuthChallenge* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_challenge(::castchannel::AuthChallenge* PROTOBUF_NULLABLE value);
  ::castchannel::AuthChallenge* PROTOBUF_NULLABLE unsafe_arena_release_challenge();

  private:
  const ::castchannel::AuthChallenge& _internal_challenge() const;
  ::castchannel::AuthChallenge* PROTOBUF_NONNULL _internal_mutable_challenge();

  public:
  // optional .castchannel.AuthResponse response = 2;
  [[nodiscard]] bool has_response()
      const;
  void clear_response() ;
  [[nodiscard]] const ::castchannel::AuthResponse& response() const;
  [[nodiscard]] ::castchannel::AuthResponse* PROTOBUF_NULLABLE release_response();
  ::castchannel::AuthResponse* PROTOBUF_NONNULL mutable_response();
  void set_allocated_response(::castchannel::AuthResponse* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_response(::castchannel::AuthResponse* PROTOBUF_NULLABLE value);
  ::castchannel::AuthResponse* PROTOBUF_NULLABLE unsafe_arena_release_response();

  private:
  const ::castchannel::AuthResponse& _internal_response() const;
  ::castchannel::AuthResponse* PROTOBUF_NONNULL _internal_mutable_response();

  public:
  // optional .castchannel.AuthError error = 3;
  [[nodiscard]] bool has_error()
      const;
  void clear_error() ;
  [[nodiscard]] const ::castchannel::AuthError& error() const;
  [[nodiscard]] ::castchannel::AuthError* PROTOBUF_NULLABLE release_error();
  ::castchannel::AuthError* PROTOBUF_NONNULL mutable_error();
  void set_allocated_error(::castchannel::AuthError* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_error(::castchannel::AuthError* PROTOBUF_NULLABLE value);
  ::castchannel::AuthError* PROTOBUF_NULLABLE unsafe_arena_release_error();

  private:
  const ::castchannel::AuthError& _internal_error() const;
  ::castchannel::AuthError* PROTOBUF_NONNULL _internal_mutable_error();

  public:
  // @@protoc_insertion_point(class_scope:castchannel.DeviceAuthMessage)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<2, 3,
                                   3, 0,
                                   2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const DeviceAuthMessage& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::castchannel::AuthChallenge* PROTOBUF_NULLABLE challenge_;
    ::castchannel::AuthResponse* PROTOBUF_NULLABLE response_;
    ::castchannel::AuthError* PROTOBUF_NULLABLE error_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_stream_5fout_2fchromecast_2fcast_5fchannel_2eproto;
};

extern const ::google::protobuf::internal::ClassDataLite<30> DeviceAuthMessage_class_data_;

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




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


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

// CastMessage

// required .castchannel.CastMessage.ProtocolVersion protocol_version = 1;
inline bool CastMessage::has_protocol_version() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  return value;
}
inline void CastMessage::clear_protocol_version() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.protocol_version_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000020U);
}
inline ::castchannel::CastMessage_ProtocolVersion CastMessage::protocol_version() const {
  // @@protoc_insertion_point(field_get:castchannel.CastMessage.protocol_version)
  return _internal_protocol_version();
}
inline void CastMessage::set_protocol_version(::castchannel::CastMessage_ProtocolVersion value) {
  _internal_set_protocol_version(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_set:castchannel.CastMessage.protocol_version)
}
inline ::castchannel::CastMessage_ProtocolVersion CastMessage::_internal_protocol_version() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::castchannel::CastMessage_ProtocolVersion>(_impl_.protocol_version_);
}
inline void CastMessage::_internal_set_protocol_version(::castchannel::CastMessage_ProtocolVersion value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::castchannel::CastMessage_ProtocolVersion_internal_data_));
                                          _impl_.protocol_version_ = value;
}

// required string source_id = 2;
inline bool CastMessage::has_source_id() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void CastMessage::clear_source_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.source_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline const ::std::string& CastMessage::source_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:castchannel.CastMessage.source_id)
  return _internal_source_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void CastMessage::set_source_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.source_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:castchannel.CastMessage.source_id)
}
inline ::std::string* PROTOBUF_NONNULL CastMessage::mutable_source_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_source_id();
  // @@protoc_insertion_point(field_mutable:castchannel.CastMessage.source_id)
  return _s;
}
inline const ::std::string& CastMessage::_internal_source_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.source_id_.Get();
}
inline void CastMessage::_internal_set_source_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.source_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL CastMessage::_internal_mutable_source_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.source_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE CastMessage::release_source_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:castchannel.CastMessage.source_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.source_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.source_id_.Set("", GetArena());
  }
  return released;
}
inline void CastMessage::set_allocated_source_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.source_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.source_id_.IsDefault()) {
    _impl_.source_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:castchannel.CastMessage.source_id)
}

// required string destination_id = 3;
inline bool CastMessage::has_destination_id() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void CastMessage::clear_destination_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.destination_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline const ::std::string& CastMessage::destination_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:castchannel.CastMessage.destination_id)
  return _internal_destination_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void CastMessage::set_destination_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.destination_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:castchannel.CastMessage.destination_id)
}
inline ::std::string* PROTOBUF_NONNULL CastMessage::mutable_destination_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_destination_id();
  // @@protoc_insertion_point(field_mutable:castchannel.CastMessage.destination_id)
  return _s;
}
inline const ::std::string& CastMessage::_internal_destination_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.destination_id_.Get();
}
inline void CastMessage::_internal_set_destination_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.destination_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL CastMessage::_internal_mutable_destination_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.destination_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE CastMessage::release_destination_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:castchannel.CastMessage.destination_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.destination_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.destination_id_.Set("", GetArena());
  }
  return released;
}
inline void CastMessage::set_allocated_destination_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.destination_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.destination_id_.IsDefault()) {
    _impl_.destination_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:castchannel.CastMessage.destination_id)
}

// required string namespace = 4;
inline bool CastMessage::has_namespace_() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void CastMessage::clear_namespace_() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.namespace__.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000004U);
}
inline const ::std::string& CastMessage::namespace_() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:castchannel.CastMessage.namespace)
  return _internal_namespace_();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void CastMessage::set_namespace_(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  _impl_.namespace__.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:castchannel.CastMessage.namespace)
}
inline ::std::string* PROTOBUF_NONNULL CastMessage::mutable_namespace_()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::std::string* _s = _internal_mutable_namespace_();
  // @@protoc_insertion_point(field_mutable:castchannel.CastMessage.namespace)
  return _s;
}
inline const ::std::string& CastMessage::_internal_namespace_() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.namespace__.Get();
}
inline void CastMessage::_internal_set_namespace_(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.namespace__.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL CastMessage::_internal_mutable_namespace_() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.namespace__.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE CastMessage::release_namespace_() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:castchannel.CastMessage.namespace)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  auto* released = _impl_.namespace__.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.namespace__.Set("", GetArena());
  }
  return released;
}
inline void CastMessage::set_allocated_namespace_(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  _impl_.namespace__.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.namespace__.IsDefault()) {
    _impl_.namespace__.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:castchannel.CastMessage.namespace)
}

// required .castchannel.CastMessage.PayloadType payload_type = 5;
inline bool CastMessage::has_payload_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U);
  return value;
}
inline void CastMessage::clear_payload_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.payload_type_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000040U);
}
inline ::castchannel::CastMessage_PayloadType CastMessage::payload_type() const {
  // @@protoc_insertion_point(field_get:castchannel.CastMessage.payload_type)
  return _internal_payload_type();
}
inline void CastMessage::set_payload_type(::castchannel::CastMessage_PayloadType value) {
  _internal_set_payload_type(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  // @@protoc_insertion_point(field_set:castchannel.CastMessage.payload_type)
}
inline ::castchannel::CastMessage_PayloadType CastMessage::_internal_payload_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::castchannel::CastMessage_PayloadType>(_impl_.payload_type_);
}
inline void CastMessage::_internal_set_payload_type(::castchannel::CastMessage_PayloadType value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::castchannel::CastMessage_PayloadType_internal_data_));
                                          _impl_.payload_type_ = value;
}

// optional string payload_utf8 = 6;
inline bool CastMessage::has_payload_utf8() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void CastMessage::clear_payload_utf8() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.payload_utf8_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000008U);
}
inline const ::std::string& CastMessage::payload_utf8() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:castchannel.CastMessage.payload_utf8)
  return _internal_payload_utf8();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void CastMessage::set_payload_utf8(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  _impl_.payload_utf8_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:castchannel.CastMessage.payload_utf8)
}
inline ::std::string* PROTOBUF_NONNULL CastMessage::mutable_payload_utf8()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::std::string* _s = _internal_mutable_payload_utf8();
  // @@protoc_insertion_point(field_mutable:castchannel.CastMessage.payload_utf8)
  return _s;
}
inline const ::std::string& CastMessage::_internal_payload_utf8() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.payload_utf8_.Get();
}
inline void CastMessage::_internal_set_payload_utf8(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.payload_utf8_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL CastMessage::_internal_mutable_payload_utf8() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.payload_utf8_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE CastMessage::release_payload_utf8() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:castchannel.CastMessage.payload_utf8)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  auto* released = _impl_.payload_utf8_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.payload_utf8_.Set("", GetArena());
  }
  return released;
}
inline void CastMessage::set_allocated_payload_utf8(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }
  _impl_.payload_utf8_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.payload_utf8_.IsDefault()) {
    _impl_.payload_utf8_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:castchannel.CastMessage.payload_utf8)
}

// optional bytes payload_binary = 7;
inline bool CastMessage::has_payload_binary() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  return value;
}
inline void CastMessage::clear_payload_binary() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.payload_binary_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000010U);
}
inline const ::std::string& CastMessage::payload_binary() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:castchannel.CastMessage.payload_binary)
  return _internal_payload_binary();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void CastMessage::set_payload_binary(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  _impl_.payload_binary_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:castchannel.CastMessage.payload_binary)
}
inline ::std::string* PROTOBUF_NONNULL CastMessage::mutable_payload_binary()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::std::string* _s = _internal_mutable_payload_binary();
  // @@protoc_insertion_point(field_mutable:castchannel.CastMessage.payload_binary)
  return _s;
}
inline const ::std::string& CastMessage::_internal_payload_binary() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.payload_binary_.Get();
}
inline void CastMessage::_internal_set_payload_binary(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.payload_binary_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL CastMessage::_internal_mutable_payload_binary() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.payload_binary_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE CastMessage::release_payload_binary() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:castchannel.CastMessage.payload_binary)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000010U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  auto* released = _impl_.payload_binary_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.payload_binary_.Set("", GetArena());
  }
  return released;
}
inline void CastMessage::set_allocated_payload_binary(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }
  _impl_.payload_binary_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.payload_binary_.IsDefault()) {
    _impl_.payload_binary_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:castchannel.CastMessage.payload_binary)
}

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

// AuthChallenge

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

// AuthResponse

// required bytes signature = 1;
inline bool AuthResponse::has_signature() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void AuthResponse::clear_signature() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.signature_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline const ::std::string& AuthResponse::signature() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:castchannel.AuthResponse.signature)
  return _internal_signature();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AuthResponse::set_signature(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.signature_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:castchannel.AuthResponse.signature)
}
inline ::std::string* PROTOBUF_NONNULL AuthResponse::mutable_signature()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_signature();
  // @@protoc_insertion_point(field_mutable:castchannel.AuthResponse.signature)
  return _s;
}
inline const ::std::string& AuthResponse::_internal_signature() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.signature_.Get();
}
inline void AuthResponse::_internal_set_signature(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.signature_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AuthResponse::_internal_mutable_signature() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.signature_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AuthResponse::release_signature() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:castchannel.AuthResponse.signature)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.signature_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.signature_.Set("", GetArena());
  }
  return released;
}
inline void AuthResponse::set_allocated_signature(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.signature_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.signature_.IsDefault()) {
    _impl_.signature_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:castchannel.AuthResponse.signature)
}

// required bytes client_auth_certificate = 2;
inline bool AuthResponse::has_client_auth_certificate() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void AuthResponse::clear_client_auth_certificate() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.client_auth_certificate_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline const ::std::string& AuthResponse::client_auth_certificate() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:castchannel.AuthResponse.client_auth_certificate)
  return _internal_client_auth_certificate();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AuthResponse::set_client_auth_certificate(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.client_auth_certificate_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:castchannel.AuthResponse.client_auth_certificate)
}
inline ::std::string* PROTOBUF_NONNULL AuthResponse::mutable_client_auth_certificate()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_client_auth_certificate();
  // @@protoc_insertion_point(field_mutable:castchannel.AuthResponse.client_auth_certificate)
  return _s;
}
inline const ::std::string& AuthResponse::_internal_client_auth_certificate() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.client_auth_certificate_.Get();
}
inline void AuthResponse::_internal_set_client_auth_certificate(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.client_auth_certificate_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AuthResponse::_internal_mutable_client_auth_certificate() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.client_auth_certificate_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AuthResponse::release_client_auth_certificate() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:castchannel.AuthResponse.client_auth_certificate)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.client_auth_certificate_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.client_auth_certificate_.Set("", GetArena());
  }
  return released;
}
inline void AuthResponse::set_allocated_client_auth_certificate(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.client_auth_certificate_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.client_auth_certificate_.IsDefault()) {
    _impl_.client_auth_certificate_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:castchannel.AuthResponse.client_auth_certificate)
}

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

// AuthError

// required .castchannel.AuthError.ErrorType error_type = 1;
inline bool AuthError::has_error_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void AuthError::clear_error_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.error_type_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline ::castchannel::AuthError_ErrorType AuthError::error_type() const {
  // @@protoc_insertion_point(field_get:castchannel.AuthError.error_type)
  return _internal_error_type();
}
inline void AuthError::set_error_type(::castchannel::AuthError_ErrorType value) {
  _internal_set_error_type(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:castchannel.AuthError.error_type)
}
inline ::castchannel::AuthError_ErrorType AuthError::_internal_error_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::castchannel::AuthError_ErrorType>(_impl_.error_type_);
}
inline void AuthError::_internal_set_error_type(::castchannel::AuthError_ErrorType value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::castchannel::AuthError_ErrorType_internal_data_));
                                          _impl_.error_type_ = value;
}

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

// DeviceAuthMessage

// optional .castchannel.AuthChallenge challenge = 1;
inline bool DeviceAuthMessage::has_challenge() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.challenge_ != nullptr);
  return value;
}
inline void DeviceAuthMessage::clear_challenge() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.challenge_ != nullptr) _impl_.challenge_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline const ::castchannel::AuthChallenge& DeviceAuthMessage::_internal_challenge() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::castchannel::AuthChallenge* p = _impl_.challenge_;
  return p != nullptr ? *p : reinterpret_cast<const ::castchannel::AuthChallenge&>(::castchannel::_AuthChallenge_default_instance_);
}
inline const ::castchannel::AuthChallenge& DeviceAuthMessage::challenge() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:castchannel.DeviceAuthMessage.challenge)
  return _internal_challenge();
}
inline void DeviceAuthMessage::unsafe_arena_set_allocated_challenge(
    ::castchannel::AuthChallenge* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.challenge_);
  }
  _impl_.challenge_ = reinterpret_cast<::castchannel::AuthChallenge*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:castchannel.DeviceAuthMessage.challenge)
}
inline ::castchannel::AuthChallenge* PROTOBUF_NULLABLE DeviceAuthMessage::release_challenge() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::castchannel::AuthChallenge* released = _impl_.challenge_;
  _impl_.challenge_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::castchannel::AuthChallenge* PROTOBUF_NULLABLE DeviceAuthMessage::unsafe_arena_release_challenge() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:castchannel.DeviceAuthMessage.challenge)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::castchannel::AuthChallenge* temp = _impl_.challenge_;
  _impl_.challenge_ = nullptr;
  return temp;
}
inline ::castchannel::AuthChallenge* PROTOBUF_NONNULL DeviceAuthMessage::_internal_mutable_challenge() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.challenge_ == nullptr) {
    auto* p = ::google::protobuf::MessageLite::DefaultConstruct<::castchannel::AuthChallenge>(GetArena());
    _impl_.challenge_ = reinterpret_cast<::castchannel::AuthChallenge*>(p);
  }
  return _impl_.challenge_;
}
inline ::castchannel::AuthChallenge* PROTOBUF_NONNULL DeviceAuthMessage::mutable_challenge()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::castchannel::AuthChallenge* _msg = _internal_mutable_challenge();
  // @@protoc_insertion_point(field_mutable:castchannel.DeviceAuthMessage.challenge)
  return _msg;
}
inline void DeviceAuthMessage::set_allocated_challenge(::castchannel::AuthChallenge* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.challenge_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }

  _impl_.challenge_ = reinterpret_cast<::castchannel::AuthChallenge*>(value);
  // @@protoc_insertion_point(field_set_allocated:castchannel.DeviceAuthMessage.challenge)
}

// optional .castchannel.AuthResponse response = 2;
inline bool DeviceAuthMessage::has_response() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.response_ != nullptr);
  return value;
}
inline void DeviceAuthMessage::clear_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.response_ != nullptr) _impl_.response_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline const ::castchannel::AuthResponse& DeviceAuthMessage::_internal_response() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::castchannel::AuthResponse* p = _impl_.response_;
  return p != nullptr ? *p : reinterpret_cast<const ::castchannel::AuthResponse&>(::castchannel::_AuthResponse_default_instance_);
}
inline const ::castchannel::AuthResponse& DeviceAuthMessage::response() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:castchannel.DeviceAuthMessage.response)
  return _internal_response();
}
inline void DeviceAuthMessage::unsafe_arena_set_allocated_response(
    ::castchannel::AuthResponse* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.response_);
  }
  _impl_.response_ = reinterpret_cast<::castchannel::AuthResponse*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:castchannel.DeviceAuthMessage.response)
}
inline ::castchannel::AuthResponse* PROTOBUF_NULLABLE DeviceAuthMessage::release_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::castchannel::AuthResponse* released = _impl_.response_;
  _impl_.response_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::castchannel::AuthResponse* PROTOBUF_NULLABLE DeviceAuthMessage::unsafe_arena_release_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:castchannel.DeviceAuthMessage.response)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::castchannel::AuthResponse* temp = _impl_.response_;
  _impl_.response_ = nullptr;
  return temp;
}
inline ::castchannel::AuthResponse* PROTOBUF_NONNULL DeviceAuthMessage::_internal_mutable_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.response_ == nullptr) {
    auto* p = ::google::protobuf::MessageLite::DefaultConstruct<::castchannel::AuthResponse>(GetArena());
    _impl_.response_ = reinterpret_cast<::castchannel::AuthResponse*>(p);
  }
  return _impl_.response_;
}
inline ::castchannel::AuthResponse* PROTOBUF_NONNULL DeviceAuthMessage::mutable_response()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::castchannel::AuthResponse* _msg = _internal_mutable_response();
  // @@protoc_insertion_point(field_mutable:castchannel.DeviceAuthMessage.response)
  return _msg;
}
inline void DeviceAuthMessage::set_allocated_response(::castchannel::AuthResponse* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.response_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }

  _impl_.response_ = reinterpret_cast<::castchannel::AuthResponse*>(value);
  // @@protoc_insertion_point(field_set_allocated:castchannel.DeviceAuthMessage.response)
}

// optional .castchannel.AuthError error = 3;
inline bool DeviceAuthMessage::has_error() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.error_ != nullptr);
  return value;
}
inline void DeviceAuthMessage::clear_error() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.error_ != nullptr) _impl_.error_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000004U);
}
inline const ::castchannel::AuthError& DeviceAuthMessage::_internal_error() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::castchannel::AuthError* p = _impl_.error_;
  return p != nullptr ? *p : reinterpret_cast<const ::castchannel::AuthError&>(::castchannel::_AuthError_default_instance_);
}
inline const ::castchannel::AuthError& DeviceAuthMessage::error() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:castchannel.DeviceAuthMessage.error)
  return _internal_error();
}
inline void DeviceAuthMessage::unsafe_arena_set_allocated_error(
    ::castchannel::AuthError* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.error_);
  }
  _impl_.error_ = reinterpret_cast<::castchannel::AuthError*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:castchannel.DeviceAuthMessage.error)
}
inline ::castchannel::AuthError* PROTOBUF_NULLABLE DeviceAuthMessage::release_error() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::castchannel::AuthError* released = _impl_.error_;
  _impl_.error_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::castchannel::AuthError* PROTOBUF_NULLABLE DeviceAuthMessage::unsafe_arena_release_error() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:castchannel.DeviceAuthMessage.error)

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::castchannel::AuthError* temp = _impl_.error_;
  _impl_.error_ = nullptr;
  return temp;
}
inline ::castchannel::AuthError* PROTOBUF_NONNULL DeviceAuthMessage::_internal_mutable_error() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.error_ == nullptr) {
    auto* p = ::google::protobuf::MessageLite::DefaultConstruct<::castchannel::AuthError>(GetArena());
    _impl_.error_ = reinterpret_cast<::castchannel::AuthError*>(p);
  }
  return _impl_.error_;
}
inline ::castchannel::AuthError* PROTOBUF_NONNULL DeviceAuthMessage::mutable_error()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::castchannel::AuthError* _msg = _internal_mutable_error();
  // @@protoc_insertion_point(field_mutable:castchannel.DeviceAuthMessage.error)
  return _msg;
}
inline void DeviceAuthMessage::set_allocated_error(::castchannel::AuthError* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.error_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }

  _impl_.error_ = reinterpret_cast<::castchannel::AuthError*>(value);
  // @@protoc_insertion_point(field_set_allocated:castchannel.DeviceAuthMessage.error)
}

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

// @@protoc_insertion_point(namespace_scope)
}  // namespace castchannel


namespace google {
namespace protobuf {

template <>
struct is_proto_enum<::castchannel::CastMessage_ProtocolVersion> : std::true_type {};
template <>
struct is_proto_enum<::castchannel::CastMessage_PayloadType> : std::true_type {};
template <>
struct is_proto_enum<::castchannel::AuthError_ErrorType> : std::true_type {};

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"
// clang-format on

#endif  // stream_5fout_2fchromecast_2fcast_5fchannel_2eproto_2epb_2eh
