volume.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-14, 18:51:48 UTC
//   C++ generator version: 0.1.4

// ----------------------------------------------------------------------------
// NOTE: This file is generated from Google APIs Discovery Service.
// Service:
//   Books API (books/v1)
// Generated from:
//   Version: v1
//   Revision: 114
// Generated by:
//    Tool: google-apis-code-generator 1.5.1
//     C++: 0.1.4
#ifndef  GOOGLE_BOOKS_API_VOLUME_H_
#define  GOOGLE_BOOKS_API_VOLUME_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/books_api/download_access_restriction.h"
#include "google/books_api/reading_position.h"
#include "google/books_api/review.h"
#include "google/books_api/volumeseriesinfo.h"

namespace Json {
class Value;
}  // namespace Json

namespace google_books_api {
using namespace googleapis;

class Volume : public client::JsonCppData {
 public:
  class VolumeAccessInfo : public client::JsonCppData {
   public:
    class VolumeAccessInfoEpub : public client::JsonCppData {
     public:
      static VolumeAccessInfoEpub* New();

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

      explicit VolumeAccessInfoEpub(Json::Value* storage);

      virtual ~VolumeAccessInfoEpub();

      const StringPiece GetTypeName() const {
        return StringPiece("google_books_api::VolumeAccessInfoEpub");
      }

      bool has_acs_token_link() const {
        return Storage().isMember("acsTokenLink");
      }

      void clear_acs_token_link() {
        MutableStorage()->removeMember("acsTokenLink");
      }


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

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

      bool has_download_link() const {
        return Storage().isMember("downloadLink");
      }

      void clear_download_link() {
        MutableStorage()->removeMember("downloadLink");
      }


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

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

      bool has_is_available() const {
        return Storage().isMember("isAvailable");
      }

      void clear_is_available() {
        MutableStorage()->removeMember("isAvailable");
      }


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

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

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

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

      explicit VolumeAccessInfoPdf(Json::Value* storage);

      virtual ~VolumeAccessInfoPdf();

      const StringPiece GetTypeName() const {
        return StringPiece("google_books_api::VolumeAccessInfoPdf");
      }

      bool has_acs_token_link() const {
        return Storage().isMember("acsTokenLink");
      }

      void clear_acs_token_link() {
        MutableStorage()->removeMember("acsTokenLink");
      }


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

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

      bool has_download_link() const {
        return Storage().isMember("downloadLink");
      }

      void clear_download_link() {
        MutableStorage()->removeMember("downloadLink");
      }


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

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

      bool has_is_available() const {
        return Storage().isMember("isAvailable");
      }

      void clear_is_available() {
        MutableStorage()->removeMember("isAvailable");
      }


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

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

     private:
      void operator=(const VolumeAccessInfoPdf&);
    };  // VolumeAccessInfoPdf
    static VolumeAccessInfo* New();

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

    explicit VolumeAccessInfo(Json::Value* storage);

    virtual ~VolumeAccessInfo();

    const StringPiece GetTypeName() const {
      return StringPiece("google_books_api::VolumeAccessInfo");
    }

    bool has_access_view_status() const {
      return Storage().isMember("accessViewStatus");
    }

    void clear_access_view_status() {
      MutableStorage()->removeMember("accessViewStatus");
    }


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

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

    bool has_country() const {
      return Storage().isMember("country");
    }

    void clear_country() {
      MutableStorage()->removeMember("country");
    }


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

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

    bool has_download_access() const {
      return Storage().isMember("downloadAccess");
    }

    void clear_download_access() {
      MutableStorage()->removeMember("downloadAccess");
    }


    const DownloadAccessRestriction get_download_access() const;

    DownloadAccessRestriction mutable_downloadAccess();

    bool has_drive_imported_content_link() const {
      return Storage().isMember("driveImportedContentLink");
    }

    void clear_drive_imported_content_link() {
      MutableStorage()->removeMember("driveImportedContentLink");
    }


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

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

    bool has_embeddable() const {
      return Storage().isMember("embeddable");
    }

    void clear_embeddable() {
      MutableStorage()->removeMember("embeddable");
    }


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

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

    bool has_epub() const {
      return Storage().isMember("epub");
    }

    void clear_epub() {
      MutableStorage()->removeMember("epub");
    }


    const VolumeAccessInfoEpub get_epub() const {
       const Json::Value& storage = Storage("epub");
      return client::JsonValueToCppValueHelper<VolumeAccessInfoEpub >(storage);
    }

    VolumeAccessInfoEpub mutable_epub() {
      Json::Value* storage = MutableStorage("epub");
      return client::JsonValueToMutableCppValueHelper<VolumeAccessInfoEpub >(storage);
    }

    bool has_explicit_offline_license_management() const {
      return Storage().isMember("explicitOfflineLicenseManagement");
    }

    void clear_explicit_offline_license_management() {
      MutableStorage()->removeMember("explicitOfflineLicenseManagement");
    }


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

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

    bool has_pdf() const {
      return Storage().isMember("pdf");
    }

    void clear_pdf() {
      MutableStorage()->removeMember("pdf");
    }


    const VolumeAccessInfoPdf get_pdf() const {
       const Json::Value& storage = Storage("pdf");
      return client::JsonValueToCppValueHelper<VolumeAccessInfoPdf >(storage);
    }

    VolumeAccessInfoPdf mutable_pdf() {
      Json::Value* storage = MutableStorage("pdf");
      return client::JsonValueToMutableCppValueHelper<VolumeAccessInfoPdf >(storage);
    }

    bool has_public_domain() const {
      return Storage().isMember("publicDomain");
    }

    void clear_public_domain() {
      MutableStorage()->removeMember("publicDomain");
    }


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

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

    bool has_quote_sharing_allowed() const {
      return Storage().isMember("quoteSharingAllowed");
    }

    void clear_quote_sharing_allowed() {
      MutableStorage()->removeMember("quoteSharingAllowed");
    }


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

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

    bool has_text_to_speech_permission() const {
      return Storage().isMember("textToSpeechPermission");
    }

    void clear_text_to_speech_permission() {
      MutableStorage()->removeMember("textToSpeechPermission");
    }


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

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

    bool has_view_order_url() const {
      return Storage().isMember("viewOrderUrl");
    }

    void clear_view_order_url() {
      MutableStorage()->removeMember("viewOrderUrl");
    }


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

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

    bool has_viewability() const {
      return Storage().isMember("viewability");
    }

    void clear_viewability() {
      MutableStorage()->removeMember("viewability");
    }


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

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

    bool has_web_reader_link() const {
      return Storage().isMember("webReaderLink");
    }

    void clear_web_reader_link() {
      MutableStorage()->removeMember("webReaderLink");
    }


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

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

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

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

      explicit VolumeLayerInfoLayers(Json::Value* storage);

      virtual ~VolumeLayerInfoLayers();

      const StringPiece GetTypeName() const {
        return StringPiece("google_books_api::VolumeLayerInfoLayers");
      }

      bool has_layer_id() const {
        return Storage().isMember("layerId");
      }

      void clear_layer_id() {
        MutableStorage()->removeMember("layerId");
      }


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

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

      bool has_volume_annotations_version() const {
        return Storage().isMember("volumeAnnotationsVersion");
      }

      void clear_volume_annotations_version() {
        MutableStorage()->removeMember("volumeAnnotationsVersion");
      }


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

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

     private:
      void operator=(const VolumeLayerInfoLayers&);
    };  // VolumeLayerInfoLayers
    static VolumeLayerInfo* New();

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

    explicit VolumeLayerInfo(Json::Value* storage);

    virtual ~VolumeLayerInfo();

    const StringPiece GetTypeName() const {
      return StringPiece("google_books_api::VolumeLayerInfo");
    }

    bool has_layers() const {
      return Storage().isMember("layers");
    }

    void clear_layers() {
      MutableStorage()->removeMember("layers");
    }


    const client::JsonCppArray<VolumeLayerInfoLayers > get_layers() const {
       const Json::Value& storage = Storage("layers");
      return client::JsonValueToCppValueHelper<client::JsonCppArray<VolumeLayerInfoLayers > >(storage);
    }

    client::JsonCppArray<VolumeLayerInfoLayers > mutable_layers() {
      Json::Value* storage = MutableStorage("layers");
      return client::JsonValueToMutableCppValueHelper<client::JsonCppArray<VolumeLayerInfoLayers > >(storage);
    }

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

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

    explicit VolumeRecommendedInfo(Json::Value* storage);

    virtual ~VolumeRecommendedInfo();

    const StringPiece GetTypeName() const {
      return StringPiece("google_books_api::VolumeRecommendedInfo");
    }

    bool has_explanation() const {
      return Storage().isMember("explanation");
    }

    void clear_explanation() {
      MutableStorage()->removeMember("explanation");
    }


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

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

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

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

      explicit VolumeSaleInfoListPrice(Json::Value* storage);

      virtual ~VolumeSaleInfoListPrice();

      const StringPiece GetTypeName() const {
        return StringPiece("google_books_api::VolumeSaleInfoListPrice");
      }

      bool has_amount() const {
        return Storage().isMember("amount");
      }

      void clear_amount() {
        MutableStorage()->removeMember("amount");
      }


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

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

      bool has_currency_code() const {
        return Storage().isMember("currencyCode");
      }

      void clear_currency_code() {
        MutableStorage()->removeMember("currencyCode");
      }


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

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

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

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

        explicit VolumeSaleInfoOffersListPrice(Json::Value* storage);

        virtual ~VolumeSaleInfoOffersListPrice();

        const StringPiece GetTypeName() const {
          return StringPiece("google_books_api::VolumeSaleInfoOffersListPrice");
        }

        bool has_amount_in_micros() const {
          return Storage().isMember("amountInMicros");
        }

        void clear_amount_in_micros() {
          MutableStorage()->removeMember("amountInMicros");
        }


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

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

        bool has_currency_code() const {
          return Storage().isMember("currencyCode");
        }

        void clear_currency_code() {
          MutableStorage()->removeMember("currencyCode");
        }


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

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

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

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

        explicit VolumeSaleInfoOffersRentalDuration(Json::Value* storage);

        virtual ~VolumeSaleInfoOffersRentalDuration();

        const StringPiece GetTypeName() const {
          return StringPiece("google_books_api::VolumeSaleInfoOffersRentalDuration");
        }

        bool has_count() const {
          return Storage().isMember("count");
        }

        void clear_count() {
          MutableStorage()->removeMember("count");
        }


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

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

        bool has_unit() const {
          return Storage().isMember("unit");
        }

        void clear_unit() {
          MutableStorage()->removeMember("unit");
        }


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

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

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

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

        explicit VolumeSaleInfoOffersRetailPrice(Json::Value* storage);

        virtual ~VolumeSaleInfoOffersRetailPrice();

        const StringPiece GetTypeName() const {
          return StringPiece("google_books_api::VolumeSaleInfoOffersRetailPrice");
        }

        bool has_amount_in_micros() const {
          return Storage().isMember("amountInMicros");
        }

        void clear_amount_in_micros() {
          MutableStorage()->removeMember("amountInMicros");
        }


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

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

        bool has_currency_code() const {
          return Storage().isMember("currencyCode");
        }

        void clear_currency_code() {
          MutableStorage()->removeMember("currencyCode");
        }


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

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

       private:
        void operator=(const VolumeSaleInfoOffersRetailPrice&);
      };  // VolumeSaleInfoOffersRetailPrice
      static VolumeSaleInfoOffers* New();

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

      explicit VolumeSaleInfoOffers(Json::Value* storage);

      virtual ~VolumeSaleInfoOffers();

      const StringPiece GetTypeName() const {
        return StringPiece("google_books_api::VolumeSaleInfoOffers");
      }

      bool has_finsky_offer_type() const {
        return Storage().isMember("finskyOfferType");
      }

      void clear_finsky_offer_type() {
        MutableStorage()->removeMember("finskyOfferType");
      }


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

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

      bool has_giftable() const {
        return Storage().isMember("giftable");
      }

      void clear_giftable() {
        MutableStorage()->removeMember("giftable");
      }


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

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

      bool has_list_price() const {
        return Storage().isMember("listPrice");
      }

      void clear_list_price() {
        MutableStorage()->removeMember("listPrice");
      }


      const VolumeSaleInfoOffersListPrice get_list_price() const {
         const Json::Value& storage = Storage("listPrice");
        return client::JsonValueToCppValueHelper<VolumeSaleInfoOffersListPrice >(storage);
      }

      VolumeSaleInfoOffersListPrice mutable_listPrice() {
        Json::Value* storage = MutableStorage("listPrice");
        return client::JsonValueToMutableCppValueHelper<VolumeSaleInfoOffersListPrice >(storage);
      }

      bool has_rental_duration() const {
        return Storage().isMember("rentalDuration");
      }

      void clear_rental_duration() {
        MutableStorage()->removeMember("rentalDuration");
      }


      const VolumeSaleInfoOffersRentalDuration get_rental_duration() const {
         const Json::Value& storage = Storage("rentalDuration");
        return client::JsonValueToCppValueHelper<VolumeSaleInfoOffersRentalDuration >(storage);
      }

      VolumeSaleInfoOffersRentalDuration mutable_rentalDuration() {
        Json::Value* storage = MutableStorage("rentalDuration");
        return client::JsonValueToMutableCppValueHelper<VolumeSaleInfoOffersRentalDuration >(storage);
      }

      bool has_retail_price() const {
        return Storage().isMember("retailPrice");
      }

      void clear_retail_price() {
        MutableStorage()->removeMember("retailPrice");
      }


      const VolumeSaleInfoOffersRetailPrice get_retail_price() const {
         const Json::Value& storage = Storage("retailPrice");
        return client::JsonValueToCppValueHelper<VolumeSaleInfoOffersRetailPrice >(storage);
      }

      VolumeSaleInfoOffersRetailPrice mutable_retailPrice() {
        Json::Value* storage = MutableStorage("retailPrice");
        return client::JsonValueToMutableCppValueHelper<VolumeSaleInfoOffersRetailPrice >(storage);
      }

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

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

      explicit VolumeSaleInfoRetailPrice(Json::Value* storage);

      virtual ~VolumeSaleInfoRetailPrice();

      const StringPiece GetTypeName() const {
        return StringPiece("google_books_api::VolumeSaleInfoRetailPrice");
      }

      bool has_amount() const {
        return Storage().isMember("amount");
      }

      void clear_amount() {
        MutableStorage()->removeMember("amount");
      }


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

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

      bool has_currency_code() const {
        return Storage().isMember("currencyCode");
      }

      void clear_currency_code() {
        MutableStorage()->removeMember("currencyCode");
      }


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

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

     private:
      void operator=(const VolumeSaleInfoRetailPrice&);
    };  // VolumeSaleInfoRetailPrice
    static VolumeSaleInfo* New();

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

    explicit VolumeSaleInfo(Json::Value* storage);

    virtual ~VolumeSaleInfo();

    const StringPiece GetTypeName() const {
      return StringPiece("google_books_api::VolumeSaleInfo");
    }

    bool has_buy_link() const {
      return Storage().isMember("buyLink");
    }

    void clear_buy_link() {
      MutableStorage()->removeMember("buyLink");
    }


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

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

    bool has_country() const {
      return Storage().isMember("country");
    }

    void clear_country() {
      MutableStorage()->removeMember("country");
    }


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

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

    bool has_is_ebook() const {
      return Storage().isMember("isEbook");
    }

    void clear_is_ebook() {
      MutableStorage()->removeMember("isEbook");
    }


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

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

    bool has_list_price() const {
      return Storage().isMember("listPrice");
    }

    void clear_list_price() {
      MutableStorage()->removeMember("listPrice");
    }


    const VolumeSaleInfoListPrice get_list_price() const {
       const Json::Value& storage = Storage("listPrice");
      return client::JsonValueToCppValueHelper<VolumeSaleInfoListPrice >(storage);
    }

    VolumeSaleInfoListPrice mutable_listPrice() {
      Json::Value* storage = MutableStorage("listPrice");
      return client::JsonValueToMutableCppValueHelper<VolumeSaleInfoListPrice >(storage);
    }

    bool has_offers() const {
      return Storage().isMember("offers");
    }

    void clear_offers() {
      MutableStorage()->removeMember("offers");
    }


    const client::JsonCppArray<VolumeSaleInfoOffers > get_offers() const {
       const Json::Value& storage = Storage("offers");
      return client::JsonValueToCppValueHelper<client::JsonCppArray<VolumeSaleInfoOffers > >(storage);
    }

    client::JsonCppArray<VolumeSaleInfoOffers > mutable_offers() {
      Json::Value* storage = MutableStorage("offers");
      return client::JsonValueToMutableCppValueHelper<client::JsonCppArray<VolumeSaleInfoOffers > >(storage);
    }

    bool has_on_sale_date() const {
      return Storage().isMember("onSaleDate");
    }

    void clear_on_sale_date() {
      MutableStorage()->removeMember("onSaleDate");
    }


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

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

    bool has_retail_price() const {
      return Storage().isMember("retailPrice");
    }

    void clear_retail_price() {
      MutableStorage()->removeMember("retailPrice");
    }


    const VolumeSaleInfoRetailPrice get_retail_price() const {
       const Json::Value& storage = Storage("retailPrice");
      return client::JsonValueToCppValueHelper<VolumeSaleInfoRetailPrice >(storage);
    }

    VolumeSaleInfoRetailPrice mutable_retailPrice() {
      Json::Value* storage = MutableStorage("retailPrice");
      return client::JsonValueToMutableCppValueHelper<VolumeSaleInfoRetailPrice >(storage);
    }

    bool has_saleability() const {
      return Storage().isMember("saleability");
    }

    void clear_saleability() {
      MutableStorage()->removeMember("saleability");
    }


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

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

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

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

    explicit VolumeSearchInfo(Json::Value* storage);

    virtual ~VolumeSearchInfo();

    const StringPiece GetTypeName() const {
      return StringPiece("google_books_api::VolumeSearchInfo");
    }

    bool has_text_snippet() const {
      return Storage().isMember("textSnippet");
    }

    void clear_text_snippet() {
      MutableStorage()->removeMember("textSnippet");
    }


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

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

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

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

      explicit VolumeUserInfoCopy(Json::Value* storage);

      virtual ~VolumeUserInfoCopy();

      const StringPiece GetTypeName() const {
        return StringPiece("google_books_api::VolumeUserInfoCopy");
      }

      bool has_allowed_character_count() const {
        return Storage().isMember("allowedCharacterCount");
      }

      void clear_allowed_character_count() {
        MutableStorage()->removeMember("allowedCharacterCount");
      }


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

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

      bool has_limit_type() const {
        return Storage().isMember("limitType");
      }

      void clear_limit_type() {
        MutableStorage()->removeMember("limitType");
      }


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

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

      bool has_remaining_character_count() const {
        return Storage().isMember("remainingCharacterCount");
      }

      void clear_remaining_character_count() {
        MutableStorage()->removeMember("remainingCharacterCount");
      }


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

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

      bool has_updated() const {
        return Storage().isMember("updated");
      }

      void clear_updated() {
        MutableStorage()->removeMember("updated");
      }


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

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

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

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

      explicit VolumeUserInfoFamilySharing(Json::Value* storage);

      virtual ~VolumeUserInfoFamilySharing();

      const StringPiece GetTypeName() const {
        return StringPiece("google_books_api::VolumeUserInfoFamilySharing");
      }

      bool has_family_role() const {
        return Storage().isMember("familyRole");
      }

      void clear_family_role() {
        MutableStorage()->removeMember("familyRole");
      }


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

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

      bool has_is_sharing_allowed() const {
        return Storage().isMember("isSharingAllowed");
      }

      void clear_is_sharing_allowed() {
        MutableStorage()->removeMember("isSharingAllowed");
      }


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

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

      bool has_is_sharing_disabled_by_fop() const {
        return Storage().isMember("isSharingDisabledByFop");
      }

      void clear_is_sharing_disabled_by_fop() {
        MutableStorage()->removeMember("isSharingDisabledByFop");
      }


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

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

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

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

      explicit VolumeUserInfoRentalPeriod(Json::Value* storage);

      virtual ~VolumeUserInfoRentalPeriod();

      const StringPiece GetTypeName() const {
        return StringPiece("google_books_api::VolumeUserInfoRentalPeriod");
      }

      bool has_end_utc_sec() const {
        return Storage().isMember("endUtcSec");
      }

      void clear_end_utc_sec() {
        MutableStorage()->removeMember("endUtcSec");
      }


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

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

      bool has_start_utc_sec() const {
        return Storage().isMember("startUtcSec");
      }

      void clear_start_utc_sec() {
        MutableStorage()->removeMember("startUtcSec");
      }


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

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

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

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

      explicit VolumeUserInfoUserUploadedVolumeInfo(Json::Value* storage);

      virtual ~VolumeUserInfoUserUploadedVolumeInfo();

      const StringPiece GetTypeName() const {
        return StringPiece("google_books_api::VolumeUserInfoUserUploadedVolumeInfo");
      }

      bool has_processing_state() const {
        return Storage().isMember("processingState");
      }

      void clear_processing_state() {
        MutableStorage()->removeMember("processingState");
      }


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

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

     private:
      void operator=(const VolumeUserInfoUserUploadedVolumeInfo&);
    };  // VolumeUserInfoUserUploadedVolumeInfo
    static VolumeUserInfo* New();

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

    explicit VolumeUserInfo(Json::Value* storage);

    virtual ~VolumeUserInfo();

    const StringPiece GetTypeName() const {
      return StringPiece("google_books_api::VolumeUserInfo");
    }

    bool has_acquired_time() const {
      return Storage().isMember("acquiredTime");
    }

    void clear_acquired_time() {
      MutableStorage()->removeMember("acquiredTime");
    }


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

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

    bool has_acquisition_type() const {
      return Storage().isMember("acquisitionType");
    }

    void clear_acquisition_type() {
      MutableStorage()->removeMember("acquisitionType");
    }


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

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

    bool has_copy() const {
      return Storage().isMember("copy");
    }

    void clear_copy() {
      MutableStorage()->removeMember("copy");
    }


    const VolumeUserInfoCopy get_copy() const {
       const Json::Value& storage = Storage("copy");
      return client::JsonValueToCppValueHelper<VolumeUserInfoCopy >(storage);
    }

    VolumeUserInfoCopy mutable_copy() {
      Json::Value* storage = MutableStorage("copy");
      return client::JsonValueToMutableCppValueHelper<VolumeUserInfoCopy >(storage);
    }

    bool has_entitlement_type() const {
      return Storage().isMember("entitlementType");
    }

    void clear_entitlement_type() {
      MutableStorage()->removeMember("entitlementType");
    }


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

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

    bool has_family_sharing() const {
      return Storage().isMember("familySharing");
    }

    void clear_family_sharing() {
      MutableStorage()->removeMember("familySharing");
    }


    const VolumeUserInfoFamilySharing get_family_sharing() const {
       const Json::Value& storage = Storage("familySharing");
      return client::JsonValueToCppValueHelper<VolumeUserInfoFamilySharing >(storage);
    }

    VolumeUserInfoFamilySharing mutable_familySharing() {
      Json::Value* storage = MutableStorage("familySharing");
      return client::JsonValueToMutableCppValueHelper<VolumeUserInfoFamilySharing >(storage);
    }

    bool has_is_family_shared_from_user() const {
      return Storage().isMember("isFamilySharedFromUser");
    }

    void clear_is_family_shared_from_user() {
      MutableStorage()->removeMember("isFamilySharedFromUser");
    }


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

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

    bool has_is_family_shared_to_user() const {
      return Storage().isMember("isFamilySharedToUser");
    }

    void clear_is_family_shared_to_user() {
      MutableStorage()->removeMember("isFamilySharedToUser");
    }


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

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

    bool has_is_family_sharing_allowed() const {
      return Storage().isMember("isFamilySharingAllowed");
    }

    void clear_is_family_sharing_allowed() {
      MutableStorage()->removeMember("isFamilySharingAllowed");
    }


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

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

    bool has_is_family_sharing_disabled_by_fop() const {
      return Storage().isMember("isFamilySharingDisabledByFop");
    }

    void clear_is_family_sharing_disabled_by_fop() {
      MutableStorage()->removeMember("isFamilySharingDisabledByFop");
    }


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

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

    bool has_is_in_my_books() const {
      return Storage().isMember("isInMyBooks");
    }

    void clear_is_in_my_books() {
      MutableStorage()->removeMember("isInMyBooks");
    }


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

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

    bool has_is_preordered() const {
      return Storage().isMember("isPreordered");
    }

    void clear_is_preordered() {
      MutableStorage()->removeMember("isPreordered");
    }


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

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

    bool has_is_purchased() const {
      return Storage().isMember("isPurchased");
    }

    void clear_is_purchased() {
      MutableStorage()->removeMember("isPurchased");
    }


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

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

    bool has_is_uploaded() const {
      return Storage().isMember("isUploaded");
    }

    void clear_is_uploaded() {
      MutableStorage()->removeMember("isUploaded");
    }


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

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

    bool has_reading_position() const {
      return Storage().isMember("readingPosition");
    }

    void clear_reading_position() {
      MutableStorage()->removeMember("readingPosition");
    }


    const ReadingPosition get_reading_position() const;

    ReadingPosition mutable_readingPosition();

    bool has_rental_period() const {
      return Storage().isMember("rentalPeriod");
    }

    void clear_rental_period() {
      MutableStorage()->removeMember("rentalPeriod");
    }


    const VolumeUserInfoRentalPeriod get_rental_period() const {
       const Json::Value& storage = Storage("rentalPeriod");
      return client::JsonValueToCppValueHelper<VolumeUserInfoRentalPeriod >(storage);
    }

    VolumeUserInfoRentalPeriod mutable_rentalPeriod() {
      Json::Value* storage = MutableStorage("rentalPeriod");
      return client::JsonValueToMutableCppValueHelper<VolumeUserInfoRentalPeriod >(storage);
    }

    bool has_rental_state() const {
      return Storage().isMember("rentalState");
    }

    void clear_rental_state() {
      MutableStorage()->removeMember("rentalState");
    }


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

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

    bool has_review() const {
      return Storage().isMember("review");
    }

    void clear_review() {
      MutableStorage()->removeMember("review");
    }


    const Review get_review() const;

    Review mutable_review();

    bool has_updated() const {
      return Storage().isMember("updated");
    }

    void clear_updated() {
      MutableStorage()->removeMember("updated");
    }


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

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

    bool has_user_uploaded_volume_info() const {
      return Storage().isMember("userUploadedVolumeInfo");
    }

    void clear_user_uploaded_volume_info() {
      MutableStorage()->removeMember("userUploadedVolumeInfo");
    }


    const VolumeUserInfoUserUploadedVolumeInfo get_user_uploaded_volume_info() const {
       const Json::Value& storage = Storage("userUploadedVolumeInfo");
      return client::JsonValueToCppValueHelper<VolumeUserInfoUserUploadedVolumeInfo >(storage);
    }

    VolumeUserInfoUserUploadedVolumeInfo mutable_userUploadedVolumeInfo() {
      Json::Value* storage = MutableStorage("userUploadedVolumeInfo");
      return client::JsonValueToMutableCppValueHelper<VolumeUserInfoUserUploadedVolumeInfo >(storage);
    }

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

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

      explicit VolumeVolumeInfoDimensions(Json::Value* storage);

      virtual ~VolumeVolumeInfoDimensions();

      const StringPiece GetTypeName() const {
        return StringPiece("google_books_api::VolumeVolumeInfoDimensions");
      }

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

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


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

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

      bool has_thickness() const {
        return Storage().isMember("thickness");
      }

      void clear_thickness() {
        MutableStorage()->removeMember("thickness");
      }


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

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

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

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


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

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

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

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

      explicit VolumeVolumeInfoImageLinks(Json::Value* storage);

      virtual ~VolumeVolumeInfoImageLinks();

      const StringPiece GetTypeName() const {
        return StringPiece("google_books_api::VolumeVolumeInfoImageLinks");
      }

      bool has_extra_large() const {
        return Storage().isMember("extraLarge");
      }

      void clear_extra_large() {
        MutableStorage()->removeMember("extraLarge");
      }


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

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

      bool has_large() const {
        return Storage().isMember("large");
      }

      void clear_large() {
        MutableStorage()->removeMember("large");
      }


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

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

      bool has_medium() const {
        return Storage().isMember("medium");
      }

      void clear_medium() {
        MutableStorage()->removeMember("medium");
      }


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

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

      bool has_small() const {
        return Storage().isMember("small");
      }

      void clear_small() {
        MutableStorage()->removeMember("small");
      }


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

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

      bool has_small_thumbnail() const {
        return Storage().isMember("smallThumbnail");
      }

      void clear_small_thumbnail() {
        MutableStorage()->removeMember("smallThumbnail");
      }


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

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

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

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


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

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

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

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

      explicit VolumeVolumeInfoIndustryIdentifiers(Json::Value* storage);

      virtual ~VolumeVolumeInfoIndustryIdentifiers();

      const StringPiece GetTypeName() const {
        return StringPiece("google_books_api::VolumeVolumeInfoIndustryIdentifiers");
      }

      bool has_identifier() const {
        return Storage().isMember("identifier");
      }

      void clear_identifier() {
        MutableStorage()->removeMember("identifier");
      }


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

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

      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 VolumeVolumeInfoIndustryIdentifiers&);
    };  // VolumeVolumeInfoIndustryIdentifiers
    class VolumeVolumeInfoPanelizationSummary : public client::JsonCppData {
     public:
      static VolumeVolumeInfoPanelizationSummary* New();

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

      explicit VolumeVolumeInfoPanelizationSummary(Json::Value* storage);

      virtual ~VolumeVolumeInfoPanelizationSummary();

      const StringPiece GetTypeName() const {
        return StringPiece("google_books_api::VolumeVolumeInfoPanelizationSummary");
      }

      bool has_contains_epub_bubbles() const {
        return Storage().isMember("containsEpubBubbles");
      }

      void clear_contains_epub_bubbles() {
        MutableStorage()->removeMember("containsEpubBubbles");
      }


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

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

      bool has_contains_image_bubbles() const {
        return Storage().isMember("containsImageBubbles");
      }

      void clear_contains_image_bubbles() {
        MutableStorage()->removeMember("containsImageBubbles");
      }


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

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

      bool has_epub_bubble_version() const {
        return Storage().isMember("epubBubbleVersion");
      }

      void clear_epub_bubble_version() {
        MutableStorage()->removeMember("epubBubbleVersion");
      }


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

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

      bool has_image_bubble_version() const {
        return Storage().isMember("imageBubbleVersion");
      }

      void clear_image_bubble_version() {
        MutableStorage()->removeMember("imageBubbleVersion");
      }


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

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

     private:
      void operator=(const VolumeVolumeInfoPanelizationSummary&);
    };  // VolumeVolumeInfoPanelizationSummary
    static VolumeVolumeInfo* New();

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

    explicit VolumeVolumeInfo(Json::Value* storage);

    virtual ~VolumeVolumeInfo();

    const StringPiece GetTypeName() const {
      return StringPiece("google_books_api::VolumeVolumeInfo");
    }

    bool has_allow_anon_logging() const {
      return Storage().isMember("allowAnonLogging");
    }

    void clear_allow_anon_logging() {
      MutableStorage()->removeMember("allowAnonLogging");
    }


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

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

    bool has_authors() const {
      return Storage().isMember("authors");
    }

    void clear_authors() {
      MutableStorage()->removeMember("authors");
    }


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

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

    bool has_average_rating() const {
      return Storage().isMember("averageRating");
    }

    void clear_average_rating() {
      MutableStorage()->removeMember("averageRating");
    }


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

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

    bool has_canonical_volume_link() const {
      return Storage().isMember("canonicalVolumeLink");
    }

    void clear_canonical_volume_link() {
      MutableStorage()->removeMember("canonicalVolumeLink");
    }


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

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

    bool has_categories() const {
      return Storage().isMember("categories");
    }

    void clear_categories() {
      MutableStorage()->removeMember("categories");
    }


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

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

    bool has_comics_content() const {
      return Storage().isMember("comicsContent");
    }

    void clear_comics_content() {
      MutableStorage()->removeMember("comicsContent");
    }


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

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

    bool has_content_version() const {
      return Storage().isMember("contentVersion");
    }

    void clear_content_version() {
      MutableStorage()->removeMember("contentVersion");
    }


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

    void set_content_version(const StringPiece& value) {
      *MutableStorage("contentVersion") = 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_dimensions() const {
      return Storage().isMember("dimensions");
    }

    void clear_dimensions() {
      MutableStorage()->removeMember("dimensions");
    }


    const VolumeVolumeInfoDimensions get_dimensions() const {
       const Json::Value& storage = Storage("dimensions");
      return client::JsonValueToCppValueHelper<VolumeVolumeInfoDimensions >(storage);
    }

    VolumeVolumeInfoDimensions mutable_dimensions() {
      Json::Value* storage = MutableStorage("dimensions");
      return client::JsonValueToMutableCppValueHelper<VolumeVolumeInfoDimensions >(storage);
    }

    bool has_image_links() const {
      return Storage().isMember("imageLinks");
    }

    void clear_image_links() {
      MutableStorage()->removeMember("imageLinks");
    }


    const VolumeVolumeInfoImageLinks get_image_links() const {
       const Json::Value& storage = Storage("imageLinks");
      return client::JsonValueToCppValueHelper<VolumeVolumeInfoImageLinks >(storage);
    }

    VolumeVolumeInfoImageLinks mutable_imageLinks() {
      Json::Value* storage = MutableStorage("imageLinks");
      return client::JsonValueToMutableCppValueHelper<VolumeVolumeInfoImageLinks >(storage);
    }

    bool has_industry_identifiers() const {
      return Storage().isMember("industryIdentifiers");
    }

    void clear_industry_identifiers() {
      MutableStorage()->removeMember("industryIdentifiers");
    }


    const client::JsonCppArray<VolumeVolumeInfoIndustryIdentifiers > get_industry_identifiers() const {
       const Json::Value& storage = Storage("industryIdentifiers");
      return client::JsonValueToCppValueHelper<client::JsonCppArray<VolumeVolumeInfoIndustryIdentifiers > >(storage);
    }

    client::JsonCppArray<VolumeVolumeInfoIndustryIdentifiers > mutable_industryIdentifiers() {
      Json::Value* storage = MutableStorage("industryIdentifiers");
      return client::JsonValueToMutableCppValueHelper<client::JsonCppArray<VolumeVolumeInfoIndustryIdentifiers > >(storage);
    }

    bool has_info_link() const {
      return Storage().isMember("infoLink");
    }

    void clear_info_link() {
      MutableStorage()->removeMember("infoLink");
    }


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

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

    bool has_language() const {
      return Storage().isMember("language");
    }

    void clear_language() {
      MutableStorage()->removeMember("language");
    }


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

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

    bool has_main_category() const {
      return Storage().isMember("mainCategory");
    }

    void clear_main_category() {
      MutableStorage()->removeMember("mainCategory");
    }


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

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

    bool has_maturity_rating() const {
      return Storage().isMember("maturityRating");
    }

    void clear_maturity_rating() {
      MutableStorage()->removeMember("maturityRating");
    }


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

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

    bool has_page_count() const {
      return Storage().isMember("pageCount");
    }

    void clear_page_count() {
      MutableStorage()->removeMember("pageCount");
    }


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

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

    bool has_panelization_summary() const {
      return Storage().isMember("panelizationSummary");
    }

    void clear_panelization_summary() {
      MutableStorage()->removeMember("panelizationSummary");
    }


    const VolumeVolumeInfoPanelizationSummary get_panelization_summary() const {
       const Json::Value& storage = Storage("panelizationSummary");
      return client::JsonValueToCppValueHelper<VolumeVolumeInfoPanelizationSummary >(storage);
    }

    VolumeVolumeInfoPanelizationSummary mutable_panelizationSummary() {
      Json::Value* storage = MutableStorage("panelizationSummary");
      return client::JsonValueToMutableCppValueHelper<VolumeVolumeInfoPanelizationSummary >(storage);
    }

    bool has_preview_link() const {
      return Storage().isMember("previewLink");
    }

    void clear_preview_link() {
      MutableStorage()->removeMember("previewLink");
    }


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

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

    bool has_print_type() const {
      return Storage().isMember("printType");
    }

    void clear_print_type() {
      MutableStorage()->removeMember("printType");
    }


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

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

    bool has_printed_page_count() const {
      return Storage().isMember("printedPageCount");
    }

    void clear_printed_page_count() {
      MutableStorage()->removeMember("printedPageCount");
    }


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

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

    bool has_published_date() const {
      return Storage().isMember("publishedDate");
    }

    void clear_published_date() {
      MutableStorage()->removeMember("publishedDate");
    }


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

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

    bool has_publisher() const {
      return Storage().isMember("publisher");
    }

    void clear_publisher() {
      MutableStorage()->removeMember("publisher");
    }


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

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

    bool has_ratings_count() const {
      return Storage().isMember("ratingsCount");
    }

    void clear_ratings_count() {
      MutableStorage()->removeMember("ratingsCount");
    }


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

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

    bool has_reading_modes() const {
      return Storage().isMember("readingModes");
    }

    void clear_reading_modes() {
      MutableStorage()->removeMember("readingModes");
    }


    const client::JsonCppData get_reading_modes() const {
       const Json::Value& storage = Storage("readingModes");
      return client::JsonValueToCppValueHelper<client::JsonCppData >(storage);
    }

    client::JsonCppData mutable_readingModes() {
      Json::Value* storage = MutableStorage("readingModes");
      return client::JsonValueToMutableCppValueHelper<client::JsonCppData >(storage);
    }

    bool has_sample_page_count() const {
      return Storage().isMember("samplePageCount");
    }

    void clear_sample_page_count() {
      MutableStorage()->removeMember("samplePageCount");
    }


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

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

    bool has_series_info() const {
      return Storage().isMember("seriesInfo");
    }

    void clear_series_info() {
      MutableStorage()->removeMember("seriesInfo");
    }


    const Volumeseriesinfo get_series_info() const;

    Volumeseriesinfo mutable_seriesInfo();

    bool has_subtitle() const {
      return Storage().isMember("subtitle");
    }

    void clear_subtitle() {
      MutableStorage()->removeMember("subtitle");
    }


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

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

    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();
    }

   private:
    void operator=(const VolumeVolumeInfo&);
  };  // VolumeVolumeInfo
  static Volume* New();

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

  explicit Volume(Json::Value* storage);

  virtual ~Volume();

  const StringPiece GetTypeName() const {
    return StringPiece("google_books_api::Volume");
  }

  bool has_access_info() const {
    return Storage().isMember("accessInfo");
  }

  void clear_access_info() {
    MutableStorage()->removeMember("accessInfo");
  }


  const VolumeAccessInfo get_access_info() const {
     const Json::Value& storage = Storage("accessInfo");
    return client::JsonValueToCppValueHelper<VolumeAccessInfo >(storage);
  }

  VolumeAccessInfo mutable_accessInfo() {
    Json::Value* storage = MutableStorage("accessInfo");
    return client::JsonValueToMutableCppValueHelper<VolumeAccessInfo >(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_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_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_layer_info() const {
    return Storage().isMember("layerInfo");
  }

  void clear_layer_info() {
    MutableStorage()->removeMember("layerInfo");
  }


  const VolumeLayerInfo get_layer_info() const {
     const Json::Value& storage = Storage("layerInfo");
    return client::JsonValueToCppValueHelper<VolumeLayerInfo >(storage);
  }

  VolumeLayerInfo mutable_layerInfo() {
    Json::Value* storage = MutableStorage("layerInfo");
    return client::JsonValueToMutableCppValueHelper<VolumeLayerInfo >(storage);
  }

  bool has_recommended_info() const {
    return Storage().isMember("recommendedInfo");
  }

  void clear_recommended_info() {
    MutableStorage()->removeMember("recommendedInfo");
  }


  const VolumeRecommendedInfo get_recommended_info() const {
     const Json::Value& storage = Storage("recommendedInfo");
    return client::JsonValueToCppValueHelper<VolumeRecommendedInfo >(storage);
  }

  VolumeRecommendedInfo mutable_recommendedInfo() {
    Json::Value* storage = MutableStorage("recommendedInfo");
    return client::JsonValueToMutableCppValueHelper<VolumeRecommendedInfo >(storage);
  }

  bool has_sale_info() const {
    return Storage().isMember("saleInfo");
  }

  void clear_sale_info() {
    MutableStorage()->removeMember("saleInfo");
  }


  const VolumeSaleInfo get_sale_info() const {
     const Json::Value& storage = Storage("saleInfo");
    return client::JsonValueToCppValueHelper<VolumeSaleInfo >(storage);
  }

  VolumeSaleInfo mutable_saleInfo() {
    Json::Value* storage = MutableStorage("saleInfo");
    return client::JsonValueToMutableCppValueHelper<VolumeSaleInfo >(storage);
  }

  bool has_search_info() const {
    return Storage().isMember("searchInfo");
  }

  void clear_search_info() {
    MutableStorage()->removeMember("searchInfo");
  }


  const VolumeSearchInfo get_search_info() const {
     const Json::Value& storage = Storage("searchInfo");
    return client::JsonValueToCppValueHelper<VolumeSearchInfo >(storage);
  }

  VolumeSearchInfo mutable_searchInfo() {
    Json::Value* storage = MutableStorage("searchInfo");
    return client::JsonValueToMutableCppValueHelper<VolumeSearchInfo >(storage);
  }

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

  void clear_user_info() {
    MutableStorage()->removeMember("userInfo");
  }


  const VolumeUserInfo get_user_info() const {
     const Json::Value& storage = Storage("userInfo");
    return client::JsonValueToCppValueHelper<VolumeUserInfo >(storage);
  }

  VolumeUserInfo mutable_userInfo() {
    Json::Value* storage = MutableStorage("userInfo");
    return client::JsonValueToMutableCppValueHelper<VolumeUserInfo >(storage);
  }

  bool has_volume_info() const {
    return Storage().isMember("volumeInfo");
  }

  void clear_volume_info() {
    MutableStorage()->removeMember("volumeInfo");
  }


  const VolumeVolumeInfo get_volume_info() const {
     const Json::Value& storage = Storage("volumeInfo");
    return client::JsonValueToCppValueHelper<VolumeVolumeInfo >(storage);
  }

  VolumeVolumeInfo mutable_volumeInfo() {
    Json::Value* storage = MutableStorage("volumeInfo");
    return client::JsonValueToMutableCppValueHelper<VolumeVolumeInfo >(storage);
  }

 private:
  void operator=(const Volume&);
};  // Volume
}  // namespace google_books_api
#endif  // GOOGLE_BOOKS_API_VOLUME_H_