bucket.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:33:41 UTC
//   C++ generator version: 0.1.4

// ----------------------------------------------------------------------------
// NOTE: This file is generated from Google APIs Discovery Service.
// Service:
//   Cloud Storage JSON API (storage/v1)
// Generated from:
//   Version: v1
//   Revision: 171
// Generated by:
//    Tool: google-apis-code-generator 1.5.1
//     C++: 0.1.4
#ifndef  GOOGLE_STORAGE_API_BUCKET_H_
#define  GOOGLE_STORAGE_API_BUCKET_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/storage_api/bucket_access_control.h"
#include "google/storage_api/object_access_control.h"

namespace Json {
class Value;
}  // namespace Json

namespace google_storage_api {
using namespace googleapis;

class Bucket : public client::JsonCppData {
 public:
  class BucketBilling : public client::JsonCppData {
   public:
    static BucketBilling* New();

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

    explicit BucketBilling(Json::Value* storage);

    virtual ~BucketBilling();

    const StringPiece GetTypeName() const {
      return StringPiece("google_storage_api::BucketBilling");
    }

    bool has_requester_pays() const {
      return Storage().isMember("requesterPays");
    }

    void clear_requester_pays() {
      MutableStorage()->removeMember("requesterPays");
    }


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

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

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

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

    explicit BucketCors(Json::Value* storage);

    virtual ~BucketCors();

    const StringPiece GetTypeName() const {
      return StringPiece("google_storage_api::BucketCors");
    }

    bool has_max_age_seconds() const {
      return Storage().isMember("maxAgeSeconds");
    }

    void clear_max_age_seconds() {
      MutableStorage()->removeMember("maxAgeSeconds");
    }


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

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

    bool has_method() const {
      return Storage().isMember("method");
    }

    void clear_method() {
      MutableStorage()->removeMember("method");
    }


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

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

    bool has_origin() const {
      return Storage().isMember("origin");
    }

    void clear_origin() {
      MutableStorage()->removeMember("origin");
    }


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

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

    bool has_response_header() const {
      return Storage().isMember("responseHeader");
    }

    void clear_response_header() {
      MutableStorage()->removeMember("responseHeader");
    }


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

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

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

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

    explicit BucketEncryption(Json::Value* storage);

    virtual ~BucketEncryption();

    const StringPiece GetTypeName() const {
      return StringPiece("google_storage_api::BucketEncryption");
    }

    bool has_default_kms_key_name() const {
      return Storage().isMember("defaultKmsKeyName");
    }

    void clear_default_kms_key_name() {
      MutableStorage()->removeMember("defaultKmsKeyName");
    }


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

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

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

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

      explicit BucketIamConfigurationBucketPolicyOnly(Json::Value* storage);

      virtual ~BucketIamConfigurationBucketPolicyOnly();

      const StringPiece GetTypeName() const {
        return StringPiece("google_storage_api::BucketIamConfigurationBucketPolicyOnly");
      }

      bool has_enabled() const {
        return Storage().isMember("enabled");
      }

      void clear_enabled() {
        MutableStorage()->removeMember("enabled");
      }


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

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

      bool has_locked_time() const {
        return Storage().isMember("lockedTime");
      }

      void clear_locked_time() {
        MutableStorage()->removeMember("lockedTime");
      }


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

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

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

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

      explicit BucketIamConfigurationUniformBucketLevelAccess(Json::Value* storage);

      virtual ~BucketIamConfigurationUniformBucketLevelAccess();

      const StringPiece GetTypeName() const {
        return StringPiece("google_storage_api::BucketIamConfigurationUniformBucketLevelAccess");
      }

      bool has_enabled() const {
        return Storage().isMember("enabled");
      }

      void clear_enabled() {
        MutableStorage()->removeMember("enabled");
      }


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

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

      bool has_locked_time() const {
        return Storage().isMember("lockedTime");
      }

      void clear_locked_time() {
        MutableStorage()->removeMember("lockedTime");
      }


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

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

     private:
      void operator=(const BucketIamConfigurationUniformBucketLevelAccess&);
    };  // BucketIamConfigurationUniformBucketLevelAccess
    static BucketIamConfiguration* New();

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

    explicit BucketIamConfiguration(Json::Value* storage);

    virtual ~BucketIamConfiguration();

    const StringPiece GetTypeName() const {
      return StringPiece("google_storage_api::BucketIamConfiguration");
    }

    bool has_bucket_policy_only() const {
      return Storage().isMember("bucketPolicyOnly");
    }

    void clear_bucket_policy_only() {
      MutableStorage()->removeMember("bucketPolicyOnly");
    }


    const BucketIamConfigurationBucketPolicyOnly get_bucket_policy_only() const {
       const Json::Value& storage = Storage("bucketPolicyOnly");
      return client::JsonValueToCppValueHelper<BucketIamConfigurationBucketPolicyOnly >(storage);
    }

    BucketIamConfigurationBucketPolicyOnly mutable_bucketPolicyOnly() {
      Json::Value* storage = MutableStorage("bucketPolicyOnly");
      return client::JsonValueToMutableCppValueHelper<BucketIamConfigurationBucketPolicyOnly >(storage);
    }

    bool has_uniform_bucket_level_access() const {
      return Storage().isMember("uniformBucketLevelAccess");
    }

    void clear_uniform_bucket_level_access() {
      MutableStorage()->removeMember("uniformBucketLevelAccess");
    }


    const BucketIamConfigurationUniformBucketLevelAccess get_uniform_bucket_level_access() const {
       const Json::Value& storage = Storage("uniformBucketLevelAccess");
      return client::JsonValueToCppValueHelper<BucketIamConfigurationUniformBucketLevelAccess >(storage);
    }

    BucketIamConfigurationUniformBucketLevelAccess mutable_uniformBucketLevelAccess() {
      Json::Value* storage = MutableStorage("uniformBucketLevelAccess");
      return client::JsonValueToMutableCppValueHelper<BucketIamConfigurationUniformBucketLevelAccess >(storage);
    }

   private:
    void operator=(const BucketIamConfiguration&);
  };  // BucketIamConfiguration
  class BucketLifecycle : public client::JsonCppData {
   public:
    class BucketLifecycleRule : public client::JsonCppData {
     public:
      class BucketLifecycleRuleAction : public client::JsonCppData {
       public:
        static BucketLifecycleRuleAction* New();

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

        explicit BucketLifecycleRuleAction(Json::Value* storage);

        virtual ~BucketLifecycleRuleAction();

        const StringPiece GetTypeName() const {
          return StringPiece("google_storage_api::BucketLifecycleRuleAction");
        }

        bool has_storage_class() const {
          return Storage().isMember("storageClass");
        }

        void clear_storage_class() {
          MutableStorage()->removeMember("storageClass");
        }


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

        void set_storage_class(const StringPiece& value) {
          *MutableStorage("storageClass") = 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 BucketLifecycleRuleAction&);
      };  // BucketLifecycleRuleAction
      class BucketLifecycleRuleCondition : public client::JsonCppData {
       public:
        static BucketLifecycleRuleCondition* New();

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

        explicit BucketLifecycleRuleCondition(Json::Value* storage);

        virtual ~BucketLifecycleRuleCondition();

        const StringPiece GetTypeName() const {
          return StringPiece("google_storage_api::BucketLifecycleRuleCondition");
        }

        bool has_age() const {
          return Storage().isMember("age");
        }

        void clear_age() {
          MutableStorage()->removeMember("age");
        }


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

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

        bool has_created_before() const {
          return Storage().isMember("createdBefore");
        }

        void clear_created_before() {
          MutableStorage()->removeMember("createdBefore");
        }


        client::Date get_created_before() const {
          const Json::Value& storage = Storage("createdBefore");
          return client::JsonValueToCppValueHelper<client::Date >(storage);
        }

        void set_created_before(client::Date value) {
          client::SetJsonValueFromCppValueHelper<client::Date >(
            value, MutableStorage("createdBefore"));
        }

        bool has_is_live() const {
          return Storage().isMember("isLive");
        }

        void clear_is_live() {
          MutableStorage()->removeMember("isLive");
        }


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

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

        bool has_matches_pattern() const {
          return Storage().isMember("matchesPattern");
        }

        void clear_matches_pattern() {
          MutableStorage()->removeMember("matchesPattern");
        }


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

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

        bool has_matches_storage_class() const {
          return Storage().isMember("matchesStorageClass");
        }

        void clear_matches_storage_class() {
          MutableStorage()->removeMember("matchesStorageClass");
        }


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

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

        bool has_num_newer_versions() const {
          return Storage().isMember("numNewerVersions");
        }

        void clear_num_newer_versions() {
          MutableStorage()->removeMember("numNewerVersions");
        }


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

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

       private:
        void operator=(const BucketLifecycleRuleCondition&);
      };  // BucketLifecycleRuleCondition
      static BucketLifecycleRule* New();

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

      explicit BucketLifecycleRule(Json::Value* storage);

      virtual ~BucketLifecycleRule();

      const StringPiece GetTypeName() const {
        return StringPiece("google_storage_api::BucketLifecycleRule");
      }

      bool has_action() const {
        return Storage().isMember("action");
      }

      void clear_action() {
        MutableStorage()->removeMember("action");
      }


      const BucketLifecycleRuleAction get_action() const {
         const Json::Value& storage = Storage("action");
        return client::JsonValueToCppValueHelper<BucketLifecycleRuleAction >(storage);
      }

      BucketLifecycleRuleAction mutable_action() {
        Json::Value* storage = MutableStorage("action");
        return client::JsonValueToMutableCppValueHelper<BucketLifecycleRuleAction >(storage);
      }

      bool has_condition() const {
        return Storage().isMember("condition");
      }

      void clear_condition() {
        MutableStorage()->removeMember("condition");
      }


      const BucketLifecycleRuleCondition get_condition() const {
         const Json::Value& storage = Storage("condition");
        return client::JsonValueToCppValueHelper<BucketLifecycleRuleCondition >(storage);
      }

      BucketLifecycleRuleCondition mutable_condition() {
        Json::Value* storage = MutableStorage("condition");
        return client::JsonValueToMutableCppValueHelper<BucketLifecycleRuleCondition >(storage);
      }

     private:
      void operator=(const BucketLifecycleRule&);
    };  // BucketLifecycleRule
    static BucketLifecycle* New();

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

    explicit BucketLifecycle(Json::Value* storage);

    virtual ~BucketLifecycle();

    const StringPiece GetTypeName() const {
      return StringPiece("google_storage_api::BucketLifecycle");
    }

    bool has_rule() const {
      return Storage().isMember("rule");
    }

    void clear_rule() {
      MutableStorage()->removeMember("rule");
    }


    const client::JsonCppArray<BucketLifecycleRule > get_rule() const {
       const Json::Value& storage = Storage("rule");
      return client::JsonValueToCppValueHelper<client::JsonCppArray<BucketLifecycleRule > >(storage);
    }

    client::JsonCppArray<BucketLifecycleRule > mutable_rule() {
      Json::Value* storage = MutableStorage("rule");
      return client::JsonValueToMutableCppValueHelper<client::JsonCppArray<BucketLifecycleRule > >(storage);
    }

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

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

    explicit BucketLogging(Json::Value* storage);

    virtual ~BucketLogging();

    const StringPiece GetTypeName() const {
      return StringPiece("google_storage_api::BucketLogging");
    }

    bool has_log_bucket() const {
      return Storage().isMember("logBucket");
    }

    void clear_log_bucket() {
      MutableStorage()->removeMember("logBucket");
    }


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

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

    bool has_log_object_prefix() const {
      return Storage().isMember("logObjectPrefix");
    }

    void clear_log_object_prefix() {
      MutableStorage()->removeMember("logObjectPrefix");
    }


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

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

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

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

    explicit BucketOwner(Json::Value* storage);

    virtual ~BucketOwner();

    const StringPiece GetTypeName() const {
      return StringPiece("google_storage_api::BucketOwner");
    }

    bool has_entity() const {
      return Storage().isMember("entity");
    }

    void clear_entity() {
      MutableStorage()->removeMember("entity");
    }


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

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

    bool has_entity_id() const {
      return Storage().isMember("entityId");
    }

    void clear_entity_id() {
      MutableStorage()->removeMember("entityId");
    }


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

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

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

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

    explicit BucketRetentionPolicy(Json::Value* storage);

    virtual ~BucketRetentionPolicy();

    const StringPiece GetTypeName() const {
      return StringPiece("google_storage_api::BucketRetentionPolicy");
    }

    bool has_effective_time() const {
      return Storage().isMember("effectiveTime");
    }

    void clear_effective_time() {
      MutableStorage()->removeMember("effectiveTime");
    }


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

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

    bool has_is_locked() const {
      return Storage().isMember("isLocked");
    }

    void clear_is_locked() {
      MutableStorage()->removeMember("isLocked");
    }


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

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

    bool has_retention_period() const {
      return Storage().isMember("retentionPeriod");
    }

    void clear_retention_period() {
      MutableStorage()->removeMember("retentionPeriod");
    }


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

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

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

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

    explicit BucketVersioning(Json::Value* storage);

    virtual ~BucketVersioning();

    const StringPiece GetTypeName() const {
      return StringPiece("google_storage_api::BucketVersioning");
    }

    bool has_enabled() const {
      return Storage().isMember("enabled");
    }

    void clear_enabled() {
      MutableStorage()->removeMember("enabled");
    }


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

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

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

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

    explicit BucketWebsite(Json::Value* storage);

    virtual ~BucketWebsite();

    const StringPiece GetTypeName() const {
      return StringPiece("google_storage_api::BucketWebsite");
    }

    bool has_main_page_suffix() const {
      return Storage().isMember("mainPageSuffix");
    }

    void clear_main_page_suffix() {
      MutableStorage()->removeMember("mainPageSuffix");
    }


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

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

    bool has_not_found_page() const {
      return Storage().isMember("notFoundPage");
    }

    void clear_not_found_page() {
      MutableStorage()->removeMember("notFoundPage");
    }


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

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

   private:
    void operator=(const BucketWebsite&);
  };  // BucketWebsite
  static Bucket* New();

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

  explicit Bucket(Json::Value* storage);

  virtual ~Bucket();

  const StringPiece GetTypeName() const {
    return StringPiece("google_storage_api::Bucket");
  }

  bool has_acl() const {
    return Storage().isMember("acl");
  }

  void clear_acl() {
    MutableStorage()->removeMember("acl");
  }


  const client::JsonCppArray<BucketAccessControl > get_acl() const;

  client::JsonCppArray<BucketAccessControl > mutable_acl();

  bool has_billing() const {
    return Storage().isMember("billing");
  }

  void clear_billing() {
    MutableStorage()->removeMember("billing");
  }


  const BucketBilling get_billing() const {
     const Json::Value& storage = Storage("billing");
    return client::JsonValueToCppValueHelper<BucketBilling >(storage);
  }

  BucketBilling mutable_billing() {
    Json::Value* storage = MutableStorage("billing");
    return client::JsonValueToMutableCppValueHelper<BucketBilling >(storage);
  }

  bool has_cors() const {
    return Storage().isMember("cors");
  }

  void clear_cors() {
    MutableStorage()->removeMember("cors");
  }


  const client::JsonCppArray<BucketCors > get_cors() const {
     const Json::Value& storage = Storage("cors");
    return client::JsonValueToCppValueHelper<client::JsonCppArray<BucketCors > >(storage);
  }

  client::JsonCppArray<BucketCors > mutable_cors() {
    Json::Value* storage = MutableStorage("cors");
    return client::JsonValueToMutableCppValueHelper<client::JsonCppArray<BucketCors > >(storage);
  }

  bool has_default_event_based_hold() const {
    return Storage().isMember("defaultEventBasedHold");
  }

  void clear_default_event_based_hold() {
    MutableStorage()->removeMember("defaultEventBasedHold");
  }


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

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

  bool has_default_object_acl() const {
    return Storage().isMember("defaultObjectAcl");
  }

  void clear_default_object_acl() {
    MutableStorage()->removeMember("defaultObjectAcl");
  }


  const client::JsonCppArray<ObjectAccessControl > get_default_object_acl() const;

  client::JsonCppArray<ObjectAccessControl > mutable_defaultObjectAcl();

  bool has_encryption() const {
    return Storage().isMember("encryption");
  }

  void clear_encryption() {
    MutableStorage()->removeMember("encryption");
  }


  const BucketEncryption get_encryption() const {
     const Json::Value& storage = Storage("encryption");
    return client::JsonValueToCppValueHelper<BucketEncryption >(storage);
  }

  BucketEncryption mutable_encryption() {
    Json::Value* storage = MutableStorage("encryption");
    return client::JsonValueToMutableCppValueHelper<BucketEncryption >(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_iam_configuration() const {
    return Storage().isMember("iamConfiguration");
  }

  void clear_iam_configuration() {
    MutableStorage()->removeMember("iamConfiguration");
  }


  const BucketIamConfiguration get_iam_configuration() const {
     const Json::Value& storage = Storage("iamConfiguration");
    return client::JsonValueToCppValueHelper<BucketIamConfiguration >(storage);
  }

  BucketIamConfiguration mutable_iamConfiguration() {
    Json::Value* storage = MutableStorage("iamConfiguration");
    return client::JsonValueToMutableCppValueHelper<BucketIamConfiguration >(storage);
  }

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

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


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

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

  bool has_lifecycle() const {
    return Storage().isMember("lifecycle");
  }

  void clear_lifecycle() {
    MutableStorage()->removeMember("lifecycle");
  }


  const BucketLifecycle get_lifecycle() const {
     const Json::Value& storage = Storage("lifecycle");
    return client::JsonValueToCppValueHelper<BucketLifecycle >(storage);
  }

  BucketLifecycle mutable_lifecycle() {
    Json::Value* storage = MutableStorage("lifecycle");
    return client::JsonValueToMutableCppValueHelper<BucketLifecycle >(storage);
  }

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

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


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

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

  bool has_location_type() const {
    return Storage().isMember("locationType");
  }

  void clear_location_type() {
    MutableStorage()->removeMember("locationType");
  }


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

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

  bool has_logging() const {
    return Storage().isMember("logging");
  }

  void clear_logging() {
    MutableStorage()->removeMember("logging");
  }


  const BucketLogging get_logging() const {
     const Json::Value& storage = Storage("logging");
    return client::JsonValueToCppValueHelper<BucketLogging >(storage);
  }

  BucketLogging mutable_logging() {
    Json::Value* storage = MutableStorage("logging");
    return client::JsonValueToMutableCppValueHelper<BucketLogging >(storage);
  }

  bool has_metageneration() const {
    return Storage().isMember("metageneration");
  }

  void clear_metageneration() {
    MutableStorage()->removeMember("metageneration");
  }


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

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

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

  void clear_owner() {
    MutableStorage()->removeMember("owner");
  }


  const BucketOwner get_owner() const {
     const Json::Value& storage = Storage("owner");
    return client::JsonValueToCppValueHelper<BucketOwner >(storage);
  }

  BucketOwner mutable_owner() {
    Json::Value* storage = MutableStorage("owner");
    return client::JsonValueToMutableCppValueHelper<BucketOwner >(storage);
  }

  bool has_project_number() const {
    return Storage().isMember("projectNumber");
  }

  void clear_project_number() {
    MutableStorage()->removeMember("projectNumber");
  }


  uint64 get_project_number() const {
    const Json::Value& storage = Storage("projectNumber");
    return client::JsonValueToCppValueHelper<uint64 >(storage);
  }

  void set_project_number(uint64 value) {
    client::SetJsonValueFromCppValueHelper<uint64 >(
      value, MutableStorage("projectNumber"));
  }

  bool has_retention_policy() const {
    return Storage().isMember("retentionPolicy");
  }

  void clear_retention_policy() {
    MutableStorage()->removeMember("retentionPolicy");
  }


  const BucketRetentionPolicy get_retention_policy() const {
     const Json::Value& storage = Storage("retentionPolicy");
    return client::JsonValueToCppValueHelper<BucketRetentionPolicy >(storage);
  }

  BucketRetentionPolicy mutable_retentionPolicy() {
    Json::Value* storage = MutableStorage("retentionPolicy");
    return client::JsonValueToMutableCppValueHelper<BucketRetentionPolicy >(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_storage_class() const {
    return Storage().isMember("storageClass");
  }

  void clear_storage_class() {
    MutableStorage()->removeMember("storageClass");
  }


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

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

  bool has_time_created() const {
    return Storage().isMember("timeCreated");
  }

  void clear_time_created() {
    MutableStorage()->removeMember("timeCreated");
  }


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

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

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

  void clear_versioning() {
    MutableStorage()->removeMember("versioning");
  }


  const BucketVersioning get_versioning() const {
     const Json::Value& storage = Storage("versioning");
    return client::JsonValueToCppValueHelper<BucketVersioning >(storage);
  }

  BucketVersioning mutable_versioning() {
    Json::Value* storage = MutableStorage("versioning");
    return client::JsonValueToMutableCppValueHelper<BucketVersioning >(storage);
  }

  bool has_website() const {
    return Storage().isMember("website");
  }

  void clear_website() {
    MutableStorage()->removeMember("website");
  }


  const BucketWebsite get_website() const {
     const Json::Value& storage = Storage("website");
    return client::JsonValueToCppValueHelper<BucketWebsite >(storage);
  }

  BucketWebsite mutable_website() {
    Json::Value* storage = MutableStorage("website");
    return client::JsonValueToMutableCppValueHelper<BucketWebsite >(storage);
  }

  bool has_zone_affinity() const {
    return Storage().isMember("zone_affinity");
  }

  void clear_zone_affinity() {
    MutableStorage()->removeMember("zone_affinity");
  }


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

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

 private:
  void operator=(const Bucket&);
};  // Bucket
}  // namespace google_storage_api
#endif  // GOOGLE_STORAGE_API_BUCKET_H_