groups.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-01-30, 02:10:42 UTC
//   C++ generator version: 0.1.4

// ----------------------------------------------------------------------------
// NOTE: This file is generated from Google APIs Discovery Service.
// Service:
//   Groups Settings API (groupssettings/v1)
// Generated from:
//   Version: v1
//   Revision: 82
// Generated by:
//    Tool: google-apis-code-generator 1.5.1
//     C++: 0.1.4
#ifndef  GOOGLE_GROUPSSETTINGS_API_GROUPS_H_
#define  GOOGLE_GROUPSSETTINGS_API_GROUPS_H_

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

namespace Json {
class Value;
}  // namespace Json

namespace google_groupssettings_api {
using namespace googleapis;

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

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

  explicit Groups(Json::Value* storage);

  virtual ~Groups();

  const StringPiece GetTypeName() const {
    return StringPiece("google_groupssettings_api::Groups");
  }

  bool has_allow_external_members() const {
    return Storage().isMember("allowExternalMembers");
  }

  void clear_allow_external_members() {
    MutableStorage()->removeMember("allowExternalMembers");
  }


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

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

  bool has_allow_google_communication() const {
    return Storage().isMember("allowGoogleCommunication");
  }

  void clear_allow_google_communication() {
    MutableStorage()->removeMember("allowGoogleCommunication");
  }


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

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

  bool has_allow_web_posting() const {
    return Storage().isMember("allowWebPosting");
  }

  void clear_allow_web_posting() {
    MutableStorage()->removeMember("allowWebPosting");
  }


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

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

  bool has_archive_only() const {
    return Storage().isMember("archiveOnly");
  }

  void clear_archive_only() {
    MutableStorage()->removeMember("archiveOnly");
  }


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

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

  bool has_custom_footer_text() const {
    return Storage().isMember("customFooterText");
  }

  void clear_custom_footer_text() {
    MutableStorage()->removeMember("customFooterText");
  }


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

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

  bool has_custom_reply_to() const {
    return Storage().isMember("customReplyTo");
  }

  void clear_custom_reply_to() {
    MutableStorage()->removeMember("customReplyTo");
  }


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

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

  bool has_custom_roles_enabled_for_settings_to_be_merged() const {
    return Storage().isMember("customRolesEnabledForSettingsToBeMerged");
  }

  void clear_custom_roles_enabled_for_settings_to_be_merged() {
    MutableStorage()->removeMember("customRolesEnabledForSettingsToBeMerged");
  }


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

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

  bool has_default_message_deny_notification_text() const {
    return Storage().isMember("defaultMessageDenyNotificationText");
  }

  void clear_default_message_deny_notification_text() {
    MutableStorage()->removeMember("defaultMessageDenyNotificationText");
  }


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

  void set_default_message_deny_notification_text(const StringPiece& value) {
    *MutableStorage("defaultMessageDenyNotificationText") = 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_email() const {
    return Storage().isMember("email");
  }

  void clear_email() {
    MutableStorage()->removeMember("email");
  }


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

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

  bool has_enable_collaborative_inbox() const {
    return Storage().isMember("enableCollaborativeInbox");
  }

  void clear_enable_collaborative_inbox() {
    MutableStorage()->removeMember("enableCollaborativeInbox");
  }


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

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

  bool has_favorite_replies_on_top() const {
    return Storage().isMember("favoriteRepliesOnTop");
  }

  void clear_favorite_replies_on_top() {
    MutableStorage()->removeMember("favoriteRepliesOnTop");
  }


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

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

  bool has_include_custom_footer() const {
    return Storage().isMember("includeCustomFooter");
  }

  void clear_include_custom_footer() {
    MutableStorage()->removeMember("includeCustomFooter");
  }


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

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

  bool has_include_in_global_address_list() const {
    return Storage().isMember("includeInGlobalAddressList");
  }

  void clear_include_in_global_address_list() {
    MutableStorage()->removeMember("includeInGlobalAddressList");
  }


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

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

  bool has_is_archived() const {
    return Storage().isMember("isArchived");
  }

  void clear_is_archived() {
    MutableStorage()->removeMember("isArchived");
  }


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

  void set_is_archived(const StringPiece& value) {
    *MutableStorage("isArchived") = 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_max_message_bytes() const {
    return Storage().isMember("maxMessageBytes");
  }

  void clear_max_message_bytes() {
    MutableStorage()->removeMember("maxMessageBytes");
  }


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

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

  bool has_members_can_post_as_the_group() const {
    return Storage().isMember("membersCanPostAsTheGroup");
  }

  void clear_members_can_post_as_the_group() {
    MutableStorage()->removeMember("membersCanPostAsTheGroup");
  }


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

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

  bool has_message_display_font() const {
    return Storage().isMember("messageDisplayFont");
  }

  void clear_message_display_font() {
    MutableStorage()->removeMember("messageDisplayFont");
  }


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

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

  bool has_message_moderation_level() const {
    return Storage().isMember("messageModerationLevel");
  }

  void clear_message_moderation_level() {
    MutableStorage()->removeMember("messageModerationLevel");
  }


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

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

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

  void clear_primary_language() {
    MutableStorage()->removeMember("primaryLanguage");
  }


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

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

  bool has_reply_to() const {
    return Storage().isMember("replyTo");
  }

  void clear_reply_to() {
    MutableStorage()->removeMember("replyTo");
  }


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

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

  bool has_send_message_deny_notification() const {
    return Storage().isMember("sendMessageDenyNotification");
  }

  void clear_send_message_deny_notification() {
    MutableStorage()->removeMember("sendMessageDenyNotification");
  }


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

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

  bool has_show_in_group_directory() const {
    return Storage().isMember("showInGroupDirectory");
  }

  void clear_show_in_group_directory() {
    MutableStorage()->removeMember("showInGroupDirectory");
  }


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

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

  bool has_spam_moderation_level() const {
    return Storage().isMember("spamModerationLevel");
  }

  void clear_spam_moderation_level() {
    MutableStorage()->removeMember("spamModerationLevel");
  }


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

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

  bool has_who_can_add() const {
    return Storage().isMember("whoCanAdd");
  }

  void clear_who_can_add() {
    MutableStorage()->removeMember("whoCanAdd");
  }


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

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

  bool has_who_can_add_references() const {
    return Storage().isMember("whoCanAddReferences");
  }

  void clear_who_can_add_references() {
    MutableStorage()->removeMember("whoCanAddReferences");
  }


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

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

  bool has_who_can_approve_members() const {
    return Storage().isMember("whoCanApproveMembers");
  }

  void clear_who_can_approve_members() {
    MutableStorage()->removeMember("whoCanApproveMembers");
  }


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

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

  bool has_who_can_approve_messages() const {
    return Storage().isMember("whoCanApproveMessages");
  }

  void clear_who_can_approve_messages() {
    MutableStorage()->removeMember("whoCanApproveMessages");
  }


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

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

  bool has_who_can_assign_topics() const {
    return Storage().isMember("whoCanAssignTopics");
  }

  void clear_who_can_assign_topics() {
    MutableStorage()->removeMember("whoCanAssignTopics");
  }


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

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

  bool has_who_can_assist_content() const {
    return Storage().isMember("whoCanAssistContent");
  }

  void clear_who_can_assist_content() {
    MutableStorage()->removeMember("whoCanAssistContent");
  }


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

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

  bool has_who_can_ban_users() const {
    return Storage().isMember("whoCanBanUsers");
  }

  void clear_who_can_ban_users() {
    MutableStorage()->removeMember("whoCanBanUsers");
  }


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

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

  bool has_who_can_contact_owner() const {
    return Storage().isMember("whoCanContactOwner");
  }

  void clear_who_can_contact_owner() {
    MutableStorage()->removeMember("whoCanContactOwner");
  }


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

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

  bool has_who_can_delete_any_post() const {
    return Storage().isMember("whoCanDeleteAnyPost");
  }

  void clear_who_can_delete_any_post() {
    MutableStorage()->removeMember("whoCanDeleteAnyPost");
  }


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

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

  bool has_who_can_delete_topics() const {
    return Storage().isMember("whoCanDeleteTopics");
  }

  void clear_who_can_delete_topics() {
    MutableStorage()->removeMember("whoCanDeleteTopics");
  }


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

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

  bool has_who_can_discover_group() const {
    return Storage().isMember("whoCanDiscoverGroup");
  }

  void clear_who_can_discover_group() {
    MutableStorage()->removeMember("whoCanDiscoverGroup");
  }


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

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

  bool has_who_can_enter_free_form_tags() const {
    return Storage().isMember("whoCanEnterFreeFormTags");
  }

  void clear_who_can_enter_free_form_tags() {
    MutableStorage()->removeMember("whoCanEnterFreeFormTags");
  }


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

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

  bool has_who_can_hide_abuse() const {
    return Storage().isMember("whoCanHideAbuse");
  }

  void clear_who_can_hide_abuse() {
    MutableStorage()->removeMember("whoCanHideAbuse");
  }


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

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

  bool has_who_can_invite() const {
    return Storage().isMember("whoCanInvite");
  }

  void clear_who_can_invite() {
    MutableStorage()->removeMember("whoCanInvite");
  }


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

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

  bool has_who_can_join() const {
    return Storage().isMember("whoCanJoin");
  }

  void clear_who_can_join() {
    MutableStorage()->removeMember("whoCanJoin");
  }


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

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

  bool has_who_can_leave_group() const {
    return Storage().isMember("whoCanLeaveGroup");
  }

  void clear_who_can_leave_group() {
    MutableStorage()->removeMember("whoCanLeaveGroup");
  }


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

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

  bool has_who_can_lock_topics() const {
    return Storage().isMember("whoCanLockTopics");
  }

  void clear_who_can_lock_topics() {
    MutableStorage()->removeMember("whoCanLockTopics");
  }


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

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

  bool has_who_can_make_topics_sticky() const {
    return Storage().isMember("whoCanMakeTopicsSticky");
  }

  void clear_who_can_make_topics_sticky() {
    MutableStorage()->removeMember("whoCanMakeTopicsSticky");
  }


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

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

  bool has_who_can_mark_duplicate() const {
    return Storage().isMember("whoCanMarkDuplicate");
  }

  void clear_who_can_mark_duplicate() {
    MutableStorage()->removeMember("whoCanMarkDuplicate");
  }


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

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

  bool has_who_can_mark_favorite_reply_on_any_topic() const {
    return Storage().isMember("whoCanMarkFavoriteReplyOnAnyTopic");
  }

  void clear_who_can_mark_favorite_reply_on_any_topic() {
    MutableStorage()->removeMember("whoCanMarkFavoriteReplyOnAnyTopic");
  }


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

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

  bool has_who_can_mark_favorite_reply_on_own_topic() const {
    return Storage().isMember("whoCanMarkFavoriteReplyOnOwnTopic");
  }

  void clear_who_can_mark_favorite_reply_on_own_topic() {
    MutableStorage()->removeMember("whoCanMarkFavoriteReplyOnOwnTopic");
  }


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

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

  bool has_who_can_mark_no_response_needed() const {
    return Storage().isMember("whoCanMarkNoResponseNeeded");
  }

  void clear_who_can_mark_no_response_needed() {
    MutableStorage()->removeMember("whoCanMarkNoResponseNeeded");
  }


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

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

  bool has_who_can_moderate_content() const {
    return Storage().isMember("whoCanModerateContent");
  }

  void clear_who_can_moderate_content() {
    MutableStorage()->removeMember("whoCanModerateContent");
  }


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

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

  bool has_who_can_moderate_members() const {
    return Storage().isMember("whoCanModerateMembers");
  }

  void clear_who_can_moderate_members() {
    MutableStorage()->removeMember("whoCanModerateMembers");
  }


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

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

  bool has_who_can_modify_members() const {
    return Storage().isMember("whoCanModifyMembers");
  }

  void clear_who_can_modify_members() {
    MutableStorage()->removeMember("whoCanModifyMembers");
  }


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

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

  bool has_who_can_modify_tags_and_categories() const {
    return Storage().isMember("whoCanModifyTagsAndCategories");
  }

  void clear_who_can_modify_tags_and_categories() {
    MutableStorage()->removeMember("whoCanModifyTagsAndCategories");
  }


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

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

  bool has_who_can_move_topics_in() const {
    return Storage().isMember("whoCanMoveTopicsIn");
  }

  void clear_who_can_move_topics_in() {
    MutableStorage()->removeMember("whoCanMoveTopicsIn");
  }


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

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

  bool has_who_can_move_topics_out() const {
    return Storage().isMember("whoCanMoveTopicsOut");
  }

  void clear_who_can_move_topics_out() {
    MutableStorage()->removeMember("whoCanMoveTopicsOut");
  }


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

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

  bool has_who_can_post_announcements() const {
    return Storage().isMember("whoCanPostAnnouncements");
  }

  void clear_who_can_post_announcements() {
    MutableStorage()->removeMember("whoCanPostAnnouncements");
  }


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

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

  bool has_who_can_post_message() const {
    return Storage().isMember("whoCanPostMessage");
  }

  void clear_who_can_post_message() {
    MutableStorage()->removeMember("whoCanPostMessage");
  }


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

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

  bool has_who_can_take_topics() const {
    return Storage().isMember("whoCanTakeTopics");
  }

  void clear_who_can_take_topics() {
    MutableStorage()->removeMember("whoCanTakeTopics");
  }


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

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

  bool has_who_can_unassign_topic() const {
    return Storage().isMember("whoCanUnassignTopic");
  }

  void clear_who_can_unassign_topic() {
    MutableStorage()->removeMember("whoCanUnassignTopic");
  }


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

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

  bool has_who_can_unmark_favorite_reply_on_any_topic() const {
    return Storage().isMember("whoCanUnmarkFavoriteReplyOnAnyTopic");
  }

  void clear_who_can_unmark_favorite_reply_on_any_topic() {
    MutableStorage()->removeMember("whoCanUnmarkFavoriteReplyOnAnyTopic");
  }


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

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

  bool has_who_can_view_group() const {
    return Storage().isMember("whoCanViewGroup");
  }

  void clear_who_can_view_group() {
    MutableStorage()->removeMember("whoCanViewGroup");
  }


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

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

  bool has_who_can_view_membership() const {
    return Storage().isMember("whoCanViewMembership");
  }

  void clear_who_can_view_membership() {
    MutableStorage()->removeMember("whoCanViewMembership");
  }


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

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

 private:
  void operator=(const Groups&);
};  // Groups
}  // namespace google_groupssettings_api
#endif  // GOOGLE_GROUPSSETTINGS_API_GROUPS_H_