about.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_ABOUT_H_
#define  GOOGLE_DRIVE_API_ABOUT_H_

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

#include "google/drive_api/user.h"

namespace Json {
class Value;
}  // namespace Json

namespace google_drive_api {
using namespace googleapis;

class About : public client::JsonCppData {
 public:
  class AboutAdditionalRoleInfo : public client::JsonCppData {
   public:
    class AboutAdditionalRoleInfoRoleSets : public client::JsonCppData {
     public:
      static AboutAdditionalRoleInfoRoleSets* New();

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

      explicit AboutAdditionalRoleInfoRoleSets(Json::Value* storage);

      virtual ~AboutAdditionalRoleInfoRoleSets();

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

      bool has_additional_roles() const {
        return Storage().isMember("additionalRoles");
      }

      void clear_additional_roles() {
        MutableStorage()->removeMember("additionalRoles");
      }


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

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

      bool has_primary_role() const {
        return Storage().isMember("primaryRole");
      }

      void clear_primary_role() {
        MutableStorage()->removeMember("primaryRole");
      }


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

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

     private:
      void operator=(const AboutAdditionalRoleInfoRoleSets&);
    };  // AboutAdditionalRoleInfoRoleSets
    static AboutAdditionalRoleInfo* New();

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

    explicit AboutAdditionalRoleInfo(Json::Value* storage);

    virtual ~AboutAdditionalRoleInfo();

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

    bool has_role_sets() const {
      return Storage().isMember("roleSets");
    }

    void clear_role_sets() {
      MutableStorage()->removeMember("roleSets");
    }


    const client::JsonCppArray<AboutAdditionalRoleInfoRoleSets > get_role_sets() const {
       const Json::Value& storage = Storage("roleSets");
      return client::JsonValueToCppValueHelper<client::JsonCppArray<AboutAdditionalRoleInfoRoleSets > >(storage);
    }

    client::JsonCppArray<AboutAdditionalRoleInfoRoleSets > mutable_roleSets() {
      Json::Value* storage = MutableStorage("roleSets");
      return client::JsonValueToMutableCppValueHelper<client::JsonCppArray<AboutAdditionalRoleInfoRoleSets > >(storage);
    }

    bool has_type() const {
      return Storage().isMember("type");
    }

    void clear_type() {
      MutableStorage()->removeMember("type");
    }


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

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

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

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

    explicit AboutDriveThemes(Json::Value* storage);

    virtual ~AboutDriveThemes();

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

    bool has_background_image_link() const {
      return Storage().isMember("backgroundImageLink");
    }

    void clear_background_image_link() {
      MutableStorage()->removeMember("backgroundImageLink");
    }


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

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

    bool has_color_rgb() const {
      return Storage().isMember("colorRgb");
    }

    void clear_color_rgb() {
      MutableStorage()->removeMember("colorRgb");
    }


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

    void set_color_rgb(const StringPiece& value) {
      *MutableStorage("colorRgb") = 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();
    }

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

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

    explicit AboutExportFormats(Json::Value* storage);

    virtual ~AboutExportFormats();

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

    bool has_source() const {
      return Storage().isMember("source");
    }

    void clear_source() {
      MutableStorage()->removeMember("source");
    }


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

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

    bool has_targets() const {
      return Storage().isMember("targets");
    }

    void clear_targets() {
      MutableStorage()->removeMember("targets");
    }


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

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

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

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

    explicit AboutFeatures(Json::Value* storage);

    virtual ~AboutFeatures();

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

    bool has_feature_name() const {
      return Storage().isMember("featureName");
    }

    void clear_feature_name() {
      MutableStorage()->removeMember("featureName");
    }


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

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

    bool has_feature_rate() const {
      return Storage().isMember("featureRate");
    }

    void clear_feature_rate() {
      MutableStorage()->removeMember("featureRate");
    }


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

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

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

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

    explicit AboutImportFormats(Json::Value* storage);

    virtual ~AboutImportFormats();

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

    bool has_source() const {
      return Storage().isMember("source");
    }

    void clear_source() {
      MutableStorage()->removeMember("source");
    }


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

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

    bool has_targets() const {
      return Storage().isMember("targets");
    }

    void clear_targets() {
      MutableStorage()->removeMember("targets");
    }


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

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

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

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

    explicit AboutMaxUploadSizes(Json::Value* storage);

    virtual ~AboutMaxUploadSizes();

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

    bool has_size() const {
      return Storage().isMember("size");
    }

    void clear_size() {
      MutableStorage()->removeMember("size");
    }


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

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

    bool has_type() const {
      return Storage().isMember("type");
    }

    void clear_type() {
      MutableStorage()->removeMember("type");
    }


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

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

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

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

    explicit AboutQuotaBytesByService(Json::Value* storage);

    virtual ~AboutQuotaBytesByService();

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

    bool has_bytes_used() const {
      return Storage().isMember("bytesUsed");
    }

    void clear_bytes_used() {
      MutableStorage()->removeMember("bytesUsed");
    }


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

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

    bool has_service_name() const {
      return Storage().isMember("serviceName");
    }

    void clear_service_name() {
      MutableStorage()->removeMember("serviceName");
    }


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

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

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

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

    explicit AboutTeamDriveThemes(Json::Value* storage);

    virtual ~AboutTeamDriveThemes();

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

    bool has_background_image_link() const {
      return Storage().isMember("backgroundImageLink");
    }

    void clear_background_image_link() {
      MutableStorage()->removeMember("backgroundImageLink");
    }


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

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

    bool has_color_rgb() const {
      return Storage().isMember("colorRgb");
    }

    void clear_color_rgb() {
      MutableStorage()->removeMember("colorRgb");
    }


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

    void set_color_rgb(const StringPiece& value) {
      *MutableStorage("colorRgb") = 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();
    }

   private:
    void operator=(const AboutTeamDriveThemes&);
  };  // AboutTeamDriveThemes
  static About* New();

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

  explicit About(Json::Value* storage);

  virtual ~About();

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

  bool has_additional_role_info() const {
    return Storage().isMember("additionalRoleInfo");
  }

  void clear_additional_role_info() {
    MutableStorage()->removeMember("additionalRoleInfo");
  }


  const client::JsonCppArray<AboutAdditionalRoleInfo > get_additional_role_info() const {
     const Json::Value& storage = Storage("additionalRoleInfo");
    return client::JsonValueToCppValueHelper<client::JsonCppArray<AboutAdditionalRoleInfo > >(storage);
  }

  client::JsonCppArray<AboutAdditionalRoleInfo > mutable_additionalRoleInfo() {
    Json::Value* storage = MutableStorage("additionalRoleInfo");
    return client::JsonValueToMutableCppValueHelper<client::JsonCppArray<AboutAdditionalRoleInfo > >(storage);
  }

  bool has_can_create_drives() const {
    return Storage().isMember("canCreateDrives");
  }

  void clear_can_create_drives() {
    MutableStorage()->removeMember("canCreateDrives");
  }


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

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

  bool has_can_create_team_drives() const {
    return Storage().isMember("canCreateTeamDrives");
  }

  void clear_can_create_team_drives() {
    MutableStorage()->removeMember("canCreateTeamDrives");
  }


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

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

  bool has_domain_sharing_policy() const {
    return Storage().isMember("domainSharingPolicy");
  }

  void clear_domain_sharing_policy() {
    MutableStorage()->removeMember("domainSharingPolicy");
  }


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

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

  bool has_drive_themes() const {
    return Storage().isMember("driveThemes");
  }

  void clear_drive_themes() {
    MutableStorage()->removeMember("driveThemes");
  }


  const client::JsonCppArray<AboutDriveThemes > get_drive_themes() const {
     const Json::Value& storage = Storage("driveThemes");
    return client::JsonValueToCppValueHelper<client::JsonCppArray<AboutDriveThemes > >(storage);
  }

  client::JsonCppArray<AboutDriveThemes > mutable_driveThemes() {
    Json::Value* storage = MutableStorage("driveThemes");
    return client::JsonValueToMutableCppValueHelper<client::JsonCppArray<AboutDriveThemes > >(storage);
  }

  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_export_formats() const {
    return Storage().isMember("exportFormats");
  }

  void clear_export_formats() {
    MutableStorage()->removeMember("exportFormats");
  }


  const client::JsonCppArray<AboutExportFormats > get_export_formats() const {
     const Json::Value& storage = Storage("exportFormats");
    return client::JsonValueToCppValueHelper<client::JsonCppArray<AboutExportFormats > >(storage);
  }

  client::JsonCppArray<AboutExportFormats > mutable_exportFormats() {
    Json::Value* storage = MutableStorage("exportFormats");
    return client::JsonValueToMutableCppValueHelper<client::JsonCppArray<AboutExportFormats > >(storage);
  }

  bool has_features() const {
    return Storage().isMember("features");
  }

  void clear_features() {
    MutableStorage()->removeMember("features");
  }


  const client::JsonCppArray<AboutFeatures > get_features() const {
     const Json::Value& storage = Storage("features");
    return client::JsonValueToCppValueHelper<client::JsonCppArray<AboutFeatures > >(storage);
  }

  client::JsonCppArray<AboutFeatures > mutable_features() {
    Json::Value* storage = MutableStorage("features");
    return client::JsonValueToMutableCppValueHelper<client::JsonCppArray<AboutFeatures > >(storage);
  }

  bool has_folder_color_palette() const {
    return Storage().isMember("folderColorPalette");
  }

  void clear_folder_color_palette() {
    MutableStorage()->removeMember("folderColorPalette");
  }


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

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

  bool has_import_formats() const {
    return Storage().isMember("importFormats");
  }

  void clear_import_formats() {
    MutableStorage()->removeMember("importFormats");
  }


  const client::JsonCppArray<AboutImportFormats > get_import_formats() const {
     const Json::Value& storage = Storage("importFormats");
    return client::JsonValueToCppValueHelper<client::JsonCppArray<AboutImportFormats > >(storage);
  }

  client::JsonCppArray<AboutImportFormats > mutable_importFormats() {
    Json::Value* storage = MutableStorage("importFormats");
    return client::JsonValueToMutableCppValueHelper<client::JsonCppArray<AboutImportFormats > >(storage);
  }

  bool has_is_current_app_installed() const {
    return Storage().isMember("isCurrentAppInstalled");
  }

  void clear_is_current_app_installed() {
    MutableStorage()->removeMember("isCurrentAppInstalled");
  }


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

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

  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_language_code() const {
    return Storage().isMember("languageCode");
  }

  void clear_language_code() {
    MutableStorage()->removeMember("languageCode");
  }


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

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

  bool has_largest_change_id() const {
    return Storage().isMember("largestChangeId");
  }

  void clear_largest_change_id() {
    MutableStorage()->removeMember("largestChangeId");
  }


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

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

  bool has_max_upload_sizes() const {
    return Storage().isMember("maxUploadSizes");
  }

  void clear_max_upload_sizes() {
    MutableStorage()->removeMember("maxUploadSizes");
  }


  const client::JsonCppArray<AboutMaxUploadSizes > get_max_upload_sizes() const {
     const Json::Value& storage = Storage("maxUploadSizes");
    return client::JsonValueToCppValueHelper<client::JsonCppArray<AboutMaxUploadSizes > >(storage);
  }

  client::JsonCppArray<AboutMaxUploadSizes > mutable_maxUploadSizes() {
    Json::Value* storage = MutableStorage("maxUploadSizes");
    return client::JsonValueToMutableCppValueHelper<client::JsonCppArray<AboutMaxUploadSizes > >(storage);
  }

  bool has_name() const {
    return Storage().isMember("name");
  }

  void clear_name() {
    MutableStorage()->removeMember("name");
  }


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

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

  bool has_permission_id() const {
    return Storage().isMember("permissionId");
  }

  void clear_permission_id() {
    MutableStorage()->removeMember("permissionId");
  }


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

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

  bool has_quota_bytes_by_service() const {
    return Storage().isMember("quotaBytesByService");
  }

  void clear_quota_bytes_by_service() {
    MutableStorage()->removeMember("quotaBytesByService");
  }


  const client::JsonCppArray<AboutQuotaBytesByService > get_quota_bytes_by_service() const {
     const Json::Value& storage = Storage("quotaBytesByService");
    return client::JsonValueToCppValueHelper<client::JsonCppArray<AboutQuotaBytesByService > >(storage);
  }

  client::JsonCppArray<AboutQuotaBytesByService > mutable_quotaBytesByService() {
    Json::Value* storage = MutableStorage("quotaBytesByService");
    return client::JsonValueToMutableCppValueHelper<client::JsonCppArray<AboutQuotaBytesByService > >(storage);
  }

  bool has_quota_bytes_total() const {
    return Storage().isMember("quotaBytesTotal");
  }

  void clear_quota_bytes_total() {
    MutableStorage()->removeMember("quotaBytesTotal");
  }


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

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

  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_quota_bytes_used_aggregate() const {
    return Storage().isMember("quotaBytesUsedAggregate");
  }

  void clear_quota_bytes_used_aggregate() {
    MutableStorage()->removeMember("quotaBytesUsedAggregate");
  }


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

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

  bool has_quota_bytes_used_in_trash() const {
    return Storage().isMember("quotaBytesUsedInTrash");
  }

  void clear_quota_bytes_used_in_trash() {
    MutableStorage()->removeMember("quotaBytesUsedInTrash");
  }


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

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

  bool has_quota_type() const {
    return Storage().isMember("quotaType");
  }

  void clear_quota_type() {
    MutableStorage()->removeMember("quotaType");
  }


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

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

  bool has_remaining_change_ids() const {
    return Storage().isMember("remainingChangeIds");
  }

  void clear_remaining_change_ids() {
    MutableStorage()->removeMember("remainingChangeIds");
  }


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

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

  bool has_root_folder_id() const {
    return Storage().isMember("rootFolderId");
  }

  void clear_root_folder_id() {
    MutableStorage()->removeMember("rootFolderId");
  }


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

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

  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_team_drive_themes() const {
    return Storage().isMember("teamDriveThemes");
  }

  void clear_team_drive_themes() {
    MutableStorage()->removeMember("teamDriveThemes");
  }


  const client::JsonCppArray<AboutTeamDriveThemes > get_team_drive_themes() const {
     const Json::Value& storage = Storage("teamDriveThemes");
    return client::JsonValueToCppValueHelper<client::JsonCppArray<AboutTeamDriveThemes > >(storage);
  }

  client::JsonCppArray<AboutTeamDriveThemes > mutable_teamDriveThemes() {
    Json::Value* storage = MutableStorage("teamDriveThemes");
    return client::JsonValueToMutableCppValueHelper<client::JsonCppArray<AboutTeamDriveThemes > >(storage);
  }

  bool has_user() const {
    return Storage().isMember("user");
  }

  void clear_user() {
    MutableStorage()->removeMember("user");
  }


  const User get_user() const;

  User mutable_user();

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