file.h

// Copyright 2010 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.

// This code was generated by google-apis-code-generator 1.5.1
//   Build date: 2018-10-08 17:45:39 UTC
//   on: 2020-03-19, 05:24:40 UTC
//   C++ generator version: 0.1.4

// ----------------------------------------------------------------------------
// NOTE: This file is generated from Google APIs Discovery Service.
// Service:
//   Drive API (drive/v2)
// Generated from:
//   Version: v2
//   Revision: 393
// Generated by:
//    Tool: google-apis-code-generator 1.5.1
//     C++: 0.1.4
#ifndef  GOOGLE_DRIVE_API_FILE_H_
#define  GOOGLE_DRIVE_API_FILE_H_

#include <string>
#include "googleapis/base/integral_types.h"
#include "googleapis/base/macros.h"
#include "googleapis/client/data/jsoncpp_data.h"
#include "googleapis/client/util/date_time.h"
#include "googleapis/strings/stringpiece.h"

#include "google/drive_api/parent_reference.h"
#include "google/drive_api/permission.h"
#include "google/drive_api/property.h"
#include "google/drive_api/user.h"

namespace Json {
class Value;
}  // namespace Json

namespace google_drive_api {
using namespace googleapis;

class File : public client::JsonCppData {
 public:
  class FileCapabilities : public client::JsonCppData {
   public:
    static FileCapabilities* New();

    explicit FileCapabilities(const Json::Value& storage);

    explicit FileCapabilities(Json::Value* storage);

    virtual ~FileCapabilities();

    const StringPiece GetTypeName() const {
      return StringPiece("google_drive_api::FileCapabilities");
    }

    bool has_can_add_children() const {
      return Storage().isMember("canAddChildren");
    }

    void clear_can_add_children() {
      MutableStorage()->removeMember("canAddChildren");
    }


    bool get_can_add_children() const {
      const Json::Value& storage = Storage("canAddChildren");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_add_children(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canAddChildren"));
    }

    bool has_can_add_my_drive_parent() const {
      return Storage().isMember("canAddMyDriveParent");
    }

    void clear_can_add_my_drive_parent() {
      MutableStorage()->removeMember("canAddMyDriveParent");
    }


    bool get_can_add_my_drive_parent() const {
      const Json::Value& storage = Storage("canAddMyDriveParent");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_add_my_drive_parent(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canAddMyDriveParent"));
    }

    bool has_can_change_copy_requires_writer_permission() const {
      return Storage().isMember("canChangeCopyRequiresWriterPermission");
    }

    void clear_can_change_copy_requires_writer_permission() {
      MutableStorage()->removeMember("canChangeCopyRequiresWriterPermission");
    }


    bool get_can_change_copy_requires_writer_permission() const {
      const Json::Value& storage = Storage("canChangeCopyRequiresWriterPermission");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_change_copy_requires_writer_permission(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canChangeCopyRequiresWriterPermission"));
    }

    bool has_can_change_restricted_download() const {
      return Storage().isMember("canChangeRestrictedDownload");
    }

    void clear_can_change_restricted_download() {
      MutableStorage()->removeMember("canChangeRestrictedDownload");
    }


    bool get_can_change_restricted_download() const {
      const Json::Value& storage = Storage("canChangeRestrictedDownload");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_change_restricted_download(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canChangeRestrictedDownload"));
    }

    bool has_can_comment() const {
      return Storage().isMember("canComment");
    }

    void clear_can_comment() {
      MutableStorage()->removeMember("canComment");
    }


    bool get_can_comment() const {
      const Json::Value& storage = Storage("canComment");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_comment(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canComment"));
    }

    bool has_can_copy() const {
      return Storage().isMember("canCopy");
    }

    void clear_can_copy() {
      MutableStorage()->removeMember("canCopy");
    }


    bool get_can_copy() const {
      const Json::Value& storage = Storage("canCopy");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_copy(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canCopy"));
    }

    bool has_can_delete() const {
      return Storage().isMember("canDelete");
    }

    void clear_can_delete() {
      MutableStorage()->removeMember("canDelete");
    }


    bool get_can_delete() const {
      const Json::Value& storage = Storage("canDelete");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_delete(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canDelete"));
    }

    bool has_can_delete_children() const {
      return Storage().isMember("canDeleteChildren");
    }

    void clear_can_delete_children() {
      MutableStorage()->removeMember("canDeleteChildren");
    }


    bool get_can_delete_children() const {
      const Json::Value& storage = Storage("canDeleteChildren");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_delete_children(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canDeleteChildren"));
    }

    bool has_can_download() const {
      return Storage().isMember("canDownload");
    }

    void clear_can_download() {
      MutableStorage()->removeMember("canDownload");
    }


    bool get_can_download() const {
      const Json::Value& storage = Storage("canDownload");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_download(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canDownload"));
    }

    bool has_can_edit() const {
      return Storage().isMember("canEdit");
    }

    void clear_can_edit() {
      MutableStorage()->removeMember("canEdit");
    }


    bool get_can_edit() const {
      const Json::Value& storage = Storage("canEdit");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_edit(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canEdit"));
    }

    bool has_can_list_children() const {
      return Storage().isMember("canListChildren");
    }

    void clear_can_list_children() {
      MutableStorage()->removeMember("canListChildren");
    }


    bool get_can_list_children() const {
      const Json::Value& storage = Storage("canListChildren");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_list_children(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canListChildren"));
    }

    bool has_can_modify_content() const {
      return Storage().isMember("canModifyContent");
    }

    void clear_can_modify_content() {
      MutableStorage()->removeMember("canModifyContent");
    }


    bool get_can_modify_content() const {
      const Json::Value& storage = Storage("canModifyContent");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_modify_content(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canModifyContent"));
    }

    bool has_can_move_children_out_of_drive() const {
      return Storage().isMember("canMoveChildrenOutOfDrive");
    }

    void clear_can_move_children_out_of_drive() {
      MutableStorage()->removeMember("canMoveChildrenOutOfDrive");
    }


    bool get_can_move_children_out_of_drive() const {
      const Json::Value& storage = Storage("canMoveChildrenOutOfDrive");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_move_children_out_of_drive(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canMoveChildrenOutOfDrive"));
    }

    bool has_can_move_children_out_of_team_drive() const {
      return Storage().isMember("canMoveChildrenOutOfTeamDrive");
    }

    void clear_can_move_children_out_of_team_drive() {
      MutableStorage()->removeMember("canMoveChildrenOutOfTeamDrive");
    }


    bool get_can_move_children_out_of_team_drive() const {
      const Json::Value& storage = Storage("canMoveChildrenOutOfTeamDrive");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_move_children_out_of_team_drive(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canMoveChildrenOutOfTeamDrive"));
    }

    bool has_can_move_children_within_drive() const {
      return Storage().isMember("canMoveChildrenWithinDrive");
    }

    void clear_can_move_children_within_drive() {
      MutableStorage()->removeMember("canMoveChildrenWithinDrive");
    }


    bool get_can_move_children_within_drive() const {
      const Json::Value& storage = Storage("canMoveChildrenWithinDrive");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_move_children_within_drive(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canMoveChildrenWithinDrive"));
    }

    bool has_can_move_children_within_team_drive() const {
      return Storage().isMember("canMoveChildrenWithinTeamDrive");
    }

    void clear_can_move_children_within_team_drive() {
      MutableStorage()->removeMember("canMoveChildrenWithinTeamDrive");
    }


    bool get_can_move_children_within_team_drive() const {
      const Json::Value& storage = Storage("canMoveChildrenWithinTeamDrive");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_move_children_within_team_drive(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canMoveChildrenWithinTeamDrive"));
    }

    bool has_can_move_item_into_team_drive() const {
      return Storage().isMember("canMoveItemIntoTeamDrive");
    }

    void clear_can_move_item_into_team_drive() {
      MutableStorage()->removeMember("canMoveItemIntoTeamDrive");
    }


    bool get_can_move_item_into_team_drive() const {
      const Json::Value& storage = Storage("canMoveItemIntoTeamDrive");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_move_item_into_team_drive(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canMoveItemIntoTeamDrive"));
    }

    bool has_can_move_item_out_of_drive() const {
      return Storage().isMember("canMoveItemOutOfDrive");
    }

    void clear_can_move_item_out_of_drive() {
      MutableStorage()->removeMember("canMoveItemOutOfDrive");
    }


    bool get_can_move_item_out_of_drive() const {
      const Json::Value& storage = Storage("canMoveItemOutOfDrive");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_move_item_out_of_drive(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canMoveItemOutOfDrive"));
    }

    bool has_can_move_item_out_of_team_drive() const {
      return Storage().isMember("canMoveItemOutOfTeamDrive");
    }

    void clear_can_move_item_out_of_team_drive() {
      MutableStorage()->removeMember("canMoveItemOutOfTeamDrive");
    }


    bool get_can_move_item_out_of_team_drive() const {
      const Json::Value& storage = Storage("canMoveItemOutOfTeamDrive");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_move_item_out_of_team_drive(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canMoveItemOutOfTeamDrive"));
    }

    bool has_can_move_item_within_drive() const {
      return Storage().isMember("canMoveItemWithinDrive");
    }

    void clear_can_move_item_within_drive() {
      MutableStorage()->removeMember("canMoveItemWithinDrive");
    }


    bool get_can_move_item_within_drive() const {
      const Json::Value& storage = Storage("canMoveItemWithinDrive");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_move_item_within_drive(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canMoveItemWithinDrive"));
    }

    bool has_can_move_item_within_team_drive() const {
      return Storage().isMember("canMoveItemWithinTeamDrive");
    }

    void clear_can_move_item_within_team_drive() {
      MutableStorage()->removeMember("canMoveItemWithinTeamDrive");
    }


    bool get_can_move_item_within_team_drive() const {
      const Json::Value& storage = Storage("canMoveItemWithinTeamDrive");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_move_item_within_team_drive(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canMoveItemWithinTeamDrive"));
    }

    bool has_can_move_team_drive_item() const {
      return Storage().isMember("canMoveTeamDriveItem");
    }

    void clear_can_move_team_drive_item() {
      MutableStorage()->removeMember("canMoveTeamDriveItem");
    }


    bool get_can_move_team_drive_item() const {
      const Json::Value& storage = Storage("canMoveTeamDriveItem");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_move_team_drive_item(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canMoveTeamDriveItem"));
    }

    bool has_can_read_drive() const {
      return Storage().isMember("canReadDrive");
    }

    void clear_can_read_drive() {
      MutableStorage()->removeMember("canReadDrive");
    }


    bool get_can_read_drive() const {
      const Json::Value& storage = Storage("canReadDrive");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_read_drive(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canReadDrive"));
    }

    bool has_can_read_revisions() const {
      return Storage().isMember("canReadRevisions");
    }

    void clear_can_read_revisions() {
      MutableStorage()->removeMember("canReadRevisions");
    }


    bool get_can_read_revisions() const {
      const Json::Value& storage = Storage("canReadRevisions");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_read_revisions(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canReadRevisions"));
    }

    bool has_can_read_team_drive() const {
      return Storage().isMember("canReadTeamDrive");
    }

    void clear_can_read_team_drive() {
      MutableStorage()->removeMember("canReadTeamDrive");
    }


    bool get_can_read_team_drive() const {
      const Json::Value& storage = Storage("canReadTeamDrive");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_read_team_drive(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canReadTeamDrive"));
    }

    bool has_can_remove_children() const {
      return Storage().isMember("canRemoveChildren");
    }

    void clear_can_remove_children() {
      MutableStorage()->removeMember("canRemoveChildren");
    }


    bool get_can_remove_children() const {
      const Json::Value& storage = Storage("canRemoveChildren");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_remove_children(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canRemoveChildren"));
    }

    bool has_can_remove_my_drive_parent() const {
      return Storage().isMember("canRemoveMyDriveParent");
    }

    void clear_can_remove_my_drive_parent() {
      MutableStorage()->removeMember("canRemoveMyDriveParent");
    }


    bool get_can_remove_my_drive_parent() const {
      const Json::Value& storage = Storage("canRemoveMyDriveParent");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_remove_my_drive_parent(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canRemoveMyDriveParent"));
    }

    bool has_can_rename() const {
      return Storage().isMember("canRename");
    }

    void clear_can_rename() {
      MutableStorage()->removeMember("canRename");
    }


    bool get_can_rename() const {
      const Json::Value& storage = Storage("canRename");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_rename(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canRename"));
    }

    bool has_can_share() const {
      return Storage().isMember("canShare");
    }

    void clear_can_share() {
      MutableStorage()->removeMember("canShare");
    }


    bool get_can_share() const {
      const Json::Value& storage = Storage("canShare");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_share(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canShare"));
    }

    bool has_can_trash() const {
      return Storage().isMember("canTrash");
    }

    void clear_can_trash() {
      MutableStorage()->removeMember("canTrash");
    }


    bool get_can_trash() const {
      const Json::Value& storage = Storage("canTrash");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_trash(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canTrash"));
    }

    bool has_can_trash_children() const {
      return Storage().isMember("canTrashChildren");
    }

    void clear_can_trash_children() {
      MutableStorage()->removeMember("canTrashChildren");
    }


    bool get_can_trash_children() const {
      const Json::Value& storage = Storage("canTrashChildren");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_trash_children(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canTrashChildren"));
    }

    bool has_can_untrash() const {
      return Storage().isMember("canUntrash");
    }

    void clear_can_untrash() {
      MutableStorage()->removeMember("canUntrash");
    }


    bool get_can_untrash() const {
      const Json::Value& storage = Storage("canUntrash");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_untrash(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canUntrash"));
    }

   private:
    void operator=(const FileCapabilities&);
  };  // FileCapabilities
  class FileImageMediaMetadata : public client::JsonCppData {
   public:
    class FileImageMediaMetadataLocation : public client::JsonCppData {
     public:
      static FileImageMediaMetadataLocation* New();

      explicit FileImageMediaMetadataLocation(const Json::Value& storage);

      explicit FileImageMediaMetadataLocation(Json::Value* storage);

      virtual ~FileImageMediaMetadataLocation();

      const StringPiece GetTypeName() const {
        return StringPiece("google_drive_api::FileImageMediaMetadataLocation");
      }

      bool has_altitude() const {
        return Storage().isMember("altitude");
      }

      void clear_altitude() {
        MutableStorage()->removeMember("altitude");
      }


      double get_altitude() const {
        const Json::Value& storage = Storage("altitude");
        return client::JsonValueToCppValueHelper<double >(storage);
      }

      void set_altitude(double value) {
        client::SetJsonValueFromCppValueHelper<double >(
          value, MutableStorage("altitude"));
      }

      bool has_latitude() const {
        return Storage().isMember("latitude");
      }

      void clear_latitude() {
        MutableStorage()->removeMember("latitude");
      }


      double get_latitude() const {
        const Json::Value& storage = Storage("latitude");
        return client::JsonValueToCppValueHelper<double >(storage);
      }

      void set_latitude(double value) {
        client::SetJsonValueFromCppValueHelper<double >(
          value, MutableStorage("latitude"));
      }

      bool has_longitude() const {
        return Storage().isMember("longitude");
      }

      void clear_longitude() {
        MutableStorage()->removeMember("longitude");
      }


      double get_longitude() const {
        const Json::Value& storage = Storage("longitude");
        return client::JsonValueToCppValueHelper<double >(storage);
      }

      void set_longitude(double value) {
        client::SetJsonValueFromCppValueHelper<double >(
          value, MutableStorage("longitude"));
      }

     private:
      void operator=(const FileImageMediaMetadataLocation&);
    };  // FileImageMediaMetadataLocation
    static FileImageMediaMetadata* New();

    explicit FileImageMediaMetadata(const Json::Value& storage);

    explicit FileImageMediaMetadata(Json::Value* storage);

    virtual ~FileImageMediaMetadata();

    const StringPiece GetTypeName() const {
      return StringPiece("google_drive_api::FileImageMediaMetadata");
    }

    bool has_aperture() const {
      return Storage().isMember("aperture");
    }

    void clear_aperture() {
      MutableStorage()->removeMember("aperture");
    }


    float get_aperture() const {
      const Json::Value& storage = Storage("aperture");
      return client::JsonValueToCppValueHelper<float >(storage);
    }

    void set_aperture(float value) {
      client::SetJsonValueFromCppValueHelper<float >(
        value, MutableStorage("aperture"));
    }

    bool has_camera_make() const {
      return Storage().isMember("cameraMake");
    }

    void clear_camera_make() {
      MutableStorage()->removeMember("cameraMake");
    }


    const StringPiece get_camera_make() const {
      const Json::Value& v = Storage("cameraMake");
      if (v == Json::Value::null) return StringPiece("");
      return StringPiece(v.asCString());
    }

    void set_camera_make(const StringPiece& value) {
      *MutableStorage("cameraMake") = value.data();
    }

    bool has_camera_model() const {
      return Storage().isMember("cameraModel");
    }

    void clear_camera_model() {
      MutableStorage()->removeMember("cameraModel");
    }


    const StringPiece get_camera_model() const {
      const Json::Value& v = Storage("cameraModel");
      if (v == Json::Value::null) return StringPiece("");
      return StringPiece(v.asCString());
    }

    void set_camera_model(const StringPiece& value) {
      *MutableStorage("cameraModel") = value.data();
    }

    bool has_color_space() const {
      return Storage().isMember("colorSpace");
    }

    void clear_color_space() {
      MutableStorage()->removeMember("colorSpace");
    }


    const StringPiece get_color_space() const {
      const Json::Value& v = Storage("colorSpace");
      if (v == Json::Value::null) return StringPiece("");
      return StringPiece(v.asCString());
    }

    void set_color_space(const StringPiece& value) {
      *MutableStorage("colorSpace") = value.data();
    }

    bool has_date() const {
      return Storage().isMember("date");
    }

    void clear_date() {
      MutableStorage()->removeMember("date");
    }


    const StringPiece get_date() const {
      const Json::Value& v = Storage("date");
      if (v == Json::Value::null) return StringPiece("");
      return StringPiece(v.asCString());
    }

    void set_date(const StringPiece& value) {
      *MutableStorage("date") = value.data();
    }

    bool has_exposure_bias() const {
      return Storage().isMember("exposureBias");
    }

    void clear_exposure_bias() {
      MutableStorage()->removeMember("exposureBias");
    }


    float get_exposure_bias() const {
      const Json::Value& storage = Storage("exposureBias");
      return client::JsonValueToCppValueHelper<float >(storage);
    }

    void set_exposure_bias(float value) {
      client::SetJsonValueFromCppValueHelper<float >(
        value, MutableStorage("exposureBias"));
    }

    bool has_exposure_mode() const {
      return Storage().isMember("exposureMode");
    }

    void clear_exposure_mode() {
      MutableStorage()->removeMember("exposureMode");
    }


    const StringPiece get_exposure_mode() const {
      const Json::Value& v = Storage("exposureMode");
      if (v == Json::Value::null) return StringPiece("");
      return StringPiece(v.asCString());
    }

    void set_exposure_mode(const StringPiece& value) {
      *MutableStorage("exposureMode") = value.data();
    }

    bool has_exposure_time() const {
      return Storage().isMember("exposureTime");
    }

    void clear_exposure_time() {
      MutableStorage()->removeMember("exposureTime");
    }


    float get_exposure_time() const {
      const Json::Value& storage = Storage("exposureTime");
      return client::JsonValueToCppValueHelper<float >(storage);
    }

    void set_exposure_time(float value) {
      client::SetJsonValueFromCppValueHelper<float >(
        value, MutableStorage("exposureTime"));
    }

    bool has_flash_used() const {
      return Storage().isMember("flashUsed");
    }

    void clear_flash_used() {
      MutableStorage()->removeMember("flashUsed");
    }


    bool get_flash_used() const {
      const Json::Value& storage = Storage("flashUsed");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_flash_used(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("flashUsed"));
    }

    bool has_focal_length() const {
      return Storage().isMember("focalLength");
    }

    void clear_focal_length() {
      MutableStorage()->removeMember("focalLength");
    }


    float get_focal_length() const {
      const Json::Value& storage = Storage("focalLength");
      return client::JsonValueToCppValueHelper<float >(storage);
    }

    void set_focal_length(float value) {
      client::SetJsonValueFromCppValueHelper<float >(
        value, MutableStorage("focalLength"));
    }

    bool has_height() const {
      return Storage().isMember("height");
    }

    void clear_height() {
      MutableStorage()->removeMember("height");
    }


    int32 get_height() const {
      const Json::Value& storage = Storage("height");
      return client::JsonValueToCppValueHelper<int32 >(storage);
    }

    void set_height(int32 value) {
      client::SetJsonValueFromCppValueHelper<int32 >(
        value, MutableStorage("height"));
    }

    bool has_iso_speed() const {
      return Storage().isMember("isoSpeed");
    }

    void clear_iso_speed() {
      MutableStorage()->removeMember("isoSpeed");
    }


    int32 get_iso_speed() const {
      const Json::Value& storage = Storage("isoSpeed");
      return client::JsonValueToCppValueHelper<int32 >(storage);
    }

    void set_iso_speed(int32 value) {
      client::SetJsonValueFromCppValueHelper<int32 >(
        value, MutableStorage("isoSpeed"));
    }

    bool has_lens() const {
      return Storage().isMember("lens");
    }

    void clear_lens() {
      MutableStorage()->removeMember("lens");
    }


    const StringPiece get_lens() const {
      const Json::Value& v = Storage("lens");
      if (v == Json::Value::null) return StringPiece("");
      return StringPiece(v.asCString());
    }

    void set_lens(const StringPiece& value) {
      *MutableStorage("lens") = value.data();
    }

    bool has_location() const {
      return Storage().isMember("location");
    }

    void clear_location() {
      MutableStorage()->removeMember("location");
    }


    const FileImageMediaMetadataLocation get_location() const {
       const Json::Value& storage = Storage("location");
      return client::JsonValueToCppValueHelper<FileImageMediaMetadataLocation >(storage);
    }

    FileImageMediaMetadataLocation mutable_location() {
      Json::Value* storage = MutableStorage("location");
      return client::JsonValueToMutableCppValueHelper<FileImageMediaMetadataLocation >(storage);
    }

    bool has_max_aperture_value() const {
      return Storage().isMember("maxApertureValue");
    }

    void clear_max_aperture_value() {
      MutableStorage()->removeMember("maxApertureValue");
    }


    float get_max_aperture_value() const {
      const Json::Value& storage = Storage("maxApertureValue");
      return client::JsonValueToCppValueHelper<float >(storage);
    }

    void set_max_aperture_value(float value) {
      client::SetJsonValueFromCppValueHelper<float >(
        value, MutableStorage("maxApertureValue"));
    }

    bool has_metering_mode() const {
      return Storage().isMember("meteringMode");
    }

    void clear_metering_mode() {
      MutableStorage()->removeMember("meteringMode");
    }


    const StringPiece get_metering_mode() const {
      const Json::Value& v = Storage("meteringMode");
      if (v == Json::Value::null) return StringPiece("");
      return StringPiece(v.asCString());
    }

    void set_metering_mode(const StringPiece& value) {
      *MutableStorage("meteringMode") = value.data();
    }

    bool has_rotation() const {
      return Storage().isMember("rotation");
    }

    void clear_rotation() {
      MutableStorage()->removeMember("rotation");
    }


    int32 get_rotation() const {
      const Json::Value& storage = Storage("rotation");
      return client::JsonValueToCppValueHelper<int32 >(storage);
    }

    void set_rotation(int32 value) {
      client::SetJsonValueFromCppValueHelper<int32 >(
        value, MutableStorage("rotation"));
    }

    bool has_sensor() const {
      return Storage().isMember("sensor");
    }

    void clear_sensor() {
      MutableStorage()->removeMember("sensor");
    }


    const StringPiece get_sensor() const {
      const Json::Value& v = Storage("sensor");
      if (v == Json::Value::null) return StringPiece("");
      return StringPiece(v.asCString());
    }

    void set_sensor(const StringPiece& value) {
      *MutableStorage("sensor") = value.data();
    }

    bool has_subject_distance() const {
      return Storage().isMember("subjectDistance");
    }

    void clear_subject_distance() {
      MutableStorage()->removeMember("subjectDistance");
    }


    int32 get_subject_distance() const {
      const Json::Value& storage = Storage("subjectDistance");
      return client::JsonValueToCppValueHelper<int32 >(storage);
    }

    void set_subject_distance(int32 value) {
      client::SetJsonValueFromCppValueHelper<int32 >(
        value, MutableStorage("subjectDistance"));
    }

    bool has_white_balance() const {
      return Storage().isMember("whiteBalance");
    }

    void clear_white_balance() {
      MutableStorage()->removeMember("whiteBalance");
    }


    const StringPiece get_white_balance() const {
      const Json::Value& v = Storage("whiteBalance");
      if (v == Json::Value::null) return StringPiece("");
      return StringPiece(v.asCString());
    }

    void set_white_balance(const StringPiece& value) {
      *MutableStorage("whiteBalance") = value.data();
    }

    bool has_width() const {
      return Storage().isMember("width");
    }

    void clear_width() {
      MutableStorage()->removeMember("width");
    }


    int32 get_width() const {
      const Json::Value& storage = Storage("width");
      return client::JsonValueToCppValueHelper<int32 >(storage);
    }

    void set_width(int32 value) {
      client::SetJsonValueFromCppValueHelper<int32 >(
        value, MutableStorage("width"));
    }

   private:
    void operator=(const FileImageMediaMetadata&);
  };  // FileImageMediaMetadata
  class FileIndexableText : public client::JsonCppData {
   public:
    static FileIndexableText* New();

    explicit FileIndexableText(const Json::Value& storage);

    explicit FileIndexableText(Json::Value* storage);

    virtual ~FileIndexableText();

    const StringPiece GetTypeName() const {
      return StringPiece("google_drive_api::FileIndexableText");
    }

    bool has_text() const {
      return Storage().isMember("text");
    }

    void clear_text() {
      MutableStorage()->removeMember("text");
    }


    const StringPiece get_text() const {
      const Json::Value& v = Storage("text");
      if (v == Json::Value::null) return StringPiece("");
      return StringPiece(v.asCString());
    }

    void set_text(const StringPiece& value) {
      *MutableStorage("text") = value.data();
    }

   private:
    void operator=(const FileIndexableText&);
  };  // FileIndexableText
  class FileLabels : public client::JsonCppData {
   public:
    static FileLabels* New();

    explicit FileLabels(const Json::Value& storage);

    explicit FileLabels(Json::Value* storage);

    virtual ~FileLabels();

    const StringPiece GetTypeName() const {
      return StringPiece("google_drive_api::FileLabels");
    }

    bool has_hidden() const {
      return Storage().isMember("hidden");
    }

    void clear_hidden() {
      MutableStorage()->removeMember("hidden");
    }


    bool get_hidden() const {
      const Json::Value& storage = Storage("hidden");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_hidden(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("hidden"));
    }

    bool has_modified() const {
      return Storage().isMember("modified");
    }

    void clear_modified() {
      MutableStorage()->removeMember("modified");
    }


    bool get_modified() const {
      const Json::Value& storage = Storage("modified");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_modified(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("modified"));
    }

    bool has_restricted() const {
      return Storage().isMember("restricted");
    }

    void clear_restricted() {
      MutableStorage()->removeMember("restricted");
    }


    bool get_restricted() const {
      const Json::Value& storage = Storage("restricted");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_restricted(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("restricted"));
    }

    bool has_starred() const {
      return Storage().isMember("starred");
    }

    void clear_starred() {
      MutableStorage()->removeMember("starred");
    }


    bool get_starred() const {
      const Json::Value& storage = Storage("starred");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_starred(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("starred"));
    }

    bool has_trashed() const {
      return Storage().isMember("trashed");
    }

    void clear_trashed() {
      MutableStorage()->removeMember("trashed");
    }


    bool get_trashed() const {
      const Json::Value& storage = Storage("trashed");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_trashed(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("trashed"));
    }

    bool has_viewed() const {
      return Storage().isMember("viewed");
    }

    void clear_viewed() {
      MutableStorage()->removeMember("viewed");
    }


    bool get_viewed() const {
      const Json::Value& storage = Storage("viewed");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_viewed(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("viewed"));
    }

   private:
    void operator=(const FileLabels&);
  };  // FileLabels
  class FileShortcutDetails : public client::JsonCppData {
   public:
    static FileShortcutDetails* New();

    explicit FileShortcutDetails(const Json::Value& storage);

    explicit FileShortcutDetails(Json::Value* storage);

    virtual ~FileShortcutDetails();

    const StringPiece GetTypeName() const {
      return StringPiece("google_drive_api::FileShortcutDetails");
    }

    bool has_target_id() const {
      return Storage().isMember("targetId");
    }

    void clear_target_id() {
      MutableStorage()->removeMember("targetId");
    }


    const StringPiece get_target_id() const {
      const Json::Value& v = Storage("targetId");
      if (v == Json::Value::null) return StringPiece("");
      return StringPiece(v.asCString());
    }

    void set_target_id(const StringPiece& value) {
      *MutableStorage("targetId") = value.data();
    }

    bool has_target_mime_type() const {
      return Storage().isMember("targetMimeType");
    }

    void clear_target_mime_type() {
      MutableStorage()->removeMember("targetMimeType");
    }


    const StringPiece get_target_mime_type() const {
      const Json::Value& v = Storage("targetMimeType");
      if (v == Json::Value::null) return StringPiece("");
      return StringPiece(v.asCString());
    }

    void set_target_mime_type(const StringPiece& value) {
      *MutableStorage("targetMimeType") = value.data();
    }

   private:
    void operator=(const FileShortcutDetails&);
  };  // FileShortcutDetails
  class FileThumbnail : public client::JsonCppData {
   public:
    static FileThumbnail* New();

    explicit FileThumbnail(const Json::Value& storage);

    explicit FileThumbnail(Json::Value* storage);

    virtual ~FileThumbnail();

    const StringPiece GetTypeName() const {
      return StringPiece("google_drive_api::FileThumbnail");
    }

    bool has_image() const {
      return Storage().isMember("image");
    }

    void clear_image() {
      MutableStorage()->removeMember("image");
    }


    const StringPiece get_image() const {
      const Json::Value& v = Storage("image");
      if (v == Json::Value::null) return StringPiece("");
      return StringPiece(v.asCString());
    }

    void set_image(const StringPiece& value) {
      *MutableStorage("image") = value.data();
    }

    bool has_mime_type() const {
      return Storage().isMember("mimeType");
    }

    void clear_mime_type() {
      MutableStorage()->removeMember("mimeType");
    }


    const StringPiece get_mime_type() const {
      const Json::Value& v = Storage("mimeType");
      if (v == Json::Value::null) return StringPiece("");
      return StringPiece(v.asCString());
    }

    void set_mime_type(const StringPiece& value) {
      *MutableStorage("mimeType") = value.data();
    }

   private:
    void operator=(const FileThumbnail&);
  };  // FileThumbnail
  class FileVideoMediaMetadata : public client::JsonCppData {
   public:
    static FileVideoMediaMetadata* New();

    explicit FileVideoMediaMetadata(const Json::Value& storage);

    explicit FileVideoMediaMetadata(Json::Value* storage);

    virtual ~FileVideoMediaMetadata();

    const StringPiece GetTypeName() const {
      return StringPiece("google_drive_api::FileVideoMediaMetadata");
    }

    bool has_duration_millis() const {
      return Storage().isMember("durationMillis");
    }

    void clear_duration_millis() {
      MutableStorage()->removeMember("durationMillis");
    }


    int64 get_duration_millis() const {
      const Json::Value& storage = Storage("durationMillis");
      return client::JsonValueToCppValueHelper<int64 >(storage);
    }

    void set_duration_millis(int64 value) {
      client::SetJsonValueFromCppValueHelper<int64 >(
        value, MutableStorage("durationMillis"));
    }

    bool has_height() const {
      return Storage().isMember("height");
    }

    void clear_height() {
      MutableStorage()->removeMember("height");
    }


    int32 get_height() const {
      const Json::Value& storage = Storage("height");
      return client::JsonValueToCppValueHelper<int32 >(storage);
    }

    void set_height(int32 value) {
      client::SetJsonValueFromCppValueHelper<int32 >(
        value, MutableStorage("height"));
    }

    bool has_width() const {
      return Storage().isMember("width");
    }

    void clear_width() {
      MutableStorage()->removeMember("width");
    }


    int32 get_width() const {
      const Json::Value& storage = Storage("width");
      return client::JsonValueToCppValueHelper<int32 >(storage);
    }

    void set_width(int32 value) {
      client::SetJsonValueFromCppValueHelper<int32 >(
        value, MutableStorage("width"));
    }

   private:
    void operator=(const FileVideoMediaMetadata&);
  };  // FileVideoMediaMetadata
  static File* New();

  explicit File(const Json::Value& storage);

  explicit File(Json::Value* storage);

  virtual ~File();

  const StringPiece GetTypeName() const {
    return StringPiece("google_drive_api::File");
  }

  bool has_alternate_link() const {
    return Storage().isMember("alternateLink");
  }

  void clear_alternate_link() {
    MutableStorage()->removeMember("alternateLink");
  }


  const StringPiece get_alternate_link() const {
    const Json::Value& v = Storage("alternateLink");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_alternate_link(const StringPiece& value) {
    *MutableStorage("alternateLink") = value.data();
  }

  bool has_app_data_contents() const {
    return Storage().isMember("appDataContents");
  }

  void clear_app_data_contents() {
    MutableStorage()->removeMember("appDataContents");
  }


  bool get_app_data_contents() const {
    const Json::Value& storage = Storage("appDataContents");
    return client::JsonValueToCppValueHelper<bool >(storage);
  }

  void set_app_data_contents(bool value) {
    client::SetJsonValueFromCppValueHelper<bool >(
      value, MutableStorage("appDataContents"));
  }

  bool has_can_comment() const {
    return Storage().isMember("canComment");
  }

  void clear_can_comment() {
    MutableStorage()->removeMember("canComment");
  }


  bool get_can_comment() const {
    const Json::Value& storage = Storage("canComment");
    return client::JsonValueToCppValueHelper<bool >(storage);
  }

  void set_can_comment(bool value) {
    client::SetJsonValueFromCppValueHelper<bool >(
      value, MutableStorage("canComment"));
  }

  bool has_can_read_revisions() const {
    return Storage().isMember("canReadRevisions");
  }

  void clear_can_read_revisions() {
    MutableStorage()->removeMember("canReadRevisions");
  }


  bool get_can_read_revisions() const {
    const Json::Value& storage = Storage("canReadRevisions");
    return client::JsonValueToCppValueHelper<bool >(storage);
  }

  void set_can_read_revisions(bool value) {
    client::SetJsonValueFromCppValueHelper<bool >(
      value, MutableStorage("canReadRevisions"));
  }

  bool has_capabilities() const {
    return Storage().isMember("capabilities");
  }

  void clear_capabilities() {
    MutableStorage()->removeMember("capabilities");
  }


  const FileCapabilities get_capabilities() const {
     const Json::Value& storage = Storage("capabilities");
    return client::JsonValueToCppValueHelper<FileCapabilities >(storage);
  }

  FileCapabilities mutable_capabilities() {
    Json::Value* storage = MutableStorage("capabilities");
    return client::JsonValueToMutableCppValueHelper<FileCapabilities >(storage);
  }

  bool has_copy_requires_writer_permission() const {
    return Storage().isMember("copyRequiresWriterPermission");
  }

  void clear_copy_requires_writer_permission() {
    MutableStorage()->removeMember("copyRequiresWriterPermission");
  }


  bool get_copy_requires_writer_permission() const {
    const Json::Value& storage = Storage("copyRequiresWriterPermission");
    return client::JsonValueToCppValueHelper<bool >(storage);
  }

  void set_copy_requires_writer_permission(bool value) {
    client::SetJsonValueFromCppValueHelper<bool >(
      value, MutableStorage("copyRequiresWriterPermission"));
  }

  bool has_copyable() const {
    return Storage().isMember("copyable");
  }

  void clear_copyable() {
    MutableStorage()->removeMember("copyable");
  }


  bool get_copyable() const {
    const Json::Value& storage = Storage("copyable");
    return client::JsonValueToCppValueHelper<bool >(storage);
  }

  void set_copyable(bool value) {
    client::SetJsonValueFromCppValueHelper<bool >(
      value, MutableStorage("copyable"));
  }

  bool has_created_date() const {
    return Storage().isMember("createdDate");
  }

  void clear_created_date() {
    MutableStorage()->removeMember("createdDate");
  }


  client::DateTime get_created_date() const {
    const Json::Value& storage = Storage("createdDate");
    return client::JsonValueToCppValueHelper<client::DateTime >(storage);
  }

  void set_created_date(client::DateTime value) {
    client::SetJsonValueFromCppValueHelper<client::DateTime >(
      value, MutableStorage("createdDate"));
  }

  bool has_default_open_with_link() const {
    return Storage().isMember("defaultOpenWithLink");
  }

  void clear_default_open_with_link() {
    MutableStorage()->removeMember("defaultOpenWithLink");
  }


  const StringPiece get_default_open_with_link() const {
    const Json::Value& v = Storage("defaultOpenWithLink");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_default_open_with_link(const StringPiece& value) {
    *MutableStorage("defaultOpenWithLink") = value.data();
  }

  bool has_description() const {
    return Storage().isMember("description");
  }

  void clear_description() {
    MutableStorage()->removeMember("description");
  }


  const StringPiece get_description() const {
    const Json::Value& v = Storage("description");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_description(const StringPiece& value) {
    *MutableStorage("description") = value.data();
  }

  bool has_download_url() const {
    return Storage().isMember("downloadUrl");
  }

  void clear_download_url() {
    MutableStorage()->removeMember("downloadUrl");
  }


  const StringPiece get_download_url() const {
    const Json::Value& v = Storage("downloadUrl");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_download_url(const StringPiece& value) {
    *MutableStorage("downloadUrl") = value.data();
  }

  bool has_drive_id() const {
    return Storage().isMember("driveId");
  }

  void clear_drive_id() {
    MutableStorage()->removeMember("driveId");
  }


  const StringPiece get_drive_id() const {
    const Json::Value& v = Storage("driveId");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_drive_id(const StringPiece& value) {
    *MutableStorage("driveId") = value.data();
  }

  bool has_editable() const {
    return Storage().isMember("editable");
  }

  void clear_editable() {
    MutableStorage()->removeMember("editable");
  }


  bool get_editable() const {
    const Json::Value& storage = Storage("editable");
    return client::JsonValueToCppValueHelper<bool >(storage);
  }

  void set_editable(bool value) {
    client::SetJsonValueFromCppValueHelper<bool >(
      value, MutableStorage("editable"));
  }

  bool has_embed_link() const {
    return Storage().isMember("embedLink");
  }

  void clear_embed_link() {
    MutableStorage()->removeMember("embedLink");
  }


  const StringPiece get_embed_link() const {
    const Json::Value& v = Storage("embedLink");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_embed_link(const StringPiece& value) {
    *MutableStorage("embedLink") = value.data();
  }

  bool has_etag() const {
    return Storage().isMember("etag");
  }

  void clear_etag() {
    MutableStorage()->removeMember("etag");
  }


  const StringPiece get_etag() const {
    const Json::Value& v = Storage("etag");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_etag(const StringPiece& value) {
    *MutableStorage("etag") = value.data();
  }

  bool has_explicitly_trashed() const {
    return Storage().isMember("explicitlyTrashed");
  }

  void clear_explicitly_trashed() {
    MutableStorage()->removeMember("explicitlyTrashed");
  }


  bool get_explicitly_trashed() const {
    const Json::Value& storage = Storage("explicitlyTrashed");
    return client::JsonValueToCppValueHelper<bool >(storage);
  }

  void set_explicitly_trashed(bool value) {
    client::SetJsonValueFromCppValueHelper<bool >(
      value, MutableStorage("explicitlyTrashed"));
  }

  bool has_export_links() const {
    return Storage().isMember("exportLinks");
  }

  void clear_export_links() {
    MutableStorage()->removeMember("exportLinks");
  }


  const client::JsonCppAssociativeArray<string > get_export_links() const {
     const Json::Value& storage = Storage("exportLinks");
    return client::JsonValueToCppValueHelper<client::JsonCppAssociativeArray<string > >(storage);
  }

  client::JsonCppAssociativeArray<string > mutable_exportLinks() {
    Json::Value* storage = MutableStorage("exportLinks");
    return client::JsonValueToMutableCppValueHelper<client::JsonCppAssociativeArray<string > >(storage);
  }

  bool has_file_extension() const {
    return Storage().isMember("fileExtension");
  }

  void clear_file_extension() {
    MutableStorage()->removeMember("fileExtension");
  }


  const StringPiece get_file_extension() const {
    const Json::Value& v = Storage("fileExtension");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_file_extension(const StringPiece& value) {
    *MutableStorage("fileExtension") = value.data();
  }

  bool has_file_size() const {
    return Storage().isMember("fileSize");
  }

  void clear_file_size() {
    MutableStorage()->removeMember("fileSize");
  }


  int64 get_file_size() const {
    const Json::Value& storage = Storage("fileSize");
    return client::JsonValueToCppValueHelper<int64 >(storage);
  }

  void set_file_size(int64 value) {
    client::SetJsonValueFromCppValueHelper<int64 >(
      value, MutableStorage("fileSize"));
  }

  bool has_folder_color_rgb() const {
    return Storage().isMember("folderColorRgb");
  }

  void clear_folder_color_rgb() {
    MutableStorage()->removeMember("folderColorRgb");
  }


  const StringPiece get_folder_color_rgb() const {
    const Json::Value& v = Storage("folderColorRgb");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_folder_color_rgb(const StringPiece& value) {
    *MutableStorage("folderColorRgb") = value.data();
  }

  bool has_full_file_extension() const {
    return Storage().isMember("fullFileExtension");
  }

  void clear_full_file_extension() {
    MutableStorage()->removeMember("fullFileExtension");
  }


  const StringPiece get_full_file_extension() const {
    const Json::Value& v = Storage("fullFileExtension");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_full_file_extension(const StringPiece& value) {
    *MutableStorage("fullFileExtension") = value.data();
  }

  bool has_has_augmented_permissions() const {
    return Storage().isMember("hasAugmentedPermissions");
  }

  void clear_has_augmented_permissions() {
    MutableStorage()->removeMember("hasAugmentedPermissions");
  }


  bool get_has_augmented_permissions() const {
    const Json::Value& storage = Storage("hasAugmentedPermissions");
    return client::JsonValueToCppValueHelper<bool >(storage);
  }

  void set_has_augmented_permissions(bool value) {
    client::SetJsonValueFromCppValueHelper<bool >(
      value, MutableStorage("hasAugmentedPermissions"));
  }

  bool has_has_thumbnail() const {
    return Storage().isMember("hasThumbnail");
  }

  void clear_has_thumbnail() {
    MutableStorage()->removeMember("hasThumbnail");
  }


  bool get_has_thumbnail() const {
    const Json::Value& storage = Storage("hasThumbnail");
    return client::JsonValueToCppValueHelper<bool >(storage);
  }

  void set_has_thumbnail(bool value) {
    client::SetJsonValueFromCppValueHelper<bool >(
      value, MutableStorage("hasThumbnail"));
  }

  bool has_head_revision_id() const {
    return Storage().isMember("headRevisionId");
  }

  void clear_head_revision_id() {
    MutableStorage()->removeMember("headRevisionId");
  }


  const StringPiece get_head_revision_id() const {
    const Json::Value& v = Storage("headRevisionId");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_head_revision_id(const StringPiece& value) {
    *MutableStorage("headRevisionId") = value.data();
  }

  bool has_icon_link() const {
    return Storage().isMember("iconLink");
  }

  void clear_icon_link() {
    MutableStorage()->removeMember("iconLink");
  }


  const StringPiece get_icon_link() const {
    const Json::Value& v = Storage("iconLink");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_icon_link(const StringPiece& value) {
    *MutableStorage("iconLink") = value.data();
  }

  bool has_id() const {
    return Storage().isMember("id");
  }

  void clear_id() {
    MutableStorage()->removeMember("id");
  }


  const StringPiece get_id() const {
    const Json::Value& v = Storage("id");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_id(const StringPiece& value) {
    *MutableStorage("id") = value.data();
  }

  bool has_image_media_metadata() const {
    return Storage().isMember("imageMediaMetadata");
  }

  void clear_image_media_metadata() {
    MutableStorage()->removeMember("imageMediaMetadata");
  }


  const FileImageMediaMetadata get_image_media_metadata() const {
     const Json::Value& storage = Storage("imageMediaMetadata");
    return client::JsonValueToCppValueHelper<FileImageMediaMetadata >(storage);
  }

  FileImageMediaMetadata mutable_imageMediaMetadata() {
    Json::Value* storage = MutableStorage("imageMediaMetadata");
    return client::JsonValueToMutableCppValueHelper<FileImageMediaMetadata >(storage);
  }

  bool has_indexable_text() const {
    return Storage().isMember("indexableText");
  }

  void clear_indexable_text() {
    MutableStorage()->removeMember("indexableText");
  }


  const FileIndexableText get_indexable_text() const {
     const Json::Value& storage = Storage("indexableText");
    return client::JsonValueToCppValueHelper<FileIndexableText >(storage);
  }

  FileIndexableText mutable_indexableText() {
    Json::Value* storage = MutableStorage("indexableText");
    return client::JsonValueToMutableCppValueHelper<FileIndexableText >(storage);
  }

  bool has_is_app_authorized() const {
    return Storage().isMember("isAppAuthorized");
  }

  void clear_is_app_authorized() {
    MutableStorage()->removeMember("isAppAuthorized");
  }


  bool get_is_app_authorized() const {
    const Json::Value& storage = Storage("isAppAuthorized");
    return client::JsonValueToCppValueHelper<bool >(storage);
  }

  void set_is_app_authorized(bool value) {
    client::SetJsonValueFromCppValueHelper<bool >(
      value, MutableStorage("isAppAuthorized"));
  }

  bool has_kind() const {
    return Storage().isMember("kind");
  }

  void clear_kind() {
    MutableStorage()->removeMember("kind");
  }


  const StringPiece get_kind() const {
    const Json::Value& v = Storage("kind");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_kind(const StringPiece& value) {
    *MutableStorage("kind") = value.data();
  }

  bool has_labels() const {
    return Storage().isMember("labels");
  }

  void clear_labels() {
    MutableStorage()->removeMember("labels");
  }


  const FileLabels get_labels() const {
     const Json::Value& storage = Storage("labels");
    return client::JsonValueToCppValueHelper<FileLabels >(storage);
  }

  FileLabels mutable_labels() {
    Json::Value* storage = MutableStorage("labels");
    return client::JsonValueToMutableCppValueHelper<FileLabels >(storage);
  }

  bool has_last_modifying_user() const {
    return Storage().isMember("lastModifyingUser");
  }

  void clear_last_modifying_user() {
    MutableStorage()->removeMember("lastModifyingUser");
  }


  const User get_last_modifying_user() const;

  User mutable_lastModifyingUser();

  bool has_last_modifying_user_name() const {
    return Storage().isMember("lastModifyingUserName");
  }

  void clear_last_modifying_user_name() {
    MutableStorage()->removeMember("lastModifyingUserName");
  }


  const StringPiece get_last_modifying_user_name() const {
    const Json::Value& v = Storage("lastModifyingUserName");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_last_modifying_user_name(const StringPiece& value) {
    *MutableStorage("lastModifyingUserName") = value.data();
  }

  bool has_last_viewed_by_me_date() const {
    return Storage().isMember("lastViewedByMeDate");
  }

  void clear_last_viewed_by_me_date() {
    MutableStorage()->removeMember("lastViewedByMeDate");
  }


  client::DateTime get_last_viewed_by_me_date() const {
    const Json::Value& storage = Storage("lastViewedByMeDate");
    return client::JsonValueToCppValueHelper<client::DateTime >(storage);
  }

  void set_last_viewed_by_me_date(client::DateTime value) {
    client::SetJsonValueFromCppValueHelper<client::DateTime >(
      value, MutableStorage("lastViewedByMeDate"));
  }

  bool has_marked_viewed_by_me_date() const {
    return Storage().isMember("markedViewedByMeDate");
  }

  void clear_marked_viewed_by_me_date() {
    MutableStorage()->removeMember("markedViewedByMeDate");
  }


  client::DateTime get_marked_viewed_by_me_date() const {
    const Json::Value& storage = Storage("markedViewedByMeDate");
    return client::JsonValueToCppValueHelper<client::DateTime >(storage);
  }

  void set_marked_viewed_by_me_date(client::DateTime value) {
    client::SetJsonValueFromCppValueHelper<client::DateTime >(
      value, MutableStorage("markedViewedByMeDate"));
  }

  bool has_md5_checksum() const {
    return Storage().isMember("md5Checksum");
  }

  void clear_md5_checksum() {
    MutableStorage()->removeMember("md5Checksum");
  }


  const StringPiece get_md5_checksum() const {
    const Json::Value& v = Storage("md5Checksum");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_md5_checksum(const StringPiece& value) {
    *MutableStorage("md5Checksum") = value.data();
  }

  bool has_mime_type() const {
    return Storage().isMember("mimeType");
  }

  void clear_mime_type() {
    MutableStorage()->removeMember("mimeType");
  }


  const StringPiece get_mime_type() const {
    const Json::Value& v = Storage("mimeType");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_mime_type(const StringPiece& value) {
    *MutableStorage("mimeType") = value.data();
  }

  bool has_modified_by_me_date() const {
    return Storage().isMember("modifiedByMeDate");
  }

  void clear_modified_by_me_date() {
    MutableStorage()->removeMember("modifiedByMeDate");
  }


  client::DateTime get_modified_by_me_date() const {
    const Json::Value& storage = Storage("modifiedByMeDate");
    return client::JsonValueToCppValueHelper<client::DateTime >(storage);
  }

  void set_modified_by_me_date(client::DateTime value) {
    client::SetJsonValueFromCppValueHelper<client::DateTime >(
      value, MutableStorage("modifiedByMeDate"));
  }

  bool has_modified_date() const {
    return Storage().isMember("modifiedDate");
  }

  void clear_modified_date() {
    MutableStorage()->removeMember("modifiedDate");
  }


  client::DateTime get_modified_date() const {
    const Json::Value& storage = Storage("modifiedDate");
    return client::JsonValueToCppValueHelper<client::DateTime >(storage);
  }

  void set_modified_date(client::DateTime value) {
    client::SetJsonValueFromCppValueHelper<client::DateTime >(
      value, MutableStorage("modifiedDate"));
  }

  bool has_open_with_links() const {
    return Storage().isMember("openWithLinks");
  }

  void clear_open_with_links() {
    MutableStorage()->removeMember("openWithLinks");
  }


  const client::JsonCppAssociativeArray<string > get_open_with_links() const {
     const Json::Value& storage = Storage("openWithLinks");
    return client::JsonValueToCppValueHelper<client::JsonCppAssociativeArray<string > >(storage);
  }

  client::JsonCppAssociativeArray<string > mutable_openWithLinks() {
    Json::Value* storage = MutableStorage("openWithLinks");
    return client::JsonValueToMutableCppValueHelper<client::JsonCppAssociativeArray<string > >(storage);
  }

  bool has_original_filename() const {
    return Storage().isMember("originalFilename");
  }

  void clear_original_filename() {
    MutableStorage()->removeMember("originalFilename");
  }


  const StringPiece get_original_filename() const {
    const Json::Value& v = Storage("originalFilename");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_original_filename(const StringPiece& value) {
    *MutableStorage("originalFilename") = value.data();
  }

  bool has_owned_by_me() const {
    return Storage().isMember("ownedByMe");
  }

  void clear_owned_by_me() {
    MutableStorage()->removeMember("ownedByMe");
  }


  bool get_owned_by_me() const {
    const Json::Value& storage = Storage("ownedByMe");
    return client::JsonValueToCppValueHelper<bool >(storage);
  }

  void set_owned_by_me(bool value) {
    client::SetJsonValueFromCppValueHelper<bool >(
      value, MutableStorage("ownedByMe"));
  }

  bool has_owner_names() const {
    return Storage().isMember("ownerNames");
  }

  void clear_owner_names() {
    MutableStorage()->removeMember("ownerNames");
  }


  const client::JsonCppArray<string > get_owner_names() const {
     const Json::Value& storage = Storage("ownerNames");
    return client::JsonValueToCppValueHelper<client::JsonCppArray<string > >(storage);
  }

  client::JsonCppArray<string > mutable_ownerNames() {
    Json::Value* storage = MutableStorage("ownerNames");
    return client::JsonValueToMutableCppValueHelper<client::JsonCppArray<string > >(storage);
  }

  bool has_owners() const {
    return Storage().isMember("owners");
  }

  void clear_owners() {
    MutableStorage()->removeMember("owners");
  }


  const client::JsonCppArray<User > get_owners() const;

  client::JsonCppArray<User > mutable_owners();

  bool has_parents() const {
    return Storage().isMember("parents");
  }

  void clear_parents() {
    MutableStorage()->removeMember("parents");
  }


  const client::JsonCppArray<ParentReference > get_parents() const;

  client::JsonCppArray<ParentReference > mutable_parents();

  bool has_permission_ids() const {
    return Storage().isMember("permissionIds");
  }

  void clear_permission_ids() {
    MutableStorage()->removeMember("permissionIds");
  }


  const client::JsonCppArray<string > get_permission_ids() const {
     const Json::Value& storage = Storage("permissionIds");
    return client::JsonValueToCppValueHelper<client::JsonCppArray<string > >(storage);
  }

  client::JsonCppArray<string > mutable_permissionIds() {
    Json::Value* storage = MutableStorage("permissionIds");
    return client::JsonValueToMutableCppValueHelper<client::JsonCppArray<string > >(storage);
  }

  bool has_permissions() const {
    return Storage().isMember("permissions");
  }

  void clear_permissions() {
    MutableStorage()->removeMember("permissions");
  }


  const client::JsonCppArray<Permission > get_permissions() const;

  client::JsonCppArray<Permission > mutable_permissions();

  bool has_properties() const {
    return Storage().isMember("properties");
  }

  void clear_properties() {
    MutableStorage()->removeMember("properties");
  }


  const client::JsonCppArray<Property > get_properties() const;

  client::JsonCppArray<Property > mutable_properties();

  bool has_quota_bytes_used() const {
    return Storage().isMember("quotaBytesUsed");
  }

  void clear_quota_bytes_used() {
    MutableStorage()->removeMember("quotaBytesUsed");
  }


  int64 get_quota_bytes_used() const {
    const Json::Value& storage = Storage("quotaBytesUsed");
    return client::JsonValueToCppValueHelper<int64 >(storage);
  }

  void set_quota_bytes_used(int64 value) {
    client::SetJsonValueFromCppValueHelper<int64 >(
      value, MutableStorage("quotaBytesUsed"));
  }

  bool has_self_link() const {
    return Storage().isMember("selfLink");
  }

  void clear_self_link() {
    MutableStorage()->removeMember("selfLink");
  }


  const StringPiece get_self_link() const {
    const Json::Value& v = Storage("selfLink");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_self_link(const StringPiece& value) {
    *MutableStorage("selfLink") = value.data();
  }

  bool has_shareable() const {
    return Storage().isMember("shareable");
  }

  void clear_shareable() {
    MutableStorage()->removeMember("shareable");
  }


  bool get_shareable() const {
    const Json::Value& storage = Storage("shareable");
    return client::JsonValueToCppValueHelper<bool >(storage);
  }

  void set_shareable(bool value) {
    client::SetJsonValueFromCppValueHelper<bool >(
      value, MutableStorage("shareable"));
  }

  bool has_shared() const {
    return Storage().isMember("shared");
  }

  void clear_shared() {
    MutableStorage()->removeMember("shared");
  }


  bool get_shared() const {
    const Json::Value& storage = Storage("shared");
    return client::JsonValueToCppValueHelper<bool >(storage);
  }

  void set_shared(bool value) {
    client::SetJsonValueFromCppValueHelper<bool >(
      value, MutableStorage("shared"));
  }

  bool has_shared_with_me_date() const {
    return Storage().isMember("sharedWithMeDate");
  }

  void clear_shared_with_me_date() {
    MutableStorage()->removeMember("sharedWithMeDate");
  }


  client::DateTime get_shared_with_me_date() const {
    const Json::Value& storage = Storage("sharedWithMeDate");
    return client::JsonValueToCppValueHelper<client::DateTime >(storage);
  }

  void set_shared_with_me_date(client::DateTime value) {
    client::SetJsonValueFromCppValueHelper<client::DateTime >(
      value, MutableStorage("sharedWithMeDate"));
  }

  bool has_sharing_user() const {
    return Storage().isMember("sharingUser");
  }

  void clear_sharing_user() {
    MutableStorage()->removeMember("sharingUser");
  }


  const User get_sharing_user() const;

  User mutable_sharingUser();

  bool has_shortcut_details() const {
    return Storage().isMember("shortcutDetails");
  }

  void clear_shortcut_details() {
    MutableStorage()->removeMember("shortcutDetails");
  }


  const FileShortcutDetails get_shortcut_details() const {
     const Json::Value& storage = Storage("shortcutDetails");
    return client::JsonValueToCppValueHelper<FileShortcutDetails >(storage);
  }

  FileShortcutDetails mutable_shortcutDetails() {
    Json::Value* storage = MutableStorage("shortcutDetails");
    return client::JsonValueToMutableCppValueHelper<FileShortcutDetails >(storage);
  }

  bool has_spaces() const {
    return Storage().isMember("spaces");
  }

  void clear_spaces() {
    MutableStorage()->removeMember("spaces");
  }


  const client::JsonCppArray<string > get_spaces() const {
     const Json::Value& storage = Storage("spaces");
    return client::JsonValueToCppValueHelper<client::JsonCppArray<string > >(storage);
  }

  client::JsonCppArray<string > mutable_spaces() {
    Json::Value* storage = MutableStorage("spaces");
    return client::JsonValueToMutableCppValueHelper<client::JsonCppArray<string > >(storage);
  }

  bool has_team_drive_id() const {
    return Storage().isMember("teamDriveId");
  }

  void clear_team_drive_id() {
    MutableStorage()->removeMember("teamDriveId");
  }


  const StringPiece get_team_drive_id() const {
    const Json::Value& v = Storage("teamDriveId");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_team_drive_id(const StringPiece& value) {
    *MutableStorage("teamDriveId") = value.data();
  }

  bool has_thumbnail() const {
    return Storage().isMember("thumbnail");
  }

  void clear_thumbnail() {
    MutableStorage()->removeMember("thumbnail");
  }


  const FileThumbnail get_thumbnail() const {
     const Json::Value& storage = Storage("thumbnail");
    return client::JsonValueToCppValueHelper<FileThumbnail >(storage);
  }

  FileThumbnail mutable_thumbnail() {
    Json::Value* storage = MutableStorage("thumbnail");
    return client::JsonValueToMutableCppValueHelper<FileThumbnail >(storage);
  }

  bool has_thumbnail_link() const {
    return Storage().isMember("thumbnailLink");
  }

  void clear_thumbnail_link() {
    MutableStorage()->removeMember("thumbnailLink");
  }


  const StringPiece get_thumbnail_link() const {
    const Json::Value& v = Storage("thumbnailLink");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_thumbnail_link(const StringPiece& value) {
    *MutableStorage("thumbnailLink") = value.data();
  }

  bool has_thumbnail_version() const {
    return Storage().isMember("thumbnailVersion");
  }

  void clear_thumbnail_version() {
    MutableStorage()->removeMember("thumbnailVersion");
  }


  int64 get_thumbnail_version() const {
    const Json::Value& storage = Storage("thumbnailVersion");
    return client::JsonValueToCppValueHelper<int64 >(storage);
  }

  void set_thumbnail_version(int64 value) {
    client::SetJsonValueFromCppValueHelper<int64 >(
      value, MutableStorage("thumbnailVersion"));
  }

  bool has_title() const {
    return Storage().isMember("title");
  }

  void clear_title() {
    MutableStorage()->removeMember("title");
  }


  const StringPiece get_title() const {
    const Json::Value& v = Storage("title");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_title(const StringPiece& value) {
    *MutableStorage("title") = value.data();
  }

  bool has_trashed_date() const {
    return Storage().isMember("trashedDate");
  }

  void clear_trashed_date() {
    MutableStorage()->removeMember("trashedDate");
  }


  client::DateTime get_trashed_date() const {
    const Json::Value& storage = Storage("trashedDate");
    return client::JsonValueToCppValueHelper<client::DateTime >(storage);
  }

  void set_trashed_date(client::DateTime value) {
    client::SetJsonValueFromCppValueHelper<client::DateTime >(
      value, MutableStorage("trashedDate"));
  }

  bool has_trashing_user() const {
    return Storage().isMember("trashingUser");
  }

  void clear_trashing_user() {
    MutableStorage()->removeMember("trashingUser");
  }


  const User get_trashing_user() const;

  User mutable_trashingUser();

  bool has_user_permission() const {
    return Storage().isMember("userPermission");
  }

  void clear_user_permission() {
    MutableStorage()->removeMember("userPermission");
  }


  const Permission get_user_permission() const;

  Permission mutable_userPermission();

  bool has_version() const {
    return Storage().isMember("version");
  }

  void clear_version() {
    MutableStorage()->removeMember("version");
  }


  int64 get_version() const {
    const Json::Value& storage = Storage("version");
    return client::JsonValueToCppValueHelper<int64 >(storage);
  }

  void set_version(int64 value) {
    client::SetJsonValueFromCppValueHelper<int64 >(
      value, MutableStorage("version"));
  }

  bool has_video_media_metadata() const {
    return Storage().isMember("videoMediaMetadata");
  }

  void clear_video_media_metadata() {
    MutableStorage()->removeMember("videoMediaMetadata");
  }


  const FileVideoMediaMetadata get_video_media_metadata() const {
     const Json::Value& storage = Storage("videoMediaMetadata");
    return client::JsonValueToCppValueHelper<FileVideoMediaMetadata >(storage);
  }

  FileVideoMediaMetadata mutable_videoMediaMetadata() {
    Json::Value* storage = MutableStorage("videoMediaMetadata");
    return client::JsonValueToMutableCppValueHelper<FileVideoMediaMetadata >(storage);
  }

  bool has_web_content_link() const {
    return Storage().isMember("webContentLink");
  }

  void clear_web_content_link() {
    MutableStorage()->removeMember("webContentLink");
  }


  const StringPiece get_web_content_link() const {
    const Json::Value& v = Storage("webContentLink");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_web_content_link(const StringPiece& value) {
    *MutableStorage("webContentLink") = value.data();
  }

  bool has_web_view_link() const {
    return Storage().isMember("webViewLink");
  }

  void clear_web_view_link() {
    MutableStorage()->removeMember("webViewLink");
  }


  const StringPiece get_web_view_link() const {
    const Json::Value& v = Storage("webViewLink");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_web_view_link(const StringPiece& value) {
    *MutableStorage("webViewLink") = value.data();
  }

  bool has_writers_can_share() const {
    return Storage().isMember("writersCanShare");
  }

  void clear_writers_can_share() {
    MutableStorage()->removeMember("writersCanShare");
  }


  bool get_writers_can_share() const {
    const Json::Value& storage = Storage("writersCanShare");
    return client::JsonValueToCppValueHelper<bool >(storage);
  }

  void set_writers_can_share(bool value) {
    client::SetJsonValueFromCppValueHelper<bool >(
      value, MutableStorage("writersCanShare"));
  }

 private:
  void operator=(const File&);
};  // File
}  // namespace google_drive_api
#endif  // GOOGLE_DRIVE_API_FILE_H_