directory_service.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, 07:22:56 UTC
//   C++ generator version: 0.1.4
//
//  Changes to this file may cause incorrect behavior and will be lost if
//  the code is regenerated.
//------------------------------------------------------------------------------
#ifndef  GOOGLE_ADMIN_ADMIN_API_DIRECTORY_SERVICE_H_
#define  GOOGLE_ADMIN_ADMIN_API_DIRECTORY_SERVICE_H_

#include <string>
#include "googleapis/base/integral_types.h"
#include "googleapis/base/macros.h"
#include "googleapis/client/service/client_service.h"
#include "googleapis/client/service/service_request_pager.h"
#include "googleapis/client/util/status.h"
#include "googleapis/client/util/uri_template.h"

#include "google/admin/admin_api/alias.h"
#include "google/admin/admin_api/aliases.h"
#include "google/admin/admin_api/app_access_collections.h"
#include "google/admin/admin_api/asp.h"
#include "google/admin/admin_api/asps.h"
#include "google/admin/admin_api/building.h"
#include "google/admin/admin_api/buildings.h"
#include "google/admin/admin_api/calendar_resource.h"
#include "google/admin/admin_api/calendar_resources.h"
#include "google/admin/admin_api/channel.h"
#include "google/admin/admin_api/chrome_os_device.h"
#include "google/admin/admin_api/chrome_os_device_action.h"
#include "google/admin/admin_api/chrome_os_devices.h"
#include "google/admin/admin_api/chrome_os_move_devices_to_ou.h"
#include "google/admin/admin_api/customer.h"
#include "google/admin/admin_api/domain_alias.h"
#include "google/admin/admin_api/domain_aliases.h"
#include "google/admin/admin_api/domains.h"
#include "google/admin/admin_api/domains2.h"
#include "google/admin/admin_api/feature.h"
#include "google/admin/admin_api/feature_rename.h"
#include "google/admin/admin_api/features.h"
#include "google/admin/admin_api/group.h"
#include "google/admin/admin_api/groups.h"
#include "google/admin/admin_api/member.h"
#include "google/admin/admin_api/members.h"
#include "google/admin/admin_api/members_has_member.h"
#include "google/admin/admin_api/mobile_device.h"
#include "google/admin/admin_api/mobile_device_action.h"
#include "google/admin/admin_api/mobile_devices.h"
#include "google/admin/admin_api/notification.h"
#include "google/admin/admin_api/notifications.h"
#include "google/admin/admin_api/org_unit.h"
#include "google/admin/admin_api/org_units.h"
#include "google/admin/admin_api/privileges.h"
#include "google/admin/admin_api/role.h"
#include "google/admin/admin_api/role_assignment.h"
#include "google/admin/admin_api/role_assignments.h"
#include "google/admin/admin_api/roles.h"
#include "google/admin/admin_api/schema.h"
#include "google/admin/admin_api/schemas.h"
#include "google/admin/admin_api/token.h"
#include "google/admin/admin_api/tokens.h"
#include "google/admin/admin_api/trusted_apps.h"
#include "google/admin/admin_api/user.h"
#include "google/admin/admin_api/user_make_admin.h"
#include "google/admin/admin_api/user_photo.h"
#include "google/admin/admin_api/user_undelete.h"
#include "google/admin/admin_api/users.h"
#include "google/admin/admin_api/verification_codes.h"


namespace google_admin_admin_api {
using namespace googleapis;
class DirectoryService;

class DirectoryServiceBaseRequest
      : public client::ClientServiceRequest {
 public:
  DirectoryServiceBaseRequest(
      const client::ClientService* service,
      client::AuthorizationCredential* credential,
      client::HttpRequest::HttpMethod method,
      const StringPiece& uri_template);

  virtual ~DirectoryServiceBaseRequest();


  void clear_alt() {
    _have_alt_ = false;
    client::ClearCppValueHelper(&alt_);
  }


  const string& get_alt() const { return alt_; }

  string* mutable_alt() {
    _have_alt_ = true;
    return &alt_;
  }


  void set_alt(const string& value) {
    _have_alt_ = true;
    alt_ = value;
  }



  void clear_fields() {
    _have_fields_ = false;
    client::ClearCppValueHelper(&fields_);
  }


  const string& get_fields() const { return fields_; }

  string* mutable_fields() {
    _have_fields_ = true;
    return &fields_;
  }


  void set_fields(const string& value) {
    _have_fields_ = true;
    fields_ = value;
  }



  void clear_key() {
    _have_key_ = false;
    client::ClearCppValueHelper(&key_);
  }


  const string& get_key() const { return key_; }

  string* mutable_key() {
    _have_key_ = true;
    return &key_;
  }


  void set_key(const string& value) {
    _have_key_ = true;
    key_ = value;
  }



  void clear_oauth_token() {
    _have_oauth_token_ = false;
    client::ClearCppValueHelper(&oauth_token_);
  }


  const string& get_oauth_token() const { return oauth_token_; }

  string* mutable_oauthToken() {
    _have_oauth_token_ = true;
    return &oauth_token_;
  }


  void set_oauth_token(const string& value) {
    _have_oauth_token_ = true;
    oauth_token_ = value;
  }



  void clear_pretty_print() {
    _have_pretty_print_ = false;
    client::ClearCppValueHelper(&pretty_print_);
  }


  bool get_pretty_print() const { return pretty_print_; }

  void set_pretty_print(bool value) {
    _have_pretty_print_ = true;
    pretty_print_ = value;
  }

  void clear_quota_user() {
    _have_quota_user_ = false;
    client::ClearCppValueHelper(&quota_user_);
  }


  const string& get_quota_user() const { return quota_user_; }

  string* mutable_quotaUser() {
    _have_quota_user_ = true;
    return &quota_user_;
  }


  void set_quota_user(const string& value) {
    _have_quota_user_ = true;
    quota_user_ = value;
  }



  void clear_user_ip() {
    _have_user_ip_ = false;
    client::ClearCppValueHelper(&user_ip_);
  }


  const string& get_user_ip() const { return user_ip_; }

  string* mutable_userIp() {
    _have_user_ip_ = true;
    return &user_ip_;
  }


  void set_user_ip(const string& value) {
    _have_user_ip_ = true;
    user_ip_ = value;
  }

  virtual util::Status AppendVariable(
      const StringPiece& variable_name,
      const client::UriTemplateConfig& config,
      string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


 protected:
  void AddJsonContentToRequest(const client::JsonCppData *content);

 private:
  string alt_;
  string fields_;
  string key_;
  string oauth_token_;
  bool pretty_print_;
  string quota_user_;
  string user_ip_;
  bool _have_alt_ : 1;
  bool _have_fields_ : 1;
  bool _have_key_ : 1;
  bool _have_oauth_token_ : 1;
  bool _have_pretty_print_ : 1;
  bool _have_quota_user_ : 1;
  bool _have_user_ip_ : 1;

  DISALLOW_COPY_AND_ASSIGN(DirectoryServiceBaseRequest);
};



class AspsResource_DeleteMethod : public DirectoryServiceBaseRequest {
 public:
  AspsResource_DeleteMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key,
      const int32& code_id);

  virtual ~AspsResource_DeleteMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string user_key_;
  int32 code_id_;
  DISALLOW_COPY_AND_ASSIGN(AspsResource_DeleteMethod);
};

class AspsResource_GetMethod : public DirectoryServiceBaseRequest {
 public:
  AspsResource_GetMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key,
      const int32& code_id);

  virtual ~AspsResource_GetMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Asp* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_key_;
  int32 code_id_;
  DISALLOW_COPY_AND_ASSIGN(AspsResource_GetMethod);
};

class AspsResource_ListMethod : public DirectoryServiceBaseRequest {
 public:
  AspsResource_ListMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key);

  virtual ~AspsResource_ListMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Asps* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_key_;
  DISALLOW_COPY_AND_ASSIGN(AspsResource_ListMethod);
};



class ChannelsResource_StopMethod : public DirectoryServiceBaseRequest {
 public:
  ChannelsResource_StopMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const Channel& _content_);

  virtual ~ChannelsResource_StopMethod();

 private:
  string _content_;
  DISALLOW_COPY_AND_ASSIGN(ChannelsResource_StopMethod);
};



class ChromeosdevicesResource_ActionMethod : public DirectoryServiceBaseRequest {
 public:
  ChromeosdevicesResource_ActionMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id,
      const absl::string_view& resource_id,
      const ChromeOsDeviceAction& _content_);

  virtual ~ChromeosdevicesResource_ActionMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string customer_id_;
  string resource_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(ChromeosdevicesResource_ActionMethod);
};

class ChromeosdevicesResource_GetMethod : public DirectoryServiceBaseRequest {
 public:
  ChromeosdevicesResource_GetMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id,
      const absl::string_view& device_id);

  virtual ~ChromeosdevicesResource_GetMethod();


    void clear_projection() {
      _have_projection_ = false;
      client::ClearCppValueHelper(&projection_);
    }


    const string& get_projection() const { return projection_; }

    string* mutable_projection() {
      _have_projection_ = true;
      return &projection_;
    }


    void set_projection(const string& value) {
      _have_projection_ = true;
      projection_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      ChromeOsDevice* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_id_;
  string device_id_;
  string projection_;
  bool _have_projection_ : 1;
  DISALLOW_COPY_AND_ASSIGN(ChromeosdevicesResource_GetMethod);
};

class ChromeosdevicesResource_ListMethod : public DirectoryServiceBaseRequest {
 public:
  ChromeosdevicesResource_ListMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id);

  virtual ~ChromeosdevicesResource_ListMethod();


    void clear_max_results() {
      _have_max_results_ = false;
      client::ClearCppValueHelper(&max_results_);
    }


    int32 get_max_results() const { return max_results_; }

    void set_max_results(int32 value) {
      _have_max_results_ = true;
      max_results_ = value;
    }

    void clear_order_by() {
      _have_order_by_ = false;
      client::ClearCppValueHelper(&order_by_);
    }


    const string& get_order_by() const { return order_by_; }

    string* mutable_orderBy() {
      _have_order_by_ = true;
      return &order_by_;
    }


    void set_order_by(const string& value) {
      _have_order_by_ = true;
      order_by_ = value;
    }



    void clear_org_unit_path() {
      _have_org_unit_path_ = false;
      client::ClearCppValueHelper(&org_unit_path_);
    }


    const string& get_org_unit_path() const { return org_unit_path_; }

    string* mutable_orgUnitPath() {
      _have_org_unit_path_ = true;
      return &org_unit_path_;
    }


    void set_org_unit_path(const string& value) {
      _have_org_unit_path_ = true;
      org_unit_path_ = value;
    }



    void clear_page_token() {
      _have_page_token_ = false;
      client::ClearCppValueHelper(&page_token_);
    }


    const string& get_page_token() const { return page_token_; }

    string* mutable_pageToken() {
      _have_page_token_ = true;
      return &page_token_;
    }


    void set_page_token(const string& value) {
      _have_page_token_ = true;
      page_token_ = value;
    }



    void clear_projection() {
      _have_projection_ = false;
      client::ClearCppValueHelper(&projection_);
    }


    const string& get_projection() const { return projection_; }

    string* mutable_projection() {
      _have_projection_ = true;
      return &projection_;
    }


    void set_projection(const string& value) {
      _have_projection_ = true;
      projection_ = value;
    }



    void clear_query() {
      _have_query_ = false;
      client::ClearCppValueHelper(&query_);
    }


    const string& get_query() const { return query_; }

    string* mutable_query() {
      _have_query_ = true;
      return &query_;
    }


    void set_query(const string& value) {
      _have_query_ = true;
      query_ = value;
    }



    void clear_sort_order() {
      _have_sort_order_ = false;
      client::ClearCppValueHelper(&sort_order_);
    }


    const string& get_sort_order() const { return sort_order_; }

    string* mutable_sortOrder() {
      _have_sort_order_ = true;
      return &sort_order_;
    }


    void set_sort_order(const string& value) {
      _have_sort_order_ = true;
      sort_order_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      ChromeOsDevices* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_id_;
  int32 max_results_;
  string order_by_;
  string org_unit_path_;
  string page_token_;
  string projection_;
  string query_;
  string sort_order_;
  bool _have_max_results_ : 1;
  bool _have_order_by_ : 1;
  bool _have_org_unit_path_ : 1;
  bool _have_page_token_ : 1;
  bool _have_projection_ : 1;
  bool _have_query_ : 1;
  bool _have_sort_order_ : 1;
  DISALLOW_COPY_AND_ASSIGN(ChromeosdevicesResource_ListMethod);
};

typedef client::ServiceRequestPager<
            ChromeosdevicesResource_ListMethod,
            ChromeOsDevices>
        ChromeosdevicesResource_ListMethodPager;

class ChromeosdevicesResource_MoveDevicesToOuMethod : public DirectoryServiceBaseRequest {
 public:
  ChromeosdevicesResource_MoveDevicesToOuMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id,
      const absl::string_view& org_unit_path,
      const ChromeOsMoveDevicesToOu& _content_);

  virtual ~ChromeosdevicesResource_MoveDevicesToOuMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


 private:
  string customer_id_;
  string org_unit_path_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(ChromeosdevicesResource_MoveDevicesToOuMethod);
};

class ChromeosdevicesResource_PatchMethod : public DirectoryServiceBaseRequest {
 public:
  ChromeosdevicesResource_PatchMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id,
      const absl::string_view& device_id,
      const ChromeOsDevice& _content_);

  virtual ~ChromeosdevicesResource_PatchMethod();


    void clear_projection() {
      _have_projection_ = false;
      client::ClearCppValueHelper(&projection_);
    }


    const string& get_projection() const { return projection_; }

    string* mutable_projection() {
      _have_projection_ = true;
      return &projection_;
    }


    void set_projection(const string& value) {
      _have_projection_ = true;
      projection_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      ChromeOsDevice* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_id_;
  string device_id_;
  string projection_;
  bool _have_projection_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(ChromeosdevicesResource_PatchMethod);
};

class ChromeosdevicesResource_UpdateMethod : public DirectoryServiceBaseRequest {
 public:
  ChromeosdevicesResource_UpdateMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id,
      const absl::string_view& device_id,
      const ChromeOsDevice& _content_);

  virtual ~ChromeosdevicesResource_UpdateMethod();


    void clear_projection() {
      _have_projection_ = false;
      client::ClearCppValueHelper(&projection_);
    }


    const string& get_projection() const { return projection_; }

    string* mutable_projection() {
      _have_projection_ = true;
      return &projection_;
    }


    void set_projection(const string& value) {
      _have_projection_ = true;
      projection_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      ChromeOsDevice* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_id_;
  string device_id_;
  string projection_;
  bool _have_projection_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(ChromeosdevicesResource_UpdateMethod);
};



class CustomersResource_GetMethod : public DirectoryServiceBaseRequest {
 public:
  CustomersResource_GetMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_key);

  virtual ~CustomersResource_GetMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Customer* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_key_;
  DISALLOW_COPY_AND_ASSIGN(CustomersResource_GetMethod);
};

class CustomersResource_PatchMethod : public DirectoryServiceBaseRequest {
 public:
  CustomersResource_PatchMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_key,
      const Customer& _content_);

  virtual ~CustomersResource_PatchMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Customer* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_key_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(CustomersResource_PatchMethod);
};

class CustomersResource_UpdateMethod : public DirectoryServiceBaseRequest {
 public:
  CustomersResource_UpdateMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_key,
      const Customer& _content_);

  virtual ~CustomersResource_UpdateMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Customer* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_key_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(CustomersResource_UpdateMethod);
};



class DomainAliasesResource_DeleteMethod : public DirectoryServiceBaseRequest {
 public:
  DomainAliasesResource_DeleteMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& domain_alias_name);

  virtual ~DomainAliasesResource_DeleteMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string customer_;
  string domain_alias_name_;
  DISALLOW_COPY_AND_ASSIGN(DomainAliasesResource_DeleteMethod);
};

class DomainAliasesResource_GetMethod : public DirectoryServiceBaseRequest {
 public:
  DomainAliasesResource_GetMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& domain_alias_name);

  virtual ~DomainAliasesResource_GetMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      DomainAlias* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string domain_alias_name_;
  DISALLOW_COPY_AND_ASSIGN(DomainAliasesResource_GetMethod);
};

class DomainAliasesResource_InsertMethod : public DirectoryServiceBaseRequest {
 public:
  DomainAliasesResource_InsertMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const DomainAlias& _content_);

  virtual ~DomainAliasesResource_InsertMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      DomainAlias* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(DomainAliasesResource_InsertMethod);
};

class DomainAliasesResource_ListMethod : public DirectoryServiceBaseRequest {
 public:
  DomainAliasesResource_ListMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer);

  virtual ~DomainAliasesResource_ListMethod();


    void clear_parent_domain_name() {
      _have_parent_domain_name_ = false;
      client::ClearCppValueHelper(&parent_domain_name_);
    }


    const string& get_parent_domain_name() const { return parent_domain_name_; }

    string* mutable_parentDomainName() {
      _have_parent_domain_name_ = true;
      return &parent_domain_name_;
    }


    void set_parent_domain_name(const string& value) {
      _have_parent_domain_name_ = true;
      parent_domain_name_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      DomainAliases* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string parent_domain_name_;
  bool _have_parent_domain_name_ : 1;
  DISALLOW_COPY_AND_ASSIGN(DomainAliasesResource_ListMethod);
};



class DomainsResource_DeleteMethod : public DirectoryServiceBaseRequest {
 public:
  DomainsResource_DeleteMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& domain_name);

  virtual ~DomainsResource_DeleteMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string customer_;
  string domain_name_;
  DISALLOW_COPY_AND_ASSIGN(DomainsResource_DeleteMethod);
};

class DomainsResource_GetMethod : public DirectoryServiceBaseRequest {
 public:
  DomainsResource_GetMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& domain_name);

  virtual ~DomainsResource_GetMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Domains* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string domain_name_;
  DISALLOW_COPY_AND_ASSIGN(DomainsResource_GetMethod);
};

class DomainsResource_InsertMethod : public DirectoryServiceBaseRequest {
 public:
  DomainsResource_InsertMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const Domains& _content_);

  virtual ~DomainsResource_InsertMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Domains* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(DomainsResource_InsertMethod);
};

class DomainsResource_ListMethod : public DirectoryServiceBaseRequest {
 public:
  DomainsResource_ListMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer);

  virtual ~DomainsResource_ListMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Domains2* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  DISALLOW_COPY_AND_ASSIGN(DomainsResource_ListMethod);
};



class GroupsResource_DeleteMethod : public DirectoryServiceBaseRequest {
 public:
  GroupsResource_DeleteMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& group_key);

  virtual ~GroupsResource_DeleteMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string group_key_;
  DISALLOW_COPY_AND_ASSIGN(GroupsResource_DeleteMethod);
};

class GroupsResource_GetMethod : public DirectoryServiceBaseRequest {
 public:
  GroupsResource_GetMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& group_key);

  virtual ~GroupsResource_GetMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Group* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string group_key_;
  DISALLOW_COPY_AND_ASSIGN(GroupsResource_GetMethod);
};

class GroupsResource_InsertMethod : public DirectoryServiceBaseRequest {
 public:
  GroupsResource_InsertMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const Group& _content_);

  virtual ~GroupsResource_InsertMethod();

  util::Status ExecuteAndParseResponse(
      Group* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string _content_;
  DISALLOW_COPY_AND_ASSIGN(GroupsResource_InsertMethod);
};

class GroupsResource_ListMethod : public DirectoryServiceBaseRequest {
 public:
  GroupsResource_ListMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~GroupsResource_ListMethod();


    void clear_customer() {
      _have_customer_ = false;
      client::ClearCppValueHelper(&customer_);
    }


    const string& get_customer() const { return customer_; }

    string* mutable_customer() {
      _have_customer_ = true;
      return &customer_;
    }


    void set_customer(const string& value) {
      _have_customer_ = true;
      customer_ = value;
    }



    void clear_domain() {
      _have_domain_ = false;
      client::ClearCppValueHelper(&domain_);
    }


    const string& get_domain() const { return domain_; }

    string* mutable_domain() {
      _have_domain_ = true;
      return &domain_;
    }


    void set_domain(const string& value) {
      _have_domain_ = true;
      domain_ = value;
    }



    void clear_max_results() {
      _have_max_results_ = false;
      client::ClearCppValueHelper(&max_results_);
    }


    int32 get_max_results() const { return max_results_; }

    void set_max_results(int32 value) {
      _have_max_results_ = true;
      max_results_ = value;
    }

    void clear_order_by() {
      _have_order_by_ = false;
      client::ClearCppValueHelper(&order_by_);
    }


    const string& get_order_by() const { return order_by_; }

    string* mutable_orderBy() {
      _have_order_by_ = true;
      return &order_by_;
    }


    void set_order_by(const string& value) {
      _have_order_by_ = true;
      order_by_ = value;
    }



    void clear_page_token() {
      _have_page_token_ = false;
      client::ClearCppValueHelper(&page_token_);
    }


    const string& get_page_token() const { return page_token_; }

    string* mutable_pageToken() {
      _have_page_token_ = true;
      return &page_token_;
    }


    void set_page_token(const string& value) {
      _have_page_token_ = true;
      page_token_ = value;
    }



    void clear_query() {
      _have_query_ = false;
      client::ClearCppValueHelper(&query_);
    }


    const string& get_query() const { return query_; }

    string* mutable_query() {
      _have_query_ = true;
      return &query_;
    }


    void set_query(const string& value) {
      _have_query_ = true;
      query_ = value;
    }



    void clear_sort_order() {
      _have_sort_order_ = false;
      client::ClearCppValueHelper(&sort_order_);
    }


    const string& get_sort_order() const { return sort_order_; }

    string* mutable_sortOrder() {
      _have_sort_order_ = true;
      return &sort_order_;
    }


    void set_sort_order(const string& value) {
      _have_sort_order_ = true;
      sort_order_ = value;
    }



    void clear_user_key() {
      _have_user_key_ = false;
      client::ClearCppValueHelper(&user_key_);
    }


    const string& get_user_key() const { return user_key_; }

    string* mutable_userKey() {
      _have_user_key_ = true;
      return &user_key_;
    }


    void set_user_key(const string& value) {
      _have_user_key_ = true;
      user_key_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      Groups* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string domain_;
  int32 max_results_;
  string order_by_;
  string page_token_;
  string query_;
  string sort_order_;
  string user_key_;
  bool _have_customer_ : 1;
  bool _have_domain_ : 1;
  bool _have_max_results_ : 1;
  bool _have_order_by_ : 1;
  bool _have_page_token_ : 1;
  bool _have_query_ : 1;
  bool _have_sort_order_ : 1;
  bool _have_user_key_ : 1;
  DISALLOW_COPY_AND_ASSIGN(GroupsResource_ListMethod);
};

typedef client::ServiceRequestPager<
            GroupsResource_ListMethod,
            Groups>
        GroupsResource_ListMethodPager;

class GroupsResource_PatchMethod : public DirectoryServiceBaseRequest {
 public:
  GroupsResource_PatchMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& group_key,
      const Group& _content_);

  virtual ~GroupsResource_PatchMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Group* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string group_key_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(GroupsResource_PatchMethod);
};

class GroupsResource_UpdateMethod : public DirectoryServiceBaseRequest {
 public:
  GroupsResource_UpdateMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& group_key,
      const Group& _content_);

  virtual ~GroupsResource_UpdateMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Group* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string group_key_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(GroupsResource_UpdateMethod);
};




class GroupsResource_AliasesResource_DeleteMethod : public DirectoryServiceBaseRequest {
 public:
  GroupsResource_AliasesResource_DeleteMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& group_key,
      const absl::string_view& alias);

  virtual ~GroupsResource_AliasesResource_DeleteMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string group_key_;
  string alias_;
  DISALLOW_COPY_AND_ASSIGN(GroupsResource_AliasesResource_DeleteMethod);
};

class GroupsResource_AliasesResource_InsertMethod : public DirectoryServiceBaseRequest {
 public:
  GroupsResource_AliasesResource_InsertMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& group_key,
      const Alias& _content_);

  virtual ~GroupsResource_AliasesResource_InsertMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Alias* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string group_key_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(GroupsResource_AliasesResource_InsertMethod);
};

class GroupsResource_AliasesResource_ListMethod : public DirectoryServiceBaseRequest {
 public:
  GroupsResource_AliasesResource_ListMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& group_key);

  virtual ~GroupsResource_AliasesResource_ListMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Aliases* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string group_key_;
  DISALLOW_COPY_AND_ASSIGN(GroupsResource_AliasesResource_ListMethod);
};



class MembersResource_DeleteMethod : public DirectoryServiceBaseRequest {
 public:
  MembersResource_DeleteMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& group_key,
      const absl::string_view& member_key);

  virtual ~MembersResource_DeleteMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string group_key_;
  string member_key_;
  DISALLOW_COPY_AND_ASSIGN(MembersResource_DeleteMethod);
};

class MembersResource_GetMethod : public DirectoryServiceBaseRequest {
 public:
  MembersResource_GetMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& group_key,
      const absl::string_view& member_key);

  virtual ~MembersResource_GetMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Member* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string group_key_;
  string member_key_;
  DISALLOW_COPY_AND_ASSIGN(MembersResource_GetMethod);
};

class MembersResource_HasMemberMethod : public DirectoryServiceBaseRequest {
 public:
  MembersResource_HasMemberMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& group_key,
      const absl::string_view& member_key);

  virtual ~MembersResource_HasMemberMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      MembersHasMember* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string group_key_;
  string member_key_;
  DISALLOW_COPY_AND_ASSIGN(MembersResource_HasMemberMethod);
};

class MembersResource_InsertMethod : public DirectoryServiceBaseRequest {
 public:
  MembersResource_InsertMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& group_key,
      const Member& _content_);

  virtual ~MembersResource_InsertMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Member* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string group_key_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(MembersResource_InsertMethod);
};

class MembersResource_ListMethod : public DirectoryServiceBaseRequest {
 public:
  MembersResource_ListMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& group_key);

  virtual ~MembersResource_ListMethod();


    void clear_include_derived_membership() {
      _have_include_derived_membership_ = false;
      client::ClearCppValueHelper(&include_derived_membership_);
    }


    bool get_include_derived_membership() const { return include_derived_membership_; }

    void set_include_derived_membership(bool value) {
      _have_include_derived_membership_ = true;
      include_derived_membership_ = value;
    }

    void clear_max_results() {
      _have_max_results_ = false;
      client::ClearCppValueHelper(&max_results_);
    }


    int32 get_max_results() const { return max_results_; }

    void set_max_results(int32 value) {
      _have_max_results_ = true;
      max_results_ = value;
    }

    void clear_page_token() {
      _have_page_token_ = false;
      client::ClearCppValueHelper(&page_token_);
    }


    const string& get_page_token() const { return page_token_; }

    string* mutable_pageToken() {
      _have_page_token_ = true;
      return &page_token_;
    }


    void set_page_token(const string& value) {
      _have_page_token_ = true;
      page_token_ = value;
    }



    void clear_roles() {
      _have_roles_ = false;
      client::ClearCppValueHelper(&roles_);
    }


    const string& get_roles() const { return roles_; }

    string* mutable_roles() {
      _have_roles_ = true;
      return &roles_;
    }


    void set_roles(const string& value) {
      _have_roles_ = true;
      roles_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      Members* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string group_key_;
  bool include_derived_membership_;
  int32 max_results_;
  string page_token_;
  string roles_;
  bool _have_include_derived_membership_ : 1;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  bool _have_roles_ : 1;
  DISALLOW_COPY_AND_ASSIGN(MembersResource_ListMethod);
};

typedef client::ServiceRequestPager<
            MembersResource_ListMethod,
            Members>
        MembersResource_ListMethodPager;

class MembersResource_PatchMethod : public DirectoryServiceBaseRequest {
 public:
  MembersResource_PatchMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& group_key,
      const absl::string_view& member_key,
      const Member& _content_);

  virtual ~MembersResource_PatchMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Member* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string group_key_;
  string member_key_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(MembersResource_PatchMethod);
};

class MembersResource_UpdateMethod : public DirectoryServiceBaseRequest {
 public:
  MembersResource_UpdateMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& group_key,
      const absl::string_view& member_key,
      const Member& _content_);

  virtual ~MembersResource_UpdateMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Member* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string group_key_;
  string member_key_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(MembersResource_UpdateMethod);
};



class MobiledevicesResource_ActionMethod : public DirectoryServiceBaseRequest {
 public:
  MobiledevicesResource_ActionMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id,
      const absl::string_view& resource_id,
      const MobileDeviceAction& _content_);

  virtual ~MobiledevicesResource_ActionMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string customer_id_;
  string resource_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(MobiledevicesResource_ActionMethod);
};

class MobiledevicesResource_DeleteMethod : public DirectoryServiceBaseRequest {
 public:
  MobiledevicesResource_DeleteMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id,
      const absl::string_view& resource_id);

  virtual ~MobiledevicesResource_DeleteMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string customer_id_;
  string resource_id_;
  DISALLOW_COPY_AND_ASSIGN(MobiledevicesResource_DeleteMethod);
};

class MobiledevicesResource_GetMethod : public DirectoryServiceBaseRequest {
 public:
  MobiledevicesResource_GetMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id,
      const absl::string_view& resource_id);

  virtual ~MobiledevicesResource_GetMethod();


    void clear_projection() {
      _have_projection_ = false;
      client::ClearCppValueHelper(&projection_);
    }


    const string& get_projection() const { return projection_; }

    string* mutable_projection() {
      _have_projection_ = true;
      return &projection_;
    }


    void set_projection(const string& value) {
      _have_projection_ = true;
      projection_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      MobileDevice* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_id_;
  string resource_id_;
  string projection_;
  bool _have_projection_ : 1;
  DISALLOW_COPY_AND_ASSIGN(MobiledevicesResource_GetMethod);
};

class MobiledevicesResource_ListMethod : public DirectoryServiceBaseRequest {
 public:
  MobiledevicesResource_ListMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id);

  virtual ~MobiledevicesResource_ListMethod();


    void clear_max_results() {
      _have_max_results_ = false;
      client::ClearCppValueHelper(&max_results_);
    }


    int32 get_max_results() const { return max_results_; }

    void set_max_results(int32 value) {
      _have_max_results_ = true;
      max_results_ = value;
    }

    void clear_order_by() {
      _have_order_by_ = false;
      client::ClearCppValueHelper(&order_by_);
    }


    const string& get_order_by() const { return order_by_; }

    string* mutable_orderBy() {
      _have_order_by_ = true;
      return &order_by_;
    }


    void set_order_by(const string& value) {
      _have_order_by_ = true;
      order_by_ = value;
    }



    void clear_page_token() {
      _have_page_token_ = false;
      client::ClearCppValueHelper(&page_token_);
    }


    const string& get_page_token() const { return page_token_; }

    string* mutable_pageToken() {
      _have_page_token_ = true;
      return &page_token_;
    }


    void set_page_token(const string& value) {
      _have_page_token_ = true;
      page_token_ = value;
    }



    void clear_projection() {
      _have_projection_ = false;
      client::ClearCppValueHelper(&projection_);
    }


    const string& get_projection() const { return projection_; }

    string* mutable_projection() {
      _have_projection_ = true;
      return &projection_;
    }


    void set_projection(const string& value) {
      _have_projection_ = true;
      projection_ = value;
    }



    void clear_query() {
      _have_query_ = false;
      client::ClearCppValueHelper(&query_);
    }


    const string& get_query() const { return query_; }

    string* mutable_query() {
      _have_query_ = true;
      return &query_;
    }


    void set_query(const string& value) {
      _have_query_ = true;
      query_ = value;
    }



    void clear_sort_order() {
      _have_sort_order_ = false;
      client::ClearCppValueHelper(&sort_order_);
    }


    const string& get_sort_order() const { return sort_order_; }

    string* mutable_sortOrder() {
      _have_sort_order_ = true;
      return &sort_order_;
    }


    void set_sort_order(const string& value) {
      _have_sort_order_ = true;
      sort_order_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      MobileDevices* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_id_;
  int32 max_results_;
  string order_by_;
  string page_token_;
  string projection_;
  string query_;
  string sort_order_;
  bool _have_max_results_ : 1;
  bool _have_order_by_ : 1;
  bool _have_page_token_ : 1;
  bool _have_projection_ : 1;
  bool _have_query_ : 1;
  bool _have_sort_order_ : 1;
  DISALLOW_COPY_AND_ASSIGN(MobiledevicesResource_ListMethod);
};

typedef client::ServiceRequestPager<
            MobiledevicesResource_ListMethod,
            MobileDevices>
        MobiledevicesResource_ListMethodPager;



class NotificationsResource_DeleteMethod : public DirectoryServiceBaseRequest {
 public:
  NotificationsResource_DeleteMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& notification_id);

  virtual ~NotificationsResource_DeleteMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string customer_;
  string notification_id_;
  DISALLOW_COPY_AND_ASSIGN(NotificationsResource_DeleteMethod);
};

class NotificationsResource_GetMethod : public DirectoryServiceBaseRequest {
 public:
  NotificationsResource_GetMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& notification_id);

  virtual ~NotificationsResource_GetMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Notification* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string notification_id_;
  DISALLOW_COPY_AND_ASSIGN(NotificationsResource_GetMethod);
};

class NotificationsResource_ListMethod : public DirectoryServiceBaseRequest {
 public:
  NotificationsResource_ListMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer);

  virtual ~NotificationsResource_ListMethod();


    void clear_language() {
      _have_language_ = false;
      client::ClearCppValueHelper(&language_);
    }


    const string& get_language() const { return language_; }

    string* mutable_language() {
      _have_language_ = true;
      return &language_;
    }


    void set_language(const string& value) {
      _have_language_ = true;
      language_ = value;
    }



    void clear_max_results() {
      _have_max_results_ = false;
      client::ClearCppValueHelper(&max_results_);
    }


    uint32 get_max_results() const { return max_results_; }

    void set_max_results(uint32 value) {
      _have_max_results_ = true;
      max_results_ = value;
    }

    void clear_page_token() {
      _have_page_token_ = false;
      client::ClearCppValueHelper(&page_token_);
    }


    const string& get_page_token() const { return page_token_; }

    string* mutable_pageToken() {
      _have_page_token_ = true;
      return &page_token_;
    }


    void set_page_token(const string& value) {
      _have_page_token_ = true;
      page_token_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      Notifications* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string language_;
  uint32 max_results_;
  string page_token_;
  bool _have_language_ : 1;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  DISALLOW_COPY_AND_ASSIGN(NotificationsResource_ListMethod);
};

typedef client::ServiceRequestPager<
            NotificationsResource_ListMethod,
            Notifications>
        NotificationsResource_ListMethodPager;

class NotificationsResource_PatchMethod : public DirectoryServiceBaseRequest {
 public:
  NotificationsResource_PatchMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& notification_id,
      const Notification& _content_);

  virtual ~NotificationsResource_PatchMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Notification* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string notification_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(NotificationsResource_PatchMethod);
};

class NotificationsResource_UpdateMethod : public DirectoryServiceBaseRequest {
 public:
  NotificationsResource_UpdateMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& notification_id,
      const Notification& _content_);

  virtual ~NotificationsResource_UpdateMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Notification* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string notification_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(NotificationsResource_UpdateMethod);
};



class OrgunitsResource_DeleteMethod : public DirectoryServiceBaseRequest {
 public:
  OrgunitsResource_DeleteMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id,
      const client::JsonCppArray<string >& org_unit_path);

  virtual ~OrgunitsResource_DeleteMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string customer_id_;
  client::JsonCppArray<string > org_unit_path_;
  DISALLOW_COPY_AND_ASSIGN(OrgunitsResource_DeleteMethod);
};

class OrgunitsResource_GetMethod : public DirectoryServiceBaseRequest {
 public:
  OrgunitsResource_GetMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id,
      const client::JsonCppArray<string >& org_unit_path);

  virtual ~OrgunitsResource_GetMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      OrgUnit* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_id_;
  client::JsonCppArray<string > org_unit_path_;
  DISALLOW_COPY_AND_ASSIGN(OrgunitsResource_GetMethod);
};

class OrgunitsResource_InsertMethod : public DirectoryServiceBaseRequest {
 public:
  OrgunitsResource_InsertMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id,
      const OrgUnit& _content_);

  virtual ~OrgunitsResource_InsertMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      OrgUnit* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(OrgunitsResource_InsertMethod);
};

class OrgunitsResource_ListMethod : public DirectoryServiceBaseRequest {
 public:
  OrgunitsResource_ListMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id);

  virtual ~OrgunitsResource_ListMethod();


    void clear_org_unit_path() {
      _have_org_unit_path_ = false;
      client::ClearCppValueHelper(&org_unit_path_);
    }


    const string& get_org_unit_path() const { return org_unit_path_; }

    string* mutable_orgUnitPath() {
      _have_org_unit_path_ = true;
      return &org_unit_path_;
    }


    void set_org_unit_path(const string& value) {
      _have_org_unit_path_ = true;
      org_unit_path_ = value;
    }



    void clear_type() {
      _have_type_ = false;
      client::ClearCppValueHelper(&type_);
    }


    const string& get_type() const { return type_; }

    string* mutable_type() {
      _have_type_ = true;
      return &type_;
    }


    void set_type(const string& value) {
      _have_type_ = true;
      type_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      OrgUnits* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_id_;
  string org_unit_path_;
  string type_;
  bool _have_org_unit_path_ : 1;
  bool _have_type_ : 1;
  DISALLOW_COPY_AND_ASSIGN(OrgunitsResource_ListMethod);
};

class OrgunitsResource_PatchMethod : public DirectoryServiceBaseRequest {
 public:
  OrgunitsResource_PatchMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id,
      const client::JsonCppArray<string >& org_unit_path,
      const OrgUnit& _content_);

  virtual ~OrgunitsResource_PatchMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      OrgUnit* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_id_;
  client::JsonCppArray<string > org_unit_path_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(OrgunitsResource_PatchMethod);
};

class OrgunitsResource_UpdateMethod : public DirectoryServiceBaseRequest {
 public:
  OrgunitsResource_UpdateMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id,
      const client::JsonCppArray<string >& org_unit_path,
      const OrgUnit& _content_);

  virtual ~OrgunitsResource_UpdateMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      OrgUnit* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_id_;
  client::JsonCppArray<string > org_unit_path_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(OrgunitsResource_UpdateMethod);
};



class PrivilegesResource_ListMethod : public DirectoryServiceBaseRequest {
 public:
  PrivilegesResource_ListMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer);

  virtual ~PrivilegesResource_ListMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Privileges* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  DISALLOW_COPY_AND_ASSIGN(PrivilegesResource_ListMethod);
};



class ResolvedAppAccessSettingsResource_GetSettingsMethod : public DirectoryServiceBaseRequest {
 public:
  ResolvedAppAccessSettingsResource_GetSettingsMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~ResolvedAppAccessSettingsResource_GetSettingsMethod();

  util::Status ExecuteAndParseResponse(
      AppAccessCollections* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  DISALLOW_COPY_AND_ASSIGN(ResolvedAppAccessSettingsResource_GetSettingsMethod);
};

class ResolvedAppAccessSettingsResource_ListTrustedAppsMethod : public DirectoryServiceBaseRequest {
 public:
  ResolvedAppAccessSettingsResource_ListTrustedAppsMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~ResolvedAppAccessSettingsResource_ListTrustedAppsMethod();

  util::Status ExecuteAndParseResponse(
      TrustedApps* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  DISALLOW_COPY_AND_ASSIGN(ResolvedAppAccessSettingsResource_ListTrustedAppsMethod);
};






class ResourcesResource_BuildingsResource_DeleteMethod : public DirectoryServiceBaseRequest {
 public:
  ResourcesResource_BuildingsResource_DeleteMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& building_id);

  virtual ~ResourcesResource_BuildingsResource_DeleteMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string customer_;
  string building_id_;
  DISALLOW_COPY_AND_ASSIGN(ResourcesResource_BuildingsResource_DeleteMethod);
};

class ResourcesResource_BuildingsResource_GetMethod : public DirectoryServiceBaseRequest {
 public:
  ResourcesResource_BuildingsResource_GetMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& building_id);

  virtual ~ResourcesResource_BuildingsResource_GetMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Building* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string building_id_;
  DISALLOW_COPY_AND_ASSIGN(ResourcesResource_BuildingsResource_GetMethod);
};

class ResourcesResource_BuildingsResource_InsertMethod : public DirectoryServiceBaseRequest {
 public:
  ResourcesResource_BuildingsResource_InsertMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const Building& _content_);

  virtual ~ResourcesResource_BuildingsResource_InsertMethod();


    void clear_coordinates_source() {
      _have_coordinates_source_ = false;
      client::ClearCppValueHelper(&coordinates_source_);
    }


    const string& get_coordinates_source() const { return coordinates_source_; }

    string* mutable_coordinatesSource() {
      _have_coordinates_source_ = true;
      return &coordinates_source_;
    }


    void set_coordinates_source(const string& value) {
      _have_coordinates_source_ = true;
      coordinates_source_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      Building* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string coordinates_source_;
  bool _have_coordinates_source_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(ResourcesResource_BuildingsResource_InsertMethod);
};

class ResourcesResource_BuildingsResource_ListMethod : public DirectoryServiceBaseRequest {
 public:
  ResourcesResource_BuildingsResource_ListMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer);

  virtual ~ResourcesResource_BuildingsResource_ListMethod();


    void clear_max_results() {
      _have_max_results_ = false;
      client::ClearCppValueHelper(&max_results_);
    }


    int32 get_max_results() const { return max_results_; }

    void set_max_results(int32 value) {
      _have_max_results_ = true;
      max_results_ = value;
    }

    void clear_page_token() {
      _have_page_token_ = false;
      client::ClearCppValueHelper(&page_token_);
    }


    const string& get_page_token() const { return page_token_; }

    string* mutable_pageToken() {
      _have_page_token_ = true;
      return &page_token_;
    }


    void set_page_token(const string& value) {
      _have_page_token_ = true;
      page_token_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      Buildings* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  int32 max_results_;
  string page_token_;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  DISALLOW_COPY_AND_ASSIGN(ResourcesResource_BuildingsResource_ListMethod);
};

typedef client::ServiceRequestPager<
            ResourcesResource_BuildingsResource_ListMethod,
            Buildings>
        ResourcesResource_BuildingsResource_ListMethodPager;

class ResourcesResource_BuildingsResource_PatchMethod : public DirectoryServiceBaseRequest {
 public:
  ResourcesResource_BuildingsResource_PatchMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& building_id,
      const Building& _content_);

  virtual ~ResourcesResource_BuildingsResource_PatchMethod();


    void clear_coordinates_source() {
      _have_coordinates_source_ = false;
      client::ClearCppValueHelper(&coordinates_source_);
    }


    const string& get_coordinates_source() const { return coordinates_source_; }

    string* mutable_coordinatesSource() {
      _have_coordinates_source_ = true;
      return &coordinates_source_;
    }


    void set_coordinates_source(const string& value) {
      _have_coordinates_source_ = true;
      coordinates_source_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      Building* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string building_id_;
  string coordinates_source_;
  bool _have_coordinates_source_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(ResourcesResource_BuildingsResource_PatchMethod);
};

class ResourcesResource_BuildingsResource_UpdateMethod : public DirectoryServiceBaseRequest {
 public:
  ResourcesResource_BuildingsResource_UpdateMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& building_id,
      const Building& _content_);

  virtual ~ResourcesResource_BuildingsResource_UpdateMethod();


    void clear_coordinates_source() {
      _have_coordinates_source_ = false;
      client::ClearCppValueHelper(&coordinates_source_);
    }


    const string& get_coordinates_source() const { return coordinates_source_; }

    string* mutable_coordinatesSource() {
      _have_coordinates_source_ = true;
      return &coordinates_source_;
    }


    void set_coordinates_source(const string& value) {
      _have_coordinates_source_ = true;
      coordinates_source_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      Building* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string building_id_;
  string coordinates_source_;
  bool _have_coordinates_source_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(ResourcesResource_BuildingsResource_UpdateMethod);
};


class ResourcesResource_CalendarsResource_DeleteMethod : public DirectoryServiceBaseRequest {
 public:
  ResourcesResource_CalendarsResource_DeleteMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& calendar_resource_id);

  virtual ~ResourcesResource_CalendarsResource_DeleteMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string customer_;
  string calendar_resource_id_;
  DISALLOW_COPY_AND_ASSIGN(ResourcesResource_CalendarsResource_DeleteMethod);
};

class ResourcesResource_CalendarsResource_GetMethod : public DirectoryServiceBaseRequest {
 public:
  ResourcesResource_CalendarsResource_GetMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& calendar_resource_id);

  virtual ~ResourcesResource_CalendarsResource_GetMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      CalendarResource* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string calendar_resource_id_;
  DISALLOW_COPY_AND_ASSIGN(ResourcesResource_CalendarsResource_GetMethod);
};

class ResourcesResource_CalendarsResource_InsertMethod : public DirectoryServiceBaseRequest {
 public:
  ResourcesResource_CalendarsResource_InsertMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const CalendarResource& _content_);

  virtual ~ResourcesResource_CalendarsResource_InsertMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      CalendarResource* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(ResourcesResource_CalendarsResource_InsertMethod);
};

class ResourcesResource_CalendarsResource_ListMethod : public DirectoryServiceBaseRequest {
 public:
  ResourcesResource_CalendarsResource_ListMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer);

  virtual ~ResourcesResource_CalendarsResource_ListMethod();


    void clear_max_results() {
      _have_max_results_ = false;
      client::ClearCppValueHelper(&max_results_);
    }


    int32 get_max_results() const { return max_results_; }

    void set_max_results(int32 value) {
      _have_max_results_ = true;
      max_results_ = value;
    }

    void clear_order_by() {
      _have_order_by_ = false;
      client::ClearCppValueHelper(&order_by_);
    }


    const string& get_order_by() const { return order_by_; }

    string* mutable_orderBy() {
      _have_order_by_ = true;
      return &order_by_;
    }


    void set_order_by(const string& value) {
      _have_order_by_ = true;
      order_by_ = value;
    }



    void clear_page_token() {
      _have_page_token_ = false;
      client::ClearCppValueHelper(&page_token_);
    }


    const string& get_page_token() const { return page_token_; }

    string* mutable_pageToken() {
      _have_page_token_ = true;
      return &page_token_;
    }


    void set_page_token(const string& value) {
      _have_page_token_ = true;
      page_token_ = value;
    }



    void clear_query() {
      _have_query_ = false;
      client::ClearCppValueHelper(&query_);
    }


    const string& get_query() const { return query_; }

    string* mutable_query() {
      _have_query_ = true;
      return &query_;
    }


    void set_query(const string& value) {
      _have_query_ = true;
      query_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      CalendarResources* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  int32 max_results_;
  string order_by_;
  string page_token_;
  string query_;
  bool _have_max_results_ : 1;
  bool _have_order_by_ : 1;
  bool _have_page_token_ : 1;
  bool _have_query_ : 1;
  DISALLOW_COPY_AND_ASSIGN(ResourcesResource_CalendarsResource_ListMethod);
};

typedef client::ServiceRequestPager<
            ResourcesResource_CalendarsResource_ListMethod,
            CalendarResources>
        ResourcesResource_CalendarsResource_ListMethodPager;

class ResourcesResource_CalendarsResource_PatchMethod : public DirectoryServiceBaseRequest {
 public:
  ResourcesResource_CalendarsResource_PatchMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& calendar_resource_id,
      const CalendarResource& _content_);

  virtual ~ResourcesResource_CalendarsResource_PatchMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      CalendarResource* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string calendar_resource_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(ResourcesResource_CalendarsResource_PatchMethod);
};

class ResourcesResource_CalendarsResource_UpdateMethod : public DirectoryServiceBaseRequest {
 public:
  ResourcesResource_CalendarsResource_UpdateMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& calendar_resource_id,
      const CalendarResource& _content_);

  virtual ~ResourcesResource_CalendarsResource_UpdateMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      CalendarResource* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string calendar_resource_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(ResourcesResource_CalendarsResource_UpdateMethod);
};


class ResourcesResource_FeaturesResource_DeleteMethod : public DirectoryServiceBaseRequest {
 public:
  ResourcesResource_FeaturesResource_DeleteMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& feature_key);

  virtual ~ResourcesResource_FeaturesResource_DeleteMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string customer_;
  string feature_key_;
  DISALLOW_COPY_AND_ASSIGN(ResourcesResource_FeaturesResource_DeleteMethod);
};

class ResourcesResource_FeaturesResource_GetMethod : public DirectoryServiceBaseRequest {
 public:
  ResourcesResource_FeaturesResource_GetMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& feature_key);

  virtual ~ResourcesResource_FeaturesResource_GetMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Feature* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string feature_key_;
  DISALLOW_COPY_AND_ASSIGN(ResourcesResource_FeaturesResource_GetMethod);
};

class ResourcesResource_FeaturesResource_InsertMethod : public DirectoryServiceBaseRequest {
 public:
  ResourcesResource_FeaturesResource_InsertMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const Feature& _content_);

  virtual ~ResourcesResource_FeaturesResource_InsertMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Feature* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(ResourcesResource_FeaturesResource_InsertMethod);
};

class ResourcesResource_FeaturesResource_ListMethod : public DirectoryServiceBaseRequest {
 public:
  ResourcesResource_FeaturesResource_ListMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer);

  virtual ~ResourcesResource_FeaturesResource_ListMethod();


    void clear_max_results() {
      _have_max_results_ = false;
      client::ClearCppValueHelper(&max_results_);
    }


    int32 get_max_results() const { return max_results_; }

    void set_max_results(int32 value) {
      _have_max_results_ = true;
      max_results_ = value;
    }

    void clear_page_token() {
      _have_page_token_ = false;
      client::ClearCppValueHelper(&page_token_);
    }


    const string& get_page_token() const { return page_token_; }

    string* mutable_pageToken() {
      _have_page_token_ = true;
      return &page_token_;
    }


    void set_page_token(const string& value) {
      _have_page_token_ = true;
      page_token_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      Features* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  int32 max_results_;
  string page_token_;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  DISALLOW_COPY_AND_ASSIGN(ResourcesResource_FeaturesResource_ListMethod);
};

typedef client::ServiceRequestPager<
            ResourcesResource_FeaturesResource_ListMethod,
            Features>
        ResourcesResource_FeaturesResource_ListMethodPager;

class ResourcesResource_FeaturesResource_PatchMethod : public DirectoryServiceBaseRequest {
 public:
  ResourcesResource_FeaturesResource_PatchMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& feature_key,
      const Feature& _content_);

  virtual ~ResourcesResource_FeaturesResource_PatchMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Feature* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string feature_key_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(ResourcesResource_FeaturesResource_PatchMethod);
};

class ResourcesResource_FeaturesResource_RenameMethod : public DirectoryServiceBaseRequest {
 public:
  ResourcesResource_FeaturesResource_RenameMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& old_name,
      const FeatureRename& _content_);

  virtual ~ResourcesResource_FeaturesResource_RenameMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string customer_;
  string old_name_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(ResourcesResource_FeaturesResource_RenameMethod);
};

class ResourcesResource_FeaturesResource_UpdateMethod : public DirectoryServiceBaseRequest {
 public:
  ResourcesResource_FeaturesResource_UpdateMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& feature_key,
      const Feature& _content_);

  virtual ~ResourcesResource_FeaturesResource_UpdateMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Feature* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string feature_key_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(ResourcesResource_FeaturesResource_UpdateMethod);
};



class RoleAssignmentsResource_DeleteMethod : public DirectoryServiceBaseRequest {
 public:
  RoleAssignmentsResource_DeleteMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& role_assignment_id);

  virtual ~RoleAssignmentsResource_DeleteMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string customer_;
  string role_assignment_id_;
  DISALLOW_COPY_AND_ASSIGN(RoleAssignmentsResource_DeleteMethod);
};

class RoleAssignmentsResource_GetMethod : public DirectoryServiceBaseRequest {
 public:
  RoleAssignmentsResource_GetMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& role_assignment_id);

  virtual ~RoleAssignmentsResource_GetMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      RoleAssignment* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string role_assignment_id_;
  DISALLOW_COPY_AND_ASSIGN(RoleAssignmentsResource_GetMethod);
};

class RoleAssignmentsResource_InsertMethod : public DirectoryServiceBaseRequest {
 public:
  RoleAssignmentsResource_InsertMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const RoleAssignment& _content_);

  virtual ~RoleAssignmentsResource_InsertMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      RoleAssignment* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(RoleAssignmentsResource_InsertMethod);
};

class RoleAssignmentsResource_ListMethod : public DirectoryServiceBaseRequest {
 public:
  RoleAssignmentsResource_ListMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer);

  virtual ~RoleAssignmentsResource_ListMethod();


    void clear_max_results() {
      _have_max_results_ = false;
      client::ClearCppValueHelper(&max_results_);
    }


    int32 get_max_results() const { return max_results_; }

    void set_max_results(int32 value) {
      _have_max_results_ = true;
      max_results_ = value;
    }

    void clear_page_token() {
      _have_page_token_ = false;
      client::ClearCppValueHelper(&page_token_);
    }


    const string& get_page_token() const { return page_token_; }

    string* mutable_pageToken() {
      _have_page_token_ = true;
      return &page_token_;
    }


    void set_page_token(const string& value) {
      _have_page_token_ = true;
      page_token_ = value;
    }



    void clear_role_id() {
      _have_role_id_ = false;
      client::ClearCppValueHelper(&role_id_);
    }


    const string& get_role_id() const { return role_id_; }

    string* mutable_roleId() {
      _have_role_id_ = true;
      return &role_id_;
    }


    void set_role_id(const string& value) {
      _have_role_id_ = true;
      role_id_ = value;
    }



    void clear_user_key() {
      _have_user_key_ = false;
      client::ClearCppValueHelper(&user_key_);
    }


    const string& get_user_key() const { return user_key_; }

    string* mutable_userKey() {
      _have_user_key_ = true;
      return &user_key_;
    }


    void set_user_key(const string& value) {
      _have_user_key_ = true;
      user_key_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      RoleAssignments* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  int32 max_results_;
  string page_token_;
  string role_id_;
  string user_key_;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  bool _have_role_id_ : 1;
  bool _have_user_key_ : 1;
  DISALLOW_COPY_AND_ASSIGN(RoleAssignmentsResource_ListMethod);
};

typedef client::ServiceRequestPager<
            RoleAssignmentsResource_ListMethod,
            RoleAssignments>
        RoleAssignmentsResource_ListMethodPager;



class RolesResource_DeleteMethod : public DirectoryServiceBaseRequest {
 public:
  RolesResource_DeleteMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& role_id);

  virtual ~RolesResource_DeleteMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string customer_;
  string role_id_;
  DISALLOW_COPY_AND_ASSIGN(RolesResource_DeleteMethod);
};

class RolesResource_GetMethod : public DirectoryServiceBaseRequest {
 public:
  RolesResource_GetMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& role_id);

  virtual ~RolesResource_GetMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Role* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string role_id_;
  DISALLOW_COPY_AND_ASSIGN(RolesResource_GetMethod);
};

class RolesResource_InsertMethod : public DirectoryServiceBaseRequest {
 public:
  RolesResource_InsertMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const Role& _content_);

  virtual ~RolesResource_InsertMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Role* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(RolesResource_InsertMethod);
};

class RolesResource_ListMethod : public DirectoryServiceBaseRequest {
 public:
  RolesResource_ListMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer);

  virtual ~RolesResource_ListMethod();


    void clear_max_results() {
      _have_max_results_ = false;
      client::ClearCppValueHelper(&max_results_);
    }


    int32 get_max_results() const { return max_results_; }

    void set_max_results(int32 value) {
      _have_max_results_ = true;
      max_results_ = value;
    }

    void clear_page_token() {
      _have_page_token_ = false;
      client::ClearCppValueHelper(&page_token_);
    }


    const string& get_page_token() const { return page_token_; }

    string* mutable_pageToken() {
      _have_page_token_ = true;
      return &page_token_;
    }


    void set_page_token(const string& value) {
      _have_page_token_ = true;
      page_token_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      Roles* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  int32 max_results_;
  string page_token_;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  DISALLOW_COPY_AND_ASSIGN(RolesResource_ListMethod);
};

typedef client::ServiceRequestPager<
            RolesResource_ListMethod,
            Roles>
        RolesResource_ListMethodPager;

class RolesResource_PatchMethod : public DirectoryServiceBaseRequest {
 public:
  RolesResource_PatchMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& role_id,
      const Role& _content_);

  virtual ~RolesResource_PatchMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Role* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string role_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(RolesResource_PatchMethod);
};

class RolesResource_UpdateMethod : public DirectoryServiceBaseRequest {
 public:
  RolesResource_UpdateMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer,
      const absl::string_view& role_id,
      const Role& _content_);

  virtual ~RolesResource_UpdateMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Role* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_;
  string role_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(RolesResource_UpdateMethod);
};



class SchemasResource_DeleteMethod : public DirectoryServiceBaseRequest {
 public:
  SchemasResource_DeleteMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id,
      const absl::string_view& schema_key);

  virtual ~SchemasResource_DeleteMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string customer_id_;
  string schema_key_;
  DISALLOW_COPY_AND_ASSIGN(SchemasResource_DeleteMethod);
};

class SchemasResource_GetMethod : public DirectoryServiceBaseRequest {
 public:
  SchemasResource_GetMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id,
      const absl::string_view& schema_key);

  virtual ~SchemasResource_GetMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Schema* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_id_;
  string schema_key_;
  DISALLOW_COPY_AND_ASSIGN(SchemasResource_GetMethod);
};

class SchemasResource_InsertMethod : public DirectoryServiceBaseRequest {
 public:
  SchemasResource_InsertMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id,
      const Schema& _content_);

  virtual ~SchemasResource_InsertMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Schema* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(SchemasResource_InsertMethod);
};

class SchemasResource_ListMethod : public DirectoryServiceBaseRequest {
 public:
  SchemasResource_ListMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id);

  virtual ~SchemasResource_ListMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Schemas* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_id_;
  DISALLOW_COPY_AND_ASSIGN(SchemasResource_ListMethod);
};

class SchemasResource_PatchMethod : public DirectoryServiceBaseRequest {
 public:
  SchemasResource_PatchMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id,
      const absl::string_view& schema_key,
      const Schema& _content_);

  virtual ~SchemasResource_PatchMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Schema* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_id_;
  string schema_key_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(SchemasResource_PatchMethod);
};

class SchemasResource_UpdateMethod : public DirectoryServiceBaseRequest {
 public:
  SchemasResource_UpdateMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& customer_id,
      const absl::string_view& schema_key,
      const Schema& _content_);

  virtual ~SchemasResource_UpdateMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Schema* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string customer_id_;
  string schema_key_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(SchemasResource_UpdateMethod);
};



class TokensResource_DeleteMethod : public DirectoryServiceBaseRequest {
 public:
  TokensResource_DeleteMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key,
      const absl::string_view& client_id);

  virtual ~TokensResource_DeleteMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string user_key_;
  string client_id_;
  DISALLOW_COPY_AND_ASSIGN(TokensResource_DeleteMethod);
};

class TokensResource_GetMethod : public DirectoryServiceBaseRequest {
 public:
  TokensResource_GetMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key,
      const absl::string_view& client_id);

  virtual ~TokensResource_GetMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Token* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_key_;
  string client_id_;
  DISALLOW_COPY_AND_ASSIGN(TokensResource_GetMethod);
};

class TokensResource_ListMethod : public DirectoryServiceBaseRequest {
 public:
  TokensResource_ListMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key);

  virtual ~TokensResource_ListMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Tokens* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_key_;
  DISALLOW_COPY_AND_ASSIGN(TokensResource_ListMethod);
};



class UsersResource_DeleteMethod : public DirectoryServiceBaseRequest {
 public:
  UsersResource_DeleteMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key);

  virtual ~UsersResource_DeleteMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string user_key_;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_DeleteMethod);
};

class UsersResource_GetMethod : public DirectoryServiceBaseRequest {
 public:
  UsersResource_GetMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key);

  virtual ~UsersResource_GetMethod();


    void clear_custom_field_mask() {
      _have_custom_field_mask_ = false;
      client::ClearCppValueHelper(&custom_field_mask_);
    }


    const string& get_custom_field_mask() const { return custom_field_mask_; }

    string* mutable_customFieldMask() {
      _have_custom_field_mask_ = true;
      return &custom_field_mask_;
    }


    void set_custom_field_mask(const string& value) {
      _have_custom_field_mask_ = true;
      custom_field_mask_ = value;
    }



    void clear_projection() {
      _have_projection_ = false;
      client::ClearCppValueHelper(&projection_);
    }


    const string& get_projection() const { return projection_; }

    string* mutable_projection() {
      _have_projection_ = true;
      return &projection_;
    }


    void set_projection(const string& value) {
      _have_projection_ = true;
      projection_ = value;
    }



    void clear_view_type() {
      _have_view_type_ = false;
      client::ClearCppValueHelper(&view_type_);
    }


    const string& get_view_type() const { return view_type_; }

    string* mutable_viewType() {
      _have_view_type_ = true;
      return &view_type_;
    }


    void set_view_type(const string& value) {
      _have_view_type_ = true;
      view_type_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      User* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_key_;
  string custom_field_mask_;
  string projection_;
  string view_type_;
  bool _have_custom_field_mask_ : 1;
  bool _have_projection_ : 1;
  bool _have_view_type_ : 1;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_GetMethod);
};

class UsersResource_InsertMethod : public DirectoryServiceBaseRequest {
 public:
  UsersResource_InsertMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const User& _content_);

  virtual ~UsersResource_InsertMethod();

  util::Status ExecuteAndParseResponse(
      User* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string _content_;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_InsertMethod);
};

class UsersResource_ListMethod : public DirectoryServiceBaseRequest {
 public:
  UsersResource_ListMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~UsersResource_ListMethod();


    void clear_custom_field_mask() {
      _have_custom_field_mask_ = false;
      client::ClearCppValueHelper(&custom_field_mask_);
    }


    const string& get_custom_field_mask() const { return custom_field_mask_; }

    string* mutable_customFieldMask() {
      _have_custom_field_mask_ = true;
      return &custom_field_mask_;
    }


    void set_custom_field_mask(const string& value) {
      _have_custom_field_mask_ = true;
      custom_field_mask_ = value;
    }



    void clear_customer() {
      _have_customer_ = false;
      client::ClearCppValueHelper(&customer_);
    }


    const string& get_customer() const { return customer_; }

    string* mutable_customer() {
      _have_customer_ = true;
      return &customer_;
    }


    void set_customer(const string& value) {
      _have_customer_ = true;
      customer_ = value;
    }



    void clear_domain() {
      _have_domain_ = false;
      client::ClearCppValueHelper(&domain_);
    }


    const string& get_domain() const { return domain_; }

    string* mutable_domain() {
      _have_domain_ = true;
      return &domain_;
    }


    void set_domain(const string& value) {
      _have_domain_ = true;
      domain_ = value;
    }



    void clear_event() {
      _have_event_ = false;
      client::ClearCppValueHelper(&event_);
    }


    const string& get_event() const { return event_; }

    string* mutable_event() {
      _have_event_ = true;
      return &event_;
    }


    void set_event(const string& value) {
      _have_event_ = true;
      event_ = value;
    }



    void clear_max_results() {
      _have_max_results_ = false;
      client::ClearCppValueHelper(&max_results_);
    }


    int32 get_max_results() const { return max_results_; }

    void set_max_results(int32 value) {
      _have_max_results_ = true;
      max_results_ = value;
    }

    void clear_order_by() {
      _have_order_by_ = false;
      client::ClearCppValueHelper(&order_by_);
    }


    const string& get_order_by() const { return order_by_; }

    string* mutable_orderBy() {
      _have_order_by_ = true;
      return &order_by_;
    }


    void set_order_by(const string& value) {
      _have_order_by_ = true;
      order_by_ = value;
    }



    void clear_page_token() {
      _have_page_token_ = false;
      client::ClearCppValueHelper(&page_token_);
    }


    const string& get_page_token() const { return page_token_; }

    string* mutable_pageToken() {
      _have_page_token_ = true;
      return &page_token_;
    }


    void set_page_token(const string& value) {
      _have_page_token_ = true;
      page_token_ = value;
    }



    void clear_projection() {
      _have_projection_ = false;
      client::ClearCppValueHelper(&projection_);
    }


    const string& get_projection() const { return projection_; }

    string* mutable_projection() {
      _have_projection_ = true;
      return &projection_;
    }


    void set_projection(const string& value) {
      _have_projection_ = true;
      projection_ = value;
    }



    void clear_query() {
      _have_query_ = false;
      client::ClearCppValueHelper(&query_);
    }


    const string& get_query() const { return query_; }

    string* mutable_query() {
      _have_query_ = true;
      return &query_;
    }


    void set_query(const string& value) {
      _have_query_ = true;
      query_ = value;
    }



    void clear_show_deleted() {
      _have_show_deleted_ = false;
      client::ClearCppValueHelper(&show_deleted_);
    }


    const string& get_show_deleted() const { return show_deleted_; }

    string* mutable_showDeleted() {
      _have_show_deleted_ = true;
      return &show_deleted_;
    }


    void set_show_deleted(const string& value) {
      _have_show_deleted_ = true;
      show_deleted_ = value;
    }



    void clear_sort_order() {
      _have_sort_order_ = false;
      client::ClearCppValueHelper(&sort_order_);
    }


    const string& get_sort_order() const { return sort_order_; }

    string* mutable_sortOrder() {
      _have_sort_order_ = true;
      return &sort_order_;
    }


    void set_sort_order(const string& value) {
      _have_sort_order_ = true;
      sort_order_ = value;
    }



    void clear_view_type() {
      _have_view_type_ = false;
      client::ClearCppValueHelper(&view_type_);
    }


    const string& get_view_type() const { return view_type_; }

    string* mutable_viewType() {
      _have_view_type_ = true;
      return &view_type_;
    }


    void set_view_type(const string& value) {
      _have_view_type_ = true;
      view_type_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      Users* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string custom_field_mask_;
  string customer_;
  string domain_;
  string event_;
  int32 max_results_;
  string order_by_;
  string page_token_;
  string projection_;
  string query_;
  string show_deleted_;
  string sort_order_;
  string view_type_;
  bool _have_custom_field_mask_ : 1;
  bool _have_customer_ : 1;
  bool _have_domain_ : 1;
  bool _have_event_ : 1;
  bool _have_max_results_ : 1;
  bool _have_order_by_ : 1;
  bool _have_page_token_ : 1;
  bool _have_projection_ : 1;
  bool _have_query_ : 1;
  bool _have_show_deleted_ : 1;
  bool _have_sort_order_ : 1;
  bool _have_view_type_ : 1;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_ListMethod);
};

typedef client::ServiceRequestPager<
            UsersResource_ListMethod,
            Users>
        UsersResource_ListMethodPager;

class UsersResource_MakeAdminMethod : public DirectoryServiceBaseRequest {
 public:
  UsersResource_MakeAdminMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key,
      const UserMakeAdmin& _content_);

  virtual ~UsersResource_MakeAdminMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string user_key_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_MakeAdminMethod);
};

class UsersResource_PatchMethod : public DirectoryServiceBaseRequest {
 public:
  UsersResource_PatchMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key,
      const User& _content_);

  virtual ~UsersResource_PatchMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      User* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_key_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_PatchMethod);
};

class UsersResource_UndeleteMethod : public DirectoryServiceBaseRequest {
 public:
  UsersResource_UndeleteMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key,
      const UserUndelete& _content_);

  virtual ~UsersResource_UndeleteMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string user_key_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_UndeleteMethod);
};

class UsersResource_UpdateMethod : public DirectoryServiceBaseRequest {
 public:
  UsersResource_UpdateMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key,
      const User& _content_);

  virtual ~UsersResource_UpdateMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      User* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_key_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_UpdateMethod);
};

class UsersResource_WatchMethod : public DirectoryServiceBaseRequest {
 public:
  UsersResource_WatchMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const Channel& _content_);

  virtual ~UsersResource_WatchMethod();


    void clear_custom_field_mask() {
      _have_custom_field_mask_ = false;
      client::ClearCppValueHelper(&custom_field_mask_);
    }


    const string& get_custom_field_mask() const { return custom_field_mask_; }

    string* mutable_customFieldMask() {
      _have_custom_field_mask_ = true;
      return &custom_field_mask_;
    }


    void set_custom_field_mask(const string& value) {
      _have_custom_field_mask_ = true;
      custom_field_mask_ = value;
    }



    void clear_customer() {
      _have_customer_ = false;
      client::ClearCppValueHelper(&customer_);
    }


    const string& get_customer() const { return customer_; }

    string* mutable_customer() {
      _have_customer_ = true;
      return &customer_;
    }


    void set_customer(const string& value) {
      _have_customer_ = true;
      customer_ = value;
    }



    void clear_domain() {
      _have_domain_ = false;
      client::ClearCppValueHelper(&domain_);
    }


    const string& get_domain() const { return domain_; }

    string* mutable_domain() {
      _have_domain_ = true;
      return &domain_;
    }


    void set_domain(const string& value) {
      _have_domain_ = true;
      domain_ = value;
    }



    void clear_event() {
      _have_event_ = false;
      client::ClearCppValueHelper(&event_);
    }


    const string& get_event() const { return event_; }

    string* mutable_event() {
      _have_event_ = true;
      return &event_;
    }


    void set_event(const string& value) {
      _have_event_ = true;
      event_ = value;
    }



    void clear_max_results() {
      _have_max_results_ = false;
      client::ClearCppValueHelper(&max_results_);
    }


    int32 get_max_results() const { return max_results_; }

    void set_max_results(int32 value) {
      _have_max_results_ = true;
      max_results_ = value;
    }

    void clear_order_by() {
      _have_order_by_ = false;
      client::ClearCppValueHelper(&order_by_);
    }


    const string& get_order_by() const { return order_by_; }

    string* mutable_orderBy() {
      _have_order_by_ = true;
      return &order_by_;
    }


    void set_order_by(const string& value) {
      _have_order_by_ = true;
      order_by_ = value;
    }



    void clear_page_token() {
      _have_page_token_ = false;
      client::ClearCppValueHelper(&page_token_);
    }


    const string& get_page_token() const { return page_token_; }

    string* mutable_pageToken() {
      _have_page_token_ = true;
      return &page_token_;
    }


    void set_page_token(const string& value) {
      _have_page_token_ = true;
      page_token_ = value;
    }



    void clear_projection() {
      _have_projection_ = false;
      client::ClearCppValueHelper(&projection_);
    }


    const string& get_projection() const { return projection_; }

    string* mutable_projection() {
      _have_projection_ = true;
      return &projection_;
    }


    void set_projection(const string& value) {
      _have_projection_ = true;
      projection_ = value;
    }



    void clear_query() {
      _have_query_ = false;
      client::ClearCppValueHelper(&query_);
    }


    const string& get_query() const { return query_; }

    string* mutable_query() {
      _have_query_ = true;
      return &query_;
    }


    void set_query(const string& value) {
      _have_query_ = true;
      query_ = value;
    }



    void clear_show_deleted() {
      _have_show_deleted_ = false;
      client::ClearCppValueHelper(&show_deleted_);
    }


    const string& get_show_deleted() const { return show_deleted_; }

    string* mutable_showDeleted() {
      _have_show_deleted_ = true;
      return &show_deleted_;
    }


    void set_show_deleted(const string& value) {
      _have_show_deleted_ = true;
      show_deleted_ = value;
    }



    void clear_sort_order() {
      _have_sort_order_ = false;
      client::ClearCppValueHelper(&sort_order_);
    }


    const string& get_sort_order() const { return sort_order_; }

    string* mutable_sortOrder() {
      _have_sort_order_ = true;
      return &sort_order_;
    }


    void set_sort_order(const string& value) {
      _have_sort_order_ = true;
      sort_order_ = value;
    }



    void clear_view_type() {
      _have_view_type_ = false;
      client::ClearCppValueHelper(&view_type_);
    }


    const string& get_view_type() const { return view_type_; }

    string* mutable_viewType() {
      _have_view_type_ = true;
      return &view_type_;
    }


    void set_view_type(const string& value) {
      _have_view_type_ = true;
      view_type_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      Channel* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string custom_field_mask_;
  string customer_;
  string domain_;
  string event_;
  int32 max_results_;
  string order_by_;
  string page_token_;
  string projection_;
  string query_;
  string show_deleted_;
  string sort_order_;
  string view_type_;
  bool _have_custom_field_mask_ : 1;
  bool _have_customer_ : 1;
  bool _have_domain_ : 1;
  bool _have_event_ : 1;
  bool _have_max_results_ : 1;
  bool _have_order_by_ : 1;
  bool _have_page_token_ : 1;
  bool _have_projection_ : 1;
  bool _have_query_ : 1;
  bool _have_show_deleted_ : 1;
  bool _have_sort_order_ : 1;
  bool _have_view_type_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_WatchMethod);
};




class UsersResource_AliasesResource_DeleteMethod : public DirectoryServiceBaseRequest {
 public:
  UsersResource_AliasesResource_DeleteMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key,
      const absl::string_view& alias);

  virtual ~UsersResource_AliasesResource_DeleteMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string user_key_;
  string alias_;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_AliasesResource_DeleteMethod);
};

class UsersResource_AliasesResource_InsertMethod : public DirectoryServiceBaseRequest {
 public:
  UsersResource_AliasesResource_InsertMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key,
      const Alias& _content_);

  virtual ~UsersResource_AliasesResource_InsertMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      Alias* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_key_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_AliasesResource_InsertMethod);
};

class UsersResource_AliasesResource_ListMethod : public DirectoryServiceBaseRequest {
 public:
  UsersResource_AliasesResource_ListMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key);

  virtual ~UsersResource_AliasesResource_ListMethod();


    void clear_event() {
      _have_event_ = false;
      client::ClearCppValueHelper(&event_);
    }


    const string& get_event() const { return event_; }

    string* mutable_event() {
      _have_event_ = true;
      return &event_;
    }


    void set_event(const string& value) {
      _have_event_ = true;
      event_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      Aliases* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_key_;
  string event_;
  bool _have_event_ : 1;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_AliasesResource_ListMethod);
};

class UsersResource_AliasesResource_WatchMethod : public DirectoryServiceBaseRequest {
 public:
  UsersResource_AliasesResource_WatchMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key,
      const Channel& _content_);

  virtual ~UsersResource_AliasesResource_WatchMethod();


    void clear_event() {
      _have_event_ = false;
      client::ClearCppValueHelper(&event_);
    }


    const string& get_event() const { return event_; }

    string* mutable_event() {
      _have_event_ = true;
      return &event_;
    }


    void set_event(const string& value) {
      _have_event_ = true;
      event_ = value;
    }

  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);

  virtual util::Status AppendOptionalQueryParameters(string* target);


  util::Status ExecuteAndParseResponse(
      Channel* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_key_;
  string event_;
  bool _have_event_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_AliasesResource_WatchMethod);
};


class UsersResource_PhotosResource_DeleteMethod : public DirectoryServiceBaseRequest {
 public:
  UsersResource_PhotosResource_DeleteMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key);

  virtual ~UsersResource_PhotosResource_DeleteMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string user_key_;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_PhotosResource_DeleteMethod);
};

class UsersResource_PhotosResource_GetMethod : public DirectoryServiceBaseRequest {
 public:
  UsersResource_PhotosResource_GetMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key);

  virtual ~UsersResource_PhotosResource_GetMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      UserPhoto* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_key_;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_PhotosResource_GetMethod);
};

class UsersResource_PhotosResource_PatchMethod : public DirectoryServiceBaseRequest {
 public:
  UsersResource_PhotosResource_PatchMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key,
      const UserPhoto& _content_);

  virtual ~UsersResource_PhotosResource_PatchMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      UserPhoto* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_key_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_PhotosResource_PatchMethod);
};

class UsersResource_PhotosResource_UpdateMethod : public DirectoryServiceBaseRequest {
 public:
  UsersResource_PhotosResource_UpdateMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key,
      const UserPhoto& _content_);

  virtual ~UsersResource_PhotosResource_UpdateMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      UserPhoto* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_key_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_PhotosResource_UpdateMethod);
};



class VerificationCodesResource_GenerateMethod : public DirectoryServiceBaseRequest {
 public:
  VerificationCodesResource_GenerateMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key);

  virtual ~VerificationCodesResource_GenerateMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string user_key_;
  DISALLOW_COPY_AND_ASSIGN(VerificationCodesResource_GenerateMethod);
};

class VerificationCodesResource_InvalidateMethod : public DirectoryServiceBaseRequest {
 public:
  VerificationCodesResource_InvalidateMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key);

  virtual ~VerificationCodesResource_InvalidateMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


 private:
  string user_key_;
  DISALLOW_COPY_AND_ASSIGN(VerificationCodesResource_InvalidateMethod);
};

class VerificationCodesResource_ListMethod : public DirectoryServiceBaseRequest {
 public:
  VerificationCodesResource_ListMethod(
      const DirectoryService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_key);

  virtual ~VerificationCodesResource_ListMethod();


  virtual util::Status AppendVariable(
        const StringPiece& variable_name,
        const client::UriTemplateConfig& config,
        string* target);


  util::Status ExecuteAndParseResponse(
      VerificationCodes* data) {
    return DirectoryServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_key_;
  DISALLOW_COPY_AND_ASSIGN(VerificationCodesResource_ListMethod);
};



class DirectoryService : public client::ClientService {
 public:
  static const char googleapis_API_NAME[];

  static const char googleapis_API_VERSION[];

  static const char googleapis_API_GENERATOR[];


  class AspsResource {
   public:
    explicit AspsResource(DirectoryService* service);

    ~AspsResource() {}


    AspsResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& user_key,
        const int32& code_id) const;

    AspsResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& user_key,
        const int32& code_id) const;

    AspsResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& user_key) const;

   private:
    DirectoryService* service_;

    DISALLOW_COPY_AND_ASSIGN(AspsResource);
  };

  class ChannelsResource {
   public:
    explicit ChannelsResource(DirectoryService* service);

    ~ChannelsResource() {}


    ChannelsResource_StopMethod* NewStopMethod(
        client::AuthorizationCredential* _credential_,
        const Channel& _content_) const;

   private:
    DirectoryService* service_;

    DISALLOW_COPY_AND_ASSIGN(ChannelsResource);
  };

  class ChromeosdevicesResource {
   public:
    explicit ChromeosdevicesResource(DirectoryService* service);

    ~ChromeosdevicesResource() {}


    ChromeosdevicesResource_ActionMethod* NewActionMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id,
        const absl::string_view& resource_id,
        const ChromeOsDeviceAction& _content_) const;

    ChromeosdevicesResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id,
        const absl::string_view& device_id) const;

    ChromeosdevicesResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id) const;

    ChromeosdevicesResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id) const;

    ChromeosdevicesResource_MoveDevicesToOuMethod* NewMoveDevicesToOuMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id,
        const absl::string_view& org_unit_path,
        const ChromeOsMoveDevicesToOu& _content_) const;

    ChromeosdevicesResource_PatchMethod* NewPatchMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id,
        const absl::string_view& device_id,
        const ChromeOsDevice& _content_) const;

    ChromeosdevicesResource_UpdateMethod* NewUpdateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id,
        const absl::string_view& device_id,
        const ChromeOsDevice& _content_) const;

   private:
    DirectoryService* service_;

    DISALLOW_COPY_AND_ASSIGN(ChromeosdevicesResource);
  };

  class CustomersResource {
   public:
    explicit CustomersResource(DirectoryService* service);

    ~CustomersResource() {}


    CustomersResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_key) const;

    CustomersResource_PatchMethod* NewPatchMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_key,
        const Customer& _content_) const;

    CustomersResource_UpdateMethod* NewUpdateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_key,
        const Customer& _content_) const;

   private:
    DirectoryService* service_;

    DISALLOW_COPY_AND_ASSIGN(CustomersResource);
  };

  class DomainAliasesResource {
   public:
    explicit DomainAliasesResource(DirectoryService* service);

    ~DomainAliasesResource() {}


    DomainAliasesResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer,
        const absl::string_view& domain_alias_name) const;

    DomainAliasesResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer,
        const absl::string_view& domain_alias_name) const;

    DomainAliasesResource_InsertMethod* NewInsertMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer,
        const DomainAlias& _content_) const;

    DomainAliasesResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer) const;

   private:
    DirectoryService* service_;

    DISALLOW_COPY_AND_ASSIGN(DomainAliasesResource);
  };

  class DomainsResource {
   public:
    explicit DomainsResource(DirectoryService* service);

    ~DomainsResource() {}


    DomainsResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer,
        const absl::string_view& domain_name) const;

    DomainsResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer,
        const absl::string_view& domain_name) const;

    DomainsResource_InsertMethod* NewInsertMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer,
        const Domains& _content_) const;

    DomainsResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer) const;

   private:
    DirectoryService* service_;

    DISALLOW_COPY_AND_ASSIGN(DomainsResource);
  };

  class GroupsResource {
   public:
    explicit GroupsResource(DirectoryService* service);

    ~GroupsResource() {}

    class AliasesResource {
     public:
      explicit AliasesResource(DirectoryService* service);

      ~AliasesResource() {}


      GroupsResource_AliasesResource_DeleteMethod* NewDeleteMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& group_key,
          const absl::string_view& alias) const;

      GroupsResource_AliasesResource_InsertMethod* NewInsertMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& group_key,
          const Alias& _content_) const;

      GroupsResource_AliasesResource_ListMethod* NewListMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& group_key) const;

     private:
      DirectoryService* service_;

      DISALLOW_COPY_AND_ASSIGN(AliasesResource);
    };
    const AliasesResource& get_aliases() const {
      return aliases_;
    }



    GroupsResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& group_key) const;

    GroupsResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& group_key) const;

    GroupsResource_InsertMethod* NewInsertMethod(
        client::AuthorizationCredential* _credential_,
        const Group& _content_) const;

    GroupsResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_) const;

    GroupsResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_) const;

    GroupsResource_PatchMethod* NewPatchMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& group_key,
        const Group& _content_) const;

    GroupsResource_UpdateMethod* NewUpdateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& group_key,
        const Group& _content_) const;

   private:
    DirectoryService* service_;
    AliasesResource aliases_;

    DISALLOW_COPY_AND_ASSIGN(GroupsResource);
  };

  class MembersResource {
   public:
    explicit MembersResource(DirectoryService* service);

    ~MembersResource() {}


    MembersResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& group_key,
        const absl::string_view& member_key) const;

    MembersResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& group_key,
        const absl::string_view& member_key) const;

    MembersResource_HasMemberMethod* NewHasMemberMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& group_key,
        const absl::string_view& member_key) const;

    MembersResource_InsertMethod* NewInsertMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& group_key,
        const Member& _content_) const;

    MembersResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& group_key) const;

    MembersResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& group_key) const;

    MembersResource_PatchMethod* NewPatchMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& group_key,
        const absl::string_view& member_key,
        const Member& _content_) const;

    MembersResource_UpdateMethod* NewUpdateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& group_key,
        const absl::string_view& member_key,
        const Member& _content_) const;

   private:
    DirectoryService* service_;

    DISALLOW_COPY_AND_ASSIGN(MembersResource);
  };

  class MobiledevicesResource {
   public:
    explicit MobiledevicesResource(DirectoryService* service);

    ~MobiledevicesResource() {}


    MobiledevicesResource_ActionMethod* NewActionMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id,
        const absl::string_view& resource_id,
        const MobileDeviceAction& _content_) const;

    MobiledevicesResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id,
        const absl::string_view& resource_id) const;

    MobiledevicesResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id,
        const absl::string_view& resource_id) const;

    MobiledevicesResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id) const;

    MobiledevicesResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id) const;

   private:
    DirectoryService* service_;

    DISALLOW_COPY_AND_ASSIGN(MobiledevicesResource);
  };

  class NotificationsResource {
   public:
    explicit NotificationsResource(DirectoryService* service);

    ~NotificationsResource() {}


    NotificationsResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer,
        const absl::string_view& notification_id) const;

    NotificationsResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer,
        const absl::string_view& notification_id) const;

    NotificationsResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer) const;

    NotificationsResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer) const;

    NotificationsResource_PatchMethod* NewPatchMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer,
        const absl::string_view& notification_id,
        const Notification& _content_) const;

    NotificationsResource_UpdateMethod* NewUpdateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer,
        const absl::string_view& notification_id,
        const Notification& _content_) const;

   private:
    DirectoryService* service_;

    DISALLOW_COPY_AND_ASSIGN(NotificationsResource);
  };

  class OrgunitsResource {
   public:
    explicit OrgunitsResource(DirectoryService* service);

    ~OrgunitsResource() {}


    OrgunitsResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id,
        const client::JsonCppArray<string >& org_unit_path) const;

    OrgunitsResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id,
        const client::JsonCppArray<string >& org_unit_path) const;

    OrgunitsResource_InsertMethod* NewInsertMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id,
        const OrgUnit& _content_) const;

    OrgunitsResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id) const;

    OrgunitsResource_PatchMethod* NewPatchMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id,
        const client::JsonCppArray<string >& org_unit_path,
        const OrgUnit& _content_) const;

    OrgunitsResource_UpdateMethod* NewUpdateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id,
        const client::JsonCppArray<string >& org_unit_path,
        const OrgUnit& _content_) const;

   private:
    DirectoryService* service_;

    DISALLOW_COPY_AND_ASSIGN(OrgunitsResource);
  };

  class PrivilegesResource {
   public:
    explicit PrivilegesResource(DirectoryService* service);

    ~PrivilegesResource() {}


    PrivilegesResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer) const;

   private:
    DirectoryService* service_;

    DISALLOW_COPY_AND_ASSIGN(PrivilegesResource);
  };

  class ResolvedAppAccessSettingsResource {
   public:
    explicit ResolvedAppAccessSettingsResource(DirectoryService* service);

    ~ResolvedAppAccessSettingsResource() {}


    ResolvedAppAccessSettingsResource_GetSettingsMethod* NewGetSettingsMethod(
        client::AuthorizationCredential* _credential_) const;

    ResolvedAppAccessSettingsResource_ListTrustedAppsMethod* NewListTrustedAppsMethod(
        client::AuthorizationCredential* _credential_) const;

   private:
    DirectoryService* service_;

    DISALLOW_COPY_AND_ASSIGN(ResolvedAppAccessSettingsResource);
  };

  class ResourcesResource {
   public:
    explicit ResourcesResource(DirectoryService* service);

    ~ResourcesResource() {}

    class BuildingsResource {
     public:
      explicit BuildingsResource(DirectoryService* service);

      ~BuildingsResource() {}


      ResourcesResource_BuildingsResource_DeleteMethod* NewDeleteMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer,
          const absl::string_view& building_id) const;

      ResourcesResource_BuildingsResource_GetMethod* NewGetMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer,
          const absl::string_view& building_id) const;

      ResourcesResource_BuildingsResource_InsertMethod* NewInsertMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer,
          const Building& _content_) const;

      ResourcesResource_BuildingsResource_ListMethod* NewListMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer) const;

      ResourcesResource_BuildingsResource_ListMethodPager* NewListMethodPager(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer) const;

      ResourcesResource_BuildingsResource_PatchMethod* NewPatchMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer,
          const absl::string_view& building_id,
          const Building& _content_) const;

      ResourcesResource_BuildingsResource_UpdateMethod* NewUpdateMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer,
          const absl::string_view& building_id,
          const Building& _content_) const;

     private:
      DirectoryService* service_;

      DISALLOW_COPY_AND_ASSIGN(BuildingsResource);
    };
    const BuildingsResource& get_buildings() const {
      return buildings_;
    }


    class CalendarsResource {
     public:
      explicit CalendarsResource(DirectoryService* service);

      ~CalendarsResource() {}


      ResourcesResource_CalendarsResource_DeleteMethod* NewDeleteMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer,
          const absl::string_view& calendar_resource_id) const;

      ResourcesResource_CalendarsResource_GetMethod* NewGetMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer,
          const absl::string_view& calendar_resource_id) const;

      ResourcesResource_CalendarsResource_InsertMethod* NewInsertMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer,
          const CalendarResource& _content_) const;

      ResourcesResource_CalendarsResource_ListMethod* NewListMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer) const;

      ResourcesResource_CalendarsResource_ListMethodPager* NewListMethodPager(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer) const;

      ResourcesResource_CalendarsResource_PatchMethod* NewPatchMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer,
          const absl::string_view& calendar_resource_id,
          const CalendarResource& _content_) const;

      ResourcesResource_CalendarsResource_UpdateMethod* NewUpdateMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer,
          const absl::string_view& calendar_resource_id,
          const CalendarResource& _content_) const;

     private:
      DirectoryService* service_;

      DISALLOW_COPY_AND_ASSIGN(CalendarsResource);
    };
    const CalendarsResource& get_calendars() const {
      return calendars_;
    }


    class FeaturesResource {
     public:
      explicit FeaturesResource(DirectoryService* service);

      ~FeaturesResource() {}


      ResourcesResource_FeaturesResource_DeleteMethod* NewDeleteMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer,
          const absl::string_view& feature_key) const;

      ResourcesResource_FeaturesResource_GetMethod* NewGetMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer,
          const absl::string_view& feature_key) const;

      ResourcesResource_FeaturesResource_InsertMethod* NewInsertMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer,
          const Feature& _content_) const;

      ResourcesResource_FeaturesResource_ListMethod* NewListMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer) const;

      ResourcesResource_FeaturesResource_ListMethodPager* NewListMethodPager(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer) const;

      ResourcesResource_FeaturesResource_PatchMethod* NewPatchMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer,
          const absl::string_view& feature_key,
          const Feature& _content_) const;

      ResourcesResource_FeaturesResource_RenameMethod* NewRenameMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer,
          const absl::string_view& old_name,
          const FeatureRename& _content_) const;

      ResourcesResource_FeaturesResource_UpdateMethod* NewUpdateMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& customer,
          const absl::string_view& feature_key,
          const Feature& _content_) const;

     private:
      DirectoryService* service_;

      DISALLOW_COPY_AND_ASSIGN(FeaturesResource);
    };
    const FeaturesResource& get_features() const {
      return features_;
    }



   private:
    DirectoryService* service_;
    BuildingsResource buildings_;
    CalendarsResource calendars_;
    FeaturesResource features_;

    DISALLOW_COPY_AND_ASSIGN(ResourcesResource);
  };

  class RoleAssignmentsResource {
   public:
    explicit RoleAssignmentsResource(DirectoryService* service);

    ~RoleAssignmentsResource() {}


    RoleAssignmentsResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer,
        const absl::string_view& role_assignment_id) const;

    RoleAssignmentsResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer,
        const absl::string_view& role_assignment_id) const;

    RoleAssignmentsResource_InsertMethod* NewInsertMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer,
        const RoleAssignment& _content_) const;

    RoleAssignmentsResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer) const;

    RoleAssignmentsResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer) const;

   private:
    DirectoryService* service_;

    DISALLOW_COPY_AND_ASSIGN(RoleAssignmentsResource);
  };

  class RolesResource {
   public:
    explicit RolesResource(DirectoryService* service);

    ~RolesResource() {}


    RolesResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer,
        const absl::string_view& role_id) const;

    RolesResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer,
        const absl::string_view& role_id) const;

    RolesResource_InsertMethod* NewInsertMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer,
        const Role& _content_) const;

    RolesResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer) const;

    RolesResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer) const;

    RolesResource_PatchMethod* NewPatchMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer,
        const absl::string_view& role_id,
        const Role& _content_) const;

    RolesResource_UpdateMethod* NewUpdateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer,
        const absl::string_view& role_id,
        const Role& _content_) const;

   private:
    DirectoryService* service_;

    DISALLOW_COPY_AND_ASSIGN(RolesResource);
  };

  class SchemasResource {
   public:
    explicit SchemasResource(DirectoryService* service);

    ~SchemasResource() {}


    SchemasResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id,
        const absl::string_view& schema_key) const;

    SchemasResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id,
        const absl::string_view& schema_key) const;

    SchemasResource_InsertMethod* NewInsertMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id,
        const Schema& _content_) const;

    SchemasResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id) const;

    SchemasResource_PatchMethod* NewPatchMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id,
        const absl::string_view& schema_key,
        const Schema& _content_) const;

    SchemasResource_UpdateMethod* NewUpdateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& customer_id,
        const absl::string_view& schema_key,
        const Schema& _content_) const;

   private:
    DirectoryService* service_;

    DISALLOW_COPY_AND_ASSIGN(SchemasResource);
  };

  class TokensResource {
   public:
    explicit TokensResource(DirectoryService* service);

    ~TokensResource() {}


    TokensResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& user_key,
        const absl::string_view& client_id) const;

    TokensResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& user_key,
        const absl::string_view& client_id) const;

    TokensResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& user_key) const;

   private:
    DirectoryService* service_;

    DISALLOW_COPY_AND_ASSIGN(TokensResource);
  };

  class UsersResource {
   public:
    explicit UsersResource(DirectoryService* service);

    ~UsersResource() {}

    class AliasesResource {
     public:
      explicit AliasesResource(DirectoryService* service);

      ~AliasesResource() {}


      UsersResource_AliasesResource_DeleteMethod* NewDeleteMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& user_key,
          const absl::string_view& alias) const;

      UsersResource_AliasesResource_InsertMethod* NewInsertMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& user_key,
          const Alias& _content_) const;

      UsersResource_AliasesResource_ListMethod* NewListMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& user_key) const;

      UsersResource_AliasesResource_WatchMethod* NewWatchMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& user_key,
          const Channel& _content_) const;

     private:
      DirectoryService* service_;

      DISALLOW_COPY_AND_ASSIGN(AliasesResource);
    };
    const AliasesResource& get_aliases() const {
      return aliases_;
    }


    class PhotosResource {
     public:
      explicit PhotosResource(DirectoryService* service);

      ~PhotosResource() {}


      UsersResource_PhotosResource_DeleteMethod* NewDeleteMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& user_key) const;

      UsersResource_PhotosResource_GetMethod* NewGetMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& user_key) const;

      UsersResource_PhotosResource_PatchMethod* NewPatchMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& user_key,
          const UserPhoto& _content_) const;

      UsersResource_PhotosResource_UpdateMethod* NewUpdateMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& user_key,
          const UserPhoto& _content_) const;

     private:
      DirectoryService* service_;

      DISALLOW_COPY_AND_ASSIGN(PhotosResource);
    };
    const PhotosResource& get_photos() const {
      return photos_;
    }



    UsersResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& user_key) const;

    UsersResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& user_key) const;

    UsersResource_InsertMethod* NewInsertMethod(
        client::AuthorizationCredential* _credential_,
        const User& _content_) const;

    UsersResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_) const;

    UsersResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_) const;

    UsersResource_MakeAdminMethod* NewMakeAdminMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& user_key,
        const UserMakeAdmin& _content_) const;

    UsersResource_PatchMethod* NewPatchMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& user_key,
        const User& _content_) const;

    UsersResource_UndeleteMethod* NewUndeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& user_key,
        const UserUndelete& _content_) const;

    UsersResource_UpdateMethod* NewUpdateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& user_key,
        const User& _content_) const;

    UsersResource_WatchMethod* NewWatchMethod(
        client::AuthorizationCredential* _credential_,
        const Channel& _content_) const;

   private:
    DirectoryService* service_;
    AliasesResource aliases_;
    PhotosResource photos_;

    DISALLOW_COPY_AND_ASSIGN(UsersResource);
  };

  class VerificationCodesResource {
   public:
    explicit VerificationCodesResource(DirectoryService* service);

    ~VerificationCodesResource() {}


    VerificationCodesResource_GenerateMethod* NewGenerateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& user_key) const;

    VerificationCodesResource_InvalidateMethod* NewInvalidateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& user_key) const;

    VerificationCodesResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& user_key) const;

   private:
    DirectoryService* service_;

    DISALLOW_COPY_AND_ASSIGN(VerificationCodesResource);
  };



  explicit DirectoryService(client::HttpTransport* transport);

  virtual ~DirectoryService();

  const AspsResource& get_asps() const {
    return asps_;
  }


  const ChannelsResource& get_channels() const {
    return channels_;
  }


  const ChromeosdevicesResource& get_chromeosdevices() const {
    return chromeosdevices_;
  }


  const CustomersResource& get_customers() const {
    return customers_;
  }


  const DomainAliasesResource& get_domain_aliases() const {
    return domain_aliases_;
  }


  const DomainsResource& get_domains() const {
    return domains_;
  }


  const GroupsResource& get_groups() const {
    return groups_;
  }


  const MembersResource& get_members() const {
    return members_;
  }


  const MobiledevicesResource& get_mobiledevices() const {
    return mobiledevices_;
  }


  const NotificationsResource& get_notifications() const {
    return notifications_;
  }


  const OrgunitsResource& get_orgunits() const {
    return orgunits_;
  }


  const PrivilegesResource& get_privileges() const {
    return privileges_;
  }


  const ResolvedAppAccessSettingsResource& get_resolved_app_access_settings() const {
    return resolved_app_access_settings_;
  }


  const ResourcesResource& get_resources() const {
    return resources_;
  }


  const RoleAssignmentsResource& get_role_assignments() const {
    return role_assignments_;
  }


  const RolesResource& get_roles() const {
    return roles_;
  }


  const SchemasResource& get_schemas() const {
    return schemas_;
  }


  const TokensResource& get_tokens() const {
    return tokens_;
  }


  const UsersResource& get_users() const {
    return users_;
  }


  const VerificationCodesResource& get_verification_codes() const {
    return verification_codes_;
  }

  class SCOPES {
   public:
    static const char ADMIN_DIRECTORY_CUSTOMER[];

    static const char ADMIN_DIRECTORY_CUSTOMER_READONLY[];

    static const char ADMIN_DIRECTORY_DEVICE_CHROMEOS[];

    static const char ADMIN_DIRECTORY_DEVICE_CHROMEOS_READONLY[];

    static const char ADMIN_DIRECTORY_DEVICE_MOBILE[];

    static const char ADMIN_DIRECTORY_DEVICE_MOBILE_ACTION[];

    static const char ADMIN_DIRECTORY_DEVICE_MOBILE_READONLY[];

    static const char ADMIN_DIRECTORY_DOMAIN[];

    static const char ADMIN_DIRECTORY_DOMAIN_READONLY[];

    static const char ADMIN_DIRECTORY_GROUP[];

    static const char ADMIN_DIRECTORY_GROUP_MEMBER[];

    static const char ADMIN_DIRECTORY_GROUP_MEMBER_READONLY[];

    static const char ADMIN_DIRECTORY_GROUP_READONLY[];

    static const char ADMIN_DIRECTORY_NOTIFICATIONS[];

    static const char ADMIN_DIRECTORY_ORGUNIT[];

    static const char ADMIN_DIRECTORY_ORGUNIT_READONLY[];

    static const char ADMIN_DIRECTORY_RESOURCE_CALENDAR[];

    static const char ADMIN_DIRECTORY_RESOURCE_CALENDAR_READONLY[];

    static const char ADMIN_DIRECTORY_ROLEMANAGEMENT[];

    static const char ADMIN_DIRECTORY_ROLEMANAGEMENT_READONLY[];

    static const char ADMIN_DIRECTORY_USER[];

    static const char ADMIN_DIRECTORY_USER_ALIAS[];

    static const char ADMIN_DIRECTORY_USER_ALIAS_READONLY[];

    static const char ADMIN_DIRECTORY_USER_READONLY[];

    static const char ADMIN_DIRECTORY_USER_SECURITY[];

    static const char ADMIN_DIRECTORY_USERSCHEMA[];

    static const char ADMIN_DIRECTORY_USERSCHEMA_READONLY[];

    static const char CLOUD_PLATFORM[];

   private:
    SCOPES();  // Never instantiated.
    ~SCOPES();  // Never instantiated.
  };

 private:
  AspsResource asps_;
  ChannelsResource channels_;
  ChromeosdevicesResource chromeosdevices_;
  CustomersResource customers_;
  DomainAliasesResource domain_aliases_;
  DomainsResource domains_;
  GroupsResource groups_;
  MembersResource members_;
  MobiledevicesResource mobiledevices_;
  NotificationsResource notifications_;
  OrgunitsResource orgunits_;
  PrivilegesResource privileges_;
  ResolvedAppAccessSettingsResource resolved_app_access_settings_;
  ResourcesResource resources_;
  RoleAssignmentsResource role_assignments_;
  RolesResource roles_;
  SchemasResource schemas_;
  TokensResource tokens_;
  UsersResource users_;
  VerificationCodesResource verification_codes_;

  DISALLOW_COPY_AND_ASSIGN(DirectoryService);
};


}  // namespace google_admin_admin_api
#endif  // GOOGLE_ADMIN_ADMIN_API_DIRECTORY_SERVICE_H_