// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: google/rpc/error_details.proto

#ifndef PROTOBUF_INCLUDED_google_2frpc_2ferror_5fdetails_2eproto
#define PROTOBUF_INCLUDED_google_2frpc_2ferror_5fdetails_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3007000
#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 3007001 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
#include <google/protobuf/duration.pb.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_google_2frpc_2ferror_5fdetails_2eproto

// Internal implementation detail -- do not use these members.
struct TableStruct_google_2frpc_2ferror_5fdetails_2eproto {
  static const ::google::protobuf::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::google::protobuf::internal::ParseTable schema[13]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors_google_2frpc_2ferror_5fdetails_2eproto();
namespace google {
namespace rpc {
class BadRequest;
class BadRequestDefaultTypeInternal;
extern BadRequestDefaultTypeInternal _BadRequest_default_instance_;
class BadRequest_FieldViolation;
class BadRequest_FieldViolationDefaultTypeInternal;
extern BadRequest_FieldViolationDefaultTypeInternal _BadRequest_FieldViolation_default_instance_;
class DebugInfo;
class DebugInfoDefaultTypeInternal;
extern DebugInfoDefaultTypeInternal _DebugInfo_default_instance_;
class Help;
class HelpDefaultTypeInternal;
extern HelpDefaultTypeInternal _Help_default_instance_;
class Help_Link;
class Help_LinkDefaultTypeInternal;
extern Help_LinkDefaultTypeInternal _Help_Link_default_instance_;
class LocalizedMessage;
class LocalizedMessageDefaultTypeInternal;
extern LocalizedMessageDefaultTypeInternal _LocalizedMessage_default_instance_;
class PreconditionFailure;
class PreconditionFailureDefaultTypeInternal;
extern PreconditionFailureDefaultTypeInternal _PreconditionFailure_default_instance_;
class PreconditionFailure_Violation;
class PreconditionFailure_ViolationDefaultTypeInternal;
extern PreconditionFailure_ViolationDefaultTypeInternal _PreconditionFailure_Violation_default_instance_;
class QuotaFailure;
class QuotaFailureDefaultTypeInternal;
extern QuotaFailureDefaultTypeInternal _QuotaFailure_default_instance_;
class QuotaFailure_Violation;
class QuotaFailure_ViolationDefaultTypeInternal;
extern QuotaFailure_ViolationDefaultTypeInternal _QuotaFailure_Violation_default_instance_;
class RequestInfo;
class RequestInfoDefaultTypeInternal;
extern RequestInfoDefaultTypeInternal _RequestInfo_default_instance_;
class ResourceInfo;
class ResourceInfoDefaultTypeInternal;
extern ResourceInfoDefaultTypeInternal _ResourceInfo_default_instance_;
class RetryInfo;
class RetryInfoDefaultTypeInternal;
extern RetryInfoDefaultTypeInternal _RetryInfo_default_instance_;
}  // namespace rpc
namespace protobuf {
template<> ::google::rpc::BadRequest* Arena::CreateMaybeMessage<::google::rpc::BadRequest>(Arena*);
template<> ::google::rpc::BadRequest_FieldViolation* Arena::CreateMaybeMessage<::google::rpc::BadRequest_FieldViolation>(Arena*);
template<> ::google::rpc::DebugInfo* Arena::CreateMaybeMessage<::google::rpc::DebugInfo>(Arena*);
template<> ::google::rpc::Help* Arena::CreateMaybeMessage<::google::rpc::Help>(Arena*);
template<> ::google::rpc::Help_Link* Arena::CreateMaybeMessage<::google::rpc::Help_Link>(Arena*);
template<> ::google::rpc::LocalizedMessage* Arena::CreateMaybeMessage<::google::rpc::LocalizedMessage>(Arena*);
template<> ::google::rpc::PreconditionFailure* Arena::CreateMaybeMessage<::google::rpc::PreconditionFailure>(Arena*);
template<> ::google::rpc::PreconditionFailure_Violation* Arena::CreateMaybeMessage<::google::rpc::PreconditionFailure_Violation>(Arena*);
template<> ::google::rpc::QuotaFailure* Arena::CreateMaybeMessage<::google::rpc::QuotaFailure>(Arena*);
template<> ::google::rpc::QuotaFailure_Violation* Arena::CreateMaybeMessage<::google::rpc::QuotaFailure_Violation>(Arena*);
template<> ::google::rpc::RequestInfo* Arena::CreateMaybeMessage<::google::rpc::RequestInfo>(Arena*);
template<> ::google::rpc::ResourceInfo* Arena::CreateMaybeMessage<::google::rpc::ResourceInfo>(Arena*);
template<> ::google::rpc::RetryInfo* Arena::CreateMaybeMessage<::google::rpc::RetryInfo>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace google {
namespace rpc {

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

class RetryInfo :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.rpc.RetryInfo) */ {
 public:
  RetryInfo();
  virtual ~RetryInfo();

  RetryInfo(const RetryInfo& from);

  inline RetryInfo& operator=(const RetryInfo& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RetryInfo(RetryInfo&& from) noexcept
    : RetryInfo() {
    *this = ::std::move(from);
  }

  inline RetryInfo& operator=(RetryInfo&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const RetryInfo& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RetryInfo* internal_default_instance() {
    return reinterpret_cast<const RetryInfo*>(
               &_RetryInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  void Swap(RetryInfo* other);
  friend void swap(RetryInfo& a, RetryInfo& b) {
    a.Swap(&b);
  }

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

  inline RetryInfo* New() const final {
    return CreateMaybeMessage<RetryInfo>(nullptr);
  }

  RetryInfo* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RetryInfo>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RetryInfo& from);
  void MergeFrom(const RetryInfo& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RetryInfo* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

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

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

  // .google.protobuf.Duration retry_delay = 1;
  bool has_retry_delay() const;
  void clear_retry_delay();
  static const int kRetryDelayFieldNumber = 1;
  const ::google::protobuf::Duration& retry_delay() const;
  ::google::protobuf::Duration* release_retry_delay();
  ::google::protobuf::Duration* mutable_retry_delay();
  void set_allocated_retry_delay(::google::protobuf::Duration* retry_delay);

  // @@protoc_insertion_point(class_scope:google.rpc.RetryInfo)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::Duration* retry_delay_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_google_2frpc_2ferror_5fdetails_2eproto;
};
// -------------------------------------------------------------------

class DebugInfo :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.rpc.DebugInfo) */ {
 public:
  DebugInfo();
  virtual ~DebugInfo();

  DebugInfo(const DebugInfo& from);

  inline DebugInfo& operator=(const DebugInfo& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  DebugInfo(DebugInfo&& from) noexcept
    : DebugInfo() {
    *this = ::std::move(from);
  }

  inline DebugInfo& operator=(DebugInfo&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const DebugInfo& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const DebugInfo* internal_default_instance() {
    return reinterpret_cast<const DebugInfo*>(
               &_DebugInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  void Swap(DebugInfo* other);
  friend void swap(DebugInfo& a, DebugInfo& b) {
    a.Swap(&b);
  }

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

  inline DebugInfo* New() const final {
    return CreateMaybeMessage<DebugInfo>(nullptr);
  }

  DebugInfo* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<DebugInfo>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const DebugInfo& from);
  void MergeFrom(const DebugInfo& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DebugInfo* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

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

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

  // repeated string stack_entries = 1;
  int stack_entries_size() const;
  void clear_stack_entries();
  static const int kStackEntriesFieldNumber = 1;
  const ::std::string& stack_entries(int index) const;
  ::std::string* mutable_stack_entries(int index);
  void set_stack_entries(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_stack_entries(int index, ::std::string&& value);
  #endif
  void set_stack_entries(int index, const char* value);
  void set_stack_entries(int index, const char* value, size_t size);
  ::std::string* add_stack_entries();
  void add_stack_entries(const ::std::string& value);
  #if LANG_CXX11
  void add_stack_entries(::std::string&& value);
  #endif
  void add_stack_entries(const char* value);
  void add_stack_entries(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField<::std::string>& stack_entries() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* mutable_stack_entries();

  // string detail = 2;
  void clear_detail();
  static const int kDetailFieldNumber = 2;
  const ::std::string& detail() const;
  void set_detail(const ::std::string& value);
  #if LANG_CXX11
  void set_detail(::std::string&& value);
  #endif
  void set_detail(const char* value);
  void set_detail(const char* value, size_t size);
  ::std::string* mutable_detail();
  ::std::string* release_detail();
  void set_allocated_detail(::std::string* detail);

  // @@protoc_insertion_point(class_scope:google.rpc.DebugInfo)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField<::std::string> stack_entries_;
  ::google::protobuf::internal::ArenaStringPtr detail_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_google_2frpc_2ferror_5fdetails_2eproto;
};
// -------------------------------------------------------------------

class QuotaFailure_Violation :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.rpc.QuotaFailure.Violation) */ {
 public:
  QuotaFailure_Violation();
  virtual ~QuotaFailure_Violation();

  QuotaFailure_Violation(const QuotaFailure_Violation& from);

  inline QuotaFailure_Violation& operator=(const QuotaFailure_Violation& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  QuotaFailure_Violation(QuotaFailure_Violation&& from) noexcept
    : QuotaFailure_Violation() {
    *this = ::std::move(from);
  }

  inline QuotaFailure_Violation& operator=(QuotaFailure_Violation&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const QuotaFailure_Violation& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const QuotaFailure_Violation* internal_default_instance() {
    return reinterpret_cast<const QuotaFailure_Violation*>(
               &_QuotaFailure_Violation_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  void Swap(QuotaFailure_Violation* other);
  friend void swap(QuotaFailure_Violation& a, QuotaFailure_Violation& b) {
    a.Swap(&b);
  }

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

  inline QuotaFailure_Violation* New() const final {
    return CreateMaybeMessage<QuotaFailure_Violation>(nullptr);
  }

  QuotaFailure_Violation* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<QuotaFailure_Violation>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const QuotaFailure_Violation& from);
  void MergeFrom(const QuotaFailure_Violation& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(QuotaFailure_Violation* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

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

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

  // string subject = 1;
  void clear_subject();
  static const int kSubjectFieldNumber = 1;
  const ::std::string& subject() const;
  void set_subject(const ::std::string& value);
  #if LANG_CXX11
  void set_subject(::std::string&& value);
  #endif
  void set_subject(const char* value);
  void set_subject(const char* value, size_t size);
  ::std::string* mutable_subject();
  ::std::string* release_subject();
  void set_allocated_subject(::std::string* subject);

  // string description = 2;
  void clear_description();
  static const int kDescriptionFieldNumber = 2;
  const ::std::string& description() const;
  void set_description(const ::std::string& value);
  #if LANG_CXX11
  void set_description(::std::string&& value);
  #endif
  void set_description(const char* value);
  void set_description(const char* value, size_t size);
  ::std::string* mutable_description();
  ::std::string* release_description();
  void set_allocated_description(::std::string* description);

  // @@protoc_insertion_point(class_scope:google.rpc.QuotaFailure.Violation)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr subject_;
  ::google::protobuf::internal::ArenaStringPtr description_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_google_2frpc_2ferror_5fdetails_2eproto;
};
// -------------------------------------------------------------------

class QuotaFailure :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.rpc.QuotaFailure) */ {
 public:
  QuotaFailure();
  virtual ~QuotaFailure();

  QuotaFailure(const QuotaFailure& from);

  inline QuotaFailure& operator=(const QuotaFailure& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  QuotaFailure(QuotaFailure&& from) noexcept
    : QuotaFailure() {
    *this = ::std::move(from);
  }

  inline QuotaFailure& operator=(QuotaFailure&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const QuotaFailure& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const QuotaFailure* internal_default_instance() {
    return reinterpret_cast<const QuotaFailure*>(
               &_QuotaFailure_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  void Swap(QuotaFailure* other);
  friend void swap(QuotaFailure& a, QuotaFailure& b) {
    a.Swap(&b);
  }

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

  inline QuotaFailure* New() const final {
    return CreateMaybeMessage<QuotaFailure>(nullptr);
  }

  QuotaFailure* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<QuotaFailure>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const QuotaFailure& from);
  void MergeFrom(const QuotaFailure& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(QuotaFailure* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

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

  typedef QuotaFailure_Violation Violation;

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

  // repeated .google.rpc.QuotaFailure.Violation violations = 1;
  int violations_size() const;
  void clear_violations();
  static const int kViolationsFieldNumber = 1;
  ::google::rpc::QuotaFailure_Violation* mutable_violations(int index);
  ::google::protobuf::RepeatedPtrField< ::google::rpc::QuotaFailure_Violation >*
      mutable_violations();
  const ::google::rpc::QuotaFailure_Violation& violations(int index) const;
  ::google::rpc::QuotaFailure_Violation* add_violations();
  const ::google::protobuf::RepeatedPtrField< ::google::rpc::QuotaFailure_Violation >&
      violations() const;

  // @@protoc_insertion_point(class_scope:google.rpc.QuotaFailure)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::google::rpc::QuotaFailure_Violation > violations_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_google_2frpc_2ferror_5fdetails_2eproto;
};
// -------------------------------------------------------------------

class PreconditionFailure_Violation :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.rpc.PreconditionFailure.Violation) */ {
 public:
  PreconditionFailure_Violation();
  virtual ~PreconditionFailure_Violation();

  PreconditionFailure_Violation(const PreconditionFailure_Violation& from);

  inline PreconditionFailure_Violation& operator=(const PreconditionFailure_Violation& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  PreconditionFailure_Violation(PreconditionFailure_Violation&& from) noexcept
    : PreconditionFailure_Violation() {
    *this = ::std::move(from);
  }

  inline PreconditionFailure_Violation& operator=(PreconditionFailure_Violation&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const PreconditionFailure_Violation& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PreconditionFailure_Violation* internal_default_instance() {
    return reinterpret_cast<const PreconditionFailure_Violation*>(
               &_PreconditionFailure_Violation_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  void Swap(PreconditionFailure_Violation* other);
  friend void swap(PreconditionFailure_Violation& a, PreconditionFailure_Violation& b) {
    a.Swap(&b);
  }

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

  inline PreconditionFailure_Violation* New() const final {
    return CreateMaybeMessage<PreconditionFailure_Violation>(nullptr);
  }

  PreconditionFailure_Violation* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<PreconditionFailure_Violation>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const PreconditionFailure_Violation& from);
  void MergeFrom(const PreconditionFailure_Violation& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PreconditionFailure_Violation* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

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

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

  // string type = 1;
  void clear_type();
  static const int kTypeFieldNumber = 1;
  const ::std::string& type() const;
  void set_type(const ::std::string& value);
  #if LANG_CXX11
  void set_type(::std::string&& value);
  #endif
  void set_type(const char* value);
  void set_type(const char* value, size_t size);
  ::std::string* mutable_type();
  ::std::string* release_type();
  void set_allocated_type(::std::string* type);

  // string subject = 2;
  void clear_subject();
  static const int kSubjectFieldNumber = 2;
  const ::std::string& subject() const;
  void set_subject(const ::std::string& value);
  #if LANG_CXX11
  void set_subject(::std::string&& value);
  #endif
  void set_subject(const char* value);
  void set_subject(const char* value, size_t size);
  ::std::string* mutable_subject();
  ::std::string* release_subject();
  void set_allocated_subject(::std::string* subject);

  // string description = 3;
  void clear_description();
  static const int kDescriptionFieldNumber = 3;
  const ::std::string& description() const;
  void set_description(const ::std::string& value);
  #if LANG_CXX11
  void set_description(::std::string&& value);
  #endif
  void set_description(const char* value);
  void set_description(const char* value, size_t size);
  ::std::string* mutable_description();
  ::std::string* release_description();
  void set_allocated_description(::std::string* description);

  // @@protoc_insertion_point(class_scope:google.rpc.PreconditionFailure.Violation)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr type_;
  ::google::protobuf::internal::ArenaStringPtr subject_;
  ::google::protobuf::internal::ArenaStringPtr description_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_google_2frpc_2ferror_5fdetails_2eproto;
};
// -------------------------------------------------------------------

class PreconditionFailure :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.rpc.PreconditionFailure) */ {
 public:
  PreconditionFailure();
  virtual ~PreconditionFailure();

  PreconditionFailure(const PreconditionFailure& from);

  inline PreconditionFailure& operator=(const PreconditionFailure& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  PreconditionFailure(PreconditionFailure&& from) noexcept
    : PreconditionFailure() {
    *this = ::std::move(from);
  }

  inline PreconditionFailure& operator=(PreconditionFailure&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const PreconditionFailure& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PreconditionFailure* internal_default_instance() {
    return reinterpret_cast<const PreconditionFailure*>(
               &_PreconditionFailure_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  void Swap(PreconditionFailure* other);
  friend void swap(PreconditionFailure& a, PreconditionFailure& b) {
    a.Swap(&b);
  }

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

  inline PreconditionFailure* New() const final {
    return CreateMaybeMessage<PreconditionFailure>(nullptr);
  }

  PreconditionFailure* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<PreconditionFailure>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const PreconditionFailure& from);
  void MergeFrom(const PreconditionFailure& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PreconditionFailure* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

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

  typedef PreconditionFailure_Violation Violation;

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

  // repeated .google.rpc.PreconditionFailure.Violation violations = 1;
  int violations_size() const;
  void clear_violations();
  static const int kViolationsFieldNumber = 1;
  ::google::rpc::PreconditionFailure_Violation* mutable_violations(int index);
  ::google::protobuf::RepeatedPtrField< ::google::rpc::PreconditionFailure_Violation >*
      mutable_violations();
  const ::google::rpc::PreconditionFailure_Violation& violations(int index) const;
  ::google::rpc::PreconditionFailure_Violation* add_violations();
  const ::google::protobuf::RepeatedPtrField< ::google::rpc::PreconditionFailure_Violation >&
      violations() const;

  // @@protoc_insertion_point(class_scope:google.rpc.PreconditionFailure)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::google::rpc::PreconditionFailure_Violation > violations_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_google_2frpc_2ferror_5fdetails_2eproto;
};
// -------------------------------------------------------------------

class BadRequest_FieldViolation :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.rpc.BadRequest.FieldViolation) */ {
 public:
  BadRequest_FieldViolation();
  virtual ~BadRequest_FieldViolation();

  BadRequest_FieldViolation(const BadRequest_FieldViolation& from);

  inline BadRequest_FieldViolation& operator=(const BadRequest_FieldViolation& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  BadRequest_FieldViolation(BadRequest_FieldViolation&& from) noexcept
    : BadRequest_FieldViolation() {
    *this = ::std::move(from);
  }

  inline BadRequest_FieldViolation& operator=(BadRequest_FieldViolation&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const BadRequest_FieldViolation& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BadRequest_FieldViolation* internal_default_instance() {
    return reinterpret_cast<const BadRequest_FieldViolation*>(
               &_BadRequest_FieldViolation_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  void Swap(BadRequest_FieldViolation* other);
  friend void swap(BadRequest_FieldViolation& a, BadRequest_FieldViolation& b) {
    a.Swap(&b);
  }

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

  inline BadRequest_FieldViolation* New() const final {
    return CreateMaybeMessage<BadRequest_FieldViolation>(nullptr);
  }

  BadRequest_FieldViolation* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<BadRequest_FieldViolation>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const BadRequest_FieldViolation& from);
  void MergeFrom(const BadRequest_FieldViolation& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BadRequest_FieldViolation* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

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

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

  // string field = 1;
  void clear_field();
  static const int kFieldFieldNumber = 1;
  const ::std::string& field() const;
  void set_field(const ::std::string& value);
  #if LANG_CXX11
  void set_field(::std::string&& value);
  #endif
  void set_field(const char* value);
  void set_field(const char* value, size_t size);
  ::std::string* mutable_field();
  ::std::string* release_field();
  void set_allocated_field(::std::string* field);

  // string description = 2;
  void clear_description();
  static const int kDescriptionFieldNumber = 2;
  const ::std::string& description() const;
  void set_description(const ::std::string& value);
  #if LANG_CXX11
  void set_description(::std::string&& value);
  #endif
  void set_description(const char* value);
  void set_description(const char* value, size_t size);
  ::std::string* mutable_description();
  ::std::string* release_description();
  void set_allocated_description(::std::string* description);

  // @@protoc_insertion_point(class_scope:google.rpc.BadRequest.FieldViolation)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr field_;
  ::google::protobuf::internal::ArenaStringPtr description_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_google_2frpc_2ferror_5fdetails_2eproto;
};
// -------------------------------------------------------------------

class BadRequest :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.rpc.BadRequest) */ {
 public:
  BadRequest();
  virtual ~BadRequest();

  BadRequest(const BadRequest& from);

  inline BadRequest& operator=(const BadRequest& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  BadRequest(BadRequest&& from) noexcept
    : BadRequest() {
    *this = ::std::move(from);
  }

  inline BadRequest& operator=(BadRequest&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const BadRequest& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BadRequest* internal_default_instance() {
    return reinterpret_cast<const BadRequest*>(
               &_BadRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  void Swap(BadRequest* other);
  friend void swap(BadRequest& a, BadRequest& b) {
    a.Swap(&b);
  }

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

  inline BadRequest* New() const final {
    return CreateMaybeMessage<BadRequest>(nullptr);
  }

  BadRequest* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<BadRequest>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const BadRequest& from);
  void MergeFrom(const BadRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BadRequest* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

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

  typedef BadRequest_FieldViolation FieldViolation;

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

  // repeated .google.rpc.BadRequest.FieldViolation field_violations = 1;
  int field_violations_size() const;
  void clear_field_violations();
  static const int kFieldViolationsFieldNumber = 1;
  ::google::rpc::BadRequest_FieldViolation* mutable_field_violations(int index);
  ::google::protobuf::RepeatedPtrField< ::google::rpc::BadRequest_FieldViolation >*
      mutable_field_violations();
  const ::google::rpc::BadRequest_FieldViolation& field_violations(int index) const;
  ::google::rpc::BadRequest_FieldViolation* add_field_violations();
  const ::google::protobuf::RepeatedPtrField< ::google::rpc::BadRequest_FieldViolation >&
      field_violations() const;

  // @@protoc_insertion_point(class_scope:google.rpc.BadRequest)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::google::rpc::BadRequest_FieldViolation > field_violations_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_google_2frpc_2ferror_5fdetails_2eproto;
};
// -------------------------------------------------------------------

class RequestInfo :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.rpc.RequestInfo) */ {
 public:
  RequestInfo();
  virtual ~RequestInfo();

  RequestInfo(const RequestInfo& from);

  inline RequestInfo& operator=(const RequestInfo& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RequestInfo(RequestInfo&& from) noexcept
    : RequestInfo() {
    *this = ::std::move(from);
  }

  inline RequestInfo& operator=(RequestInfo&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const RequestInfo& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RequestInfo* internal_default_instance() {
    return reinterpret_cast<const RequestInfo*>(
               &_RequestInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  void Swap(RequestInfo* other);
  friend void swap(RequestInfo& a, RequestInfo& b) {
    a.Swap(&b);
  }

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

  inline RequestInfo* New() const final {
    return CreateMaybeMessage<RequestInfo>(nullptr);
  }

  RequestInfo* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RequestInfo>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RequestInfo& from);
  void MergeFrom(const RequestInfo& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RequestInfo* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

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

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

  // string request_id = 1;
  void clear_request_id();
  static const int kRequestIdFieldNumber = 1;
  const ::std::string& request_id() const;
  void set_request_id(const ::std::string& value);
  #if LANG_CXX11
  void set_request_id(::std::string&& value);
  #endif
  void set_request_id(const char* value);
  void set_request_id(const char* value, size_t size);
  ::std::string* mutable_request_id();
  ::std::string* release_request_id();
  void set_allocated_request_id(::std::string* request_id);

  // string serving_data = 2;
  void clear_serving_data();
  static const int kServingDataFieldNumber = 2;
  const ::std::string& serving_data() const;
  void set_serving_data(const ::std::string& value);
  #if LANG_CXX11
  void set_serving_data(::std::string&& value);
  #endif
  void set_serving_data(const char* value);
  void set_serving_data(const char* value, size_t size);
  ::std::string* mutable_serving_data();
  ::std::string* release_serving_data();
  void set_allocated_serving_data(::std::string* serving_data);

  // @@protoc_insertion_point(class_scope:google.rpc.RequestInfo)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr request_id_;
  ::google::protobuf::internal::ArenaStringPtr serving_data_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_google_2frpc_2ferror_5fdetails_2eproto;
};
// -------------------------------------------------------------------

class ResourceInfo :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.rpc.ResourceInfo) */ {
 public:
  ResourceInfo();
  virtual ~ResourceInfo();

  ResourceInfo(const ResourceInfo& from);

  inline ResourceInfo& operator=(const ResourceInfo& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ResourceInfo(ResourceInfo&& from) noexcept
    : ResourceInfo() {
    *this = ::std::move(from);
  }

  inline ResourceInfo& operator=(ResourceInfo&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const ResourceInfo& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ResourceInfo* internal_default_instance() {
    return reinterpret_cast<const ResourceInfo*>(
               &_ResourceInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  void Swap(ResourceInfo* other);
  friend void swap(ResourceInfo& a, ResourceInfo& b) {
    a.Swap(&b);
  }

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

  inline ResourceInfo* New() const final {
    return CreateMaybeMessage<ResourceInfo>(nullptr);
  }

  ResourceInfo* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ResourceInfo>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ResourceInfo& from);
  void MergeFrom(const ResourceInfo& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ResourceInfo* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

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

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

  // string resource_type = 1;
  void clear_resource_type();
  static const int kResourceTypeFieldNumber = 1;
  const ::std::string& resource_type() const;
  void set_resource_type(const ::std::string& value);
  #if LANG_CXX11
  void set_resource_type(::std::string&& value);
  #endif
  void set_resource_type(const char* value);
  void set_resource_type(const char* value, size_t size);
  ::std::string* mutable_resource_type();
  ::std::string* release_resource_type();
  void set_allocated_resource_type(::std::string* resource_type);

  // string resource_name = 2;
  void clear_resource_name();
  static const int kResourceNameFieldNumber = 2;
  const ::std::string& resource_name() const;
  void set_resource_name(const ::std::string& value);
  #if LANG_CXX11
  void set_resource_name(::std::string&& value);
  #endif
  void set_resource_name(const char* value);
  void set_resource_name(const char* value, size_t size);
  ::std::string* mutable_resource_name();
  ::std::string* release_resource_name();
  void set_allocated_resource_name(::std::string* resource_name);

  // string owner = 3;
  void clear_owner();
  static const int kOwnerFieldNumber = 3;
  const ::std::string& owner() const;
  void set_owner(const ::std::string& value);
  #if LANG_CXX11
  void set_owner(::std::string&& value);
  #endif
  void set_owner(const char* value);
  void set_owner(const char* value, size_t size);
  ::std::string* mutable_owner();
  ::std::string* release_owner();
  void set_allocated_owner(::std::string* owner);

  // string description = 4;
  void clear_description();
  static const int kDescriptionFieldNumber = 4;
  const ::std::string& description() const;
  void set_description(const ::std::string& value);
  #if LANG_CXX11
  void set_description(::std::string&& value);
  #endif
  void set_description(const char* value);
  void set_description(const char* value, size_t size);
  ::std::string* mutable_description();
  ::std::string* release_description();
  void set_allocated_description(::std::string* description);

  // @@protoc_insertion_point(class_scope:google.rpc.ResourceInfo)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr resource_type_;
  ::google::protobuf::internal::ArenaStringPtr resource_name_;
  ::google::protobuf::internal::ArenaStringPtr owner_;
  ::google::protobuf::internal::ArenaStringPtr description_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_google_2frpc_2ferror_5fdetails_2eproto;
};
// -------------------------------------------------------------------

class Help_Link :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.rpc.Help.Link) */ {
 public:
  Help_Link();
  virtual ~Help_Link();

  Help_Link(const Help_Link& from);

  inline Help_Link& operator=(const Help_Link& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Help_Link(Help_Link&& from) noexcept
    : Help_Link() {
    *this = ::std::move(from);
  }

  inline Help_Link& operator=(Help_Link&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const Help_Link& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Help_Link* internal_default_instance() {
    return reinterpret_cast<const Help_Link*>(
               &_Help_Link_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  void Swap(Help_Link* other);
  friend void swap(Help_Link& a, Help_Link& b) {
    a.Swap(&b);
  }

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

  inline Help_Link* New() const final {
    return CreateMaybeMessage<Help_Link>(nullptr);
  }

  Help_Link* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<Help_Link>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const Help_Link& from);
  void MergeFrom(const Help_Link& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Help_Link* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

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

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

  // string description = 1;
  void clear_description();
  static const int kDescriptionFieldNumber = 1;
  const ::std::string& description() const;
  void set_description(const ::std::string& value);
  #if LANG_CXX11
  void set_description(::std::string&& value);
  #endif
  void set_description(const char* value);
  void set_description(const char* value, size_t size);
  ::std::string* mutable_description();
  ::std::string* release_description();
  void set_allocated_description(::std::string* description);

  // string url = 2;
  void clear_url();
  static const int kUrlFieldNumber = 2;
  const ::std::string& url() const;
  void set_url(const ::std::string& value);
  #if LANG_CXX11
  void set_url(::std::string&& value);
  #endif
  void set_url(const char* value);
  void set_url(const char* value, size_t size);
  ::std::string* mutable_url();
  ::std::string* release_url();
  void set_allocated_url(::std::string* url);

  // @@protoc_insertion_point(class_scope:google.rpc.Help.Link)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr description_;
  ::google::protobuf::internal::ArenaStringPtr url_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_google_2frpc_2ferror_5fdetails_2eproto;
};
// -------------------------------------------------------------------

class Help :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.rpc.Help) */ {
 public:
  Help();
  virtual ~Help();

  Help(const Help& from);

  inline Help& operator=(const Help& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Help(Help&& from) noexcept
    : Help() {
    *this = ::std::move(from);
  }

  inline Help& operator=(Help&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const Help& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Help* internal_default_instance() {
    return reinterpret_cast<const Help*>(
               &_Help_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  void Swap(Help* other);
  friend void swap(Help& a, Help& b) {
    a.Swap(&b);
  }

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

  inline Help* New() const final {
    return CreateMaybeMessage<Help>(nullptr);
  }

  Help* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<Help>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const Help& from);
  void MergeFrom(const Help& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Help* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

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

  typedef Help_Link Link;

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

  // repeated .google.rpc.Help.Link links = 1;
  int links_size() const;
  void clear_links();
  static const int kLinksFieldNumber = 1;
  ::google::rpc::Help_Link* mutable_links(int index);
  ::google::protobuf::RepeatedPtrField< ::google::rpc::Help_Link >*
      mutable_links();
  const ::google::rpc::Help_Link& links(int index) const;
  ::google::rpc::Help_Link* add_links();
  const ::google::protobuf::RepeatedPtrField< ::google::rpc::Help_Link >&
      links() const;

  // @@protoc_insertion_point(class_scope:google.rpc.Help)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::google::rpc::Help_Link > links_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_google_2frpc_2ferror_5fdetails_2eproto;
};
// -------------------------------------------------------------------

class LocalizedMessage :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.rpc.LocalizedMessage) */ {
 public:
  LocalizedMessage();
  virtual ~LocalizedMessage();

  LocalizedMessage(const LocalizedMessage& from);

  inline LocalizedMessage& operator=(const LocalizedMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  LocalizedMessage(LocalizedMessage&& from) noexcept
    : LocalizedMessage() {
    *this = ::std::move(from);
  }

  inline LocalizedMessage& operator=(LocalizedMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const LocalizedMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LocalizedMessage* internal_default_instance() {
    return reinterpret_cast<const LocalizedMessage*>(
               &_LocalizedMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  void Swap(LocalizedMessage* other);
  friend void swap(LocalizedMessage& a, LocalizedMessage& b) {
    a.Swap(&b);
  }

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

  inline LocalizedMessage* New() const final {
    return CreateMaybeMessage<LocalizedMessage>(nullptr);
  }

  LocalizedMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<LocalizedMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const LocalizedMessage& from);
  void MergeFrom(const LocalizedMessage& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LocalizedMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

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

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

  // string locale = 1;
  void clear_locale();
  static const int kLocaleFieldNumber = 1;
  const ::std::string& locale() const;
  void set_locale(const ::std::string& value);
  #if LANG_CXX11
  void set_locale(::std::string&& value);
  #endif
  void set_locale(const char* value);
  void set_locale(const char* value, size_t size);
  ::std::string* mutable_locale();
  ::std::string* release_locale();
  void set_allocated_locale(::std::string* locale);

  // string message = 2;
  void clear_message();
  static const int kMessageFieldNumber = 2;
  const ::std::string& message() const;
  void set_message(const ::std::string& value);
  #if LANG_CXX11
  void set_message(::std::string&& value);
  #endif
  void set_message(const char* value);
  void set_message(const char* value, size_t size);
  ::std::string* mutable_message();
  ::std::string* release_message();
  void set_allocated_message(::std::string* message);

  // @@protoc_insertion_point(class_scope:google.rpc.LocalizedMessage)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr locale_;
  ::google::protobuf::internal::ArenaStringPtr message_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_google_2frpc_2ferror_5fdetails_2eproto;
};
// ===================================================================


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

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

// .google.protobuf.Duration retry_delay = 1;
inline bool RetryInfo::has_retry_delay() const {
  return this != internal_default_instance() && retry_delay_ != nullptr;
}
inline const ::google::protobuf::Duration& RetryInfo::retry_delay() const {
  const ::google::protobuf::Duration* p = retry_delay_;
  // @@protoc_insertion_point(field_get:google.rpc.RetryInfo.retry_delay)
  return p != nullptr ? *p : *reinterpret_cast<const ::google::protobuf::Duration*>(
      &::google::protobuf::_Duration_default_instance_);
}
inline ::google::protobuf::Duration* RetryInfo::release_retry_delay() {
  // @@protoc_insertion_point(field_release:google.rpc.RetryInfo.retry_delay)
  
  ::google::protobuf::Duration* temp = retry_delay_;
  retry_delay_ = nullptr;
  return temp;
}
inline ::google::protobuf::Duration* RetryInfo::mutable_retry_delay() {
  
  if (retry_delay_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::protobuf::Duration>(GetArenaNoVirtual());
    retry_delay_ = p;
  }
  // @@protoc_insertion_point(field_mutable:google.rpc.RetryInfo.retry_delay)
  return retry_delay_;
}
inline void RetryInfo::set_allocated_retry_delay(::google::protobuf::Duration* retry_delay) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(retry_delay_);
  }
  if (retry_delay) {
    ::google::protobuf::Arena* submessage_arena =
      reinterpret_cast<::google::protobuf::MessageLite*>(retry_delay)->GetArena();
    if (message_arena != submessage_arena) {
      retry_delay = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, retry_delay, submessage_arena);
    }
    
  } else {
    
  }
  retry_delay_ = retry_delay;
  // @@protoc_insertion_point(field_set_allocated:google.rpc.RetryInfo.retry_delay)
}

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

// DebugInfo

// repeated string stack_entries = 1;
inline int DebugInfo::stack_entries_size() const {
  return stack_entries_.size();
}
inline void DebugInfo::clear_stack_entries() {
  stack_entries_.Clear();
}
inline const ::std::string& DebugInfo::stack_entries(int index) const {
  // @@protoc_insertion_point(field_get:google.rpc.DebugInfo.stack_entries)
  return stack_entries_.Get(index);
}
inline ::std::string* DebugInfo::mutable_stack_entries(int index) {
  // @@protoc_insertion_point(field_mutable:google.rpc.DebugInfo.stack_entries)
  return stack_entries_.Mutable(index);
}
inline void DebugInfo::set_stack_entries(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:google.rpc.DebugInfo.stack_entries)
  stack_entries_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void DebugInfo::set_stack_entries(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:google.rpc.DebugInfo.stack_entries)
  stack_entries_.Mutable(index)->assign(std::move(value));
}
#endif
inline void DebugInfo::set_stack_entries(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  stack_entries_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:google.rpc.DebugInfo.stack_entries)
}
inline void DebugInfo::set_stack_entries(int index, const char* value, size_t size) {
  stack_entries_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:google.rpc.DebugInfo.stack_entries)
}
inline ::std::string* DebugInfo::add_stack_entries() {
  // @@protoc_insertion_point(field_add_mutable:google.rpc.DebugInfo.stack_entries)
  return stack_entries_.Add();
}
inline void DebugInfo::add_stack_entries(const ::std::string& value) {
  stack_entries_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:google.rpc.DebugInfo.stack_entries)
}
#if LANG_CXX11
inline void DebugInfo::add_stack_entries(::std::string&& value) {
  stack_entries_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:google.rpc.DebugInfo.stack_entries)
}
#endif
inline void DebugInfo::add_stack_entries(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  stack_entries_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:google.rpc.DebugInfo.stack_entries)
}
inline void DebugInfo::add_stack_entries(const char* value, size_t size) {
  stack_entries_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:google.rpc.DebugInfo.stack_entries)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
DebugInfo::stack_entries() const {
  // @@protoc_insertion_point(field_list:google.rpc.DebugInfo.stack_entries)
  return stack_entries_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>*
DebugInfo::mutable_stack_entries() {
  // @@protoc_insertion_point(field_mutable_list:google.rpc.DebugInfo.stack_entries)
  return &stack_entries_;
}

// string detail = 2;
inline void DebugInfo::clear_detail() {
  detail_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& DebugInfo::detail() const {
  // @@protoc_insertion_point(field_get:google.rpc.DebugInfo.detail)
  return detail_.GetNoArena();
}
inline void DebugInfo::set_detail(const ::std::string& value) {
  
  detail_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.rpc.DebugInfo.detail)
}
#if LANG_CXX11
inline void DebugInfo::set_detail(::std::string&& value) {
  
  detail_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.rpc.DebugInfo.detail)
}
#endif
inline void DebugInfo::set_detail(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  detail_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.rpc.DebugInfo.detail)
}
inline void DebugInfo::set_detail(const char* value, size_t size) {
  
  detail_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.rpc.DebugInfo.detail)
}
inline ::std::string* DebugInfo::mutable_detail() {
  
  // @@protoc_insertion_point(field_mutable:google.rpc.DebugInfo.detail)
  return detail_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* DebugInfo::release_detail() {
  // @@protoc_insertion_point(field_release:google.rpc.DebugInfo.detail)
  
  return detail_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DebugInfo::set_allocated_detail(::std::string* detail) {
  if (detail != nullptr) {
    
  } else {
    
  }
  detail_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), detail);
  // @@protoc_insertion_point(field_set_allocated:google.rpc.DebugInfo.detail)
}

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

// QuotaFailure_Violation

// string subject = 1;
inline void QuotaFailure_Violation::clear_subject() {
  subject_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& QuotaFailure_Violation::subject() const {
  // @@protoc_insertion_point(field_get:google.rpc.QuotaFailure.Violation.subject)
  return subject_.GetNoArena();
}
inline void QuotaFailure_Violation::set_subject(const ::std::string& value) {
  
  subject_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.rpc.QuotaFailure.Violation.subject)
}
#if LANG_CXX11
inline void QuotaFailure_Violation::set_subject(::std::string&& value) {
  
  subject_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.rpc.QuotaFailure.Violation.subject)
}
#endif
inline void QuotaFailure_Violation::set_subject(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  subject_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.rpc.QuotaFailure.Violation.subject)
}
inline void QuotaFailure_Violation::set_subject(const char* value, size_t size) {
  
  subject_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.rpc.QuotaFailure.Violation.subject)
}
inline ::std::string* QuotaFailure_Violation::mutable_subject() {
  
  // @@protoc_insertion_point(field_mutable:google.rpc.QuotaFailure.Violation.subject)
  return subject_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* QuotaFailure_Violation::release_subject() {
  // @@protoc_insertion_point(field_release:google.rpc.QuotaFailure.Violation.subject)
  
  return subject_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void QuotaFailure_Violation::set_allocated_subject(::std::string* subject) {
  if (subject != nullptr) {
    
  } else {
    
  }
  subject_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), subject);
  // @@protoc_insertion_point(field_set_allocated:google.rpc.QuotaFailure.Violation.subject)
}

// string description = 2;
inline void QuotaFailure_Violation::clear_description() {
  description_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& QuotaFailure_Violation::description() const {
  // @@protoc_insertion_point(field_get:google.rpc.QuotaFailure.Violation.description)
  return description_.GetNoArena();
}
inline void QuotaFailure_Violation::set_description(const ::std::string& value) {
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.rpc.QuotaFailure.Violation.description)
}
#if LANG_CXX11
inline void QuotaFailure_Violation::set_description(::std::string&& value) {
  
  description_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.rpc.QuotaFailure.Violation.description)
}
#endif
inline void QuotaFailure_Violation::set_description(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.rpc.QuotaFailure.Violation.description)
}
inline void QuotaFailure_Violation::set_description(const char* value, size_t size) {
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.rpc.QuotaFailure.Violation.description)
}
inline ::std::string* QuotaFailure_Violation::mutable_description() {
  
  // @@protoc_insertion_point(field_mutable:google.rpc.QuotaFailure.Violation.description)
  return description_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* QuotaFailure_Violation::release_description() {
  // @@protoc_insertion_point(field_release:google.rpc.QuotaFailure.Violation.description)
  
  return description_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void QuotaFailure_Violation::set_allocated_description(::std::string* description) {
  if (description != nullptr) {
    
  } else {
    
  }
  description_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), description);
  // @@protoc_insertion_point(field_set_allocated:google.rpc.QuotaFailure.Violation.description)
}

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

// QuotaFailure

// repeated .google.rpc.QuotaFailure.Violation violations = 1;
inline int QuotaFailure::violations_size() const {
  return violations_.size();
}
inline void QuotaFailure::clear_violations() {
  violations_.Clear();
}
inline ::google::rpc::QuotaFailure_Violation* QuotaFailure::mutable_violations(int index) {
  // @@protoc_insertion_point(field_mutable:google.rpc.QuotaFailure.violations)
  return violations_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::google::rpc::QuotaFailure_Violation >*
QuotaFailure::mutable_violations() {
  // @@protoc_insertion_point(field_mutable_list:google.rpc.QuotaFailure.violations)
  return &violations_;
}
inline const ::google::rpc::QuotaFailure_Violation& QuotaFailure::violations(int index) const {
  // @@protoc_insertion_point(field_get:google.rpc.QuotaFailure.violations)
  return violations_.Get(index);
}
inline ::google::rpc::QuotaFailure_Violation* QuotaFailure::add_violations() {
  // @@protoc_insertion_point(field_add:google.rpc.QuotaFailure.violations)
  return violations_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::google::rpc::QuotaFailure_Violation >&
QuotaFailure::violations() const {
  // @@protoc_insertion_point(field_list:google.rpc.QuotaFailure.violations)
  return violations_;
}

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

// PreconditionFailure_Violation

// string type = 1;
inline void PreconditionFailure_Violation::clear_type() {
  type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& PreconditionFailure_Violation::type() const {
  // @@protoc_insertion_point(field_get:google.rpc.PreconditionFailure.Violation.type)
  return type_.GetNoArena();
}
inline void PreconditionFailure_Violation::set_type(const ::std::string& value) {
  
  type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.rpc.PreconditionFailure.Violation.type)
}
#if LANG_CXX11
inline void PreconditionFailure_Violation::set_type(::std::string&& value) {
  
  type_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.rpc.PreconditionFailure.Violation.type)
}
#endif
inline void PreconditionFailure_Violation::set_type(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.rpc.PreconditionFailure.Violation.type)
}
inline void PreconditionFailure_Violation::set_type(const char* value, size_t size) {
  
  type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.rpc.PreconditionFailure.Violation.type)
}
inline ::std::string* PreconditionFailure_Violation::mutable_type() {
  
  // @@protoc_insertion_point(field_mutable:google.rpc.PreconditionFailure.Violation.type)
  return type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* PreconditionFailure_Violation::release_type() {
  // @@protoc_insertion_point(field_release:google.rpc.PreconditionFailure.Violation.type)
  
  return type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void PreconditionFailure_Violation::set_allocated_type(::std::string* type) {
  if (type != nullptr) {
    
  } else {
    
  }
  type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type);
  // @@protoc_insertion_point(field_set_allocated:google.rpc.PreconditionFailure.Violation.type)
}

// string subject = 2;
inline void PreconditionFailure_Violation::clear_subject() {
  subject_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& PreconditionFailure_Violation::subject() const {
  // @@protoc_insertion_point(field_get:google.rpc.PreconditionFailure.Violation.subject)
  return subject_.GetNoArena();
}
inline void PreconditionFailure_Violation::set_subject(const ::std::string& value) {
  
  subject_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.rpc.PreconditionFailure.Violation.subject)
}
#if LANG_CXX11
inline void PreconditionFailure_Violation::set_subject(::std::string&& value) {
  
  subject_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.rpc.PreconditionFailure.Violation.subject)
}
#endif
inline void PreconditionFailure_Violation::set_subject(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  subject_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.rpc.PreconditionFailure.Violation.subject)
}
inline void PreconditionFailure_Violation::set_subject(const char* value, size_t size) {
  
  subject_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.rpc.PreconditionFailure.Violation.subject)
}
inline ::std::string* PreconditionFailure_Violation::mutable_subject() {
  
  // @@protoc_insertion_point(field_mutable:google.rpc.PreconditionFailure.Violation.subject)
  return subject_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* PreconditionFailure_Violation::release_subject() {
  // @@protoc_insertion_point(field_release:google.rpc.PreconditionFailure.Violation.subject)
  
  return subject_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void PreconditionFailure_Violation::set_allocated_subject(::std::string* subject) {
  if (subject != nullptr) {
    
  } else {
    
  }
  subject_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), subject);
  // @@protoc_insertion_point(field_set_allocated:google.rpc.PreconditionFailure.Violation.subject)
}

// string description = 3;
inline void PreconditionFailure_Violation::clear_description() {
  description_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& PreconditionFailure_Violation::description() const {
  // @@protoc_insertion_point(field_get:google.rpc.PreconditionFailure.Violation.description)
  return description_.GetNoArena();
}
inline void PreconditionFailure_Violation::set_description(const ::std::string& value) {
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.rpc.PreconditionFailure.Violation.description)
}
#if LANG_CXX11
inline void PreconditionFailure_Violation::set_description(::std::string&& value) {
  
  description_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.rpc.PreconditionFailure.Violation.description)
}
#endif
inline void PreconditionFailure_Violation::set_description(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.rpc.PreconditionFailure.Violation.description)
}
inline void PreconditionFailure_Violation::set_description(const char* value, size_t size) {
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.rpc.PreconditionFailure.Violation.description)
}
inline ::std::string* PreconditionFailure_Violation::mutable_description() {
  
  // @@protoc_insertion_point(field_mutable:google.rpc.PreconditionFailure.Violation.description)
  return description_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* PreconditionFailure_Violation::release_description() {
  // @@protoc_insertion_point(field_release:google.rpc.PreconditionFailure.Violation.description)
  
  return description_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void PreconditionFailure_Violation::set_allocated_description(::std::string* description) {
  if (description != nullptr) {
    
  } else {
    
  }
  description_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), description);
  // @@protoc_insertion_point(field_set_allocated:google.rpc.PreconditionFailure.Violation.description)
}

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

// PreconditionFailure

// repeated .google.rpc.PreconditionFailure.Violation violations = 1;
inline int PreconditionFailure::violations_size() const {
  return violations_.size();
}
inline void PreconditionFailure::clear_violations() {
  violations_.Clear();
}
inline ::google::rpc::PreconditionFailure_Violation* PreconditionFailure::mutable_violations(int index) {
  // @@protoc_insertion_point(field_mutable:google.rpc.PreconditionFailure.violations)
  return violations_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::google::rpc::PreconditionFailure_Violation >*
PreconditionFailure::mutable_violations() {
  // @@protoc_insertion_point(field_mutable_list:google.rpc.PreconditionFailure.violations)
  return &violations_;
}
inline const ::google::rpc::PreconditionFailure_Violation& PreconditionFailure::violations(int index) const {
  // @@protoc_insertion_point(field_get:google.rpc.PreconditionFailure.violations)
  return violations_.Get(index);
}
inline ::google::rpc::PreconditionFailure_Violation* PreconditionFailure::add_violations() {
  // @@protoc_insertion_point(field_add:google.rpc.PreconditionFailure.violations)
  return violations_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::google::rpc::PreconditionFailure_Violation >&
PreconditionFailure::violations() const {
  // @@protoc_insertion_point(field_list:google.rpc.PreconditionFailure.violations)
  return violations_;
}

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

// BadRequest_FieldViolation

// string field = 1;
inline void BadRequest_FieldViolation::clear_field() {
  field_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& BadRequest_FieldViolation::field() const {
  // @@protoc_insertion_point(field_get:google.rpc.BadRequest.FieldViolation.field)
  return field_.GetNoArena();
}
inline void BadRequest_FieldViolation::set_field(const ::std::string& value) {
  
  field_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.rpc.BadRequest.FieldViolation.field)
}
#if LANG_CXX11
inline void BadRequest_FieldViolation::set_field(::std::string&& value) {
  
  field_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.rpc.BadRequest.FieldViolation.field)
}
#endif
inline void BadRequest_FieldViolation::set_field(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  field_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.rpc.BadRequest.FieldViolation.field)
}
inline void BadRequest_FieldViolation::set_field(const char* value, size_t size) {
  
  field_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.rpc.BadRequest.FieldViolation.field)
}
inline ::std::string* BadRequest_FieldViolation::mutable_field() {
  
  // @@protoc_insertion_point(field_mutable:google.rpc.BadRequest.FieldViolation.field)
  return field_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* BadRequest_FieldViolation::release_field() {
  // @@protoc_insertion_point(field_release:google.rpc.BadRequest.FieldViolation.field)
  
  return field_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void BadRequest_FieldViolation::set_allocated_field(::std::string* field) {
  if (field != nullptr) {
    
  } else {
    
  }
  field_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), field);
  // @@protoc_insertion_point(field_set_allocated:google.rpc.BadRequest.FieldViolation.field)
}

// string description = 2;
inline void BadRequest_FieldViolation::clear_description() {
  description_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& BadRequest_FieldViolation::description() const {
  // @@protoc_insertion_point(field_get:google.rpc.BadRequest.FieldViolation.description)
  return description_.GetNoArena();
}
inline void BadRequest_FieldViolation::set_description(const ::std::string& value) {
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.rpc.BadRequest.FieldViolation.description)
}
#if LANG_CXX11
inline void BadRequest_FieldViolation::set_description(::std::string&& value) {
  
  description_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.rpc.BadRequest.FieldViolation.description)
}
#endif
inline void BadRequest_FieldViolation::set_description(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.rpc.BadRequest.FieldViolation.description)
}
inline void BadRequest_FieldViolation::set_description(const char* value, size_t size) {
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.rpc.BadRequest.FieldViolation.description)
}
inline ::std::string* BadRequest_FieldViolation::mutable_description() {
  
  // @@protoc_insertion_point(field_mutable:google.rpc.BadRequest.FieldViolation.description)
  return description_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* BadRequest_FieldViolation::release_description() {
  // @@protoc_insertion_point(field_release:google.rpc.BadRequest.FieldViolation.description)
  
  return description_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void BadRequest_FieldViolation::set_allocated_description(::std::string* description) {
  if (description != nullptr) {
    
  } else {
    
  }
  description_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), description);
  // @@protoc_insertion_point(field_set_allocated:google.rpc.BadRequest.FieldViolation.description)
}

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

// BadRequest

// repeated .google.rpc.BadRequest.FieldViolation field_violations = 1;
inline int BadRequest::field_violations_size() const {
  return field_violations_.size();
}
inline void BadRequest::clear_field_violations() {
  field_violations_.Clear();
}
inline ::google::rpc::BadRequest_FieldViolation* BadRequest::mutable_field_violations(int index) {
  // @@protoc_insertion_point(field_mutable:google.rpc.BadRequest.field_violations)
  return field_violations_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::google::rpc::BadRequest_FieldViolation >*
BadRequest::mutable_field_violations() {
  // @@protoc_insertion_point(field_mutable_list:google.rpc.BadRequest.field_violations)
  return &field_violations_;
}
inline const ::google::rpc::BadRequest_FieldViolation& BadRequest::field_violations(int index) const {
  // @@protoc_insertion_point(field_get:google.rpc.BadRequest.field_violations)
  return field_violations_.Get(index);
}
inline ::google::rpc::BadRequest_FieldViolation* BadRequest::add_field_violations() {
  // @@protoc_insertion_point(field_add:google.rpc.BadRequest.field_violations)
  return field_violations_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::google::rpc::BadRequest_FieldViolation >&
BadRequest::field_violations() const {
  // @@protoc_insertion_point(field_list:google.rpc.BadRequest.field_violations)
  return field_violations_;
}

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

// RequestInfo

// string request_id = 1;
inline void RequestInfo::clear_request_id() {
  request_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& RequestInfo::request_id() const {
  // @@protoc_insertion_point(field_get:google.rpc.RequestInfo.request_id)
  return request_id_.GetNoArena();
}
inline void RequestInfo::set_request_id(const ::std::string& value) {
  
  request_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.rpc.RequestInfo.request_id)
}
#if LANG_CXX11
inline void RequestInfo::set_request_id(::std::string&& value) {
  
  request_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.rpc.RequestInfo.request_id)
}
#endif
inline void RequestInfo::set_request_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  request_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.rpc.RequestInfo.request_id)
}
inline void RequestInfo::set_request_id(const char* value, size_t size) {
  
  request_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.rpc.RequestInfo.request_id)
}
inline ::std::string* RequestInfo::mutable_request_id() {
  
  // @@protoc_insertion_point(field_mutable:google.rpc.RequestInfo.request_id)
  return request_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RequestInfo::release_request_id() {
  // @@protoc_insertion_point(field_release:google.rpc.RequestInfo.request_id)
  
  return request_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RequestInfo::set_allocated_request_id(::std::string* request_id) {
  if (request_id != nullptr) {
    
  } else {
    
  }
  request_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), request_id);
  // @@protoc_insertion_point(field_set_allocated:google.rpc.RequestInfo.request_id)
}

// string serving_data = 2;
inline void RequestInfo::clear_serving_data() {
  serving_data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& RequestInfo::serving_data() const {
  // @@protoc_insertion_point(field_get:google.rpc.RequestInfo.serving_data)
  return serving_data_.GetNoArena();
}
inline void RequestInfo::set_serving_data(const ::std::string& value) {
  
  serving_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.rpc.RequestInfo.serving_data)
}
#if LANG_CXX11
inline void RequestInfo::set_serving_data(::std::string&& value) {
  
  serving_data_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.rpc.RequestInfo.serving_data)
}
#endif
inline void RequestInfo::set_serving_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  serving_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.rpc.RequestInfo.serving_data)
}
inline void RequestInfo::set_serving_data(const char* value, size_t size) {
  
  serving_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.rpc.RequestInfo.serving_data)
}
inline ::std::string* RequestInfo::mutable_serving_data() {
  
  // @@protoc_insertion_point(field_mutable:google.rpc.RequestInfo.serving_data)
  return serving_data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RequestInfo::release_serving_data() {
  // @@protoc_insertion_point(field_release:google.rpc.RequestInfo.serving_data)
  
  return serving_data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RequestInfo::set_allocated_serving_data(::std::string* serving_data) {
  if (serving_data != nullptr) {
    
  } else {
    
  }
  serving_data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), serving_data);
  // @@protoc_insertion_point(field_set_allocated:google.rpc.RequestInfo.serving_data)
}

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

// ResourceInfo

// string resource_type = 1;
inline void ResourceInfo::clear_resource_type() {
  resource_type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ResourceInfo::resource_type() const {
  // @@protoc_insertion_point(field_get:google.rpc.ResourceInfo.resource_type)
  return resource_type_.GetNoArena();
}
inline void ResourceInfo::set_resource_type(const ::std::string& value) {
  
  resource_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.rpc.ResourceInfo.resource_type)
}
#if LANG_CXX11
inline void ResourceInfo::set_resource_type(::std::string&& value) {
  
  resource_type_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.rpc.ResourceInfo.resource_type)
}
#endif
inline void ResourceInfo::set_resource_type(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  resource_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.rpc.ResourceInfo.resource_type)
}
inline void ResourceInfo::set_resource_type(const char* value, size_t size) {
  
  resource_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.rpc.ResourceInfo.resource_type)
}
inline ::std::string* ResourceInfo::mutable_resource_type() {
  
  // @@protoc_insertion_point(field_mutable:google.rpc.ResourceInfo.resource_type)
  return resource_type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ResourceInfo::release_resource_type() {
  // @@protoc_insertion_point(field_release:google.rpc.ResourceInfo.resource_type)
  
  return resource_type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ResourceInfo::set_allocated_resource_type(::std::string* resource_type) {
  if (resource_type != nullptr) {
    
  } else {
    
  }
  resource_type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), resource_type);
  // @@protoc_insertion_point(field_set_allocated:google.rpc.ResourceInfo.resource_type)
}

// string resource_name = 2;
inline void ResourceInfo::clear_resource_name() {
  resource_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ResourceInfo::resource_name() const {
  // @@protoc_insertion_point(field_get:google.rpc.ResourceInfo.resource_name)
  return resource_name_.GetNoArena();
}
inline void ResourceInfo::set_resource_name(const ::std::string& value) {
  
  resource_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.rpc.ResourceInfo.resource_name)
}
#if LANG_CXX11
inline void ResourceInfo::set_resource_name(::std::string&& value) {
  
  resource_name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.rpc.ResourceInfo.resource_name)
}
#endif
inline void ResourceInfo::set_resource_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  resource_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.rpc.ResourceInfo.resource_name)
}
inline void ResourceInfo::set_resource_name(const char* value, size_t size) {
  
  resource_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.rpc.ResourceInfo.resource_name)
}
inline ::std::string* ResourceInfo::mutable_resource_name() {
  
  // @@protoc_insertion_point(field_mutable:google.rpc.ResourceInfo.resource_name)
  return resource_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ResourceInfo::release_resource_name() {
  // @@protoc_insertion_point(field_release:google.rpc.ResourceInfo.resource_name)
  
  return resource_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ResourceInfo::set_allocated_resource_name(::std::string* resource_name) {
  if (resource_name != nullptr) {
    
  } else {
    
  }
  resource_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), resource_name);
  // @@protoc_insertion_point(field_set_allocated:google.rpc.ResourceInfo.resource_name)
}

// string owner = 3;
inline void ResourceInfo::clear_owner() {
  owner_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ResourceInfo::owner() const {
  // @@protoc_insertion_point(field_get:google.rpc.ResourceInfo.owner)
  return owner_.GetNoArena();
}
inline void ResourceInfo::set_owner(const ::std::string& value) {
  
  owner_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.rpc.ResourceInfo.owner)
}
#if LANG_CXX11
inline void ResourceInfo::set_owner(::std::string&& value) {
  
  owner_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.rpc.ResourceInfo.owner)
}
#endif
inline void ResourceInfo::set_owner(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  owner_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.rpc.ResourceInfo.owner)
}
inline void ResourceInfo::set_owner(const char* value, size_t size) {
  
  owner_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.rpc.ResourceInfo.owner)
}
inline ::std::string* ResourceInfo::mutable_owner() {
  
  // @@protoc_insertion_point(field_mutable:google.rpc.ResourceInfo.owner)
  return owner_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ResourceInfo::release_owner() {
  // @@protoc_insertion_point(field_release:google.rpc.ResourceInfo.owner)
  
  return owner_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ResourceInfo::set_allocated_owner(::std::string* owner) {
  if (owner != nullptr) {
    
  } else {
    
  }
  owner_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), owner);
  // @@protoc_insertion_point(field_set_allocated:google.rpc.ResourceInfo.owner)
}

// string description = 4;
inline void ResourceInfo::clear_description() {
  description_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ResourceInfo::description() const {
  // @@protoc_insertion_point(field_get:google.rpc.ResourceInfo.description)
  return description_.GetNoArena();
}
inline void ResourceInfo::set_description(const ::std::string& value) {
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.rpc.ResourceInfo.description)
}
#if LANG_CXX11
inline void ResourceInfo::set_description(::std::string&& value) {
  
  description_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.rpc.ResourceInfo.description)
}
#endif
inline void ResourceInfo::set_description(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.rpc.ResourceInfo.description)
}
inline void ResourceInfo::set_description(const char* value, size_t size) {
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.rpc.ResourceInfo.description)
}
inline ::std::string* ResourceInfo::mutable_description() {
  
  // @@protoc_insertion_point(field_mutable:google.rpc.ResourceInfo.description)
  return description_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ResourceInfo::release_description() {
  // @@protoc_insertion_point(field_release:google.rpc.ResourceInfo.description)
  
  return description_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ResourceInfo::set_allocated_description(::std::string* description) {
  if (description != nullptr) {
    
  } else {
    
  }
  description_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), description);
  // @@protoc_insertion_point(field_set_allocated:google.rpc.ResourceInfo.description)
}

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

// Help_Link

// string description = 1;
inline void Help_Link::clear_description() {
  description_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Help_Link::description() const {
  // @@protoc_insertion_point(field_get:google.rpc.Help.Link.description)
  return description_.GetNoArena();
}
inline void Help_Link::set_description(const ::std::string& value) {
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.rpc.Help.Link.description)
}
#if LANG_CXX11
inline void Help_Link::set_description(::std::string&& value) {
  
  description_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.rpc.Help.Link.description)
}
#endif
inline void Help_Link::set_description(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.rpc.Help.Link.description)
}
inline void Help_Link::set_description(const char* value, size_t size) {
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.rpc.Help.Link.description)
}
inline ::std::string* Help_Link::mutable_description() {
  
  // @@protoc_insertion_point(field_mutable:google.rpc.Help.Link.description)
  return description_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Help_Link::release_description() {
  // @@protoc_insertion_point(field_release:google.rpc.Help.Link.description)
  
  return description_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Help_Link::set_allocated_description(::std::string* description) {
  if (description != nullptr) {
    
  } else {
    
  }
  description_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), description);
  // @@protoc_insertion_point(field_set_allocated:google.rpc.Help.Link.description)
}

// string url = 2;
inline void Help_Link::clear_url() {
  url_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Help_Link::url() const {
  // @@protoc_insertion_point(field_get:google.rpc.Help.Link.url)
  return url_.GetNoArena();
}
inline void Help_Link::set_url(const ::std::string& value) {
  
  url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.rpc.Help.Link.url)
}
#if LANG_CXX11
inline void Help_Link::set_url(::std::string&& value) {
  
  url_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.rpc.Help.Link.url)
}
#endif
inline void Help_Link::set_url(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.rpc.Help.Link.url)
}
inline void Help_Link::set_url(const char* value, size_t size) {
  
  url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.rpc.Help.Link.url)
}
inline ::std::string* Help_Link::mutable_url() {
  
  // @@protoc_insertion_point(field_mutable:google.rpc.Help.Link.url)
  return url_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Help_Link::release_url() {
  // @@protoc_insertion_point(field_release:google.rpc.Help.Link.url)
  
  return url_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Help_Link::set_allocated_url(::std::string* url) {
  if (url != nullptr) {
    
  } else {
    
  }
  url_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), url);
  // @@protoc_insertion_point(field_set_allocated:google.rpc.Help.Link.url)
}

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

// Help

// repeated .google.rpc.Help.Link links = 1;
inline int Help::links_size() const {
  return links_.size();
}
inline void Help::clear_links() {
  links_.Clear();
}
inline ::google::rpc::Help_Link* Help::mutable_links(int index) {
  // @@protoc_insertion_point(field_mutable:google.rpc.Help.links)
  return links_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::google::rpc::Help_Link >*
Help::mutable_links() {
  // @@protoc_insertion_point(field_mutable_list:google.rpc.Help.links)
  return &links_;
}
inline const ::google::rpc::Help_Link& Help::links(int index) const {
  // @@protoc_insertion_point(field_get:google.rpc.Help.links)
  return links_.Get(index);
}
inline ::google::rpc::Help_Link* Help::add_links() {
  // @@protoc_insertion_point(field_add:google.rpc.Help.links)
  return links_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::google::rpc::Help_Link >&
Help::links() const {
  // @@protoc_insertion_point(field_list:google.rpc.Help.links)
  return links_;
}

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

// LocalizedMessage

// string locale = 1;
inline void LocalizedMessage::clear_locale() {
  locale_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& LocalizedMessage::locale() const {
  // @@protoc_insertion_point(field_get:google.rpc.LocalizedMessage.locale)
  return locale_.GetNoArena();
}
inline void LocalizedMessage::set_locale(const ::std::string& value) {
  
  locale_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.rpc.LocalizedMessage.locale)
}
#if LANG_CXX11
inline void LocalizedMessage::set_locale(::std::string&& value) {
  
  locale_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.rpc.LocalizedMessage.locale)
}
#endif
inline void LocalizedMessage::set_locale(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  locale_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.rpc.LocalizedMessage.locale)
}
inline void LocalizedMessage::set_locale(const char* value, size_t size) {
  
  locale_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.rpc.LocalizedMessage.locale)
}
inline ::std::string* LocalizedMessage::mutable_locale() {
  
  // @@protoc_insertion_point(field_mutable:google.rpc.LocalizedMessage.locale)
  return locale_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* LocalizedMessage::release_locale() {
  // @@protoc_insertion_point(field_release:google.rpc.LocalizedMessage.locale)
  
  return locale_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void LocalizedMessage::set_allocated_locale(::std::string* locale) {
  if (locale != nullptr) {
    
  } else {
    
  }
  locale_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), locale);
  // @@protoc_insertion_point(field_set_allocated:google.rpc.LocalizedMessage.locale)
}

// string message = 2;
inline void LocalizedMessage::clear_message() {
  message_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& LocalizedMessage::message() const {
  // @@protoc_insertion_point(field_get:google.rpc.LocalizedMessage.message)
  return message_.GetNoArena();
}
inline void LocalizedMessage::set_message(const ::std::string& value) {
  
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.rpc.LocalizedMessage.message)
}
#if LANG_CXX11
inline void LocalizedMessage::set_message(::std::string&& value) {
  
  message_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.rpc.LocalizedMessage.message)
}
#endif
inline void LocalizedMessage::set_message(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.rpc.LocalizedMessage.message)
}
inline void LocalizedMessage::set_message(const char* value, size_t size) {
  
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.rpc.LocalizedMessage.message)
}
inline ::std::string* LocalizedMessage::mutable_message() {
  
  // @@protoc_insertion_point(field_mutable:google.rpc.LocalizedMessage.message)
  return message_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* LocalizedMessage::release_message() {
  // @@protoc_insertion_point(field_release:google.rpc.LocalizedMessage.message)
  
  return message_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void LocalizedMessage::set_allocated_message(::std::string* message) {
  if (message != nullptr) {
    
  } else {
    
  }
  message_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), message);
  // @@protoc_insertion_point(field_set_allocated:google.rpc.LocalizedMessage.message)
}

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace rpc
}  // namespace google

// @@protoc_insertion_point(global_scope)

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