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

#ifndef PROTOBUF_messages_2eproto__INCLUDED
#define PROTOBUF_messages_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 2005000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "common.pb.h"
#include "auth.pb.h"
#include "collection.pb.h"
#include "media.pb.h"
// @@protoc_insertion_point(includes)

namespace Remote {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_messages_2eproto();
void protobuf_AssignDesc_messages_2eproto();
void protobuf_ShutdownFile_messages_2eproto();

class ClientMessage;
class ServerMessage;

enum ClientMessage_Type {
  ClientMessage_Type_AuthRequest = 1,
  ClientMessage_Type_AudioCollectionRequest = 2,
  ClientMessage_Type_MediaRequest = 3
};
bool ClientMessage_Type_IsValid(int value);
const ClientMessage_Type ClientMessage_Type_Type_MIN = ClientMessage_Type_AuthRequest;
const ClientMessage_Type ClientMessage_Type_Type_MAX = ClientMessage_Type_MediaRequest;
const int ClientMessage_Type_Type_ARRAYSIZE = ClientMessage_Type_Type_MAX + 1;

const ::google::protobuf::EnumDescriptor* ClientMessage_Type_descriptor();
inline const ::std::string& ClientMessage_Type_Name(ClientMessage_Type value) {
  return ::google::protobuf::internal::NameOfEnum(
    ClientMessage_Type_descriptor(), value);
}
inline bool ClientMessage_Type_Parse(
    const ::std::string& name, ClientMessage_Type* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ClientMessage_Type>(
    ClientMessage_Type_descriptor(), name, value);
}
enum ServerMessage_Type {
  ServerMessage_Type_AuthResponse = 1,
  ServerMessage_Type_AudioCollectionResponse = 2,
  ServerMessage_Type_MediaResponse = 3
};
bool ServerMessage_Type_IsValid(int value);
const ServerMessage_Type ServerMessage_Type_Type_MIN = ServerMessage_Type_AuthResponse;
const ServerMessage_Type ServerMessage_Type_Type_MAX = ServerMessage_Type_MediaResponse;
const int ServerMessage_Type_Type_ARRAYSIZE = ServerMessage_Type_Type_MAX + 1;

const ::google::protobuf::EnumDescriptor* ServerMessage_Type_descriptor();
inline const ::std::string& ServerMessage_Type_Name(ServerMessage_Type value) {
  return ::google::protobuf::internal::NameOfEnum(
    ServerMessage_Type_descriptor(), value);
}
inline bool ServerMessage_Type_Parse(
    const ::std::string& name, ServerMessage_Type* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ServerMessage_Type>(
    ServerMessage_Type_descriptor(), name, value);
}
// ===================================================================

class ClientMessage : public ::google::protobuf::Message {
 public:
  ClientMessage();
  virtual ~ClientMessage();

  ClientMessage(const ClientMessage& from);

  inline ClientMessage& operator=(const ClientMessage& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ClientMessage& default_instance();

  void Swap(ClientMessage* other);

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

  ClientMessage* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ClientMessage& from);
  void MergeFrom(const ClientMessage& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

  typedef ClientMessage_Type Type;
  static const Type AuthRequest = ClientMessage_Type_AuthRequest;
  static const Type AudioCollectionRequest = ClientMessage_Type_AudioCollectionRequest;
  static const Type MediaRequest = ClientMessage_Type_MediaRequest;
  static inline bool Type_IsValid(int value) {
    return ClientMessage_Type_IsValid(value);
  }
  static const Type Type_MIN =
    ClientMessage_Type_Type_MIN;
  static const Type Type_MAX =
    ClientMessage_Type_Type_MAX;
  static const int Type_ARRAYSIZE =
    ClientMessage_Type_Type_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Type_descriptor() {
    return ClientMessage_Type_descriptor();
  }
  static inline const ::std::string& Type_Name(Type value) {
    return ClientMessage_Type_Name(value);
  }
  static inline bool Type_Parse(const ::std::string& name,
      Type* value) {
    return ClientMessage_Type_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // required .Remote.ClientMessage.Type type = 1;
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 1;
  inline ::Remote::ClientMessage_Type type() const;
  inline void set_type(::Remote::ClientMessage_Type value);

  // optional .Remote.AuthRequest auth_request = 2;
  inline bool has_auth_request() const;
  inline void clear_auth_request();
  static const int kAuthRequestFieldNumber = 2;
  inline const ::Remote::AuthRequest& auth_request() const;
  inline ::Remote::AuthRequest* mutable_auth_request();
  inline ::Remote::AuthRequest* release_auth_request();
  inline void set_allocated_auth_request(::Remote::AuthRequest* auth_request);

  // optional .Remote.AudioCollectionRequest audio_collection_request = 3;
  inline bool has_audio_collection_request() const;
  inline void clear_audio_collection_request();
  static const int kAudioCollectionRequestFieldNumber = 3;
  inline const ::Remote::AudioCollectionRequest& audio_collection_request() const;
  inline ::Remote::AudioCollectionRequest* mutable_audio_collection_request();
  inline ::Remote::AudioCollectionRequest* release_audio_collection_request();
  inline void set_allocated_audio_collection_request(::Remote::AudioCollectionRequest* audio_collection_request);

  // optional .Remote.MediaRequest media_request = 4;
  inline bool has_media_request() const;
  inline void clear_media_request();
  static const int kMediaRequestFieldNumber = 4;
  inline const ::Remote::MediaRequest& media_request() const;
  inline ::Remote::MediaRequest* mutable_media_request();
  inline ::Remote::MediaRequest* release_media_request();
  inline void set_allocated_media_request(::Remote::MediaRequest* media_request);

  // @@protoc_insertion_point(class_scope:Remote.ClientMessage)
 private:
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_auth_request();
  inline void clear_has_auth_request();
  inline void set_has_audio_collection_request();
  inline void clear_has_audio_collection_request();
  inline void set_has_media_request();
  inline void clear_has_media_request();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::Remote::AuthRequest* auth_request_;
  ::Remote::AudioCollectionRequest* audio_collection_request_;
  ::Remote::MediaRequest* media_request_;
  int type_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  friend void  protobuf_AddDesc_messages_2eproto();
  friend void protobuf_AssignDesc_messages_2eproto();
  friend void protobuf_ShutdownFile_messages_2eproto();

  void InitAsDefaultInstance();
  static ClientMessage* default_instance_;
};
// -------------------------------------------------------------------

class ServerMessage : public ::google::protobuf::Message {
 public:
  ServerMessage();
  virtual ~ServerMessage();

  ServerMessage(const ServerMessage& from);

  inline ServerMessage& operator=(const ServerMessage& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ServerMessage& default_instance();

  void Swap(ServerMessage* other);

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

  ServerMessage* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ServerMessage& from);
  void MergeFrom(const ServerMessage& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

  typedef ServerMessage_Type Type;
  static const Type AuthResponse = ServerMessage_Type_AuthResponse;
  static const Type AudioCollectionResponse = ServerMessage_Type_AudioCollectionResponse;
  static const Type MediaResponse = ServerMessage_Type_MediaResponse;
  static inline bool Type_IsValid(int value) {
    return ServerMessage_Type_IsValid(value);
  }
  static const Type Type_MIN =
    ServerMessage_Type_Type_MIN;
  static const Type Type_MAX =
    ServerMessage_Type_Type_MAX;
  static const int Type_ARRAYSIZE =
    ServerMessage_Type_Type_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Type_descriptor() {
    return ServerMessage_Type_descriptor();
  }
  static inline const ::std::string& Type_Name(Type value) {
    return ServerMessage_Type_Name(value);
  }
  static inline bool Type_Parse(const ::std::string& name,
      Type* value) {
    return ServerMessage_Type_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // required .Remote.ServerMessage.Type type = 1;
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 1;
  inline ::Remote::ServerMessage_Type type() const;
  inline void set_type(::Remote::ServerMessage_Type value);

  // optional .Remote.AuthResponse auth_response = 2;
  inline bool has_auth_response() const;
  inline void clear_auth_response();
  static const int kAuthResponseFieldNumber = 2;
  inline const ::Remote::AuthResponse& auth_response() const;
  inline ::Remote::AuthResponse* mutable_auth_response();
  inline ::Remote::AuthResponse* release_auth_response();
  inline void set_allocated_auth_response(::Remote::AuthResponse* auth_response);

  // optional .Remote.AudioCollectionResponse audio_collection_response = 3;
  inline bool has_audio_collection_response() const;
  inline void clear_audio_collection_response();
  static const int kAudioCollectionResponseFieldNumber = 3;
  inline const ::Remote::AudioCollectionResponse& audio_collection_response() const;
  inline ::Remote::AudioCollectionResponse* mutable_audio_collection_response();
  inline ::Remote::AudioCollectionResponse* release_audio_collection_response();
  inline void set_allocated_audio_collection_response(::Remote::AudioCollectionResponse* audio_collection_response);

  // optional .Remote.MediaResponse media_response = 4;
  inline bool has_media_response() const;
  inline void clear_media_response();
  static const int kMediaResponseFieldNumber = 4;
  inline const ::Remote::MediaResponse& media_response() const;
  inline ::Remote::MediaResponse* mutable_media_response();
  inline ::Remote::MediaResponse* release_media_response();
  inline void set_allocated_media_response(::Remote::MediaResponse* media_response);

  // @@protoc_insertion_point(class_scope:Remote.ServerMessage)
 private:
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_auth_response();
  inline void clear_has_auth_response();
  inline void set_has_audio_collection_response();
  inline void clear_has_audio_collection_response();
  inline void set_has_media_response();
  inline void clear_has_media_response();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::Remote::AuthResponse* auth_response_;
  ::Remote::AudioCollectionResponse* audio_collection_response_;
  ::Remote::MediaResponse* media_response_;
  int type_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  friend void  protobuf_AddDesc_messages_2eproto();
  friend void protobuf_AssignDesc_messages_2eproto();
  friend void protobuf_ShutdownFile_messages_2eproto();

  void InitAsDefaultInstance();
  static ServerMessage* default_instance_;
};
// ===================================================================


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

// ClientMessage

// required .Remote.ClientMessage.Type type = 1;
inline bool ClientMessage::has_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ClientMessage::set_has_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ClientMessage::clear_has_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ClientMessage::clear_type() {
  type_ = 1;
  clear_has_type();
}
inline ::Remote::ClientMessage_Type ClientMessage::type() const {
  return static_cast< ::Remote::ClientMessage_Type >(type_);
}
inline void ClientMessage::set_type(::Remote::ClientMessage_Type value) {
  assert(::Remote::ClientMessage_Type_IsValid(value));
  set_has_type();
  type_ = value;
}

// optional .Remote.AuthRequest auth_request = 2;
inline bool ClientMessage::has_auth_request() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ClientMessage::set_has_auth_request() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ClientMessage::clear_has_auth_request() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ClientMessage::clear_auth_request() {
  if (auth_request_ != NULL) auth_request_->::Remote::AuthRequest::Clear();
  clear_has_auth_request();
}
inline const ::Remote::AuthRequest& ClientMessage::auth_request() const {
  return auth_request_ != NULL ? *auth_request_ : *default_instance_->auth_request_;
}
inline ::Remote::AuthRequest* ClientMessage::mutable_auth_request() {
  set_has_auth_request();
  if (auth_request_ == NULL) auth_request_ = new ::Remote::AuthRequest;
  return auth_request_;
}
inline ::Remote::AuthRequest* ClientMessage::release_auth_request() {
  clear_has_auth_request();
  ::Remote::AuthRequest* temp = auth_request_;
  auth_request_ = NULL;
  return temp;
}
inline void ClientMessage::set_allocated_auth_request(::Remote::AuthRequest* auth_request) {
  delete auth_request_;
  auth_request_ = auth_request;
  if (auth_request) {
    set_has_auth_request();
  } else {
    clear_has_auth_request();
  }
}

// optional .Remote.AudioCollectionRequest audio_collection_request = 3;
inline bool ClientMessage::has_audio_collection_request() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ClientMessage::set_has_audio_collection_request() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ClientMessage::clear_has_audio_collection_request() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ClientMessage::clear_audio_collection_request() {
  if (audio_collection_request_ != NULL) audio_collection_request_->::Remote::AudioCollectionRequest::Clear();
  clear_has_audio_collection_request();
}
inline const ::Remote::AudioCollectionRequest& ClientMessage::audio_collection_request() const {
  return audio_collection_request_ != NULL ? *audio_collection_request_ : *default_instance_->audio_collection_request_;
}
inline ::Remote::AudioCollectionRequest* ClientMessage::mutable_audio_collection_request() {
  set_has_audio_collection_request();
  if (audio_collection_request_ == NULL) audio_collection_request_ = new ::Remote::AudioCollectionRequest;
  return audio_collection_request_;
}
inline ::Remote::AudioCollectionRequest* ClientMessage::release_audio_collection_request() {
  clear_has_audio_collection_request();
  ::Remote::AudioCollectionRequest* temp = audio_collection_request_;
  audio_collection_request_ = NULL;
  return temp;
}
inline void ClientMessage::set_allocated_audio_collection_request(::Remote::AudioCollectionRequest* audio_collection_request) {
  delete audio_collection_request_;
  audio_collection_request_ = audio_collection_request;
  if (audio_collection_request) {
    set_has_audio_collection_request();
  } else {
    clear_has_audio_collection_request();
  }
}

// optional .Remote.MediaRequest media_request = 4;
inline bool ClientMessage::has_media_request() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ClientMessage::set_has_media_request() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ClientMessage::clear_has_media_request() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ClientMessage::clear_media_request() {
  if (media_request_ != NULL) media_request_->::Remote::MediaRequest::Clear();
  clear_has_media_request();
}
inline const ::Remote::MediaRequest& ClientMessage::media_request() const {
  return media_request_ != NULL ? *media_request_ : *default_instance_->media_request_;
}
inline ::Remote::MediaRequest* ClientMessage::mutable_media_request() {
  set_has_media_request();
  if (media_request_ == NULL) media_request_ = new ::Remote::MediaRequest;
  return media_request_;
}
inline ::Remote::MediaRequest* ClientMessage::release_media_request() {
  clear_has_media_request();
  ::Remote::MediaRequest* temp = media_request_;
  media_request_ = NULL;
  return temp;
}
inline void ClientMessage::set_allocated_media_request(::Remote::MediaRequest* media_request) {
  delete media_request_;
  media_request_ = media_request;
  if (media_request) {
    set_has_media_request();
  } else {
    clear_has_media_request();
  }
}

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

// ServerMessage

// required .Remote.ServerMessage.Type type = 1;
inline bool ServerMessage::has_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ServerMessage::set_has_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ServerMessage::clear_has_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ServerMessage::clear_type() {
  type_ = 1;
  clear_has_type();
}
inline ::Remote::ServerMessage_Type ServerMessage::type() const {
  return static_cast< ::Remote::ServerMessage_Type >(type_);
}
inline void ServerMessage::set_type(::Remote::ServerMessage_Type value) {
  assert(::Remote::ServerMessage_Type_IsValid(value));
  set_has_type();
  type_ = value;
}

// optional .Remote.AuthResponse auth_response = 2;
inline bool ServerMessage::has_auth_response() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ServerMessage::set_has_auth_response() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ServerMessage::clear_has_auth_response() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ServerMessage::clear_auth_response() {
  if (auth_response_ != NULL) auth_response_->::Remote::AuthResponse::Clear();
  clear_has_auth_response();
}
inline const ::Remote::AuthResponse& ServerMessage::auth_response() const {
  return auth_response_ != NULL ? *auth_response_ : *default_instance_->auth_response_;
}
inline ::Remote::AuthResponse* ServerMessage::mutable_auth_response() {
  set_has_auth_response();
  if (auth_response_ == NULL) auth_response_ = new ::Remote::AuthResponse;
  return auth_response_;
}
inline ::Remote::AuthResponse* ServerMessage::release_auth_response() {
  clear_has_auth_response();
  ::Remote::AuthResponse* temp = auth_response_;
  auth_response_ = NULL;
  return temp;
}
inline void ServerMessage::set_allocated_auth_response(::Remote::AuthResponse* auth_response) {
  delete auth_response_;
  auth_response_ = auth_response;
  if (auth_response) {
    set_has_auth_response();
  } else {
    clear_has_auth_response();
  }
}

// optional .Remote.AudioCollectionResponse audio_collection_response = 3;
inline bool ServerMessage::has_audio_collection_response() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ServerMessage::set_has_audio_collection_response() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ServerMessage::clear_has_audio_collection_response() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ServerMessage::clear_audio_collection_response() {
  if (audio_collection_response_ != NULL) audio_collection_response_->::Remote::AudioCollectionResponse::Clear();
  clear_has_audio_collection_response();
}
inline const ::Remote::AudioCollectionResponse& ServerMessage::audio_collection_response() const {
  return audio_collection_response_ != NULL ? *audio_collection_response_ : *default_instance_->audio_collection_response_;
}
inline ::Remote::AudioCollectionResponse* ServerMessage::mutable_audio_collection_response() {
  set_has_audio_collection_response();
  if (audio_collection_response_ == NULL) audio_collection_response_ = new ::Remote::AudioCollectionResponse;
  return audio_collection_response_;
}
inline ::Remote::AudioCollectionResponse* ServerMessage::release_audio_collection_response() {
  clear_has_audio_collection_response();
  ::Remote::AudioCollectionResponse* temp = audio_collection_response_;
  audio_collection_response_ = NULL;
  return temp;
}
inline void ServerMessage::set_allocated_audio_collection_response(::Remote::AudioCollectionResponse* audio_collection_response) {
  delete audio_collection_response_;
  audio_collection_response_ = audio_collection_response;
  if (audio_collection_response) {
    set_has_audio_collection_response();
  } else {
    clear_has_audio_collection_response();
  }
}

// optional .Remote.MediaResponse media_response = 4;
inline bool ServerMessage::has_media_response() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ServerMessage::set_has_media_response() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ServerMessage::clear_has_media_response() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ServerMessage::clear_media_response() {
  if (media_response_ != NULL) media_response_->::Remote::MediaResponse::Clear();
  clear_has_media_response();
}
inline const ::Remote::MediaResponse& ServerMessage::media_response() const {
  return media_response_ != NULL ? *media_response_ : *default_instance_->media_response_;
}
inline ::Remote::MediaResponse* ServerMessage::mutable_media_response() {
  set_has_media_response();
  if (media_response_ == NULL) media_response_ = new ::Remote::MediaResponse;
  return media_response_;
}
inline ::Remote::MediaResponse* ServerMessage::release_media_response() {
  clear_has_media_response();
  ::Remote::MediaResponse* temp = media_response_;
  media_response_ = NULL;
  return temp;
}
inline void ServerMessage::set_allocated_media_response(::Remote::MediaResponse* media_response) {
  delete media_response_;
  media_response_ = media_response;
  if (media_response) {
    set_has_media_response();
  } else {
    clear_has_media_response();
  }
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace Remote

#ifndef SWIG
namespace google {
namespace protobuf {

template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Remote::ClientMessage_Type>() {
  return ::Remote::ClientMessage_Type_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Remote::ServerMessage_Type>() {
  return ::Remote::ServerMessage_Type_descriptor();
}

}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_messages_2eproto__INCLUDED