zhuyujia-webhopper/collector/adg-linux/gen/components/drive/drive.pb.h

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

#ifndef PROTOBUF_drive_2eproto__INCLUDED
#define PROTOBUF_drive_2eproto__INCLUDED

#include <string>

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

#if GOOGLE_PROTOBUF_VERSION < 3003000
#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 3003002 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/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/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
// @@protoc_insertion_point(includes)
namespace drive {
class CapabilitiesInfo;
class CapabilitiesInfoDefaultTypeInternal;
extern CapabilitiesInfoDefaultTypeInternal _CapabilitiesInfo_default_instance_;
class DirectorySpecificInfo;
class DirectorySpecificInfoDefaultTypeInternal;
extern DirectorySpecificInfoDefaultTypeInternal _DirectorySpecificInfo_default_instance_;
class FileCacheEntry;
class FileCacheEntryDefaultTypeInternal;
extern FileCacheEntryDefaultTypeInternal _FileCacheEntry_default_instance_;
class FileSpecificInfo;
class FileSpecificInfoDefaultTypeInternal;
extern FileSpecificInfoDefaultTypeInternal _FileSpecificInfo_default_instance_;
class PlatformFileInfoProto;
class PlatformFileInfoProtoDefaultTypeInternal;
extern PlatformFileInfoProtoDefaultTypeInternal _PlatformFileInfoProto_default_instance_;
class Property;
class PropertyDefaultTypeInternal;
extern PropertyDefaultTypeInternal _Property_default_instance_;
class ResourceEntry;
class ResourceEntryDefaultTypeInternal;
extern ResourceEntryDefaultTypeInternal _ResourceEntry_default_instance_;
class ResourceMetadataHeader;
class ResourceMetadataHeaderDefaultTypeInternal;
extern ResourceMetadataHeaderDefaultTypeInternal _ResourceMetadataHeader_default_instance_;
class TeamDriveRootSpecificInfo;
class TeamDriveRootSpecificInfoDefaultTypeInternal;
extern TeamDriveRootSpecificInfoDefaultTypeInternal _TeamDriveRootSpecificInfo_default_instance_;
}  // namespace drive

namespace drive {

namespace protobuf_drive_2eproto {
// Internal implementation detail -- do not call these.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[];
  static const ::google::protobuf::uint32 offsets[];
  static void InitDefaultsImpl();
  static void Shutdown();
};
void AddDescriptors();
void InitDefaults();
}  // namespace protobuf_drive_2eproto

enum Property_Visibility {
  Property_Visibility_PRIVATE = 0,
  Property_Visibility_PUBLIC = 1
};
bool Property_Visibility_IsValid(int value);
const Property_Visibility Property_Visibility_Visibility_MIN = Property_Visibility_PRIVATE;
const Property_Visibility Property_Visibility_Visibility_MAX = Property_Visibility_PUBLIC;
const int Property_Visibility_Visibility_ARRAYSIZE = Property_Visibility_Visibility_MAX + 1;

enum ResourceEntry_EditState {
  ResourceEntry_EditState_CLEAN = 0,
  ResourceEntry_EditState_DIRTY = 1,
  ResourceEntry_EditState_SYNCING = 2
};
bool ResourceEntry_EditState_IsValid(int value);
const ResourceEntry_EditState ResourceEntry_EditState_EditState_MIN = ResourceEntry_EditState_CLEAN;
const ResourceEntry_EditState ResourceEntry_EditState_EditState_MAX = ResourceEntry_EditState_SYNCING;
const int ResourceEntry_EditState_EditState_ARRAYSIZE = ResourceEntry_EditState_EditState_MAX + 1;

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

class PlatformFileInfoProto : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:drive.PlatformFileInfoProto) */ {
 public:
  PlatformFileInfoProto();
  virtual ~PlatformFileInfoProto();

  PlatformFileInfoProto(const PlatformFileInfoProto& from);

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

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const PlatformFileInfoProto& default_instance();

  static inline const PlatformFileInfoProto* internal_default_instance() {
    return reinterpret_cast<const PlatformFileInfoProto*>(
               &_PlatformFileInfoProto_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    0;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(PlatformFileInfoProto* other);

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

  inline PlatformFileInfoProto* New() const PROTOBUF_FINAL { return New(NULL); }

  PlatformFileInfoProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const PlatformFileInfoProto& from);
  void MergeFrom(const PlatformFileInfoProto& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PlatformFileInfoProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

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

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

  // optional int64 size = 1;
  bool has_size() const;
  void clear_size();
  static const int kSizeFieldNumber = 1;
  ::google::protobuf::int64 size() const;
  void set_size(::google::protobuf::int64 value);

  // optional int64 last_modified = 4;
  bool has_last_modified() const;
  void clear_last_modified();
  static const int kLastModifiedFieldNumber = 4;
  ::google::protobuf::int64 last_modified() const;
  void set_last_modified(::google::protobuf::int64 value);

  // optional int64 last_accessed = 5;
  bool has_last_accessed() const;
  void clear_last_accessed();
  static const int kLastAccessedFieldNumber = 5;
  ::google::protobuf::int64 last_accessed() const;
  void set_last_accessed(::google::protobuf::int64 value);

  // optional int64 creation_time = 6;
  bool has_creation_time() const;
  void clear_creation_time();
  static const int kCreationTimeFieldNumber = 6;
  ::google::protobuf::int64 creation_time() const;
  void set_creation_time(::google::protobuf::int64 value);

  // optional bool is_directory = 2;
  bool has_is_directory() const;
  void clear_is_directory();
  static const int kIsDirectoryFieldNumber = 2;
  bool is_directory() const;
  void set_is_directory(bool value);

  // optional bool is_symbolic_link = 3;
  bool has_is_symbolic_link() const;
  void clear_is_symbolic_link();
  static const int kIsSymbolicLinkFieldNumber = 3;
  bool is_symbolic_link() const;
  void set_is_symbolic_link(bool value);

  // @@protoc_insertion_point(class_scope:drive.PlatformFileInfoProto)
 private:
  void set_has_size();
  void clear_has_size();
  void set_has_is_directory();
  void clear_has_is_directory();
  void set_has_is_symbolic_link();
  void clear_has_is_symbolic_link();
  void set_has_last_modified();
  void clear_has_last_modified();
  void set_has_last_accessed();
  void clear_has_last_accessed();
  void set_has_creation_time();
  void clear_has_creation_time();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::int64 size_;
  ::google::protobuf::int64 last_modified_;
  ::google::protobuf::int64 last_accessed_;
  ::google::protobuf::int64 creation_time_;
  bool is_directory_;
  bool is_symbolic_link_;
  friend struct protobuf_drive_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Property : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:drive.Property) */ {
 public:
  Property();
  virtual ~Property();

  Property(const Property& from);

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

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const Property& default_instance();

  static inline const Property* internal_default_instance() {
    return reinterpret_cast<const Property*>(
               &_Property_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    1;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(Property* other);

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

  inline Property* New() const PROTOBUF_FINAL { return New(NULL); }

  Property* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const Property& from);
  void MergeFrom(const Property& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Property* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

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

  typedef Property_Visibility Visibility;
  static const Visibility PRIVATE =
    Property_Visibility_PRIVATE;
  static const Visibility PUBLIC =
    Property_Visibility_PUBLIC;
  static inline bool Visibility_IsValid(int value) {
    return Property_Visibility_IsValid(value);
  }
  static const Visibility Visibility_MIN =
    Property_Visibility_Visibility_MIN;
  static const Visibility Visibility_MAX =
    Property_Visibility_Visibility_MAX;
  static const int Visibility_ARRAYSIZE =
    Property_Visibility_Visibility_ARRAYSIZE;

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

  // optional string key = 1;
  bool has_key() const;
  void clear_key();
  static const int kKeyFieldNumber = 1;
  const ::std::string& key() const;
  void set_key(const ::std::string& value);
  #if LANG_CXX11
  void set_key(::std::string&& value);
  #endif
  void set_key(const char* value);
  void set_key(const char* value, size_t size);
  ::std::string* mutable_key();
  ::std::string* release_key();
  void set_allocated_key(::std::string* key);

  // optional string value = 2;
  bool has_value() const;
  void clear_value();
  static const int kValueFieldNumber = 2;
  const ::std::string& value() const;
  void set_value(const ::std::string& value);
  #if LANG_CXX11
  void set_value(::std::string&& value);
  #endif
  void set_value(const char* value);
  void set_value(const char* value, size_t size);
  ::std::string* mutable_value();
  ::std::string* release_value();
  void set_allocated_value(::std::string* value);

  // optional .drive.Property.Visibility visibility = 3;
  bool has_visibility() const;
  void clear_visibility();
  static const int kVisibilityFieldNumber = 3;
  ::drive::Property_Visibility visibility() const;
  void set_visibility(::drive::Property_Visibility value);

  // @@protoc_insertion_point(class_scope:drive.Property)
 private:
  void set_has_key();
  void clear_has_key();
  void set_has_value();
  void clear_has_value();
  void set_has_visibility();
  void clear_has_visibility();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr key_;
  ::google::protobuf::internal::ArenaStringPtr value_;
  int visibility_;
  friend struct protobuf_drive_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class CapabilitiesInfo : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:drive.CapabilitiesInfo) */ {
 public:
  CapabilitiesInfo();
  virtual ~CapabilitiesInfo();

  CapabilitiesInfo(const CapabilitiesInfo& from);

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

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const CapabilitiesInfo& default_instance();

  static inline const CapabilitiesInfo* internal_default_instance() {
    return reinterpret_cast<const CapabilitiesInfo*>(
               &_CapabilitiesInfo_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    2;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(CapabilitiesInfo* other);

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

  inline CapabilitiesInfo* New() const PROTOBUF_FINAL { return New(NULL); }

  CapabilitiesInfo* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const CapabilitiesInfo& from);
  void MergeFrom(const CapabilitiesInfo& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(CapabilitiesInfo* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

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

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

  // optional bool can_copy = 1;
  bool has_can_copy() const;
  void clear_can_copy();
  static const int kCanCopyFieldNumber = 1;
  bool can_copy() const;
  void set_can_copy(bool value);

  // optional bool can_delete = 2;
  bool has_can_delete() const;
  void clear_can_delete();
  static const int kCanDeleteFieldNumber = 2;
  bool can_delete() const;
  void set_can_delete(bool value);

  // optional bool can_rename = 3;
  bool has_can_rename() const;
  void clear_can_rename();
  static const int kCanRenameFieldNumber = 3;
  bool can_rename() const;
  void set_can_rename(bool value);

  // optional bool can_add_children = 4;
  bool has_can_add_children() const;
  void clear_can_add_children();
  static const int kCanAddChildrenFieldNumber = 4;
  bool can_add_children() const;
  void set_can_add_children(bool value);

  // optional bool can_share = 5;
  bool has_can_share() const;
  void clear_can_share();
  static const int kCanShareFieldNumber = 5;
  bool can_share() const;
  void set_can_share(bool value);

  // @@protoc_insertion_point(class_scope:drive.CapabilitiesInfo)
 private:
  void set_has_can_copy();
  void clear_has_can_copy();
  void set_has_can_delete();
  void clear_has_can_delete();
  void set_has_can_rename();
  void clear_has_can_rename();
  void set_has_can_add_children();
  void clear_has_can_add_children();
  void set_has_can_share();
  void clear_has_can_share();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  bool can_copy_;
  bool can_delete_;
  bool can_rename_;
  bool can_add_children_;
  bool can_share_;
  friend struct protobuf_drive_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class FileSpecificInfo : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:drive.FileSpecificInfo) */ {
 public:
  FileSpecificInfo();
  virtual ~FileSpecificInfo();

  FileSpecificInfo(const FileSpecificInfo& from);

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

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const FileSpecificInfo& default_instance();

  static inline const FileSpecificInfo* internal_default_instance() {
    return reinterpret_cast<const FileSpecificInfo*>(
               &_FileSpecificInfo_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    3;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(FileSpecificInfo* other);

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

  inline FileSpecificInfo* New() const PROTOBUF_FINAL { return New(NULL); }

  FileSpecificInfo* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const FileSpecificInfo& from);
  void MergeFrom(const FileSpecificInfo& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(FileSpecificInfo* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

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

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

  // optional string content_mime_type = 3;
  bool has_content_mime_type() const;
  void clear_content_mime_type();
  static const int kContentMimeTypeFieldNumber = 3;
  const ::std::string& content_mime_type() const;
  void set_content_mime_type(const ::std::string& value);
  #if LANG_CXX11
  void set_content_mime_type(::std::string&& value);
  #endif
  void set_content_mime_type(const char* value);
  void set_content_mime_type(const char* value, size_t size);
  ::std::string* mutable_content_mime_type();
  ::std::string* release_content_mime_type();
  void set_allocated_content_mime_type(::std::string* content_mime_type);

  // optional string md5 = 4;
  bool has_md5() const;
  void clear_md5();
  static const int kMd5FieldNumber = 4;
  const ::std::string& md5() const;
  void set_md5(const ::std::string& value);
  #if LANG_CXX11
  void set_md5(::std::string&& value);
  #endif
  void set_md5(const char* value);
  void set_md5(const char* value, size_t size);
  ::std::string* mutable_md5();
  ::std::string* release_md5();
  void set_allocated_md5(::std::string* md5);

  // optional string document_extension = 5;
  bool has_document_extension() const;
  void clear_document_extension();
  static const int kDocumentExtensionFieldNumber = 5;
  const ::std::string& document_extension() const;
  void set_document_extension(const ::std::string& value);
  #if LANG_CXX11
  void set_document_extension(::std::string&& value);
  #endif
  void set_document_extension(const char* value);
  void set_document_extension(const char* value, size_t size);
  ::std::string* mutable_document_extension();
  ::std::string* release_document_extension();
  void set_allocated_document_extension(::std::string* document_extension);

  // optional .drive.FileCacheEntry cache_state = 11;
  bool has_cache_state() const;
  void clear_cache_state();
  static const int kCacheStateFieldNumber = 11;
  const ::drive::FileCacheEntry& cache_state() const;
  ::drive::FileCacheEntry* mutable_cache_state();
  ::drive::FileCacheEntry* release_cache_state();
  void set_allocated_cache_state(::drive::FileCacheEntry* cache_state);

  // optional int64 image_width = 8;
  bool has_image_width() const;
  void clear_image_width();
  static const int kImageWidthFieldNumber = 8;
  ::google::protobuf::int64 image_width() const;
  void set_image_width(::google::protobuf::int64 value);

  // optional int64 image_height = 9;
  bool has_image_height() const;
  void clear_image_height();
  static const int kImageHeightFieldNumber = 9;
  ::google::protobuf::int64 image_height() const;
  void set_image_height(::google::protobuf::int64 value);

  // optional bool is_hosted_document = 6;
  bool has_is_hosted_document() const;
  void clear_is_hosted_document();
  static const int kIsHostedDocumentFieldNumber = 6;
  bool is_hosted_document() const;
  void set_is_hosted_document(bool value);

  // optional int64 image_rotation = 10;
  bool has_image_rotation() const;
  void clear_image_rotation();
  static const int kImageRotationFieldNumber = 10;
  ::google::protobuf::int64 image_rotation() const;
  void set_image_rotation(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:drive.FileSpecificInfo)
 private:
  void set_has_content_mime_type();
  void clear_has_content_mime_type();
  void set_has_md5();
  void clear_has_md5();
  void set_has_document_extension();
  void clear_has_document_extension();
  void set_has_is_hosted_document();
  void clear_has_is_hosted_document();
  void set_has_image_width();
  void clear_has_image_width();
  void set_has_image_height();
  void clear_has_image_height();
  void set_has_image_rotation();
  void clear_has_image_rotation();
  void set_has_cache_state();
  void clear_has_cache_state();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr content_mime_type_;
  ::google::protobuf::internal::ArenaStringPtr md5_;
  ::google::protobuf::internal::ArenaStringPtr document_extension_;
  ::drive::FileCacheEntry* cache_state_;
  ::google::protobuf::int64 image_width_;
  ::google::protobuf::int64 image_height_;
  bool is_hosted_document_;
  ::google::protobuf::int64 image_rotation_;
  friend struct protobuf_drive_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TeamDriveRootSpecificInfo : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:drive.TeamDriveRootSpecificInfo) */ {
 public:
  TeamDriveRootSpecificInfo();
  virtual ~TeamDriveRootSpecificInfo();

  TeamDriveRootSpecificInfo(const TeamDriveRootSpecificInfo& from);

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

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const TeamDriveRootSpecificInfo& default_instance();

  static inline const TeamDriveRootSpecificInfo* internal_default_instance() {
    return reinterpret_cast<const TeamDriveRootSpecificInfo*>(
               &_TeamDriveRootSpecificInfo_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    4;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(TeamDriveRootSpecificInfo* other);

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

  inline TeamDriveRootSpecificInfo* New() const PROTOBUF_FINAL { return New(NULL); }

  TeamDriveRootSpecificInfo* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const TeamDriveRootSpecificInfo& from);
  void MergeFrom(const TeamDriveRootSpecificInfo& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TeamDriveRootSpecificInfo* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

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

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

  // optional string start_page_token = 1;
  bool has_start_page_token() const;
  void clear_start_page_token();
  static const int kStartPageTokenFieldNumber = 1;
  const ::std::string& start_page_token() const;
  void set_start_page_token(const ::std::string& value);
  #if LANG_CXX11
  void set_start_page_token(::std::string&& value);
  #endif
  void set_start_page_token(const char* value);
  void set_start_page_token(const char* value, size_t size);
  ::std::string* mutable_start_page_token();
  ::std::string* release_start_page_token();
  void set_allocated_start_page_token(::std::string* start_page_token);

  // @@protoc_insertion_point(class_scope:drive.TeamDriveRootSpecificInfo)
 private:
  void set_has_start_page_token();
  void clear_has_start_page_token();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr start_page_token_;
  friend struct protobuf_drive_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class DirectorySpecificInfo : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:drive.DirectorySpecificInfo) */ {
 public:
  DirectorySpecificInfo();
  virtual ~DirectorySpecificInfo();

  DirectorySpecificInfo(const DirectorySpecificInfo& from);

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

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const DirectorySpecificInfo& default_instance();

  static inline const DirectorySpecificInfo* internal_default_instance() {
    return reinterpret_cast<const DirectorySpecificInfo*>(
               &_DirectorySpecificInfo_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    5;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(DirectorySpecificInfo* other);

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

  inline DirectorySpecificInfo* New() const PROTOBUF_FINAL { return New(NULL); }

  DirectorySpecificInfo* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const DirectorySpecificInfo& from);
  void MergeFrom(const DirectorySpecificInfo& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DirectorySpecificInfo* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

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

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

  // optional string start_page_token = 2;
  bool has_start_page_token() const;
  void clear_start_page_token();
  static const int kStartPageTokenFieldNumber = 2;
  const ::std::string& start_page_token() const;
  void set_start_page_token(const ::std::string& value);
  #if LANG_CXX11
  void set_start_page_token(::std::string&& value);
  #endif
  void set_start_page_token(const char* value);
  void set_start_page_token(const char* value, size_t size);
  ::std::string* mutable_start_page_token();
  ::std::string* release_start_page_token();
  void set_allocated_start_page_token(::std::string* start_page_token);

  // optional int64 changestamp = 1 [deprecated = true];
  GOOGLE_PROTOBUF_DEPRECATED_ATTR bool has_changestamp() const;
  GOOGLE_PROTOBUF_DEPRECATED_ATTR void clear_changestamp();
  GOOGLE_PROTOBUF_DEPRECATED_ATTR static const int kChangestampFieldNumber = 1;
  GOOGLE_PROTOBUF_DEPRECATED_ATTR ::google::protobuf::int64 changestamp() const;
  GOOGLE_PROTOBUF_DEPRECATED_ATTR void set_changestamp(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:drive.DirectorySpecificInfo)
 private:
  void set_has_changestamp();
  void clear_has_changestamp();
  void set_has_start_page_token();
  void clear_has_start_page_token();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr start_page_token_;
  ::google::protobuf::int64 changestamp_;
  friend struct protobuf_drive_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ResourceEntry : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:drive.ResourceEntry) */ {
 public:
  ResourceEntry();
  virtual ~ResourceEntry();

  ResourceEntry(const ResourceEntry& from);

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

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ResourceEntry& default_instance();

  static inline const ResourceEntry* internal_default_instance() {
    return reinterpret_cast<const ResourceEntry*>(
               &_ResourceEntry_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    6;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(ResourceEntry* other);

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

  inline ResourceEntry* New() const PROTOBUF_FINAL { return New(NULL); }

  ResourceEntry* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const ResourceEntry& from);
  void MergeFrom(const ResourceEntry& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ResourceEntry* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

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

  typedef ResourceEntry_EditState EditState;
  static const EditState CLEAN =
    ResourceEntry_EditState_CLEAN;
  static const EditState DIRTY =
    ResourceEntry_EditState_DIRTY;
  static const EditState SYNCING =
    ResourceEntry_EditState_SYNCING;
  static inline bool EditState_IsValid(int value) {
    return ResourceEntry_EditState_IsValid(value);
  }
  static const EditState EditState_MIN =
    ResourceEntry_EditState_EditState_MIN;
  static const EditState EditState_MAX =
    ResourceEntry_EditState_EditState_MAX;
  static const int EditState_ARRAYSIZE =
    ResourceEntry_EditState_EditState_ARRAYSIZE;

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

  // repeated .drive.Property new_properties = 19;
  int new_properties_size() const;
  void clear_new_properties();
  static const int kNewPropertiesFieldNumber = 19;
  const ::drive::Property& new_properties(int index) const;
  ::drive::Property* mutable_new_properties(int index);
  ::drive::Property* add_new_properties();
  ::google::protobuf::RepeatedPtrField< ::drive::Property >*
      mutable_new_properties();
  const ::google::protobuf::RepeatedPtrField< ::drive::Property >&
      new_properties() const;

  // optional string base_name = 2;
  bool has_base_name() const;
  void clear_base_name();
  static const int kBaseNameFieldNumber = 2;
  const ::std::string& base_name() const;
  void set_base_name(const ::std::string& value);
  #if LANG_CXX11
  void set_base_name(::std::string&& value);
  #endif
  void set_base_name(const char* value);
  void set_base_name(const char* value, size_t size);
  ::std::string* mutable_base_name();
  ::std::string* release_base_name();
  void set_allocated_base_name(::std::string* base_name);

  // optional string title = 3;
  bool has_title() const;
  void clear_title();
  static const int kTitleFieldNumber = 3;
  const ::std::string& title() const;
  void set_title(const ::std::string& value);
  #if LANG_CXX11
  void set_title(::std::string&& value);
  #endif
  void set_title(const char* value);
  void set_title(const char* value, size_t size);
  ::std::string* mutable_title();
  ::std::string* release_title();
  void set_allocated_title(::std::string* title);

  // optional string resource_id = 4;
  bool has_resource_id() const;
  void clear_resource_id();
  static const int kResourceIdFieldNumber = 4;
  const ::std::string& resource_id() const;
  void set_resource_id(const ::std::string& value);
  #if LANG_CXX11
  void set_resource_id(::std::string&& value);
  #endif
  void set_resource_id(const char* value);
  void set_resource_id(const char* value, size_t size);
  ::std::string* mutable_resource_id();
  ::std::string* release_resource_id();
  void set_allocated_resource_id(::std::string* resource_id);

  // optional string parent_local_id = 7;
  bool has_parent_local_id() const;
  void clear_parent_local_id();
  static const int kParentLocalIdFieldNumber = 7;
  const ::std::string& parent_local_id() const;
  void set_parent_local_id(const ::std::string& value);
  #if LANG_CXX11
  void set_parent_local_id(::std::string&& value);
  #endif
  void set_parent_local_id(const char* value);
  void set_parent_local_id(const char* value, size_t size);
  ::std::string* mutable_parent_local_id();
  ::std::string* release_parent_local_id();
  void set_allocated_parent_local_id(::std::string* parent_local_id);

  // optional string local_id = 15;
  bool has_local_id() const;
  void clear_local_id();
  static const int kLocalIdFieldNumber = 15;
  const ::std::string& local_id() const;
  void set_local_id(const ::std::string& value);
  #if LANG_CXX11
  void set_local_id(::std::string&& value);
  #endif
  void set_local_id(const char* value);
  void set_local_id(const char* value, size_t size);
  ::std::string* mutable_local_id();
  ::std::string* release_local_id();
  void set_allocated_local_id(::std::string* local_id);

  // optional string alternate_url = 22;
  bool has_alternate_url() const;
  void clear_alternate_url();
  static const int kAlternateUrlFieldNumber = 22;
  const ::std::string& alternate_url() const;
  void set_alternate_url(const ::std::string& value);
  #if LANG_CXX11
  void set_alternate_url(::std::string&& value);
  #endif
  void set_alternate_url(const char* value);
  void set_alternate_url(const char* value, size_t size);
  ::std::string* mutable_alternate_url();
  ::std::string* release_alternate_url();
  void set_allocated_alternate_url(::std::string* alternate_url);

  // optional .drive.PlatformFileInfoProto file_info = 1;
  bool has_file_info() const;
  void clear_file_info();
  static const int kFileInfoFieldNumber = 1;
  const ::drive::PlatformFileInfoProto& file_info() const;
  ::drive::PlatformFileInfoProto* mutable_file_info();
  ::drive::PlatformFileInfoProto* release_file_info();
  void set_allocated_file_info(::drive::PlatformFileInfoProto* file_info);

  // optional .drive.FileSpecificInfo file_specific_info = 9;
  bool has_file_specific_info() const;
  void clear_file_specific_info();
  static const int kFileSpecificInfoFieldNumber = 9;
  const ::drive::FileSpecificInfo& file_specific_info() const;
  ::drive::FileSpecificInfo* mutable_file_specific_info();
  ::drive::FileSpecificInfo* release_file_specific_info();
  void set_allocated_file_specific_info(::drive::FileSpecificInfo* file_specific_info);

  // optional .drive.DirectorySpecificInfo directory_specific_info = 13;
  bool has_directory_specific_info() const;
  void clear_directory_specific_info();
  static const int kDirectorySpecificInfoFieldNumber = 13;
  const ::drive::DirectorySpecificInfo& directory_specific_info() const;
  ::drive::DirectorySpecificInfo* mutable_directory_specific_info();
  ::drive::DirectorySpecificInfo* release_directory_specific_info();
  void set_allocated_directory_specific_info(::drive::DirectorySpecificInfo* directory_specific_info);

  // optional .drive.TeamDriveRootSpecificInfo team_drive_root_specific_info = 23;
  bool has_team_drive_root_specific_info() const;
  void clear_team_drive_root_specific_info();
  static const int kTeamDriveRootSpecificInfoFieldNumber = 23;
  const ::drive::TeamDriveRootSpecificInfo& team_drive_root_specific_info() const;
  ::drive::TeamDriveRootSpecificInfo* mutable_team_drive_root_specific_info();
  ::drive::TeamDriveRootSpecificInfo* release_team_drive_root_specific_info();
  void set_allocated_team_drive_root_specific_info(::drive::TeamDriveRootSpecificInfo* team_drive_root_specific_info);

  // optional .drive.CapabilitiesInfo capabilities_info = 24;
  bool has_capabilities_info() const;
  void clear_capabilities_info();
  static const int kCapabilitiesInfoFieldNumber = 24;
  const ::drive::CapabilitiesInfo& capabilities_info() const;
  ::drive::CapabilitiesInfo* mutable_capabilities_info();
  ::drive::CapabilitiesInfo* release_capabilities_info();
  void set_allocated_capabilities_info(::drive::CapabilitiesInfo* capabilities_info);

  // optional bool deleted = 11;
  bool has_deleted() const;
  void clear_deleted();
  static const int kDeletedFieldNumber = 11;
  bool deleted() const;
  void set_deleted(bool value);

  // optional bool starred = 20;
  bool has_starred() const;
  void clear_starred();
  static const int kStarredFieldNumber = 20;
  bool starred() const;
  void set_starred(bool value);

  // optional bool shared_with_me = 14;
  bool has_shared_with_me() const;
  void clear_shared_with_me();
  static const int kSharedWithMeFieldNumber = 14;
  bool shared_with_me() const;
  void set_shared_with_me(bool value);

  // optional bool shared = 17;
  bool has_shared() const;
  void clear_shared();
  static const int kSharedFieldNumber = 17;
  bool shared() const;
  void set_shared(bool value);

  // optional .drive.ResourceEntry.EditState metadata_edit_state = 16;
  bool has_metadata_edit_state() const;
  void clear_metadata_edit_state();
  static const int kMetadataEditStateFieldNumber = 16;
  ::drive::ResourceEntry_EditState metadata_edit_state() const;
  void set_metadata_edit_state(::drive::ResourceEntry_EditState value);

  // optional int64 modification_date = 18;
  bool has_modification_date() const;
  void clear_modification_date();
  static const int kModificationDateFieldNumber = 18;
  ::google::protobuf::int64 modification_date() const;
  void set_modification_date(::google::protobuf::int64 value);

  // optional int64 last_modified_by_me = 21;
  bool has_last_modified_by_me() const;
  void clear_last_modified_by_me();
  static const int kLastModifiedByMeFieldNumber = 21;
  ::google::protobuf::int64 last_modified_by_me() const;
  void set_last_modified_by_me(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:drive.ResourceEntry)
 private:
  void set_has_file_info();
  void clear_has_file_info();
  void set_has_base_name();
  void clear_has_base_name();
  void set_has_title();
  void clear_has_title();
  void set_has_resource_id();
  void clear_has_resource_id();
  void set_has_local_id();
  void clear_has_local_id();
  void set_has_parent_local_id();
  void clear_has_parent_local_id();
  void set_has_deleted();
  void clear_has_deleted();
  void set_has_starred();
  void clear_has_starred();
  void set_has_shared_with_me();
  void clear_has_shared_with_me();
  void set_has_shared();
  void clear_has_shared();
  void set_has_capabilities_info();
  void clear_has_capabilities_info();
  void set_has_file_specific_info();
  void clear_has_file_specific_info();
  void set_has_directory_specific_info();
  void clear_has_directory_specific_info();
  void set_has_team_drive_root_specific_info();
  void clear_has_team_drive_root_specific_info();
  void set_has_metadata_edit_state();
  void clear_has_metadata_edit_state();
  void set_has_modification_date();
  void clear_has_modification_date();
  void set_has_last_modified_by_me();
  void clear_has_last_modified_by_me();
  void set_has_alternate_url();
  void clear_has_alternate_url();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::drive::Property > new_properties_;
  ::google::protobuf::internal::ArenaStringPtr base_name_;
  ::google::protobuf::internal::ArenaStringPtr title_;
  ::google::protobuf::internal::ArenaStringPtr resource_id_;
  ::google::protobuf::internal::ArenaStringPtr parent_local_id_;
  ::google::protobuf::internal::ArenaStringPtr local_id_;
  ::google::protobuf::internal::ArenaStringPtr alternate_url_;
  ::drive::PlatformFileInfoProto* file_info_;
  ::drive::FileSpecificInfo* file_specific_info_;
  ::drive::DirectorySpecificInfo* directory_specific_info_;
  ::drive::TeamDriveRootSpecificInfo* team_drive_root_specific_info_;
  ::drive::CapabilitiesInfo* capabilities_info_;
  bool deleted_;
  bool starred_;
  bool shared_with_me_;
  bool shared_;
  int metadata_edit_state_;
  ::google::protobuf::int64 modification_date_;
  ::google::protobuf::int64 last_modified_by_me_;
  friend struct protobuf_drive_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ResourceMetadataHeader : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:drive.ResourceMetadataHeader) */ {
 public:
  ResourceMetadataHeader();
  virtual ~ResourceMetadataHeader();

  ResourceMetadataHeader(const ResourceMetadataHeader& from);

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

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ResourceMetadataHeader& default_instance();

  static inline const ResourceMetadataHeader* internal_default_instance() {
    return reinterpret_cast<const ResourceMetadataHeader*>(
               &_ResourceMetadataHeader_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    7;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(ResourceMetadataHeader* other);

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

  inline ResourceMetadataHeader* New() const PROTOBUF_FINAL { return New(NULL); }

  ResourceMetadataHeader* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const ResourceMetadataHeader& from);
  void MergeFrom(const ResourceMetadataHeader& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ResourceMetadataHeader* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

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

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

  // optional string start_page_token = 4;
  bool has_start_page_token() const;
  void clear_start_page_token();
  static const int kStartPageTokenFieldNumber = 4;
  const ::std::string& start_page_token() const;
  void set_start_page_token(const ::std::string& value);
  #if LANG_CXX11
  void set_start_page_token(::std::string&& value);
  #endif
  void set_start_page_token(const char* value);
  void set_start_page_token(const char* value, size_t size);
  ::std::string* mutable_start_page_token();
  ::std::string* release_start_page_token();
  void set_allocated_start_page_token(::std::string* start_page_token);

  // optional int64 largest_changestamp = 2 [deprecated = true];
  GOOGLE_PROTOBUF_DEPRECATED_ATTR bool has_largest_changestamp() const;
  GOOGLE_PROTOBUF_DEPRECATED_ATTR void clear_largest_changestamp();
  GOOGLE_PROTOBUF_DEPRECATED_ATTR static const int kLargestChangestampFieldNumber = 2;
  GOOGLE_PROTOBUF_DEPRECATED_ATTR ::google::protobuf::int64 largest_changestamp() const;
  GOOGLE_PROTOBUF_DEPRECATED_ATTR void set_largest_changestamp(::google::protobuf::int64 value);

  // optional int32 version = 1;
  bool has_version() const;
  void clear_version();
  static const int kVersionFieldNumber = 1;
  ::google::protobuf::int32 version() const;
  void set_version(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:drive.ResourceMetadataHeader)
 private:
  void set_has_version();
  void clear_has_version();
  void set_has_largest_changestamp();
  void clear_has_largest_changestamp();
  void set_has_start_page_token();
  void clear_has_start_page_token();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr start_page_token_;
  ::google::protobuf::int64 largest_changestamp_;
  ::google::protobuf::int32 version_;
  friend struct protobuf_drive_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class FileCacheEntry : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:drive.FileCacheEntry) */ {
 public:
  FileCacheEntry();
  virtual ~FileCacheEntry();

  FileCacheEntry(const FileCacheEntry& from);

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

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const FileCacheEntry& default_instance();

  static inline const FileCacheEntry* internal_default_instance() {
    return reinterpret_cast<const FileCacheEntry*>(
               &_FileCacheEntry_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    8;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(FileCacheEntry* other);

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

  inline FileCacheEntry* New() const PROTOBUF_FINAL { return New(NULL); }

  FileCacheEntry* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const FileCacheEntry& from);
  void MergeFrom(const FileCacheEntry& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(FileCacheEntry* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

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

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

  // optional string md5 = 1;
  bool has_md5() const;
  void clear_md5();
  static const int kMd5FieldNumber = 1;
  const ::std::string& md5() const;
  void set_md5(const ::std::string& value);
  #if LANG_CXX11
  void set_md5(::std::string&& value);
  #endif
  void set_md5(const char* value);
  void set_md5(const char* value, size_t size);
  ::std::string* mutable_md5();
  ::std::string* release_md5();
  void set_allocated_md5(::std::string* md5);

  // optional bool is_present = 2;
  bool has_is_present() const;
  void clear_is_present();
  static const int kIsPresentFieldNumber = 2;
  bool is_present() const;
  void set_is_present(bool value);

  // optional bool is_pinned = 3;
  bool has_is_pinned() const;
  void clear_is_pinned();
  static const int kIsPinnedFieldNumber = 3;
  bool is_pinned() const;
  void set_is_pinned(bool value);

  // optional bool is_dirty = 4;
  bool has_is_dirty() const;
  void clear_is_dirty();
  static const int kIsDirtyFieldNumber = 4;
  bool is_dirty() const;
  void set_is_dirty(bool value);

  // @@protoc_insertion_point(class_scope:drive.FileCacheEntry)
 private:
  void set_has_md5();
  void clear_has_md5();
  void set_has_is_present();
  void clear_has_is_present();
  void set_has_is_pinned();
  void clear_has_is_pinned();
  void set_has_is_dirty();
  void clear_has_is_dirty();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr md5_;
  bool is_present_;
  bool is_pinned_;
  bool is_dirty_;
  friend struct protobuf_drive_2eproto::TableStruct;
};
// ===================================================================


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

#if !PROTOBUF_INLINE_NOT_IN_HEADERS
// PlatformFileInfoProto

// optional int64 size = 1;
inline bool PlatformFileInfoProto::has_size() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PlatformFileInfoProto::set_has_size() {
  _has_bits_[0] |= 0x00000001u;
}
inline void PlatformFileInfoProto::clear_has_size() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void PlatformFileInfoProto::clear_size() {
  size_ = GOOGLE_LONGLONG(0);
  clear_has_size();
}
inline ::google::protobuf::int64 PlatformFileInfoProto::size() const {
  // @@protoc_insertion_point(field_get:drive.PlatformFileInfoProto.size)
  return size_;
}
inline void PlatformFileInfoProto::set_size(::google::protobuf::int64 value) {
  set_has_size();
  size_ = value;
  // @@protoc_insertion_point(field_set:drive.PlatformFileInfoProto.size)
}

// optional bool is_directory = 2;
inline bool PlatformFileInfoProto::has_is_directory() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void PlatformFileInfoProto::set_has_is_directory() {
  _has_bits_[0] |= 0x00000010u;
}
inline void PlatformFileInfoProto::clear_has_is_directory() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void PlatformFileInfoProto::clear_is_directory() {
  is_directory_ = false;
  clear_has_is_directory();
}
inline bool PlatformFileInfoProto::is_directory() const {
  // @@protoc_insertion_point(field_get:drive.PlatformFileInfoProto.is_directory)
  return is_directory_;
}
inline void PlatformFileInfoProto::set_is_directory(bool value) {
  set_has_is_directory();
  is_directory_ = value;
  // @@protoc_insertion_point(field_set:drive.PlatformFileInfoProto.is_directory)
}

// optional bool is_symbolic_link = 3;
inline bool PlatformFileInfoProto::has_is_symbolic_link() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void PlatformFileInfoProto::set_has_is_symbolic_link() {
  _has_bits_[0] |= 0x00000020u;
}
inline void PlatformFileInfoProto::clear_has_is_symbolic_link() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void PlatformFileInfoProto::clear_is_symbolic_link() {
  is_symbolic_link_ = false;
  clear_has_is_symbolic_link();
}
inline bool PlatformFileInfoProto::is_symbolic_link() const {
  // @@protoc_insertion_point(field_get:drive.PlatformFileInfoProto.is_symbolic_link)
  return is_symbolic_link_;
}
inline void PlatformFileInfoProto::set_is_symbolic_link(bool value) {
  set_has_is_symbolic_link();
  is_symbolic_link_ = value;
  // @@protoc_insertion_point(field_set:drive.PlatformFileInfoProto.is_symbolic_link)
}

// optional int64 last_modified = 4;
inline bool PlatformFileInfoProto::has_last_modified() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PlatformFileInfoProto::set_has_last_modified() {
  _has_bits_[0] |= 0x00000002u;
}
inline void PlatformFileInfoProto::clear_has_last_modified() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void PlatformFileInfoProto::clear_last_modified() {
  last_modified_ = GOOGLE_LONGLONG(0);
  clear_has_last_modified();
}
inline ::google::protobuf::int64 PlatformFileInfoProto::last_modified() const {
  // @@protoc_insertion_point(field_get:drive.PlatformFileInfoProto.last_modified)
  return last_modified_;
}
inline void PlatformFileInfoProto::set_last_modified(::google::protobuf::int64 value) {
  set_has_last_modified();
  last_modified_ = value;
  // @@protoc_insertion_point(field_set:drive.PlatformFileInfoProto.last_modified)
}

// optional int64 last_accessed = 5;
inline bool PlatformFileInfoProto::has_last_accessed() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void PlatformFileInfoProto::set_has_last_accessed() {
  _has_bits_[0] |= 0x00000004u;
}
inline void PlatformFileInfoProto::clear_has_last_accessed() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void PlatformFileInfoProto::clear_last_accessed() {
  last_accessed_ = GOOGLE_LONGLONG(0);
  clear_has_last_accessed();
}
inline ::google::protobuf::int64 PlatformFileInfoProto::last_accessed() const {
  // @@protoc_insertion_point(field_get:drive.PlatformFileInfoProto.last_accessed)
  return last_accessed_;
}
inline void PlatformFileInfoProto::set_last_accessed(::google::protobuf::int64 value) {
  set_has_last_accessed();
  last_accessed_ = value;
  // @@protoc_insertion_point(field_set:drive.PlatformFileInfoProto.last_accessed)
}

// optional int64 creation_time = 6;
inline bool PlatformFileInfoProto::has_creation_time() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void PlatformFileInfoProto::set_has_creation_time() {
  _has_bits_[0] |= 0x00000008u;
}
inline void PlatformFileInfoProto::clear_has_creation_time() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void PlatformFileInfoProto::clear_creation_time() {
  creation_time_ = GOOGLE_LONGLONG(0);
  clear_has_creation_time();
}
inline ::google::protobuf::int64 PlatformFileInfoProto::creation_time() const {
  // @@protoc_insertion_point(field_get:drive.PlatformFileInfoProto.creation_time)
  return creation_time_;
}
inline void PlatformFileInfoProto::set_creation_time(::google::protobuf::int64 value) {
  set_has_creation_time();
  creation_time_ = value;
  // @@protoc_insertion_point(field_set:drive.PlatformFileInfoProto.creation_time)
}

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

// Property

// optional string key = 1;
inline bool Property::has_key() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Property::set_has_key() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Property::clear_has_key() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Property::clear_key() {
  key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_key();
}
inline const ::std::string& Property::key() const {
  // @@protoc_insertion_point(field_get:drive.Property.key)
  return key_.GetNoArena();
}
inline void Property::set_key(const ::std::string& value) {
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.Property.key)
}
#if LANG_CXX11
inline void Property::set_key(::std::string&& value) {
  set_has_key();
  key_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.Property.key)
}
#endif
inline void Property::set_key(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.Property.key)
}
inline void Property::set_key(const char* value, size_t size) {
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.Property.key)
}
inline ::std::string* Property::mutable_key() {
  set_has_key();
  // @@protoc_insertion_point(field_mutable:drive.Property.key)
  return key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Property::release_key() {
  // @@protoc_insertion_point(field_release:drive.Property.key)
  clear_has_key();
  return key_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Property::set_allocated_key(::std::string* key) {
  if (key != NULL) {
    set_has_key();
  } else {
    clear_has_key();
  }
  key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), key);
  // @@protoc_insertion_point(field_set_allocated:drive.Property.key)
}

// optional string value = 2;
inline bool Property::has_value() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Property::set_has_value() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Property::clear_has_value() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Property::clear_value() {
  value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_value();
}
inline const ::std::string& Property::value() const {
  // @@protoc_insertion_point(field_get:drive.Property.value)
  return value_.GetNoArena();
}
inline void Property::set_value(const ::std::string& value) {
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.Property.value)
}
#if LANG_CXX11
inline void Property::set_value(::std::string&& value) {
  set_has_value();
  value_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.Property.value)
}
#endif
inline void Property::set_value(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.Property.value)
}
inline void Property::set_value(const char* value, size_t size) {
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.Property.value)
}
inline ::std::string* Property::mutable_value() {
  set_has_value();
  // @@protoc_insertion_point(field_mutable:drive.Property.value)
  return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Property::release_value() {
  // @@protoc_insertion_point(field_release:drive.Property.value)
  clear_has_value();
  return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Property::set_allocated_value(::std::string* value) {
  if (value != NULL) {
    set_has_value();
  } else {
    clear_has_value();
  }
  value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set_allocated:drive.Property.value)
}

// optional .drive.Property.Visibility visibility = 3;
inline bool Property::has_visibility() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Property::set_has_visibility() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Property::clear_has_visibility() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Property::clear_visibility() {
  visibility_ = 0;
  clear_has_visibility();
}
inline ::drive::Property_Visibility Property::visibility() const {
  // @@protoc_insertion_point(field_get:drive.Property.visibility)
  return static_cast< ::drive::Property_Visibility >(visibility_);
}
inline void Property::set_visibility(::drive::Property_Visibility value) {
  assert(::drive::Property_Visibility_IsValid(value));
  set_has_visibility();
  visibility_ = value;
  // @@protoc_insertion_point(field_set:drive.Property.visibility)
}

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

// CapabilitiesInfo

// optional bool can_copy = 1;
inline bool CapabilitiesInfo::has_can_copy() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CapabilitiesInfo::set_has_can_copy() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CapabilitiesInfo::clear_has_can_copy() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CapabilitiesInfo::clear_can_copy() {
  can_copy_ = false;
  clear_has_can_copy();
}
inline bool CapabilitiesInfo::can_copy() const {
  // @@protoc_insertion_point(field_get:drive.CapabilitiesInfo.can_copy)
  return can_copy_;
}
inline void CapabilitiesInfo::set_can_copy(bool value) {
  set_has_can_copy();
  can_copy_ = value;
  // @@protoc_insertion_point(field_set:drive.CapabilitiesInfo.can_copy)
}

// optional bool can_delete = 2;
inline bool CapabilitiesInfo::has_can_delete() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CapabilitiesInfo::set_has_can_delete() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CapabilitiesInfo::clear_has_can_delete() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CapabilitiesInfo::clear_can_delete() {
  can_delete_ = false;
  clear_has_can_delete();
}
inline bool CapabilitiesInfo::can_delete() const {
  // @@protoc_insertion_point(field_get:drive.CapabilitiesInfo.can_delete)
  return can_delete_;
}
inline void CapabilitiesInfo::set_can_delete(bool value) {
  set_has_can_delete();
  can_delete_ = value;
  // @@protoc_insertion_point(field_set:drive.CapabilitiesInfo.can_delete)
}

// optional bool can_rename = 3;
inline bool CapabilitiesInfo::has_can_rename() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CapabilitiesInfo::set_has_can_rename() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CapabilitiesInfo::clear_has_can_rename() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CapabilitiesInfo::clear_can_rename() {
  can_rename_ = false;
  clear_has_can_rename();
}
inline bool CapabilitiesInfo::can_rename() const {
  // @@protoc_insertion_point(field_get:drive.CapabilitiesInfo.can_rename)
  return can_rename_;
}
inline void CapabilitiesInfo::set_can_rename(bool value) {
  set_has_can_rename();
  can_rename_ = value;
  // @@protoc_insertion_point(field_set:drive.CapabilitiesInfo.can_rename)
}

// optional bool can_add_children = 4;
inline bool CapabilitiesInfo::has_can_add_children() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void CapabilitiesInfo::set_has_can_add_children() {
  _has_bits_[0] |= 0x00000008u;
}
inline void CapabilitiesInfo::clear_has_can_add_children() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void CapabilitiesInfo::clear_can_add_children() {
  can_add_children_ = false;
  clear_has_can_add_children();
}
inline bool CapabilitiesInfo::can_add_children() const {
  // @@protoc_insertion_point(field_get:drive.CapabilitiesInfo.can_add_children)
  return can_add_children_;
}
inline void CapabilitiesInfo::set_can_add_children(bool value) {
  set_has_can_add_children();
  can_add_children_ = value;
  // @@protoc_insertion_point(field_set:drive.CapabilitiesInfo.can_add_children)
}

// optional bool can_share = 5;
inline bool CapabilitiesInfo::has_can_share() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void CapabilitiesInfo::set_has_can_share() {
  _has_bits_[0] |= 0x00000010u;
}
inline void CapabilitiesInfo::clear_has_can_share() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void CapabilitiesInfo::clear_can_share() {
  can_share_ = false;
  clear_has_can_share();
}
inline bool CapabilitiesInfo::can_share() const {
  // @@protoc_insertion_point(field_get:drive.CapabilitiesInfo.can_share)
  return can_share_;
}
inline void CapabilitiesInfo::set_can_share(bool value) {
  set_has_can_share();
  can_share_ = value;
  // @@protoc_insertion_point(field_set:drive.CapabilitiesInfo.can_share)
}

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

// FileSpecificInfo

// optional string content_mime_type = 3;
inline bool FileSpecificInfo::has_content_mime_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void FileSpecificInfo::set_has_content_mime_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void FileSpecificInfo::clear_has_content_mime_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void FileSpecificInfo::clear_content_mime_type() {
  content_mime_type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_content_mime_type();
}
inline const ::std::string& FileSpecificInfo::content_mime_type() const {
  // @@protoc_insertion_point(field_get:drive.FileSpecificInfo.content_mime_type)
  return content_mime_type_.GetNoArena();
}
inline void FileSpecificInfo::set_content_mime_type(const ::std::string& value) {
  set_has_content_mime_type();
  content_mime_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.FileSpecificInfo.content_mime_type)
}
#if LANG_CXX11
inline void FileSpecificInfo::set_content_mime_type(::std::string&& value) {
  set_has_content_mime_type();
  content_mime_type_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.FileSpecificInfo.content_mime_type)
}
#endif
inline void FileSpecificInfo::set_content_mime_type(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_content_mime_type();
  content_mime_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.FileSpecificInfo.content_mime_type)
}
inline void FileSpecificInfo::set_content_mime_type(const char* value, size_t size) {
  set_has_content_mime_type();
  content_mime_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.FileSpecificInfo.content_mime_type)
}
inline ::std::string* FileSpecificInfo::mutable_content_mime_type() {
  set_has_content_mime_type();
  // @@protoc_insertion_point(field_mutable:drive.FileSpecificInfo.content_mime_type)
  return content_mime_type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* FileSpecificInfo::release_content_mime_type() {
  // @@protoc_insertion_point(field_release:drive.FileSpecificInfo.content_mime_type)
  clear_has_content_mime_type();
  return content_mime_type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void FileSpecificInfo::set_allocated_content_mime_type(::std::string* content_mime_type) {
  if (content_mime_type != NULL) {
    set_has_content_mime_type();
  } else {
    clear_has_content_mime_type();
  }
  content_mime_type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), content_mime_type);
  // @@protoc_insertion_point(field_set_allocated:drive.FileSpecificInfo.content_mime_type)
}

// optional string md5 = 4;
inline bool FileSpecificInfo::has_md5() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void FileSpecificInfo::set_has_md5() {
  _has_bits_[0] |= 0x00000002u;
}
inline void FileSpecificInfo::clear_has_md5() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void FileSpecificInfo::clear_md5() {
  md5_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_md5();
}
inline const ::std::string& FileSpecificInfo::md5() const {
  // @@protoc_insertion_point(field_get:drive.FileSpecificInfo.md5)
  return md5_.GetNoArena();
}
inline void FileSpecificInfo::set_md5(const ::std::string& value) {
  set_has_md5();
  md5_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.FileSpecificInfo.md5)
}
#if LANG_CXX11
inline void FileSpecificInfo::set_md5(::std::string&& value) {
  set_has_md5();
  md5_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.FileSpecificInfo.md5)
}
#endif
inline void FileSpecificInfo::set_md5(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_md5();
  md5_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.FileSpecificInfo.md5)
}
inline void FileSpecificInfo::set_md5(const char* value, size_t size) {
  set_has_md5();
  md5_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.FileSpecificInfo.md5)
}
inline ::std::string* FileSpecificInfo::mutable_md5() {
  set_has_md5();
  // @@protoc_insertion_point(field_mutable:drive.FileSpecificInfo.md5)
  return md5_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* FileSpecificInfo::release_md5() {
  // @@protoc_insertion_point(field_release:drive.FileSpecificInfo.md5)
  clear_has_md5();
  return md5_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void FileSpecificInfo::set_allocated_md5(::std::string* md5) {
  if (md5 != NULL) {
    set_has_md5();
  } else {
    clear_has_md5();
  }
  md5_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), md5);
  // @@protoc_insertion_point(field_set_allocated:drive.FileSpecificInfo.md5)
}

// optional string document_extension = 5;
inline bool FileSpecificInfo::has_document_extension() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void FileSpecificInfo::set_has_document_extension() {
  _has_bits_[0] |= 0x00000004u;
}
inline void FileSpecificInfo::clear_has_document_extension() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void FileSpecificInfo::clear_document_extension() {
  document_extension_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_document_extension();
}
inline const ::std::string& FileSpecificInfo::document_extension() const {
  // @@protoc_insertion_point(field_get:drive.FileSpecificInfo.document_extension)
  return document_extension_.GetNoArena();
}
inline void FileSpecificInfo::set_document_extension(const ::std::string& value) {
  set_has_document_extension();
  document_extension_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.FileSpecificInfo.document_extension)
}
#if LANG_CXX11
inline void FileSpecificInfo::set_document_extension(::std::string&& value) {
  set_has_document_extension();
  document_extension_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.FileSpecificInfo.document_extension)
}
#endif
inline void FileSpecificInfo::set_document_extension(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_document_extension();
  document_extension_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.FileSpecificInfo.document_extension)
}
inline void FileSpecificInfo::set_document_extension(const char* value, size_t size) {
  set_has_document_extension();
  document_extension_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.FileSpecificInfo.document_extension)
}
inline ::std::string* FileSpecificInfo::mutable_document_extension() {
  set_has_document_extension();
  // @@protoc_insertion_point(field_mutable:drive.FileSpecificInfo.document_extension)
  return document_extension_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* FileSpecificInfo::release_document_extension() {
  // @@protoc_insertion_point(field_release:drive.FileSpecificInfo.document_extension)
  clear_has_document_extension();
  return document_extension_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void FileSpecificInfo::set_allocated_document_extension(::std::string* document_extension) {
  if (document_extension != NULL) {
    set_has_document_extension();
  } else {
    clear_has_document_extension();
  }
  document_extension_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), document_extension);
  // @@protoc_insertion_point(field_set_allocated:drive.FileSpecificInfo.document_extension)
}

// optional bool is_hosted_document = 6;
inline bool FileSpecificInfo::has_is_hosted_document() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void FileSpecificInfo::set_has_is_hosted_document() {
  _has_bits_[0] |= 0x00000040u;
}
inline void FileSpecificInfo::clear_has_is_hosted_document() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void FileSpecificInfo::clear_is_hosted_document() {
  is_hosted_document_ = false;
  clear_has_is_hosted_document();
}
inline bool FileSpecificInfo::is_hosted_document() const {
  // @@protoc_insertion_point(field_get:drive.FileSpecificInfo.is_hosted_document)
  return is_hosted_document_;
}
inline void FileSpecificInfo::set_is_hosted_document(bool value) {
  set_has_is_hosted_document();
  is_hosted_document_ = value;
  // @@protoc_insertion_point(field_set:drive.FileSpecificInfo.is_hosted_document)
}

// optional int64 image_width = 8;
inline bool FileSpecificInfo::has_image_width() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void FileSpecificInfo::set_has_image_width() {
  _has_bits_[0] |= 0x00000010u;
}
inline void FileSpecificInfo::clear_has_image_width() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void FileSpecificInfo::clear_image_width() {
  image_width_ = GOOGLE_LONGLONG(0);
  clear_has_image_width();
}
inline ::google::protobuf::int64 FileSpecificInfo::image_width() const {
  // @@protoc_insertion_point(field_get:drive.FileSpecificInfo.image_width)
  return image_width_;
}
inline void FileSpecificInfo::set_image_width(::google::protobuf::int64 value) {
  set_has_image_width();
  image_width_ = value;
  // @@protoc_insertion_point(field_set:drive.FileSpecificInfo.image_width)
}

// optional int64 image_height = 9;
inline bool FileSpecificInfo::has_image_height() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void FileSpecificInfo::set_has_image_height() {
  _has_bits_[0] |= 0x00000020u;
}
inline void FileSpecificInfo::clear_has_image_height() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void FileSpecificInfo::clear_image_height() {
  image_height_ = GOOGLE_LONGLONG(0);
  clear_has_image_height();
}
inline ::google::protobuf::int64 FileSpecificInfo::image_height() const {
  // @@protoc_insertion_point(field_get:drive.FileSpecificInfo.image_height)
  return image_height_;
}
inline void FileSpecificInfo::set_image_height(::google::protobuf::int64 value) {
  set_has_image_height();
  image_height_ = value;
  // @@protoc_insertion_point(field_set:drive.FileSpecificInfo.image_height)
}

// optional int64 image_rotation = 10;
inline bool FileSpecificInfo::has_image_rotation() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void FileSpecificInfo::set_has_image_rotation() {
  _has_bits_[0] |= 0x00000080u;
}
inline void FileSpecificInfo::clear_has_image_rotation() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void FileSpecificInfo::clear_image_rotation() {
  image_rotation_ = GOOGLE_LONGLONG(0);
  clear_has_image_rotation();
}
inline ::google::protobuf::int64 FileSpecificInfo::image_rotation() const {
  // @@protoc_insertion_point(field_get:drive.FileSpecificInfo.image_rotation)
  return image_rotation_;
}
inline void FileSpecificInfo::set_image_rotation(::google::protobuf::int64 value) {
  set_has_image_rotation();
  image_rotation_ = value;
  // @@protoc_insertion_point(field_set:drive.FileSpecificInfo.image_rotation)
}

// optional .drive.FileCacheEntry cache_state = 11;
inline bool FileSpecificInfo::has_cache_state() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void FileSpecificInfo::set_has_cache_state() {
  _has_bits_[0] |= 0x00000008u;
}
inline void FileSpecificInfo::clear_has_cache_state() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void FileSpecificInfo::clear_cache_state() {
  if (cache_state_ != NULL) cache_state_->::drive::FileCacheEntry::Clear();
  clear_has_cache_state();
}
inline const ::drive::FileCacheEntry& FileSpecificInfo::cache_state() const {
  // @@protoc_insertion_point(field_get:drive.FileSpecificInfo.cache_state)
  return cache_state_ != NULL ? *cache_state_
                         : *::drive::FileCacheEntry::internal_default_instance();
}
inline ::drive::FileCacheEntry* FileSpecificInfo::mutable_cache_state() {
  set_has_cache_state();
  if (cache_state_ == NULL) {
    cache_state_ = new ::drive::FileCacheEntry;
  }
  // @@protoc_insertion_point(field_mutable:drive.FileSpecificInfo.cache_state)
  return cache_state_;
}
inline ::drive::FileCacheEntry* FileSpecificInfo::release_cache_state() {
  // @@protoc_insertion_point(field_release:drive.FileSpecificInfo.cache_state)
  clear_has_cache_state();
  ::drive::FileCacheEntry* temp = cache_state_;
  cache_state_ = NULL;
  return temp;
}
inline void FileSpecificInfo::set_allocated_cache_state(::drive::FileCacheEntry* cache_state) {
  delete cache_state_;
  cache_state_ = cache_state;
  if (cache_state) {
    set_has_cache_state();
  } else {
    clear_has_cache_state();
  }
  // @@protoc_insertion_point(field_set_allocated:drive.FileSpecificInfo.cache_state)
}

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

// TeamDriveRootSpecificInfo

// optional string start_page_token = 1;
inline bool TeamDriveRootSpecificInfo::has_start_page_token() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TeamDriveRootSpecificInfo::set_has_start_page_token() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TeamDriveRootSpecificInfo::clear_has_start_page_token() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TeamDriveRootSpecificInfo::clear_start_page_token() {
  start_page_token_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_start_page_token();
}
inline const ::std::string& TeamDriveRootSpecificInfo::start_page_token() const {
  // @@protoc_insertion_point(field_get:drive.TeamDriveRootSpecificInfo.start_page_token)
  return start_page_token_.GetNoArena();
}
inline void TeamDriveRootSpecificInfo::set_start_page_token(const ::std::string& value) {
  set_has_start_page_token();
  start_page_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.TeamDriveRootSpecificInfo.start_page_token)
}
#if LANG_CXX11
inline void TeamDriveRootSpecificInfo::set_start_page_token(::std::string&& value) {
  set_has_start_page_token();
  start_page_token_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.TeamDriveRootSpecificInfo.start_page_token)
}
#endif
inline void TeamDriveRootSpecificInfo::set_start_page_token(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_start_page_token();
  start_page_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.TeamDriveRootSpecificInfo.start_page_token)
}
inline void TeamDriveRootSpecificInfo::set_start_page_token(const char* value, size_t size) {
  set_has_start_page_token();
  start_page_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.TeamDriveRootSpecificInfo.start_page_token)
}
inline ::std::string* TeamDriveRootSpecificInfo::mutable_start_page_token() {
  set_has_start_page_token();
  // @@protoc_insertion_point(field_mutable:drive.TeamDriveRootSpecificInfo.start_page_token)
  return start_page_token_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TeamDriveRootSpecificInfo::release_start_page_token() {
  // @@protoc_insertion_point(field_release:drive.TeamDriveRootSpecificInfo.start_page_token)
  clear_has_start_page_token();
  return start_page_token_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TeamDriveRootSpecificInfo::set_allocated_start_page_token(::std::string* start_page_token) {
  if (start_page_token != NULL) {
    set_has_start_page_token();
  } else {
    clear_has_start_page_token();
  }
  start_page_token_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), start_page_token);
  // @@protoc_insertion_point(field_set_allocated:drive.TeamDriveRootSpecificInfo.start_page_token)
}

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

// DirectorySpecificInfo

// optional int64 changestamp = 1 [deprecated = true];
inline bool DirectorySpecificInfo::has_changestamp() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DirectorySpecificInfo::set_has_changestamp() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DirectorySpecificInfo::clear_has_changestamp() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DirectorySpecificInfo::clear_changestamp() {
  changestamp_ = GOOGLE_LONGLONG(0);
  clear_has_changestamp();
}
inline ::google::protobuf::int64 DirectorySpecificInfo::changestamp() const {
  // @@protoc_insertion_point(field_get:drive.DirectorySpecificInfo.changestamp)
  return changestamp_;
}
inline void DirectorySpecificInfo::set_changestamp(::google::protobuf::int64 value) {
  set_has_changestamp();
  changestamp_ = value;
  // @@protoc_insertion_point(field_set:drive.DirectorySpecificInfo.changestamp)
}

// optional string start_page_token = 2;
inline bool DirectorySpecificInfo::has_start_page_token() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DirectorySpecificInfo::set_has_start_page_token() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DirectorySpecificInfo::clear_has_start_page_token() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DirectorySpecificInfo::clear_start_page_token() {
  start_page_token_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_start_page_token();
}
inline const ::std::string& DirectorySpecificInfo::start_page_token() const {
  // @@protoc_insertion_point(field_get:drive.DirectorySpecificInfo.start_page_token)
  return start_page_token_.GetNoArena();
}
inline void DirectorySpecificInfo::set_start_page_token(const ::std::string& value) {
  set_has_start_page_token();
  start_page_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.DirectorySpecificInfo.start_page_token)
}
#if LANG_CXX11
inline void DirectorySpecificInfo::set_start_page_token(::std::string&& value) {
  set_has_start_page_token();
  start_page_token_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.DirectorySpecificInfo.start_page_token)
}
#endif
inline void DirectorySpecificInfo::set_start_page_token(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_start_page_token();
  start_page_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.DirectorySpecificInfo.start_page_token)
}
inline void DirectorySpecificInfo::set_start_page_token(const char* value, size_t size) {
  set_has_start_page_token();
  start_page_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.DirectorySpecificInfo.start_page_token)
}
inline ::std::string* DirectorySpecificInfo::mutable_start_page_token() {
  set_has_start_page_token();
  // @@protoc_insertion_point(field_mutable:drive.DirectorySpecificInfo.start_page_token)
  return start_page_token_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* DirectorySpecificInfo::release_start_page_token() {
  // @@protoc_insertion_point(field_release:drive.DirectorySpecificInfo.start_page_token)
  clear_has_start_page_token();
  return start_page_token_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DirectorySpecificInfo::set_allocated_start_page_token(::std::string* start_page_token) {
  if (start_page_token != NULL) {
    set_has_start_page_token();
  } else {
    clear_has_start_page_token();
  }
  start_page_token_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), start_page_token);
  // @@protoc_insertion_point(field_set_allocated:drive.DirectorySpecificInfo.start_page_token)
}

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

// ResourceEntry

// optional .drive.PlatformFileInfoProto file_info = 1;
inline bool ResourceEntry::has_file_info() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ResourceEntry::set_has_file_info() {
  _has_bits_[0] |= 0x00000040u;
}
inline void ResourceEntry::clear_has_file_info() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void ResourceEntry::clear_file_info() {
  if (file_info_ != NULL) file_info_->::drive::PlatformFileInfoProto::Clear();
  clear_has_file_info();
}
inline const ::drive::PlatformFileInfoProto& ResourceEntry::file_info() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.file_info)
  return file_info_ != NULL ? *file_info_
                         : *::drive::PlatformFileInfoProto::internal_default_instance();
}
inline ::drive::PlatformFileInfoProto* ResourceEntry::mutable_file_info() {
  set_has_file_info();
  if (file_info_ == NULL) {
    file_info_ = new ::drive::PlatformFileInfoProto;
  }
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.file_info)
  return file_info_;
}
inline ::drive::PlatformFileInfoProto* ResourceEntry::release_file_info() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.file_info)
  clear_has_file_info();
  ::drive::PlatformFileInfoProto* temp = file_info_;
  file_info_ = NULL;
  return temp;
}
inline void ResourceEntry::set_allocated_file_info(::drive::PlatformFileInfoProto* file_info) {
  delete file_info_;
  file_info_ = file_info;
  if (file_info) {
    set_has_file_info();
  } else {
    clear_has_file_info();
  }
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.file_info)
}

// optional string base_name = 2;
inline bool ResourceEntry::has_base_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ResourceEntry::set_has_base_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ResourceEntry::clear_has_base_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ResourceEntry::clear_base_name() {
  base_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_base_name();
}
inline const ::std::string& ResourceEntry::base_name() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.base_name)
  return base_name_.GetNoArena();
}
inline void ResourceEntry::set_base_name(const ::std::string& value) {
  set_has_base_name();
  base_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.base_name)
}
#if LANG_CXX11
inline void ResourceEntry::set_base_name(::std::string&& value) {
  set_has_base_name();
  base_name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.ResourceEntry.base_name)
}
#endif
inline void ResourceEntry::set_base_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_base_name();
  base_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.ResourceEntry.base_name)
}
inline void ResourceEntry::set_base_name(const char* value, size_t size) {
  set_has_base_name();
  base_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.ResourceEntry.base_name)
}
inline ::std::string* ResourceEntry::mutable_base_name() {
  set_has_base_name();
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.base_name)
  return base_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ResourceEntry::release_base_name() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.base_name)
  clear_has_base_name();
  return base_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ResourceEntry::set_allocated_base_name(::std::string* base_name) {
  if (base_name != NULL) {
    set_has_base_name();
  } else {
    clear_has_base_name();
  }
  base_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), base_name);
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.base_name)
}

// optional string title = 3;
inline bool ResourceEntry::has_title() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ResourceEntry::set_has_title() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ResourceEntry::clear_has_title() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ResourceEntry::clear_title() {
  title_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_title();
}
inline const ::std::string& ResourceEntry::title() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.title)
  return title_.GetNoArena();
}
inline void ResourceEntry::set_title(const ::std::string& value) {
  set_has_title();
  title_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.title)
}
#if LANG_CXX11
inline void ResourceEntry::set_title(::std::string&& value) {
  set_has_title();
  title_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.ResourceEntry.title)
}
#endif
inline void ResourceEntry::set_title(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_title();
  title_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.ResourceEntry.title)
}
inline void ResourceEntry::set_title(const char* value, size_t size) {
  set_has_title();
  title_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.ResourceEntry.title)
}
inline ::std::string* ResourceEntry::mutable_title() {
  set_has_title();
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.title)
  return title_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ResourceEntry::release_title() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.title)
  clear_has_title();
  return title_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ResourceEntry::set_allocated_title(::std::string* title) {
  if (title != NULL) {
    set_has_title();
  } else {
    clear_has_title();
  }
  title_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), title);
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.title)
}

// optional string resource_id = 4;
inline bool ResourceEntry::has_resource_id() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ResourceEntry::set_has_resource_id() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ResourceEntry::clear_has_resource_id() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ResourceEntry::clear_resource_id() {
  resource_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_resource_id();
}
inline const ::std::string& ResourceEntry::resource_id() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.resource_id)
  return resource_id_.GetNoArena();
}
inline void ResourceEntry::set_resource_id(const ::std::string& value) {
  set_has_resource_id();
  resource_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.resource_id)
}
#if LANG_CXX11
inline void ResourceEntry::set_resource_id(::std::string&& value) {
  set_has_resource_id();
  resource_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.ResourceEntry.resource_id)
}
#endif
inline void ResourceEntry::set_resource_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_resource_id();
  resource_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.ResourceEntry.resource_id)
}
inline void ResourceEntry::set_resource_id(const char* value, size_t size) {
  set_has_resource_id();
  resource_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.ResourceEntry.resource_id)
}
inline ::std::string* ResourceEntry::mutable_resource_id() {
  set_has_resource_id();
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.resource_id)
  return resource_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ResourceEntry::release_resource_id() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.resource_id)
  clear_has_resource_id();
  return resource_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ResourceEntry::set_allocated_resource_id(::std::string* resource_id) {
  if (resource_id != NULL) {
    set_has_resource_id();
  } else {
    clear_has_resource_id();
  }
  resource_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), resource_id);
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.resource_id)
}

// optional string local_id = 15;
inline bool ResourceEntry::has_local_id() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ResourceEntry::set_has_local_id() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ResourceEntry::clear_has_local_id() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ResourceEntry::clear_local_id() {
  local_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_local_id();
}
inline const ::std::string& ResourceEntry::local_id() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.local_id)
  return local_id_.GetNoArena();
}
inline void ResourceEntry::set_local_id(const ::std::string& value) {
  set_has_local_id();
  local_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.local_id)
}
#if LANG_CXX11
inline void ResourceEntry::set_local_id(::std::string&& value) {
  set_has_local_id();
  local_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.ResourceEntry.local_id)
}
#endif
inline void ResourceEntry::set_local_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_local_id();
  local_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.ResourceEntry.local_id)
}
inline void ResourceEntry::set_local_id(const char* value, size_t size) {
  set_has_local_id();
  local_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.ResourceEntry.local_id)
}
inline ::std::string* ResourceEntry::mutable_local_id() {
  set_has_local_id();
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.local_id)
  return local_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ResourceEntry::release_local_id() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.local_id)
  clear_has_local_id();
  return local_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ResourceEntry::set_allocated_local_id(::std::string* local_id) {
  if (local_id != NULL) {
    set_has_local_id();
  } else {
    clear_has_local_id();
  }
  local_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), local_id);
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.local_id)
}

// optional string parent_local_id = 7;
inline bool ResourceEntry::has_parent_local_id() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ResourceEntry::set_has_parent_local_id() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ResourceEntry::clear_has_parent_local_id() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ResourceEntry::clear_parent_local_id() {
  parent_local_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_parent_local_id();
}
inline const ::std::string& ResourceEntry::parent_local_id() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.parent_local_id)
  return parent_local_id_.GetNoArena();
}
inline void ResourceEntry::set_parent_local_id(const ::std::string& value) {
  set_has_parent_local_id();
  parent_local_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.parent_local_id)
}
#if LANG_CXX11
inline void ResourceEntry::set_parent_local_id(::std::string&& value) {
  set_has_parent_local_id();
  parent_local_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.ResourceEntry.parent_local_id)
}
#endif
inline void ResourceEntry::set_parent_local_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_parent_local_id();
  parent_local_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.ResourceEntry.parent_local_id)
}
inline void ResourceEntry::set_parent_local_id(const char* value, size_t size) {
  set_has_parent_local_id();
  parent_local_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.ResourceEntry.parent_local_id)
}
inline ::std::string* ResourceEntry::mutable_parent_local_id() {
  set_has_parent_local_id();
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.parent_local_id)
  return parent_local_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ResourceEntry::release_parent_local_id() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.parent_local_id)
  clear_has_parent_local_id();
  return parent_local_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ResourceEntry::set_allocated_parent_local_id(::std::string* parent_local_id) {
  if (parent_local_id != NULL) {
    set_has_parent_local_id();
  } else {
    clear_has_parent_local_id();
  }
  parent_local_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), parent_local_id);
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.parent_local_id)
}

// optional bool deleted = 11;
inline bool ResourceEntry::has_deleted() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void ResourceEntry::set_has_deleted() {
  _has_bits_[0] |= 0x00000800u;
}
inline void ResourceEntry::clear_has_deleted() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void ResourceEntry::clear_deleted() {
  deleted_ = false;
  clear_has_deleted();
}
inline bool ResourceEntry::deleted() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.deleted)
  return deleted_;
}
inline void ResourceEntry::set_deleted(bool value) {
  set_has_deleted();
  deleted_ = value;
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.deleted)
}

// optional bool starred = 20;
inline bool ResourceEntry::has_starred() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void ResourceEntry::set_has_starred() {
  _has_bits_[0] |= 0x00001000u;
}
inline void ResourceEntry::clear_has_starred() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void ResourceEntry::clear_starred() {
  starred_ = false;
  clear_has_starred();
}
inline bool ResourceEntry::starred() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.starred)
  return starred_;
}
inline void ResourceEntry::set_starred(bool value) {
  set_has_starred();
  starred_ = value;
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.starred)
}

// optional bool shared_with_me = 14;
inline bool ResourceEntry::has_shared_with_me() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void ResourceEntry::set_has_shared_with_me() {
  _has_bits_[0] |= 0x00002000u;
}
inline void ResourceEntry::clear_has_shared_with_me() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void ResourceEntry::clear_shared_with_me() {
  shared_with_me_ = false;
  clear_has_shared_with_me();
}
inline bool ResourceEntry::shared_with_me() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.shared_with_me)
  return shared_with_me_;
}
inline void ResourceEntry::set_shared_with_me(bool value) {
  set_has_shared_with_me();
  shared_with_me_ = value;
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.shared_with_me)
}

// optional bool shared = 17;
inline bool ResourceEntry::has_shared() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void ResourceEntry::set_has_shared() {
  _has_bits_[0] |= 0x00004000u;
}
inline void ResourceEntry::clear_has_shared() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void ResourceEntry::clear_shared() {
  shared_ = false;
  clear_has_shared();
}
inline bool ResourceEntry::shared() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.shared)
  return shared_;
}
inline void ResourceEntry::set_shared(bool value) {
  set_has_shared();
  shared_ = value;
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.shared)
}

// optional .drive.CapabilitiesInfo capabilities_info = 24;
inline bool ResourceEntry::has_capabilities_info() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void ResourceEntry::set_has_capabilities_info() {
  _has_bits_[0] |= 0x00000400u;
}
inline void ResourceEntry::clear_has_capabilities_info() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void ResourceEntry::clear_capabilities_info() {
  if (capabilities_info_ != NULL) capabilities_info_->::drive::CapabilitiesInfo::Clear();
  clear_has_capabilities_info();
}
inline const ::drive::CapabilitiesInfo& ResourceEntry::capabilities_info() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.capabilities_info)
  return capabilities_info_ != NULL ? *capabilities_info_
                         : *::drive::CapabilitiesInfo::internal_default_instance();
}
inline ::drive::CapabilitiesInfo* ResourceEntry::mutable_capabilities_info() {
  set_has_capabilities_info();
  if (capabilities_info_ == NULL) {
    capabilities_info_ = new ::drive::CapabilitiesInfo;
  }
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.capabilities_info)
  return capabilities_info_;
}
inline ::drive::CapabilitiesInfo* ResourceEntry::release_capabilities_info() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.capabilities_info)
  clear_has_capabilities_info();
  ::drive::CapabilitiesInfo* temp = capabilities_info_;
  capabilities_info_ = NULL;
  return temp;
}
inline void ResourceEntry::set_allocated_capabilities_info(::drive::CapabilitiesInfo* capabilities_info) {
  delete capabilities_info_;
  capabilities_info_ = capabilities_info;
  if (capabilities_info) {
    set_has_capabilities_info();
  } else {
    clear_has_capabilities_info();
  }
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.capabilities_info)
}

// optional .drive.FileSpecificInfo file_specific_info = 9;
inline bool ResourceEntry::has_file_specific_info() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void ResourceEntry::set_has_file_specific_info() {
  _has_bits_[0] |= 0x00000080u;
}
inline void ResourceEntry::clear_has_file_specific_info() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void ResourceEntry::clear_file_specific_info() {
  if (file_specific_info_ != NULL) file_specific_info_->::drive::FileSpecificInfo::Clear();
  clear_has_file_specific_info();
}
inline const ::drive::FileSpecificInfo& ResourceEntry::file_specific_info() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.file_specific_info)
  return file_specific_info_ != NULL ? *file_specific_info_
                         : *::drive::FileSpecificInfo::internal_default_instance();
}
inline ::drive::FileSpecificInfo* ResourceEntry::mutable_file_specific_info() {
  set_has_file_specific_info();
  if (file_specific_info_ == NULL) {
    file_specific_info_ = new ::drive::FileSpecificInfo;
  }
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.file_specific_info)
  return file_specific_info_;
}
inline ::drive::FileSpecificInfo* ResourceEntry::release_file_specific_info() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.file_specific_info)
  clear_has_file_specific_info();
  ::drive::FileSpecificInfo* temp = file_specific_info_;
  file_specific_info_ = NULL;
  return temp;
}
inline void ResourceEntry::set_allocated_file_specific_info(::drive::FileSpecificInfo* file_specific_info) {
  delete file_specific_info_;
  file_specific_info_ = file_specific_info;
  if (file_specific_info) {
    set_has_file_specific_info();
  } else {
    clear_has_file_specific_info();
  }
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.file_specific_info)
}

// optional .drive.DirectorySpecificInfo directory_specific_info = 13;
inline bool ResourceEntry::has_directory_specific_info() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void ResourceEntry::set_has_directory_specific_info() {
  _has_bits_[0] |= 0x00000100u;
}
inline void ResourceEntry::clear_has_directory_specific_info() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void ResourceEntry::clear_directory_specific_info() {
  if (directory_specific_info_ != NULL) directory_specific_info_->::drive::DirectorySpecificInfo::Clear();
  clear_has_directory_specific_info();
}
inline const ::drive::DirectorySpecificInfo& ResourceEntry::directory_specific_info() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.directory_specific_info)
  return directory_specific_info_ != NULL ? *directory_specific_info_
                         : *::drive::DirectorySpecificInfo::internal_default_instance();
}
inline ::drive::DirectorySpecificInfo* ResourceEntry::mutable_directory_specific_info() {
  set_has_directory_specific_info();
  if (directory_specific_info_ == NULL) {
    directory_specific_info_ = new ::drive::DirectorySpecificInfo;
  }
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.directory_specific_info)
  return directory_specific_info_;
}
inline ::drive::DirectorySpecificInfo* ResourceEntry::release_directory_specific_info() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.directory_specific_info)
  clear_has_directory_specific_info();
  ::drive::DirectorySpecificInfo* temp = directory_specific_info_;
  directory_specific_info_ = NULL;
  return temp;
}
inline void ResourceEntry::set_allocated_directory_specific_info(::drive::DirectorySpecificInfo* directory_specific_info) {
  delete directory_specific_info_;
  directory_specific_info_ = directory_specific_info;
  if (directory_specific_info) {
    set_has_directory_specific_info();
  } else {
    clear_has_directory_specific_info();
  }
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.directory_specific_info)
}

// optional .drive.TeamDriveRootSpecificInfo team_drive_root_specific_info = 23;
inline bool ResourceEntry::has_team_drive_root_specific_info() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void ResourceEntry::set_has_team_drive_root_specific_info() {
  _has_bits_[0] |= 0x00000200u;
}
inline void ResourceEntry::clear_has_team_drive_root_specific_info() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void ResourceEntry::clear_team_drive_root_specific_info() {
  if (team_drive_root_specific_info_ != NULL) team_drive_root_specific_info_->::drive::TeamDriveRootSpecificInfo::Clear();
  clear_has_team_drive_root_specific_info();
}
inline const ::drive::TeamDriveRootSpecificInfo& ResourceEntry::team_drive_root_specific_info() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.team_drive_root_specific_info)
  return team_drive_root_specific_info_ != NULL ? *team_drive_root_specific_info_
                         : *::drive::TeamDriveRootSpecificInfo::internal_default_instance();
}
inline ::drive::TeamDriveRootSpecificInfo* ResourceEntry::mutable_team_drive_root_specific_info() {
  set_has_team_drive_root_specific_info();
  if (team_drive_root_specific_info_ == NULL) {
    team_drive_root_specific_info_ = new ::drive::TeamDriveRootSpecificInfo;
  }
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.team_drive_root_specific_info)
  return team_drive_root_specific_info_;
}
inline ::drive::TeamDriveRootSpecificInfo* ResourceEntry::release_team_drive_root_specific_info() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.team_drive_root_specific_info)
  clear_has_team_drive_root_specific_info();
  ::drive::TeamDriveRootSpecificInfo* temp = team_drive_root_specific_info_;
  team_drive_root_specific_info_ = NULL;
  return temp;
}
inline void ResourceEntry::set_allocated_team_drive_root_specific_info(::drive::TeamDriveRootSpecificInfo* team_drive_root_specific_info) {
  delete team_drive_root_specific_info_;
  team_drive_root_specific_info_ = team_drive_root_specific_info;
  if (team_drive_root_specific_info) {
    set_has_team_drive_root_specific_info();
  } else {
    clear_has_team_drive_root_specific_info();
  }
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.team_drive_root_specific_info)
}

// optional .drive.ResourceEntry.EditState metadata_edit_state = 16;
inline bool ResourceEntry::has_metadata_edit_state() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void ResourceEntry::set_has_metadata_edit_state() {
  _has_bits_[0] |= 0x00008000u;
}
inline void ResourceEntry::clear_has_metadata_edit_state() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void ResourceEntry::clear_metadata_edit_state() {
  metadata_edit_state_ = 0;
  clear_has_metadata_edit_state();
}
inline ::drive::ResourceEntry_EditState ResourceEntry::metadata_edit_state() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.metadata_edit_state)
  return static_cast< ::drive::ResourceEntry_EditState >(metadata_edit_state_);
}
inline void ResourceEntry::set_metadata_edit_state(::drive::ResourceEntry_EditState value) {
  assert(::drive::ResourceEntry_EditState_IsValid(value));
  set_has_metadata_edit_state();
  metadata_edit_state_ = value;
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.metadata_edit_state)
}

// optional int64 modification_date = 18;
inline bool ResourceEntry::has_modification_date() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void ResourceEntry::set_has_modification_date() {
  _has_bits_[0] |= 0x00010000u;
}
inline void ResourceEntry::clear_has_modification_date() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void ResourceEntry::clear_modification_date() {
  modification_date_ = GOOGLE_LONGLONG(0);
  clear_has_modification_date();
}
inline ::google::protobuf::int64 ResourceEntry::modification_date() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.modification_date)
  return modification_date_;
}
inline void ResourceEntry::set_modification_date(::google::protobuf::int64 value) {
  set_has_modification_date();
  modification_date_ = value;
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.modification_date)
}

// repeated .drive.Property new_properties = 19;
inline int ResourceEntry::new_properties_size() const {
  return new_properties_.size();
}
inline void ResourceEntry::clear_new_properties() {
  new_properties_.Clear();
}
inline const ::drive::Property& ResourceEntry::new_properties(int index) const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.new_properties)
  return new_properties_.Get(index);
}
inline ::drive::Property* ResourceEntry::mutable_new_properties(int index) {
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.new_properties)
  return new_properties_.Mutable(index);
}
inline ::drive::Property* ResourceEntry::add_new_properties() {
  // @@protoc_insertion_point(field_add:drive.ResourceEntry.new_properties)
  return new_properties_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::drive::Property >*
ResourceEntry::mutable_new_properties() {
  // @@protoc_insertion_point(field_mutable_list:drive.ResourceEntry.new_properties)
  return &new_properties_;
}
inline const ::google::protobuf::RepeatedPtrField< ::drive::Property >&
ResourceEntry::new_properties() const {
  // @@protoc_insertion_point(field_list:drive.ResourceEntry.new_properties)
  return new_properties_;
}

// optional int64 last_modified_by_me = 21;
inline bool ResourceEntry::has_last_modified_by_me() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void ResourceEntry::set_has_last_modified_by_me() {
  _has_bits_[0] |= 0x00020000u;
}
inline void ResourceEntry::clear_has_last_modified_by_me() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void ResourceEntry::clear_last_modified_by_me() {
  last_modified_by_me_ = GOOGLE_LONGLONG(0);
  clear_has_last_modified_by_me();
}
inline ::google::protobuf::int64 ResourceEntry::last_modified_by_me() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.last_modified_by_me)
  return last_modified_by_me_;
}
inline void ResourceEntry::set_last_modified_by_me(::google::protobuf::int64 value) {
  set_has_last_modified_by_me();
  last_modified_by_me_ = value;
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.last_modified_by_me)
}

// optional string alternate_url = 22;
inline bool ResourceEntry::has_alternate_url() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ResourceEntry::set_has_alternate_url() {
  _has_bits_[0] |= 0x00000020u;
}
inline void ResourceEntry::clear_has_alternate_url() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void ResourceEntry::clear_alternate_url() {
  alternate_url_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_alternate_url();
}
inline const ::std::string& ResourceEntry::alternate_url() const {
  // @@protoc_insertion_point(field_get:drive.ResourceEntry.alternate_url)
  return alternate_url_.GetNoArena();
}
inline void ResourceEntry::set_alternate_url(const ::std::string& value) {
  set_has_alternate_url();
  alternate_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.ResourceEntry.alternate_url)
}
#if LANG_CXX11
inline void ResourceEntry::set_alternate_url(::std::string&& value) {
  set_has_alternate_url();
  alternate_url_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.ResourceEntry.alternate_url)
}
#endif
inline void ResourceEntry::set_alternate_url(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_alternate_url();
  alternate_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.ResourceEntry.alternate_url)
}
inline void ResourceEntry::set_alternate_url(const char* value, size_t size) {
  set_has_alternate_url();
  alternate_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.ResourceEntry.alternate_url)
}
inline ::std::string* ResourceEntry::mutable_alternate_url() {
  set_has_alternate_url();
  // @@protoc_insertion_point(field_mutable:drive.ResourceEntry.alternate_url)
  return alternate_url_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ResourceEntry::release_alternate_url() {
  // @@protoc_insertion_point(field_release:drive.ResourceEntry.alternate_url)
  clear_has_alternate_url();
  return alternate_url_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ResourceEntry::set_allocated_alternate_url(::std::string* alternate_url) {
  if (alternate_url != NULL) {
    set_has_alternate_url();
  } else {
    clear_has_alternate_url();
  }
  alternate_url_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), alternate_url);
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceEntry.alternate_url)
}

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

// ResourceMetadataHeader

// optional int32 version = 1;
inline bool ResourceMetadataHeader::has_version() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ResourceMetadataHeader::set_has_version() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ResourceMetadataHeader::clear_has_version() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ResourceMetadataHeader::clear_version() {
  version_ = 0;
  clear_has_version();
}
inline ::google::protobuf::int32 ResourceMetadataHeader::version() const {
  // @@protoc_insertion_point(field_get:drive.ResourceMetadataHeader.version)
  return version_;
}
inline void ResourceMetadataHeader::set_version(::google::protobuf::int32 value) {
  set_has_version();
  version_ = value;
  // @@protoc_insertion_point(field_set:drive.ResourceMetadataHeader.version)
}

// optional int64 largest_changestamp = 2 [deprecated = true];
inline bool ResourceMetadataHeader::has_largest_changestamp() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ResourceMetadataHeader::set_has_largest_changestamp() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ResourceMetadataHeader::clear_has_largest_changestamp() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ResourceMetadataHeader::clear_largest_changestamp() {
  largest_changestamp_ = GOOGLE_LONGLONG(0);
  clear_has_largest_changestamp();
}
inline ::google::protobuf::int64 ResourceMetadataHeader::largest_changestamp() const {
  // @@protoc_insertion_point(field_get:drive.ResourceMetadataHeader.largest_changestamp)
  return largest_changestamp_;
}
inline void ResourceMetadataHeader::set_largest_changestamp(::google::protobuf::int64 value) {
  set_has_largest_changestamp();
  largest_changestamp_ = value;
  // @@protoc_insertion_point(field_set:drive.ResourceMetadataHeader.largest_changestamp)
}

// optional string start_page_token = 4;
inline bool ResourceMetadataHeader::has_start_page_token() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ResourceMetadataHeader::set_has_start_page_token() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ResourceMetadataHeader::clear_has_start_page_token() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ResourceMetadataHeader::clear_start_page_token() {
  start_page_token_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_start_page_token();
}
inline const ::std::string& ResourceMetadataHeader::start_page_token() const {
  // @@protoc_insertion_point(field_get:drive.ResourceMetadataHeader.start_page_token)
  return start_page_token_.GetNoArena();
}
inline void ResourceMetadataHeader::set_start_page_token(const ::std::string& value) {
  set_has_start_page_token();
  start_page_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.ResourceMetadataHeader.start_page_token)
}
#if LANG_CXX11
inline void ResourceMetadataHeader::set_start_page_token(::std::string&& value) {
  set_has_start_page_token();
  start_page_token_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.ResourceMetadataHeader.start_page_token)
}
#endif
inline void ResourceMetadataHeader::set_start_page_token(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_start_page_token();
  start_page_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.ResourceMetadataHeader.start_page_token)
}
inline void ResourceMetadataHeader::set_start_page_token(const char* value, size_t size) {
  set_has_start_page_token();
  start_page_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.ResourceMetadataHeader.start_page_token)
}
inline ::std::string* ResourceMetadataHeader::mutable_start_page_token() {
  set_has_start_page_token();
  // @@protoc_insertion_point(field_mutable:drive.ResourceMetadataHeader.start_page_token)
  return start_page_token_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ResourceMetadataHeader::release_start_page_token() {
  // @@protoc_insertion_point(field_release:drive.ResourceMetadataHeader.start_page_token)
  clear_has_start_page_token();
  return start_page_token_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ResourceMetadataHeader::set_allocated_start_page_token(::std::string* start_page_token) {
  if (start_page_token != NULL) {
    set_has_start_page_token();
  } else {
    clear_has_start_page_token();
  }
  start_page_token_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), start_page_token);
  // @@protoc_insertion_point(field_set_allocated:drive.ResourceMetadataHeader.start_page_token)
}

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

// FileCacheEntry

// optional string md5 = 1;
inline bool FileCacheEntry::has_md5() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void FileCacheEntry::set_has_md5() {
  _has_bits_[0] |= 0x00000001u;
}
inline void FileCacheEntry::clear_has_md5() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void FileCacheEntry::clear_md5() {
  md5_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_md5();
}
inline const ::std::string& FileCacheEntry::md5() const {
  // @@protoc_insertion_point(field_get:drive.FileCacheEntry.md5)
  return md5_.GetNoArena();
}
inline void FileCacheEntry::set_md5(const ::std::string& value) {
  set_has_md5();
  md5_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:drive.FileCacheEntry.md5)
}
#if LANG_CXX11
inline void FileCacheEntry::set_md5(::std::string&& value) {
  set_has_md5();
  md5_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:drive.FileCacheEntry.md5)
}
#endif
inline void FileCacheEntry::set_md5(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_md5();
  md5_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:drive.FileCacheEntry.md5)
}
inline void FileCacheEntry::set_md5(const char* value, size_t size) {
  set_has_md5();
  md5_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:drive.FileCacheEntry.md5)
}
inline ::std::string* FileCacheEntry::mutable_md5() {
  set_has_md5();
  // @@protoc_insertion_point(field_mutable:drive.FileCacheEntry.md5)
  return md5_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* FileCacheEntry::release_md5() {
  // @@protoc_insertion_point(field_release:drive.FileCacheEntry.md5)
  clear_has_md5();
  return md5_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void FileCacheEntry::set_allocated_md5(::std::string* md5) {
  if (md5 != NULL) {
    set_has_md5();
  } else {
    clear_has_md5();
  }
  md5_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), md5);
  // @@protoc_insertion_point(field_set_allocated:drive.FileCacheEntry.md5)
}

// optional bool is_present = 2;
inline bool FileCacheEntry::has_is_present() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void FileCacheEntry::set_has_is_present() {
  _has_bits_[0] |= 0x00000002u;
}
inline void FileCacheEntry::clear_has_is_present() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void FileCacheEntry::clear_is_present() {
  is_present_ = false;
  clear_has_is_present();
}
inline bool FileCacheEntry::is_present() const {
  // @@protoc_insertion_point(field_get:drive.FileCacheEntry.is_present)
  return is_present_;
}
inline void FileCacheEntry::set_is_present(bool value) {
  set_has_is_present();
  is_present_ = value;
  // @@protoc_insertion_point(field_set:drive.FileCacheEntry.is_present)
}

// optional bool is_pinned = 3;
inline bool FileCacheEntry::has_is_pinned() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void FileCacheEntry::set_has_is_pinned() {
  _has_bits_[0] |= 0x00000004u;
}
inline void FileCacheEntry::clear_has_is_pinned() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void FileCacheEntry::clear_is_pinned() {
  is_pinned_ = false;
  clear_has_is_pinned();
}
inline bool FileCacheEntry::is_pinned() const {
  // @@protoc_insertion_point(field_get:drive.FileCacheEntry.is_pinned)
  return is_pinned_;
}
inline void FileCacheEntry::set_is_pinned(bool value) {
  set_has_is_pinned();
  is_pinned_ = value;
  // @@protoc_insertion_point(field_set:drive.FileCacheEntry.is_pinned)
}

// optional bool is_dirty = 4;
inline bool FileCacheEntry::has_is_dirty() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void FileCacheEntry::set_has_is_dirty() {
  _has_bits_[0] |= 0x00000008u;
}
inline void FileCacheEntry::clear_has_is_dirty() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void FileCacheEntry::clear_is_dirty() {
  is_dirty_ = false;
  clear_has_is_dirty();
}
inline bool FileCacheEntry::is_dirty() const {
  // @@protoc_insertion_point(field_get:drive.FileCacheEntry.is_dirty)
  return is_dirty_;
}
inline void FileCacheEntry::set_is_dirty(bool value) {
  set_has_is_dirty();
  is_dirty_ = value;
  // @@protoc_insertion_point(field_set:drive.FileCacheEntry.is_dirty)
}

#endif  // !PROTOBUF_INLINE_NOT_IN_HEADERS
// -------------------------------------------------------------------

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)


}  // namespace drive

#ifndef SWIG
namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::drive::Property_Visibility> : ::google::protobuf::internal::true_type {};
template <> struct is_proto_enum< ::drive::ResourceEntry_EditState> : ::google::protobuf::internal::true_type {};

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

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_drive_2eproto__INCLUDED