drive_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-03-19, 05:24:40 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_DRIVE_API_DRIVE_SERVICE_H_
#define  GOOGLE_DRIVE_API_DRIVE_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/media_uploader.h"
#include "googleapis/client/service/service_request_pager.h"
#include "googleapis/client/util/status.h"
#include "googleapis/client/util/uri_template.h"

#include "google/drive_api/about.h"
#include "google/drive_api/app.h"
#include "google/drive_api/app_list.h"
#include "google/drive_api/change.h"
#include "google/drive_api/change_list.h"
#include "google/drive_api/channel.h"
#include "google/drive_api/child_list.h"
#include "google/drive_api/child_reference.h"
#include "google/drive_api/comment.h"
#include "google/drive_api/comment_list.h"
#include "google/drive_api/comment_reply.h"
#include "google/drive_api/comment_reply_list.h"
#include "google/drive_api/drive.h"
#include "google/drive_api/drive_list.h"
#include "google/drive_api/file.h"
#include "google/drive_api/file_list.h"
#include "google/drive_api/generated_ids.h"
#include "google/drive_api/parent_list.h"
#include "google/drive_api/parent_reference.h"
#include "google/drive_api/permission.h"
#include "google/drive_api/permission_id.h"
#include "google/drive_api/permission_list.h"
#include "google/drive_api/property.h"
#include "google/drive_api/property_list.h"
#include "google/drive_api/revision.h"
#include "google/drive_api/revision_list.h"
#include "google/drive_api/start_page_token.h"
#include "google/drive_api/team_drive.h"
#include "google/drive_api/team_drive_list.h"


namespace google_drive_api {
using namespace googleapis;
class DriveService;

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

  virtual ~DriveServiceBaseRequest();


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



class AboutResource_GetMethod : public DriveServiceBaseRequest {
 public:
  AboutResource_GetMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~AboutResource_GetMethod();


    void clear_include_subscribed() {
      _have_include_subscribed_ = false;
      client::ClearCppValueHelper(&include_subscribed_);
    }


    bool get_include_subscribed() const { return include_subscribed_; }

    void set_include_subscribed(bool value) {
      _have_include_subscribed_ = true;
      include_subscribed_ = value;
    }

    void clear_max_change_id_count() {
      _have_max_change_id_count_ = false;
      client::ClearCppValueHelper(&max_change_id_count_);
    }


    int64 get_max_change_id_count() const { return max_change_id_count_; }

    void set_max_change_id_count(int64 value) {
      _have_max_change_id_count_ = true;
      max_change_id_count_ = value;
    }

    void clear_start_change_id() {
      _have_start_change_id_ = false;
      client::ClearCppValueHelper(&start_change_id_);
    }


    int64 get_start_change_id() const { return start_change_id_; }

    void set_start_change_id(int64 value) {
      _have_start_change_id_ = true;
      start_change_id_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      About* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  bool include_subscribed_;
  int64 max_change_id_count_;
  int64 start_change_id_;
  bool _have_include_subscribed_ : 1;
  bool _have_max_change_id_count_ : 1;
  bool _have_start_change_id_ : 1;
  DISALLOW_COPY_AND_ASSIGN(AboutResource_GetMethod);
};



class AppsResource_GetMethod : public DriveServiceBaseRequest {
 public:
  AppsResource_GetMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& app_id);

  virtual ~AppsResource_GetMethod();


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


  util::Status ExecuteAndParseResponse(
      App* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string app_id_;
  DISALLOW_COPY_AND_ASSIGN(AppsResource_GetMethod);
};

class AppsResource_ListMethod : public DriveServiceBaseRequest {
 public:
  AppsResource_ListMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~AppsResource_ListMethod();


    void clear_app_filter_extensions() {
      _have_app_filter_extensions_ = false;
      client::ClearCppValueHelper(&app_filter_extensions_);
    }


    const string& get_app_filter_extensions() const { return app_filter_extensions_; }

    string* mutable_appFilterExtensions() {
      _have_app_filter_extensions_ = true;
      return &app_filter_extensions_;
    }


    void set_app_filter_extensions(const string& value) {
      _have_app_filter_extensions_ = true;
      app_filter_extensions_ = value;
    }



    void clear_app_filter_mime_types() {
      _have_app_filter_mime_types_ = false;
      client::ClearCppValueHelper(&app_filter_mime_types_);
    }


    const string& get_app_filter_mime_types() const { return app_filter_mime_types_; }

    string* mutable_appFilterMimeTypes() {
      _have_app_filter_mime_types_ = true;
      return &app_filter_mime_types_;
    }


    void set_app_filter_mime_types(const string& value) {
      _have_app_filter_mime_types_ = true;
      app_filter_mime_types_ = value;
    }



    void clear_language_code() {
      _have_language_code_ = false;
      client::ClearCppValueHelper(&language_code_);
    }


    const string& get_language_code() const { return language_code_; }

    string* mutable_languageCode() {
      _have_language_code_ = true;
      return &language_code_;
    }


    void set_language_code(const string& value) {
      _have_language_code_ = true;
      language_code_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      AppList* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string app_filter_extensions_;
  string app_filter_mime_types_;
  string language_code_;
  bool _have_app_filter_extensions_ : 1;
  bool _have_app_filter_mime_types_ : 1;
  bool _have_language_code_ : 1;
  DISALLOW_COPY_AND_ASSIGN(AppsResource_ListMethod);
};



class ChangesResource_GetMethod : public DriveServiceBaseRequest {
 public:
  ChangesResource_GetMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& change_id);

  virtual ~ChangesResource_GetMethod();


    void clear_drive_id() {
      _have_drive_id_ = false;
      client::ClearCppValueHelper(&drive_id_);
    }


    const string& get_drive_id() const { return drive_id_; }

    string* mutable_driveId() {
      _have_drive_id_ = true;
      return &drive_id_;
    }


    void set_drive_id(const string& value) {
      _have_drive_id_ = true;
      drive_id_ = value;
    }



    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

    void clear_team_drive_id() {
      _have_team_drive_id_ = false;
      client::ClearCppValueHelper(&team_drive_id_);
    }


    const string& get_team_drive_id() const { return team_drive_id_; }

    string* mutable_teamDriveId() {
      _have_team_drive_id_ = true;
      return &team_drive_id_;
    }


    void set_team_drive_id(const string& value) {
      _have_team_drive_id_ = true;
      team_drive_id_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      Change* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string change_id_;
  string drive_id_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  string team_drive_id_;
  bool _have_drive_id_ : 1;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;
  bool _have_team_drive_id_ : 1;
  DISALLOW_COPY_AND_ASSIGN(ChangesResource_GetMethod);
};

class ChangesResource_GetStartPageTokenMethod : public DriveServiceBaseRequest {
 public:
  ChangesResource_GetStartPageTokenMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~ChangesResource_GetStartPageTokenMethod();


    void clear_drive_id() {
      _have_drive_id_ = false;
      client::ClearCppValueHelper(&drive_id_);
    }


    const string& get_drive_id() const { return drive_id_; }

    string* mutable_driveId() {
      _have_drive_id_ = true;
      return &drive_id_;
    }


    void set_drive_id(const string& value) {
      _have_drive_id_ = true;
      drive_id_ = value;
    }



    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

    void clear_team_drive_id() {
      _have_team_drive_id_ = false;
      client::ClearCppValueHelper(&team_drive_id_);
    }


    const string& get_team_drive_id() const { return team_drive_id_; }

    string* mutable_teamDriveId() {
      _have_team_drive_id_ = true;
      return &team_drive_id_;
    }


    void set_team_drive_id(const string& value) {
      _have_team_drive_id_ = true;
      team_drive_id_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      StartPageToken* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string drive_id_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  string team_drive_id_;
  bool _have_drive_id_ : 1;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;
  bool _have_team_drive_id_ : 1;
  DISALLOW_COPY_AND_ASSIGN(ChangesResource_GetStartPageTokenMethod);
};

class ChangesResource_ListMethod : public DriveServiceBaseRequest {
 public:
  ChangesResource_ListMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~ChangesResource_ListMethod();


    void clear_drive_id() {
      _have_drive_id_ = false;
      client::ClearCppValueHelper(&drive_id_);
    }


    const string& get_drive_id() const { return drive_id_; }

    string* mutable_driveId() {
      _have_drive_id_ = true;
      return &drive_id_;
    }


    void set_drive_id(const string& value) {
      _have_drive_id_ = true;
      drive_id_ = value;
    }



    void clear_include_corpus_removals() {
      _have_include_corpus_removals_ = false;
      client::ClearCppValueHelper(&include_corpus_removals_);
    }


    bool get_include_corpus_removals() const { return include_corpus_removals_; }

    void set_include_corpus_removals(bool value) {
      _have_include_corpus_removals_ = true;
      include_corpus_removals_ = value;
    }

    void clear_include_deleted() {
      _have_include_deleted_ = false;
      client::ClearCppValueHelper(&include_deleted_);
    }


    bool get_include_deleted() const { return include_deleted_; }

    void set_include_deleted(bool value) {
      _have_include_deleted_ = true;
      include_deleted_ = value;
    }

    void clear_include_items_from_all_drives() {
      _have_include_items_from_all_drives_ = false;
      client::ClearCppValueHelper(&include_items_from_all_drives_);
    }


    bool get_include_items_from_all_drives() const { return include_items_from_all_drives_; }

    void set_include_items_from_all_drives(bool value) {
      _have_include_items_from_all_drives_ = true;
      include_items_from_all_drives_ = value;
    }

    void clear_include_subscribed() {
      _have_include_subscribed_ = false;
      client::ClearCppValueHelper(&include_subscribed_);
    }


    bool get_include_subscribed() const { return include_subscribed_; }

    void set_include_subscribed(bool value) {
      _have_include_subscribed_ = true;
      include_subscribed_ = value;
    }

    void clear_include_team_drive_items() {
      _have_include_team_drive_items_ = false;
      client::ClearCppValueHelper(&include_team_drive_items_);
    }


    bool get_include_team_drive_items() const { return include_team_drive_items_; }

    void set_include_team_drive_items(bool value) {
      _have_include_team_drive_items_ = true;
      include_team_drive_items_ = 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_spaces() {
      _have_spaces_ = false;
      client::ClearCppValueHelper(&spaces_);
    }


    const string& get_spaces() const { return spaces_; }

    string* mutable_spaces() {
      _have_spaces_ = true;
      return &spaces_;
    }


    void set_spaces(const string& value) {
      _have_spaces_ = true;
      spaces_ = value;
    }



    void clear_start_change_id() {
      _have_start_change_id_ = false;
      client::ClearCppValueHelper(&start_change_id_);
    }


    int64 get_start_change_id() const { return start_change_id_; }

    void set_start_change_id(int64 value) {
      _have_start_change_id_ = true;
      start_change_id_ = value;
    }

    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

    void clear_team_drive_id() {
      _have_team_drive_id_ = false;
      client::ClearCppValueHelper(&team_drive_id_);
    }


    const string& get_team_drive_id() const { return team_drive_id_; }

    string* mutable_teamDriveId() {
      _have_team_drive_id_ = true;
      return &team_drive_id_;
    }


    void set_team_drive_id(const string& value) {
      _have_team_drive_id_ = true;
      team_drive_id_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      ChangeList* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string drive_id_;
  bool include_corpus_removals_;
  bool include_deleted_;
  bool include_items_from_all_drives_;
  bool include_subscribed_;
  bool include_team_drive_items_;
  int32 max_results_;
  string page_token_;
  string spaces_;
  int64 start_change_id_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  string team_drive_id_;
  bool _have_drive_id_ : 1;
  bool _have_include_corpus_removals_ : 1;
  bool _have_include_deleted_ : 1;
  bool _have_include_items_from_all_drives_ : 1;
  bool _have_include_subscribed_ : 1;
  bool _have_include_team_drive_items_ : 1;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  bool _have_spaces_ : 1;
  bool _have_start_change_id_ : 1;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;
  bool _have_team_drive_id_ : 1;
  DISALLOW_COPY_AND_ASSIGN(ChangesResource_ListMethod);
};

typedef client::ServiceRequestPager<
            ChangesResource_ListMethod,
            ChangeList>
        ChangesResource_ListMethodPager;

class ChangesResource_WatchMethod : public DriveServiceBaseRequest {
 public:
  ChangesResource_WatchMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const Channel& _content_);

  virtual ~ChangesResource_WatchMethod();


    void clear_drive_id() {
      _have_drive_id_ = false;
      client::ClearCppValueHelper(&drive_id_);
    }


    const string& get_drive_id() const { return drive_id_; }

    string* mutable_driveId() {
      _have_drive_id_ = true;
      return &drive_id_;
    }


    void set_drive_id(const string& value) {
      _have_drive_id_ = true;
      drive_id_ = value;
    }



    void clear_include_corpus_removals() {
      _have_include_corpus_removals_ = false;
      client::ClearCppValueHelper(&include_corpus_removals_);
    }


    bool get_include_corpus_removals() const { return include_corpus_removals_; }

    void set_include_corpus_removals(bool value) {
      _have_include_corpus_removals_ = true;
      include_corpus_removals_ = value;
    }

    void clear_include_deleted() {
      _have_include_deleted_ = false;
      client::ClearCppValueHelper(&include_deleted_);
    }


    bool get_include_deleted() const { return include_deleted_; }

    void set_include_deleted(bool value) {
      _have_include_deleted_ = true;
      include_deleted_ = value;
    }

    void clear_include_items_from_all_drives() {
      _have_include_items_from_all_drives_ = false;
      client::ClearCppValueHelper(&include_items_from_all_drives_);
    }


    bool get_include_items_from_all_drives() const { return include_items_from_all_drives_; }

    void set_include_items_from_all_drives(bool value) {
      _have_include_items_from_all_drives_ = true;
      include_items_from_all_drives_ = value;
    }

    void clear_include_subscribed() {
      _have_include_subscribed_ = false;
      client::ClearCppValueHelper(&include_subscribed_);
    }


    bool get_include_subscribed() const { return include_subscribed_; }

    void set_include_subscribed(bool value) {
      _have_include_subscribed_ = true;
      include_subscribed_ = value;
    }

    void clear_include_team_drive_items() {
      _have_include_team_drive_items_ = false;
      client::ClearCppValueHelper(&include_team_drive_items_);
    }


    bool get_include_team_drive_items() const { return include_team_drive_items_; }

    void set_include_team_drive_items(bool value) {
      _have_include_team_drive_items_ = true;
      include_team_drive_items_ = 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_spaces() {
      _have_spaces_ = false;
      client::ClearCppValueHelper(&spaces_);
    }


    const string& get_spaces() const { return spaces_; }

    string* mutable_spaces() {
      _have_spaces_ = true;
      return &spaces_;
    }


    void set_spaces(const string& value) {
      _have_spaces_ = true;
      spaces_ = value;
    }



    void clear_start_change_id() {
      _have_start_change_id_ = false;
      client::ClearCppValueHelper(&start_change_id_);
    }


    int64 get_start_change_id() const { return start_change_id_; }

    void set_start_change_id(int64 value) {
      _have_start_change_id_ = true;
      start_change_id_ = value;
    }

    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

    void clear_team_drive_id() {
      _have_team_drive_id_ = false;
      client::ClearCppValueHelper(&team_drive_id_);
    }


    const string& get_team_drive_id() const { return team_drive_id_; }

    string* mutable_teamDriveId() {
      _have_team_drive_id_ = true;
      return &team_drive_id_;
    }


    void set_team_drive_id(const string& value) {
      _have_team_drive_id_ = true;
      team_drive_id_ = 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 DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string drive_id_;
  bool include_corpus_removals_;
  bool include_deleted_;
  bool include_items_from_all_drives_;
  bool include_subscribed_;
  bool include_team_drive_items_;
  int32 max_results_;
  string page_token_;
  string spaces_;
  int64 start_change_id_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  string team_drive_id_;
  bool _have_drive_id_ : 1;
  bool _have_include_corpus_removals_ : 1;
  bool _have_include_deleted_ : 1;
  bool _have_include_items_from_all_drives_ : 1;
  bool _have_include_subscribed_ : 1;
  bool _have_include_team_drive_items_ : 1;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  bool _have_spaces_ : 1;
  bool _have_start_change_id_ : 1;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;
  bool _have_team_drive_id_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(ChangesResource_WatchMethod);
};



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

  virtual ~ChannelsResource_StopMethod();

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



class ChildrenResource_DeleteMethod : public DriveServiceBaseRequest {
 public:
  ChildrenResource_DeleteMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& folder_id,
      const absl::string_view& child_id);

  virtual ~ChildrenResource_DeleteMethod();


    void clear_enforce_single_parent() {
      _have_enforce_single_parent_ = false;
      client::ClearCppValueHelper(&enforce_single_parent_);
    }


    bool get_enforce_single_parent() const { return enforce_single_parent_; }

    void set_enforce_single_parent(bool value) {
      _have_enforce_single_parent_ = true;
      enforce_single_parent_ = value;
    }

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

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


 private:
  string folder_id_;
  string child_id_;
  bool enforce_single_parent_;
  bool _have_enforce_single_parent_ : 1;
  DISALLOW_COPY_AND_ASSIGN(ChildrenResource_DeleteMethod);
};

class ChildrenResource_GetMethod : public DriveServiceBaseRequest {
 public:
  ChildrenResource_GetMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& folder_id,
      const absl::string_view& child_id);

  virtual ~ChildrenResource_GetMethod();


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


  util::Status ExecuteAndParseResponse(
      ChildReference* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string folder_id_;
  string child_id_;
  DISALLOW_COPY_AND_ASSIGN(ChildrenResource_GetMethod);
};

class ChildrenResource_InsertMethod : public DriveServiceBaseRequest {
 public:
  ChildrenResource_InsertMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& folder_id,
      const ChildReference& _content_);

  virtual ~ChildrenResource_InsertMethod();


    void clear_enforce_single_parent() {
      _have_enforce_single_parent_ = false;
      client::ClearCppValueHelper(&enforce_single_parent_);
    }


    bool get_enforce_single_parent() const { return enforce_single_parent_; }

    void set_enforce_single_parent(bool value) {
      _have_enforce_single_parent_ = true;
      enforce_single_parent_ = value;
    }

    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      ChildReference* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string folder_id_;
  bool enforce_single_parent_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  bool _have_enforce_single_parent_ : 1;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(ChildrenResource_InsertMethod);
};

class ChildrenResource_ListMethod : public DriveServiceBaseRequest {
 public:
  ChildrenResource_ListMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& folder_id);

  virtual ~ChildrenResource_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_q() {
      _have_q_ = false;
      client::ClearCppValueHelper(&q_);
    }


    const string& get_q() const { return q_; }

    string* mutable_q() {
      _have_q_ = true;
      return &q_;
    }


    void set_q(const string& value) {
      _have_q_ = true;
      q_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      ChildList* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string folder_id_;
  int32 max_results_;
  string order_by_;
  string page_token_;
  string q_;
  bool _have_max_results_ : 1;
  bool _have_order_by_ : 1;
  bool _have_page_token_ : 1;
  bool _have_q_ : 1;
  DISALLOW_COPY_AND_ASSIGN(ChildrenResource_ListMethod);
};

typedef client::ServiceRequestPager<
            ChildrenResource_ListMethod,
            ChildList>
        ChildrenResource_ListMethodPager;



class CommentsResource_DeleteMethod : public DriveServiceBaseRequest {
 public:
  CommentsResource_DeleteMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& comment_id);

  virtual ~CommentsResource_DeleteMethod();


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


 private:
  string file_id_;
  string comment_id_;
  DISALLOW_COPY_AND_ASSIGN(CommentsResource_DeleteMethod);
};

class CommentsResource_GetMethod : public DriveServiceBaseRequest {
 public:
  CommentsResource_GetMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& comment_id);

  virtual ~CommentsResource_GetMethod();


    void clear_include_deleted() {
      _have_include_deleted_ = false;
      client::ClearCppValueHelper(&include_deleted_);
    }


    bool get_include_deleted() const { return include_deleted_; }

    void set_include_deleted(bool value) {
      _have_include_deleted_ = true;
      include_deleted_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      Comment* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  string comment_id_;
  bool include_deleted_;
  bool _have_include_deleted_ : 1;
  DISALLOW_COPY_AND_ASSIGN(CommentsResource_GetMethod);
};

class CommentsResource_InsertMethod : public DriveServiceBaseRequest {
 public:
  CommentsResource_InsertMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const Comment& _content_);

  virtual ~CommentsResource_InsertMethod();


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


  util::Status ExecuteAndParseResponse(
      Comment* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(CommentsResource_InsertMethod);
};

class CommentsResource_ListMethod : public DriveServiceBaseRequest {
 public:
  CommentsResource_ListMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id);

  virtual ~CommentsResource_ListMethod();


    void clear_include_deleted() {
      _have_include_deleted_ = false;
      client::ClearCppValueHelper(&include_deleted_);
    }


    bool get_include_deleted() const { return include_deleted_; }

    void set_include_deleted(bool value) {
      _have_include_deleted_ = true;
      include_deleted_ = 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_updated_min() {
      _have_updated_min_ = false;
      client::ClearCppValueHelper(&updated_min_);
    }


    const string& get_updated_min() const { return updated_min_; }

    string* mutable_updatedMin() {
      _have_updated_min_ = true;
      return &updated_min_;
    }


    void set_updated_min(const string& value) {
      _have_updated_min_ = true;
      updated_min_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      CommentList* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  bool include_deleted_;
  int32 max_results_;
  string page_token_;
  string updated_min_;
  bool _have_include_deleted_ : 1;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  bool _have_updated_min_ : 1;
  DISALLOW_COPY_AND_ASSIGN(CommentsResource_ListMethod);
};

typedef client::ServiceRequestPager<
            CommentsResource_ListMethod,
            CommentList>
        CommentsResource_ListMethodPager;

class CommentsResource_PatchMethod : public DriveServiceBaseRequest {
 public:
  CommentsResource_PatchMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& comment_id,
      const Comment& _content_);

  virtual ~CommentsResource_PatchMethod();


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


  util::Status ExecuteAndParseResponse(
      Comment* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  string comment_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(CommentsResource_PatchMethod);
};

class CommentsResource_UpdateMethod : public DriveServiceBaseRequest {
 public:
  CommentsResource_UpdateMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& comment_id,
      const Comment& _content_);

  virtual ~CommentsResource_UpdateMethod();


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


  util::Status ExecuteAndParseResponse(
      Comment* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  string comment_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(CommentsResource_UpdateMethod);
};



class DrivesResource_DeleteMethod : public DriveServiceBaseRequest {
 public:
  DrivesResource_DeleteMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& drive_id);

  virtual ~DrivesResource_DeleteMethod();


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


 private:
  string drive_id_;
  DISALLOW_COPY_AND_ASSIGN(DrivesResource_DeleteMethod);
};

class DrivesResource_GetMethod : public DriveServiceBaseRequest {
 public:
  DrivesResource_GetMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& drive_id);

  virtual ~DrivesResource_GetMethod();


    void clear_use_domain_admin_access() {
      _have_use_domain_admin_access_ = false;
      client::ClearCppValueHelper(&use_domain_admin_access_);
    }


    bool get_use_domain_admin_access() const { return use_domain_admin_access_; }

    void set_use_domain_admin_access(bool value) {
      _have_use_domain_admin_access_ = true;
      use_domain_admin_access_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      Drive* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string drive_id_;
  bool use_domain_admin_access_;
  bool _have_use_domain_admin_access_ : 1;
  DISALLOW_COPY_AND_ASSIGN(DrivesResource_GetMethod);
};

class DrivesResource_HideMethod : public DriveServiceBaseRequest {
 public:
  DrivesResource_HideMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& drive_id);

  virtual ~DrivesResource_HideMethod();


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


  util::Status ExecuteAndParseResponse(
      Drive* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string drive_id_;
  DISALLOW_COPY_AND_ASSIGN(DrivesResource_HideMethod);
};

class DrivesResource_InsertMethod : public DriveServiceBaseRequest {
 public:
  DrivesResource_InsertMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& request_id,
      const Drive& _content_);

  virtual ~DrivesResource_InsertMethod();


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

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


  util::Status ExecuteAndParseResponse(
      Drive* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string request_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(DrivesResource_InsertMethod);
};

class DrivesResource_ListMethod : public DriveServiceBaseRequest {
 public:
  DrivesResource_ListMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~DrivesResource_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_q() {
      _have_q_ = false;
      client::ClearCppValueHelper(&q_);
    }


    const string& get_q() const { return q_; }

    string* mutable_q() {
      _have_q_ = true;
      return &q_;
    }


    void set_q(const string& value) {
      _have_q_ = true;
      q_ = value;
    }



    void clear_use_domain_admin_access() {
      _have_use_domain_admin_access_ = false;
      client::ClearCppValueHelper(&use_domain_admin_access_);
    }


    bool get_use_domain_admin_access() const { return use_domain_admin_access_; }

    void set_use_domain_admin_access(bool value) {
      _have_use_domain_admin_access_ = true;
      use_domain_admin_access_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      DriveList* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  int32 max_results_;
  string page_token_;
  string q_;
  bool use_domain_admin_access_;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  bool _have_q_ : 1;
  bool _have_use_domain_admin_access_ : 1;
  DISALLOW_COPY_AND_ASSIGN(DrivesResource_ListMethod);
};

typedef client::ServiceRequestPager<
            DrivesResource_ListMethod,
            DriveList>
        DrivesResource_ListMethodPager;

class DrivesResource_UnhideMethod : public DriveServiceBaseRequest {
 public:
  DrivesResource_UnhideMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& drive_id);

  virtual ~DrivesResource_UnhideMethod();


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


  util::Status ExecuteAndParseResponse(
      Drive* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string drive_id_;
  DISALLOW_COPY_AND_ASSIGN(DrivesResource_UnhideMethod);
};

class DrivesResource_UpdateMethod : public DriveServiceBaseRequest {
 public:
  DrivesResource_UpdateMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& drive_id,
      const Drive& _content_);

  virtual ~DrivesResource_UpdateMethod();


    void clear_use_domain_admin_access() {
      _have_use_domain_admin_access_ = false;
      client::ClearCppValueHelper(&use_domain_admin_access_);
    }


    bool get_use_domain_admin_access() const { return use_domain_admin_access_; }

    void set_use_domain_admin_access(bool value) {
      _have_use_domain_admin_access_ = true;
      use_domain_admin_access_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      Drive* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string drive_id_;
  bool use_domain_admin_access_;
  bool _have_use_domain_admin_access_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(DrivesResource_UpdateMethod);
};



class FilesResource_CopyMethod : public DriveServiceBaseRequest {
 public:
  FilesResource_CopyMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const File& _content_);

  virtual ~FilesResource_CopyMethod();


    void clear_convert() {
      _have_convert_ = false;
      client::ClearCppValueHelper(&convert_);
    }


    bool get_convert() const { return convert_; }

    void set_convert(bool value) {
      _have_convert_ = true;
      convert_ = value;
    }

    void clear_enforce_single_parent() {
      _have_enforce_single_parent_ = false;
      client::ClearCppValueHelper(&enforce_single_parent_);
    }


    bool get_enforce_single_parent() const { return enforce_single_parent_; }

    void set_enforce_single_parent(bool value) {
      _have_enforce_single_parent_ = true;
      enforce_single_parent_ = value;
    }

    void clear_ocr() {
      _have_ocr_ = false;
      client::ClearCppValueHelper(&ocr_);
    }


    bool get_ocr() const { return ocr_; }

    void set_ocr(bool value) {
      _have_ocr_ = true;
      ocr_ = value;
    }

    void clear_ocr_language() {
      _have_ocr_language_ = false;
      client::ClearCppValueHelper(&ocr_language_);
    }


    const string& get_ocr_language() const { return ocr_language_; }

    string* mutable_ocrLanguage() {
      _have_ocr_language_ = true;
      return &ocr_language_;
    }


    void set_ocr_language(const string& value) {
      _have_ocr_language_ = true;
      ocr_language_ = value;
    }



    void clear_pinned() {
      _have_pinned_ = false;
      client::ClearCppValueHelper(&pinned_);
    }


    bool get_pinned() const { return pinned_; }

    void set_pinned(bool value) {
      _have_pinned_ = true;
      pinned_ = value;
    }

    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

    void clear_timed_text_language() {
      _have_timed_text_language_ = false;
      client::ClearCppValueHelper(&timed_text_language_);
    }


    const string& get_timed_text_language() const { return timed_text_language_; }

    string* mutable_timedTextLanguage() {
      _have_timed_text_language_ = true;
      return &timed_text_language_;
    }


    void set_timed_text_language(const string& value) {
      _have_timed_text_language_ = true;
      timed_text_language_ = value;
    }



    void clear_timed_text_track_name() {
      _have_timed_text_track_name_ = false;
      client::ClearCppValueHelper(&timed_text_track_name_);
    }


    const string& get_timed_text_track_name() const { return timed_text_track_name_; }

    string* mutable_timedTextTrackName() {
      _have_timed_text_track_name_ = true;
      return &timed_text_track_name_;
    }


    void set_timed_text_track_name(const string& value) {
      _have_timed_text_track_name_ = true;
      timed_text_track_name_ = value;
    }



    void clear_visibility() {
      _have_visibility_ = false;
      client::ClearCppValueHelper(&visibility_);
    }


    const string& get_visibility() const { return visibility_; }

    string* mutable_visibility() {
      _have_visibility_ = true;
      return &visibility_;
    }


    void set_visibility(const string& value) {
      _have_visibility_ = true;
      visibility_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      File* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  bool convert_;
  bool enforce_single_parent_;
  bool ocr_;
  string ocr_language_;
  bool pinned_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  string timed_text_language_;
  string timed_text_track_name_;
  string visibility_;
  bool _have_convert_ : 1;
  bool _have_enforce_single_parent_ : 1;
  bool _have_ocr_ : 1;
  bool _have_ocr_language_ : 1;
  bool _have_pinned_ : 1;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;
  bool _have_timed_text_language_ : 1;
  bool _have_timed_text_track_name_ : 1;
  bool _have_visibility_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(FilesResource_CopyMethod);
};

class FilesResource_DeleteMethod : public DriveServiceBaseRequest {
 public:
  FilesResource_DeleteMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id);

  virtual ~FilesResource_DeleteMethod();


    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

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

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


 private:
  string file_id_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;
  DISALLOW_COPY_AND_ASSIGN(FilesResource_DeleteMethod);
};

class FilesResource_EmptyTrashMethod : public DriveServiceBaseRequest {
 public:
  FilesResource_EmptyTrashMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~FilesResource_EmptyTrashMethod();

 private:
  DISALLOW_COPY_AND_ASSIGN(FilesResource_EmptyTrashMethod);
};

class FilesResource_ExportMethod : public DriveServiceBaseRequest {
 public:
  FilesResource_ExportMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& mime_type);

  virtual ~FilesResource_ExportMethod();


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

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


  bool get_use_media_download() const   {
    return DriveServiceBaseRequest::get_use_media_download();
  }

  void set_use_media_download(bool use) {
    DriveServiceBaseRequest::set_use_media_download(use);
  }

 private:
  string file_id_;
  string mime_type_;
  DISALLOW_COPY_AND_ASSIGN(FilesResource_ExportMethod);
};

class FilesResource_GenerateIdsMethod : public DriveServiceBaseRequest {
 public:
  FilesResource_GenerateIdsMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~FilesResource_GenerateIdsMethod();


    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_space() {
      _have_space_ = false;
      client::ClearCppValueHelper(&space_);
    }


    const string& get_space() const { return space_; }

    string* mutable_space() {
      _have_space_ = true;
      return &space_;
    }


    void set_space(const string& value) {
      _have_space_ = true;
      space_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      GeneratedIds* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  int32 max_results_;
  string space_;
  bool _have_max_results_ : 1;
  bool _have_space_ : 1;
  DISALLOW_COPY_AND_ASSIGN(FilesResource_GenerateIdsMethod);
};

class FilesResource_GetMethod : public DriveServiceBaseRequest {
 public:
  FilesResource_GetMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id);

  virtual ~FilesResource_GetMethod();


    void clear_acknowledge_abuse() {
      _have_acknowledge_abuse_ = false;
      client::ClearCppValueHelper(&acknowledge_abuse_);
    }


    bool get_acknowledge_abuse() const { return acknowledge_abuse_; }

    void set_acknowledge_abuse(bool value) {
      _have_acknowledge_abuse_ = true;
      acknowledge_abuse_ = 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_revision_id() {
      _have_revision_id_ = false;
      client::ClearCppValueHelper(&revision_id_);
    }


    const string& get_revision_id() const { return revision_id_; }

    string* mutable_revisionId() {
      _have_revision_id_ = true;
      return &revision_id_;
    }


    void set_revision_id(const string& value) {
      _have_revision_id_ = true;
      revision_id_ = value;
    }



    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

    void clear_update_viewed_date() {
      _have_update_viewed_date_ = false;
      client::ClearCppValueHelper(&update_viewed_date_);
    }


    bool get_update_viewed_date() const { return update_viewed_date_; }

    void set_update_viewed_date(bool value) {
      _have_update_viewed_date_ = true;
      update_viewed_date_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      File* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

  bool get_use_media_download() const   {
    return DriveServiceBaseRequest::get_use_media_download();
  }

  void set_use_media_download(bool use) {
    DriveServiceBaseRequest::set_use_media_download(use);
  }

 private:
  string file_id_;
  bool acknowledge_abuse_;
  string projection_;
  string revision_id_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  bool update_viewed_date_;
  bool _have_acknowledge_abuse_ : 1;
  bool _have_projection_ : 1;
  bool _have_revision_id_ : 1;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;
  bool _have_update_viewed_date_ : 1;
  DISALLOW_COPY_AND_ASSIGN(FilesResource_GetMethod);
};

class FilesResource_InsertMethod : public DriveServiceBaseRequest {
 public:
  FilesResource_InsertMethod(
        const DriveService* _service_,
        client::AuthorizationCredential* _credential_);
  FilesResource_InsertMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const File* _metadata_,
      const StringPiece& _media_content_type_,
      client::DataReader* _media_content_reader_);

  virtual ~FilesResource_InsertMethod();


    void clear_convert() {
      _have_convert_ = false;
      client::ClearCppValueHelper(&convert_);
    }


    bool get_convert() const { return convert_; }

    void set_convert(bool value) {
      _have_convert_ = true;
      convert_ = value;
    }

    void clear_enforce_single_parent() {
      _have_enforce_single_parent_ = false;
      client::ClearCppValueHelper(&enforce_single_parent_);
    }


    bool get_enforce_single_parent() const { return enforce_single_parent_; }

    void set_enforce_single_parent(bool value) {
      _have_enforce_single_parent_ = true;
      enforce_single_parent_ = value;
    }

    void clear_ocr() {
      _have_ocr_ = false;
      client::ClearCppValueHelper(&ocr_);
    }


    bool get_ocr() const { return ocr_; }

    void set_ocr(bool value) {
      _have_ocr_ = true;
      ocr_ = value;
    }

    void clear_ocr_language() {
      _have_ocr_language_ = false;
      client::ClearCppValueHelper(&ocr_language_);
    }


    const string& get_ocr_language() const { return ocr_language_; }

    string* mutable_ocrLanguage() {
      _have_ocr_language_ = true;
      return &ocr_language_;
    }


    void set_ocr_language(const string& value) {
      _have_ocr_language_ = true;
      ocr_language_ = value;
    }



    void clear_pinned() {
      _have_pinned_ = false;
      client::ClearCppValueHelper(&pinned_);
    }


    bool get_pinned() const { return pinned_; }

    void set_pinned(bool value) {
      _have_pinned_ = true;
      pinned_ = value;
    }

    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

    void clear_timed_text_language() {
      _have_timed_text_language_ = false;
      client::ClearCppValueHelper(&timed_text_language_);
    }


    const string& get_timed_text_language() const { return timed_text_language_; }

    string* mutable_timedTextLanguage() {
      _have_timed_text_language_ = true;
      return &timed_text_language_;
    }


    void set_timed_text_language(const string& value) {
      _have_timed_text_language_ = true;
      timed_text_language_ = value;
    }



    void clear_timed_text_track_name() {
      _have_timed_text_track_name_ = false;
      client::ClearCppValueHelper(&timed_text_track_name_);
    }


    const string& get_timed_text_track_name() const { return timed_text_track_name_; }

    string* mutable_timedTextTrackName() {
      _have_timed_text_track_name_ = true;
      return &timed_text_track_name_;
    }


    void set_timed_text_track_name(const string& value) {
      _have_timed_text_track_name_ = true;
      timed_text_track_name_ = value;
    }



    void clear_use_content_as_indexable_text() {
      _have_use_content_as_indexable_text_ = false;
      client::ClearCppValueHelper(&use_content_as_indexable_text_);
    }


    bool get_use_content_as_indexable_text() const { return use_content_as_indexable_text_; }

    void set_use_content_as_indexable_text(bool value) {
      _have_use_content_as_indexable_text_ = true;
      use_content_as_indexable_text_ = value;
    }

    void clear_visibility() {
      _have_visibility_ = false;
      client::ClearCppValueHelper(&visibility_);
    }


    const string& get_visibility() const { return visibility_; }

    string* mutable_visibility() {
      _have_visibility_ = true;
      return &visibility_;
    }


    void set_visibility(const string& value) {
      _have_visibility_ = true;
      visibility_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      File* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }


  static const client::MediaUploadSpec SIMPLE_MEDIA_UPLOAD;
  static const client::MediaUploadSpec RESUMABLE_MEDIA_UPLOAD;

 private:
  bool convert_;
  bool enforce_single_parent_;
  bool ocr_;
  string ocr_language_;
  bool pinned_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  string timed_text_language_;
  string timed_text_track_name_;
  bool use_content_as_indexable_text_;
  string visibility_;
  bool _have_convert_ : 1;
  bool _have_enforce_single_parent_ : 1;
  bool _have_ocr_ : 1;
  bool _have_ocr_language_ : 1;
  bool _have_pinned_ : 1;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;
  bool _have_timed_text_language_ : 1;
  bool _have_timed_text_track_name_ : 1;
  bool _have_use_content_as_indexable_text_ : 1;
  bool _have_visibility_ : 1;
  DISALLOW_COPY_AND_ASSIGN(FilesResource_InsertMethod);
};

class FilesResource_ListMethod : public DriveServiceBaseRequest {
 public:
  FilesResource_ListMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~FilesResource_ListMethod();


    void clear_corpora() {
      _have_corpora_ = false;
      client::ClearCppValueHelper(&corpora_);
    }


    const string& get_corpora() const { return corpora_; }

    string* mutable_corpora() {
      _have_corpora_ = true;
      return &corpora_;
    }


    void set_corpora(const string& value) {
      _have_corpora_ = true;
      corpora_ = value;
    }



    void clear_corpus() {
      _have_corpus_ = false;
      client::ClearCppValueHelper(&corpus_);
    }


    const string& get_corpus() const { return corpus_; }

    string* mutable_corpus() {
      _have_corpus_ = true;
      return &corpus_;
    }


    void set_corpus(const string& value) {
      _have_corpus_ = true;
      corpus_ = value;
    }



    void clear_drive_id() {
      _have_drive_id_ = false;
      client::ClearCppValueHelper(&drive_id_);
    }


    const string& get_drive_id() const { return drive_id_; }

    string* mutable_driveId() {
      _have_drive_id_ = true;
      return &drive_id_;
    }


    void set_drive_id(const string& value) {
      _have_drive_id_ = true;
      drive_id_ = value;
    }



    void clear_include_items_from_all_drives() {
      _have_include_items_from_all_drives_ = false;
      client::ClearCppValueHelper(&include_items_from_all_drives_);
    }


    bool get_include_items_from_all_drives() const { return include_items_from_all_drives_; }

    void set_include_items_from_all_drives(bool value) {
      _have_include_items_from_all_drives_ = true;
      include_items_from_all_drives_ = value;
    }

    void clear_include_team_drive_items() {
      _have_include_team_drive_items_ = false;
      client::ClearCppValueHelper(&include_team_drive_items_);
    }


    bool get_include_team_drive_items() const { return include_team_drive_items_; }

    void set_include_team_drive_items(bool value) {
      _have_include_team_drive_items_ = true;
      include_team_drive_items_ = 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_q() {
      _have_q_ = false;
      client::ClearCppValueHelper(&q_);
    }


    const string& get_q() const { return q_; }

    string* mutable_q() {
      _have_q_ = true;
      return &q_;
    }


    void set_q(const string& value) {
      _have_q_ = true;
      q_ = value;
    }



    void clear_spaces() {
      _have_spaces_ = false;
      client::ClearCppValueHelper(&spaces_);
    }


    const string& get_spaces() const { return spaces_; }

    string* mutable_spaces() {
      _have_spaces_ = true;
      return &spaces_;
    }


    void set_spaces(const string& value) {
      _have_spaces_ = true;
      spaces_ = value;
    }



    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

    void clear_team_drive_id() {
      _have_team_drive_id_ = false;
      client::ClearCppValueHelper(&team_drive_id_);
    }


    const string& get_team_drive_id() const { return team_drive_id_; }

    string* mutable_teamDriveId() {
      _have_team_drive_id_ = true;
      return &team_drive_id_;
    }


    void set_team_drive_id(const string& value) {
      _have_team_drive_id_ = true;
      team_drive_id_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      FileList* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string corpora_;
  string corpus_;
  string drive_id_;
  bool include_items_from_all_drives_;
  bool include_team_drive_items_;
  int32 max_results_;
  string order_by_;
  string page_token_;
  string projection_;
  string q_;
  string spaces_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  string team_drive_id_;
  bool _have_corpora_ : 1;
  bool _have_corpus_ : 1;
  bool _have_drive_id_ : 1;
  bool _have_include_items_from_all_drives_ : 1;
  bool _have_include_team_drive_items_ : 1;
  bool _have_max_results_ : 1;
  bool _have_order_by_ : 1;
  bool _have_page_token_ : 1;
  bool _have_projection_ : 1;
  bool _have_q_ : 1;
  bool _have_spaces_ : 1;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;
  bool _have_team_drive_id_ : 1;
  DISALLOW_COPY_AND_ASSIGN(FilesResource_ListMethod);
};

typedef client::ServiceRequestPager<
            FilesResource_ListMethod,
            FileList>
        FilesResource_ListMethodPager;

class FilesResource_PatchMethod : public DriveServiceBaseRequest {
 public:
  FilesResource_PatchMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const File& _content_);

  virtual ~FilesResource_PatchMethod();


    void clear_add_parents() {
      _have_add_parents_ = false;
      client::ClearCppValueHelper(&add_parents_);
    }


    const string& get_add_parents() const { return add_parents_; }

    string* mutable_addParents() {
      _have_add_parents_ = true;
      return &add_parents_;
    }


    void set_add_parents(const string& value) {
      _have_add_parents_ = true;
      add_parents_ = value;
    }



    void clear_convert() {
      _have_convert_ = false;
      client::ClearCppValueHelper(&convert_);
    }


    bool get_convert() const { return convert_; }

    void set_convert(bool value) {
      _have_convert_ = true;
      convert_ = value;
    }

    void clear_enforce_single_parent() {
      _have_enforce_single_parent_ = false;
      client::ClearCppValueHelper(&enforce_single_parent_);
    }


    bool get_enforce_single_parent() const { return enforce_single_parent_; }

    void set_enforce_single_parent(bool value) {
      _have_enforce_single_parent_ = true;
      enforce_single_parent_ = value;
    }

    void clear_modified_date_behavior() {
      _have_modified_date_behavior_ = false;
      client::ClearCppValueHelper(&modified_date_behavior_);
    }


    const string& get_modified_date_behavior() const { return modified_date_behavior_; }

    string* mutable_modifiedDateBehavior() {
      _have_modified_date_behavior_ = true;
      return &modified_date_behavior_;
    }


    void set_modified_date_behavior(const string& value) {
      _have_modified_date_behavior_ = true;
      modified_date_behavior_ = value;
    }



    void clear_new_revision() {
      _have_new_revision_ = false;
      client::ClearCppValueHelper(&new_revision_);
    }


    bool get_new_revision() const { return new_revision_; }

    void set_new_revision(bool value) {
      _have_new_revision_ = true;
      new_revision_ = value;
    }

    void clear_ocr() {
      _have_ocr_ = false;
      client::ClearCppValueHelper(&ocr_);
    }


    bool get_ocr() const { return ocr_; }

    void set_ocr(bool value) {
      _have_ocr_ = true;
      ocr_ = value;
    }

    void clear_ocr_language() {
      _have_ocr_language_ = false;
      client::ClearCppValueHelper(&ocr_language_);
    }


    const string& get_ocr_language() const { return ocr_language_; }

    string* mutable_ocrLanguage() {
      _have_ocr_language_ = true;
      return &ocr_language_;
    }


    void set_ocr_language(const string& value) {
      _have_ocr_language_ = true;
      ocr_language_ = value;
    }



    void clear_pinned() {
      _have_pinned_ = false;
      client::ClearCppValueHelper(&pinned_);
    }


    bool get_pinned() const { return pinned_; }

    void set_pinned(bool value) {
      _have_pinned_ = true;
      pinned_ = value;
    }

    void clear_remove_parents() {
      _have_remove_parents_ = false;
      client::ClearCppValueHelper(&remove_parents_);
    }


    const string& get_remove_parents() const { return remove_parents_; }

    string* mutable_removeParents() {
      _have_remove_parents_ = true;
      return &remove_parents_;
    }


    void set_remove_parents(const string& value) {
      _have_remove_parents_ = true;
      remove_parents_ = value;
    }



    void clear_set_modified_date() {
      _have_set_modified_date_ = false;
      client::ClearCppValueHelper(&set_modified_date_);
    }


    bool get_set_modified_date() const { return set_modified_date_; }

    void set_set_modified_date(bool value) {
      _have_set_modified_date_ = true;
      set_modified_date_ = value;
    }

    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

    void clear_timed_text_language() {
      _have_timed_text_language_ = false;
      client::ClearCppValueHelper(&timed_text_language_);
    }


    const string& get_timed_text_language() const { return timed_text_language_; }

    string* mutable_timedTextLanguage() {
      _have_timed_text_language_ = true;
      return &timed_text_language_;
    }


    void set_timed_text_language(const string& value) {
      _have_timed_text_language_ = true;
      timed_text_language_ = value;
    }



    void clear_timed_text_track_name() {
      _have_timed_text_track_name_ = false;
      client::ClearCppValueHelper(&timed_text_track_name_);
    }


    const string& get_timed_text_track_name() const { return timed_text_track_name_; }

    string* mutable_timedTextTrackName() {
      _have_timed_text_track_name_ = true;
      return &timed_text_track_name_;
    }


    void set_timed_text_track_name(const string& value) {
      _have_timed_text_track_name_ = true;
      timed_text_track_name_ = value;
    }



    void clear_update_viewed_date() {
      _have_update_viewed_date_ = false;
      client::ClearCppValueHelper(&update_viewed_date_);
    }


    bool get_update_viewed_date() const { return update_viewed_date_; }

    void set_update_viewed_date(bool value) {
      _have_update_viewed_date_ = true;
      update_viewed_date_ = value;
    }

    void clear_use_content_as_indexable_text() {
      _have_use_content_as_indexable_text_ = false;
      client::ClearCppValueHelper(&use_content_as_indexable_text_);
    }


    bool get_use_content_as_indexable_text() const { return use_content_as_indexable_text_; }

    void set_use_content_as_indexable_text(bool value) {
      _have_use_content_as_indexable_text_ = true;
      use_content_as_indexable_text_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      File* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  string add_parents_;
  bool convert_;
  bool enforce_single_parent_;
  string modified_date_behavior_;
  bool new_revision_;
  bool ocr_;
  string ocr_language_;
  bool pinned_;
  string remove_parents_;
  bool set_modified_date_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  string timed_text_language_;
  string timed_text_track_name_;
  bool update_viewed_date_;
  bool use_content_as_indexable_text_;
  bool _have_add_parents_ : 1;
  bool _have_convert_ : 1;
  bool _have_enforce_single_parent_ : 1;
  bool _have_modified_date_behavior_ : 1;
  bool _have_new_revision_ : 1;
  bool _have_ocr_ : 1;
  bool _have_ocr_language_ : 1;
  bool _have_pinned_ : 1;
  bool _have_remove_parents_ : 1;
  bool _have_set_modified_date_ : 1;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;
  bool _have_timed_text_language_ : 1;
  bool _have_timed_text_track_name_ : 1;
  bool _have_update_viewed_date_ : 1;
  bool _have_use_content_as_indexable_text_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(FilesResource_PatchMethod);
};

class FilesResource_TouchMethod : public DriveServiceBaseRequest {
 public:
  FilesResource_TouchMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id);

  virtual ~FilesResource_TouchMethod();


    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      File* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;
  DISALLOW_COPY_AND_ASSIGN(FilesResource_TouchMethod);
};

class FilesResource_TrashMethod : public DriveServiceBaseRequest {
 public:
  FilesResource_TrashMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id);

  virtual ~FilesResource_TrashMethod();


    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      File* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;
  DISALLOW_COPY_AND_ASSIGN(FilesResource_TrashMethod);
};

class FilesResource_UntrashMethod : public DriveServiceBaseRequest {
 public:
  FilesResource_UntrashMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id);

  virtual ~FilesResource_UntrashMethod();


    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      File* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;
  DISALLOW_COPY_AND_ASSIGN(FilesResource_UntrashMethod);
};

class FilesResource_UpdateMethod : public DriveServiceBaseRequest {
 public:
  FilesResource_UpdateMethod(
        const DriveService* _service_,
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id);
  FilesResource_UpdateMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const File* _metadata_,
      const StringPiece& _media_content_type_,
      client::DataReader* _media_content_reader_);

  virtual ~FilesResource_UpdateMethod();


    void clear_add_parents() {
      _have_add_parents_ = false;
      client::ClearCppValueHelper(&add_parents_);
    }


    const string& get_add_parents() const { return add_parents_; }

    string* mutable_addParents() {
      _have_add_parents_ = true;
      return &add_parents_;
    }


    void set_add_parents(const string& value) {
      _have_add_parents_ = true;
      add_parents_ = value;
    }



    void clear_convert() {
      _have_convert_ = false;
      client::ClearCppValueHelper(&convert_);
    }


    bool get_convert() const { return convert_; }

    void set_convert(bool value) {
      _have_convert_ = true;
      convert_ = value;
    }

    void clear_enforce_single_parent() {
      _have_enforce_single_parent_ = false;
      client::ClearCppValueHelper(&enforce_single_parent_);
    }


    bool get_enforce_single_parent() const { return enforce_single_parent_; }

    void set_enforce_single_parent(bool value) {
      _have_enforce_single_parent_ = true;
      enforce_single_parent_ = value;
    }

    void clear_modified_date_behavior() {
      _have_modified_date_behavior_ = false;
      client::ClearCppValueHelper(&modified_date_behavior_);
    }


    const string& get_modified_date_behavior() const { return modified_date_behavior_; }

    string* mutable_modifiedDateBehavior() {
      _have_modified_date_behavior_ = true;
      return &modified_date_behavior_;
    }


    void set_modified_date_behavior(const string& value) {
      _have_modified_date_behavior_ = true;
      modified_date_behavior_ = value;
    }



    void clear_new_revision() {
      _have_new_revision_ = false;
      client::ClearCppValueHelper(&new_revision_);
    }


    bool get_new_revision() const { return new_revision_; }

    void set_new_revision(bool value) {
      _have_new_revision_ = true;
      new_revision_ = value;
    }

    void clear_ocr() {
      _have_ocr_ = false;
      client::ClearCppValueHelper(&ocr_);
    }


    bool get_ocr() const { return ocr_; }

    void set_ocr(bool value) {
      _have_ocr_ = true;
      ocr_ = value;
    }

    void clear_ocr_language() {
      _have_ocr_language_ = false;
      client::ClearCppValueHelper(&ocr_language_);
    }


    const string& get_ocr_language() const { return ocr_language_; }

    string* mutable_ocrLanguage() {
      _have_ocr_language_ = true;
      return &ocr_language_;
    }


    void set_ocr_language(const string& value) {
      _have_ocr_language_ = true;
      ocr_language_ = value;
    }



    void clear_pinned() {
      _have_pinned_ = false;
      client::ClearCppValueHelper(&pinned_);
    }


    bool get_pinned() const { return pinned_; }

    void set_pinned(bool value) {
      _have_pinned_ = true;
      pinned_ = value;
    }

    void clear_remove_parents() {
      _have_remove_parents_ = false;
      client::ClearCppValueHelper(&remove_parents_);
    }


    const string& get_remove_parents() const { return remove_parents_; }

    string* mutable_removeParents() {
      _have_remove_parents_ = true;
      return &remove_parents_;
    }


    void set_remove_parents(const string& value) {
      _have_remove_parents_ = true;
      remove_parents_ = value;
    }



    void clear_set_modified_date() {
      _have_set_modified_date_ = false;
      client::ClearCppValueHelper(&set_modified_date_);
    }


    bool get_set_modified_date() const { return set_modified_date_; }

    void set_set_modified_date(bool value) {
      _have_set_modified_date_ = true;
      set_modified_date_ = value;
    }

    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

    void clear_timed_text_language() {
      _have_timed_text_language_ = false;
      client::ClearCppValueHelper(&timed_text_language_);
    }


    const string& get_timed_text_language() const { return timed_text_language_; }

    string* mutable_timedTextLanguage() {
      _have_timed_text_language_ = true;
      return &timed_text_language_;
    }


    void set_timed_text_language(const string& value) {
      _have_timed_text_language_ = true;
      timed_text_language_ = value;
    }



    void clear_timed_text_track_name() {
      _have_timed_text_track_name_ = false;
      client::ClearCppValueHelper(&timed_text_track_name_);
    }


    const string& get_timed_text_track_name() const { return timed_text_track_name_; }

    string* mutable_timedTextTrackName() {
      _have_timed_text_track_name_ = true;
      return &timed_text_track_name_;
    }


    void set_timed_text_track_name(const string& value) {
      _have_timed_text_track_name_ = true;
      timed_text_track_name_ = value;
    }



    void clear_update_viewed_date() {
      _have_update_viewed_date_ = false;
      client::ClearCppValueHelper(&update_viewed_date_);
    }


    bool get_update_viewed_date() const { return update_viewed_date_; }

    void set_update_viewed_date(bool value) {
      _have_update_viewed_date_ = true;
      update_viewed_date_ = value;
    }

    void clear_use_content_as_indexable_text() {
      _have_use_content_as_indexable_text_ = false;
      client::ClearCppValueHelper(&use_content_as_indexable_text_);
    }


    bool get_use_content_as_indexable_text() const { return use_content_as_indexable_text_; }

    void set_use_content_as_indexable_text(bool value) {
      _have_use_content_as_indexable_text_ = true;
      use_content_as_indexable_text_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      File* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }


  static const client::MediaUploadSpec SIMPLE_MEDIA_UPLOAD;
  static const client::MediaUploadSpec RESUMABLE_MEDIA_UPLOAD;

 private:
  string file_id_;
  string add_parents_;
  bool convert_;
  bool enforce_single_parent_;
  string modified_date_behavior_;
  bool new_revision_;
  bool ocr_;
  string ocr_language_;
  bool pinned_;
  string remove_parents_;
  bool set_modified_date_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  string timed_text_language_;
  string timed_text_track_name_;
  bool update_viewed_date_;
  bool use_content_as_indexable_text_;
  bool _have_add_parents_ : 1;
  bool _have_convert_ : 1;
  bool _have_enforce_single_parent_ : 1;
  bool _have_modified_date_behavior_ : 1;
  bool _have_new_revision_ : 1;
  bool _have_ocr_ : 1;
  bool _have_ocr_language_ : 1;
  bool _have_pinned_ : 1;
  bool _have_remove_parents_ : 1;
  bool _have_set_modified_date_ : 1;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;
  bool _have_timed_text_language_ : 1;
  bool _have_timed_text_track_name_ : 1;
  bool _have_update_viewed_date_ : 1;
  bool _have_use_content_as_indexable_text_ : 1;
  DISALLOW_COPY_AND_ASSIGN(FilesResource_UpdateMethod);
};

class FilesResource_WatchMethod : public DriveServiceBaseRequest {
 public:
  FilesResource_WatchMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const Channel& _content_);

  virtual ~FilesResource_WatchMethod();


    void clear_acknowledge_abuse() {
      _have_acknowledge_abuse_ = false;
      client::ClearCppValueHelper(&acknowledge_abuse_);
    }


    bool get_acknowledge_abuse() const { return acknowledge_abuse_; }

    void set_acknowledge_abuse(bool value) {
      _have_acknowledge_abuse_ = true;
      acknowledge_abuse_ = 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_revision_id() {
      _have_revision_id_ = false;
      client::ClearCppValueHelper(&revision_id_);
    }


    const string& get_revision_id() const { return revision_id_; }

    string* mutable_revisionId() {
      _have_revision_id_ = true;
      return &revision_id_;
    }


    void set_revision_id(const string& value) {
      _have_revision_id_ = true;
      revision_id_ = value;
    }



    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

    void clear_update_viewed_date() {
      _have_update_viewed_date_ = false;
      client::ClearCppValueHelper(&update_viewed_date_);
    }


    bool get_update_viewed_date() const { return update_viewed_date_; }

    void set_update_viewed_date(bool value) {
      _have_update_viewed_date_ = true;
      update_viewed_date_ = 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 DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

  bool get_use_media_download() const   {
    return DriveServiceBaseRequest::get_use_media_download();
  }

  void set_use_media_download(bool use) {
    DriveServiceBaseRequest::set_use_media_download(use);
  }

 private:
  string file_id_;
  bool acknowledge_abuse_;
  string projection_;
  string revision_id_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  bool update_viewed_date_;
  bool _have_acknowledge_abuse_ : 1;
  bool _have_projection_ : 1;
  bool _have_revision_id_ : 1;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;
  bool _have_update_viewed_date_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(FilesResource_WatchMethod);
};



class ParentsResource_DeleteMethod : public DriveServiceBaseRequest {
 public:
  ParentsResource_DeleteMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& parent_id);

  virtual ~ParentsResource_DeleteMethod();


    void clear_enforce_single_parent() {
      _have_enforce_single_parent_ = false;
      client::ClearCppValueHelper(&enforce_single_parent_);
    }


    bool get_enforce_single_parent() const { return enforce_single_parent_; }

    void set_enforce_single_parent(bool value) {
      _have_enforce_single_parent_ = true;
      enforce_single_parent_ = value;
    }

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

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


 private:
  string file_id_;
  string parent_id_;
  bool enforce_single_parent_;
  bool _have_enforce_single_parent_ : 1;
  DISALLOW_COPY_AND_ASSIGN(ParentsResource_DeleteMethod);
};

class ParentsResource_GetMethod : public DriveServiceBaseRequest {
 public:
  ParentsResource_GetMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& parent_id);

  virtual ~ParentsResource_GetMethod();


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


  util::Status ExecuteAndParseResponse(
      ParentReference* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  string parent_id_;
  DISALLOW_COPY_AND_ASSIGN(ParentsResource_GetMethod);
};

class ParentsResource_InsertMethod : public DriveServiceBaseRequest {
 public:
  ParentsResource_InsertMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const ParentReference& _content_);

  virtual ~ParentsResource_InsertMethod();


    void clear_enforce_single_parent() {
      _have_enforce_single_parent_ = false;
      client::ClearCppValueHelper(&enforce_single_parent_);
    }


    bool get_enforce_single_parent() const { return enforce_single_parent_; }

    void set_enforce_single_parent(bool value) {
      _have_enforce_single_parent_ = true;
      enforce_single_parent_ = value;
    }

    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      ParentReference* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  bool enforce_single_parent_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  bool _have_enforce_single_parent_ : 1;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(ParentsResource_InsertMethod);
};

class ParentsResource_ListMethod : public DriveServiceBaseRequest {
 public:
  ParentsResource_ListMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id);

  virtual ~ParentsResource_ListMethod();


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


  util::Status ExecuteAndParseResponse(
      ParentList* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  DISALLOW_COPY_AND_ASSIGN(ParentsResource_ListMethod);
};



class PermissionsResource_DeleteMethod : public DriveServiceBaseRequest {
 public:
  PermissionsResource_DeleteMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& permission_id);

  virtual ~PermissionsResource_DeleteMethod();


    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

    void clear_use_domain_admin_access() {
      _have_use_domain_admin_access_ = false;
      client::ClearCppValueHelper(&use_domain_admin_access_);
    }


    bool get_use_domain_admin_access() const { return use_domain_admin_access_; }

    void set_use_domain_admin_access(bool value) {
      _have_use_domain_admin_access_ = true;
      use_domain_admin_access_ = value;
    }

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

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


 private:
  string file_id_;
  string permission_id_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  bool use_domain_admin_access_;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;
  bool _have_use_domain_admin_access_ : 1;
  DISALLOW_COPY_AND_ASSIGN(PermissionsResource_DeleteMethod);
};

class PermissionsResource_GetMethod : public DriveServiceBaseRequest {
 public:
  PermissionsResource_GetMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& permission_id);

  virtual ~PermissionsResource_GetMethod();


    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

    void clear_use_domain_admin_access() {
      _have_use_domain_admin_access_ = false;
      client::ClearCppValueHelper(&use_domain_admin_access_);
    }


    bool get_use_domain_admin_access() const { return use_domain_admin_access_; }

    void set_use_domain_admin_access(bool value) {
      _have_use_domain_admin_access_ = true;
      use_domain_admin_access_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      Permission* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  string permission_id_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  bool use_domain_admin_access_;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;
  bool _have_use_domain_admin_access_ : 1;
  DISALLOW_COPY_AND_ASSIGN(PermissionsResource_GetMethod);
};

class PermissionsResource_GetIdForEmailMethod : public DriveServiceBaseRequest {
 public:
  PermissionsResource_GetIdForEmailMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& email);

  virtual ~PermissionsResource_GetIdForEmailMethod();


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


  util::Status ExecuteAndParseResponse(
      PermissionId* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string email_;
  DISALLOW_COPY_AND_ASSIGN(PermissionsResource_GetIdForEmailMethod);
};

class PermissionsResource_InsertMethod : public DriveServiceBaseRequest {
 public:
  PermissionsResource_InsertMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const Permission& _content_);

  virtual ~PermissionsResource_InsertMethod();


    void clear_email_message() {
      _have_email_message_ = false;
      client::ClearCppValueHelper(&email_message_);
    }


    const string& get_email_message() const { return email_message_; }

    string* mutable_emailMessage() {
      _have_email_message_ = true;
      return &email_message_;
    }


    void set_email_message(const string& value) {
      _have_email_message_ = true;
      email_message_ = value;
    }



    void clear_enforce_single_parent() {
      _have_enforce_single_parent_ = false;
      client::ClearCppValueHelper(&enforce_single_parent_);
    }


    bool get_enforce_single_parent() const { return enforce_single_parent_; }

    void set_enforce_single_parent(bool value) {
      _have_enforce_single_parent_ = true;
      enforce_single_parent_ = value;
    }

    void clear_move_to_new_owners_root() {
      _have_move_to_new_owners_root_ = false;
      client::ClearCppValueHelper(&move_to_new_owners_root_);
    }


    bool get_move_to_new_owners_root() const { return move_to_new_owners_root_; }

    void set_move_to_new_owners_root(bool value) {
      _have_move_to_new_owners_root_ = true;
      move_to_new_owners_root_ = value;
    }

    void clear_send_notification_emails() {
      _have_send_notification_emails_ = false;
      client::ClearCppValueHelper(&send_notification_emails_);
    }


    bool get_send_notification_emails() const { return send_notification_emails_; }

    void set_send_notification_emails(bool value) {
      _have_send_notification_emails_ = true;
      send_notification_emails_ = value;
    }

    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

    void clear_use_domain_admin_access() {
      _have_use_domain_admin_access_ = false;
      client::ClearCppValueHelper(&use_domain_admin_access_);
    }


    bool get_use_domain_admin_access() const { return use_domain_admin_access_; }

    void set_use_domain_admin_access(bool value) {
      _have_use_domain_admin_access_ = true;
      use_domain_admin_access_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      Permission* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  string email_message_;
  bool enforce_single_parent_;
  bool move_to_new_owners_root_;
  bool send_notification_emails_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  bool use_domain_admin_access_;
  bool _have_email_message_ : 1;
  bool _have_enforce_single_parent_ : 1;
  bool _have_move_to_new_owners_root_ : 1;
  bool _have_send_notification_emails_ : 1;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;
  bool _have_use_domain_admin_access_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(PermissionsResource_InsertMethod);
};

class PermissionsResource_ListMethod : public DriveServiceBaseRequest {
 public:
  PermissionsResource_ListMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id);

  virtual ~PermissionsResource_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_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

    void clear_use_domain_admin_access() {
      _have_use_domain_admin_access_ = false;
      client::ClearCppValueHelper(&use_domain_admin_access_);
    }


    bool get_use_domain_admin_access() const { return use_domain_admin_access_; }

    void set_use_domain_admin_access(bool value) {
      _have_use_domain_admin_access_ = true;
      use_domain_admin_access_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      PermissionList* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  int32 max_results_;
  string page_token_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  bool use_domain_admin_access_;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;
  bool _have_use_domain_admin_access_ : 1;
  DISALLOW_COPY_AND_ASSIGN(PermissionsResource_ListMethod);
};

typedef client::ServiceRequestPager<
            PermissionsResource_ListMethod,
            PermissionList>
        PermissionsResource_ListMethodPager;

class PermissionsResource_PatchMethod : public DriveServiceBaseRequest {
 public:
  PermissionsResource_PatchMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& permission_id,
      const Permission& _content_);

  virtual ~PermissionsResource_PatchMethod();


    void clear_remove_expiration() {
      _have_remove_expiration_ = false;
      client::ClearCppValueHelper(&remove_expiration_);
    }


    bool get_remove_expiration() const { return remove_expiration_; }

    void set_remove_expiration(bool value) {
      _have_remove_expiration_ = true;
      remove_expiration_ = value;
    }

    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

    void clear_transfer_ownership() {
      _have_transfer_ownership_ = false;
      client::ClearCppValueHelper(&transfer_ownership_);
    }


    bool get_transfer_ownership() const { return transfer_ownership_; }

    void set_transfer_ownership(bool value) {
      _have_transfer_ownership_ = true;
      transfer_ownership_ = value;
    }

    void clear_use_domain_admin_access() {
      _have_use_domain_admin_access_ = false;
      client::ClearCppValueHelper(&use_domain_admin_access_);
    }


    bool get_use_domain_admin_access() const { return use_domain_admin_access_; }

    void set_use_domain_admin_access(bool value) {
      _have_use_domain_admin_access_ = true;
      use_domain_admin_access_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      Permission* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  string permission_id_;
  bool remove_expiration_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  bool transfer_ownership_;
  bool use_domain_admin_access_;
  bool _have_remove_expiration_ : 1;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;
  bool _have_transfer_ownership_ : 1;
  bool _have_use_domain_admin_access_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(PermissionsResource_PatchMethod);
};

class PermissionsResource_UpdateMethod : public DriveServiceBaseRequest {
 public:
  PermissionsResource_UpdateMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& permission_id,
      const Permission& _content_);

  virtual ~PermissionsResource_UpdateMethod();


    void clear_remove_expiration() {
      _have_remove_expiration_ = false;
      client::ClearCppValueHelper(&remove_expiration_);
    }


    bool get_remove_expiration() const { return remove_expiration_; }

    void set_remove_expiration(bool value) {
      _have_remove_expiration_ = true;
      remove_expiration_ = value;
    }

    void clear_supports_all_drives() {
      _have_supports_all_drives_ = false;
      client::ClearCppValueHelper(&supports_all_drives_);
    }


    bool get_supports_all_drives() const { return supports_all_drives_; }

    void set_supports_all_drives(bool value) {
      _have_supports_all_drives_ = true;
      supports_all_drives_ = value;
    }

    void clear_supports_team_drives() {
      _have_supports_team_drives_ = false;
      client::ClearCppValueHelper(&supports_team_drives_);
    }


    bool get_supports_team_drives() const { return supports_team_drives_; }

    void set_supports_team_drives(bool value) {
      _have_supports_team_drives_ = true;
      supports_team_drives_ = value;
    }

    void clear_transfer_ownership() {
      _have_transfer_ownership_ = false;
      client::ClearCppValueHelper(&transfer_ownership_);
    }


    bool get_transfer_ownership() const { return transfer_ownership_; }

    void set_transfer_ownership(bool value) {
      _have_transfer_ownership_ = true;
      transfer_ownership_ = value;
    }

    void clear_use_domain_admin_access() {
      _have_use_domain_admin_access_ = false;
      client::ClearCppValueHelper(&use_domain_admin_access_);
    }


    bool get_use_domain_admin_access() const { return use_domain_admin_access_; }

    void set_use_domain_admin_access(bool value) {
      _have_use_domain_admin_access_ = true;
      use_domain_admin_access_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      Permission* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  string permission_id_;
  bool remove_expiration_;
  bool supports_all_drives_;
  bool supports_team_drives_;
  bool transfer_ownership_;
  bool use_domain_admin_access_;
  bool _have_remove_expiration_ : 1;
  bool _have_supports_all_drives_ : 1;
  bool _have_supports_team_drives_ : 1;
  bool _have_transfer_ownership_ : 1;
  bool _have_use_domain_admin_access_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(PermissionsResource_UpdateMethod);
};



class PropertiesResource_DeleteMethod : public DriveServiceBaseRequest {
 public:
  PropertiesResource_DeleteMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& property_key);

  virtual ~PropertiesResource_DeleteMethod();


    void clear_visibility() {
      _have_visibility_ = false;
      client::ClearCppValueHelper(&visibility_);
    }


    const string& get_visibility() const { return visibility_; }

    string* mutable_visibility() {
      _have_visibility_ = true;
      return &visibility_;
    }


    void set_visibility(const string& value) {
      _have_visibility_ = true;
      visibility_ = value;
    }

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

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


 private:
  string file_id_;
  string property_key_;
  string visibility_;
  bool _have_visibility_ : 1;
  DISALLOW_COPY_AND_ASSIGN(PropertiesResource_DeleteMethod);
};

class PropertiesResource_GetMethod : public DriveServiceBaseRequest {
 public:
  PropertiesResource_GetMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& property_key);

  virtual ~PropertiesResource_GetMethod();


    void clear_visibility() {
      _have_visibility_ = false;
      client::ClearCppValueHelper(&visibility_);
    }


    const string& get_visibility() const { return visibility_; }

    string* mutable_visibility() {
      _have_visibility_ = true;
      return &visibility_;
    }


    void set_visibility(const string& value) {
      _have_visibility_ = true;
      visibility_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      Property* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  string property_key_;
  string visibility_;
  bool _have_visibility_ : 1;
  DISALLOW_COPY_AND_ASSIGN(PropertiesResource_GetMethod);
};

class PropertiesResource_InsertMethod : public DriveServiceBaseRequest {
 public:
  PropertiesResource_InsertMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const Property& _content_);

  virtual ~PropertiesResource_InsertMethod();


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


  util::Status ExecuteAndParseResponse(
      Property* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(PropertiesResource_InsertMethod);
};

class PropertiesResource_ListMethod : public DriveServiceBaseRequest {
 public:
  PropertiesResource_ListMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id);

  virtual ~PropertiesResource_ListMethod();


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


  util::Status ExecuteAndParseResponse(
      PropertyList* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  DISALLOW_COPY_AND_ASSIGN(PropertiesResource_ListMethod);
};

class PropertiesResource_PatchMethod : public DriveServiceBaseRequest {
 public:
  PropertiesResource_PatchMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& property_key,
      const Property& _content_);

  virtual ~PropertiesResource_PatchMethod();


    void clear_visibility() {
      _have_visibility_ = false;
      client::ClearCppValueHelper(&visibility_);
    }


    const string& get_visibility() const { return visibility_; }

    string* mutable_visibility() {
      _have_visibility_ = true;
      return &visibility_;
    }


    void set_visibility(const string& value) {
      _have_visibility_ = true;
      visibility_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      Property* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  string property_key_;
  string visibility_;
  bool _have_visibility_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(PropertiesResource_PatchMethod);
};

class PropertiesResource_UpdateMethod : public DriveServiceBaseRequest {
 public:
  PropertiesResource_UpdateMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& property_key,
      const Property& _content_);

  virtual ~PropertiesResource_UpdateMethod();


    void clear_visibility() {
      _have_visibility_ = false;
      client::ClearCppValueHelper(&visibility_);
    }


    const string& get_visibility() const { return visibility_; }

    string* mutable_visibility() {
      _have_visibility_ = true;
      return &visibility_;
    }


    void set_visibility(const string& value) {
      _have_visibility_ = true;
      visibility_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      Property* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  string property_key_;
  string visibility_;
  bool _have_visibility_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(PropertiesResource_UpdateMethod);
};



class RepliesResource_DeleteMethod : public DriveServiceBaseRequest {
 public:
  RepliesResource_DeleteMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& comment_id,
      const absl::string_view& reply_id);

  virtual ~RepliesResource_DeleteMethod();


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


 private:
  string file_id_;
  string comment_id_;
  string reply_id_;
  DISALLOW_COPY_AND_ASSIGN(RepliesResource_DeleteMethod);
};

class RepliesResource_GetMethod : public DriveServiceBaseRequest {
 public:
  RepliesResource_GetMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& comment_id,
      const absl::string_view& reply_id);

  virtual ~RepliesResource_GetMethod();


    void clear_include_deleted() {
      _have_include_deleted_ = false;
      client::ClearCppValueHelper(&include_deleted_);
    }


    bool get_include_deleted() const { return include_deleted_; }

    void set_include_deleted(bool value) {
      _have_include_deleted_ = true;
      include_deleted_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      CommentReply* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  string comment_id_;
  string reply_id_;
  bool include_deleted_;
  bool _have_include_deleted_ : 1;
  DISALLOW_COPY_AND_ASSIGN(RepliesResource_GetMethod);
};

class RepliesResource_InsertMethod : public DriveServiceBaseRequest {
 public:
  RepliesResource_InsertMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& comment_id,
      const CommentReply& _content_);

  virtual ~RepliesResource_InsertMethod();


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


  util::Status ExecuteAndParseResponse(
      CommentReply* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  string comment_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(RepliesResource_InsertMethod);
};

class RepliesResource_ListMethod : public DriveServiceBaseRequest {
 public:
  RepliesResource_ListMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& comment_id);

  virtual ~RepliesResource_ListMethod();


    void clear_include_deleted() {
      _have_include_deleted_ = false;
      client::ClearCppValueHelper(&include_deleted_);
    }


    bool get_include_deleted() const { return include_deleted_; }

    void set_include_deleted(bool value) {
      _have_include_deleted_ = true;
      include_deleted_ = 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;
    }

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

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


  util::Status ExecuteAndParseResponse(
      CommentReplyList* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  string comment_id_;
  bool include_deleted_;
  int32 max_results_;
  string page_token_;
  bool _have_include_deleted_ : 1;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  DISALLOW_COPY_AND_ASSIGN(RepliesResource_ListMethod);
};

typedef client::ServiceRequestPager<
            RepliesResource_ListMethod,
            CommentReplyList>
        RepliesResource_ListMethodPager;

class RepliesResource_PatchMethod : public DriveServiceBaseRequest {
 public:
  RepliesResource_PatchMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& comment_id,
      const absl::string_view& reply_id,
      const CommentReply& _content_);

  virtual ~RepliesResource_PatchMethod();


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


  util::Status ExecuteAndParseResponse(
      CommentReply* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  string comment_id_;
  string reply_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(RepliesResource_PatchMethod);
};

class RepliesResource_UpdateMethod : public DriveServiceBaseRequest {
 public:
  RepliesResource_UpdateMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& comment_id,
      const absl::string_view& reply_id,
      const CommentReply& _content_);

  virtual ~RepliesResource_UpdateMethod();


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


  util::Status ExecuteAndParseResponse(
      CommentReply* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  string comment_id_;
  string reply_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(RepliesResource_UpdateMethod);
};



class RevisionsResource_DeleteMethod : public DriveServiceBaseRequest {
 public:
  RevisionsResource_DeleteMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& revision_id);

  virtual ~RevisionsResource_DeleteMethod();


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


 private:
  string file_id_;
  string revision_id_;
  DISALLOW_COPY_AND_ASSIGN(RevisionsResource_DeleteMethod);
};

class RevisionsResource_GetMethod : public DriveServiceBaseRequest {
 public:
  RevisionsResource_GetMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& revision_id);

  virtual ~RevisionsResource_GetMethod();


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


  util::Status ExecuteAndParseResponse(
      Revision* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  string revision_id_;
  DISALLOW_COPY_AND_ASSIGN(RevisionsResource_GetMethod);
};

class RevisionsResource_ListMethod : public DriveServiceBaseRequest {
 public:
  RevisionsResource_ListMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id);

  virtual ~RevisionsResource_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(
      RevisionList* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  int32 max_results_;
  string page_token_;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  DISALLOW_COPY_AND_ASSIGN(RevisionsResource_ListMethod);
};

typedef client::ServiceRequestPager<
            RevisionsResource_ListMethod,
            RevisionList>
        RevisionsResource_ListMethodPager;

class RevisionsResource_PatchMethod : public DriveServiceBaseRequest {
 public:
  RevisionsResource_PatchMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& revision_id,
      const Revision& _content_);

  virtual ~RevisionsResource_PatchMethod();


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


  util::Status ExecuteAndParseResponse(
      Revision* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  string revision_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(RevisionsResource_PatchMethod);
};

class RevisionsResource_UpdateMethod : public DriveServiceBaseRequest {
 public:
  RevisionsResource_UpdateMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& file_id,
      const absl::string_view& revision_id,
      const Revision& _content_);

  virtual ~RevisionsResource_UpdateMethod();


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


  util::Status ExecuteAndParseResponse(
      Revision* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string file_id_;
  string revision_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(RevisionsResource_UpdateMethod);
};



class TeamdrivesResource_DeleteMethod : public DriveServiceBaseRequest {
 public:
  TeamdrivesResource_DeleteMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& team_drive_id);

  virtual ~TeamdrivesResource_DeleteMethod();


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


 private:
  string team_drive_id_;
  DISALLOW_COPY_AND_ASSIGN(TeamdrivesResource_DeleteMethod);
};

class TeamdrivesResource_GetMethod : public DriveServiceBaseRequest {
 public:
  TeamdrivesResource_GetMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& team_drive_id);

  virtual ~TeamdrivesResource_GetMethod();


    void clear_use_domain_admin_access() {
      _have_use_domain_admin_access_ = false;
      client::ClearCppValueHelper(&use_domain_admin_access_);
    }


    bool get_use_domain_admin_access() const { return use_domain_admin_access_; }

    void set_use_domain_admin_access(bool value) {
      _have_use_domain_admin_access_ = true;
      use_domain_admin_access_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      TeamDrive* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string team_drive_id_;
  bool use_domain_admin_access_;
  bool _have_use_domain_admin_access_ : 1;
  DISALLOW_COPY_AND_ASSIGN(TeamdrivesResource_GetMethod);
};

class TeamdrivesResource_InsertMethod : public DriveServiceBaseRequest {
 public:
  TeamdrivesResource_InsertMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& request_id,
      const TeamDrive& _content_);

  virtual ~TeamdrivesResource_InsertMethod();


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

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


  util::Status ExecuteAndParseResponse(
      TeamDrive* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string request_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(TeamdrivesResource_InsertMethod);
};

class TeamdrivesResource_ListMethod : public DriveServiceBaseRequest {
 public:
  TeamdrivesResource_ListMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~TeamdrivesResource_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_q() {
      _have_q_ = false;
      client::ClearCppValueHelper(&q_);
    }


    const string& get_q() const { return q_; }

    string* mutable_q() {
      _have_q_ = true;
      return &q_;
    }


    void set_q(const string& value) {
      _have_q_ = true;
      q_ = value;
    }



    void clear_use_domain_admin_access() {
      _have_use_domain_admin_access_ = false;
      client::ClearCppValueHelper(&use_domain_admin_access_);
    }


    bool get_use_domain_admin_access() const { return use_domain_admin_access_; }

    void set_use_domain_admin_access(bool value) {
      _have_use_domain_admin_access_ = true;
      use_domain_admin_access_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      TeamDriveList* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  int32 max_results_;
  string page_token_;
  string q_;
  bool use_domain_admin_access_;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  bool _have_q_ : 1;
  bool _have_use_domain_admin_access_ : 1;
  DISALLOW_COPY_AND_ASSIGN(TeamdrivesResource_ListMethod);
};

typedef client::ServiceRequestPager<
            TeamdrivesResource_ListMethod,
            TeamDriveList>
        TeamdrivesResource_ListMethodPager;

class TeamdrivesResource_UpdateMethod : public DriveServiceBaseRequest {
 public:
  TeamdrivesResource_UpdateMethod(
      const DriveService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& team_drive_id,
      const TeamDrive& _content_);

  virtual ~TeamdrivesResource_UpdateMethod();


    void clear_use_domain_admin_access() {
      _have_use_domain_admin_access_ = false;
      client::ClearCppValueHelper(&use_domain_admin_access_);
    }


    bool get_use_domain_admin_access() const { return use_domain_admin_access_; }

    void set_use_domain_admin_access(bool value) {
      _have_use_domain_admin_access_ = true;
      use_domain_admin_access_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      TeamDrive* data) {
    return DriveServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string team_drive_id_;
  bool use_domain_admin_access_;
  bool _have_use_domain_admin_access_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(TeamdrivesResource_UpdateMethod);
};



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

  static const char googleapis_API_VERSION[];

  static const char googleapis_API_GENERATOR[];


  class AboutResource {
   public:
    explicit AboutResource(DriveService* service);

    ~AboutResource() {}


    AboutResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_) const;

   private:
    DriveService* service_;

    DISALLOW_COPY_AND_ASSIGN(AboutResource);
  };

  class AppsResource {
   public:
    explicit AppsResource(DriveService* service);

    ~AppsResource() {}


    AppsResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& app_id) const;

    AppsResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_) const;

   private:
    DriveService* service_;

    DISALLOW_COPY_AND_ASSIGN(AppsResource);
  };

  class ChangesResource {
   public:
    explicit ChangesResource(DriveService* service);

    ~ChangesResource() {}


    ChangesResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& change_id) const;

    ChangesResource_GetStartPageTokenMethod* NewGetStartPageTokenMethod(
        client::AuthorizationCredential* _credential_) const;

    ChangesResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_) const;

    ChangesResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_) const;

    ChangesResource_WatchMethod* NewWatchMethod(
        client::AuthorizationCredential* _credential_,
        const Channel& _content_) const;

   private:
    DriveService* service_;

    DISALLOW_COPY_AND_ASSIGN(ChangesResource);
  };

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

    ~ChannelsResource() {}


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

   private:
    DriveService* service_;

    DISALLOW_COPY_AND_ASSIGN(ChannelsResource);
  };

  class ChildrenResource {
   public:
    explicit ChildrenResource(DriveService* service);

    ~ChildrenResource() {}


    ChildrenResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& folder_id,
        const absl::string_view& child_id) const;

    ChildrenResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& folder_id,
        const absl::string_view& child_id) const;

    ChildrenResource_InsertMethod* NewInsertMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& folder_id,
        const ChildReference& _content_) const;

    ChildrenResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& folder_id) const;

    ChildrenResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& folder_id) const;

   private:
    DriveService* service_;

    DISALLOW_COPY_AND_ASSIGN(ChildrenResource);
  };

  class CommentsResource {
   public:
    explicit CommentsResource(DriveService* service);

    ~CommentsResource() {}


    CommentsResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& comment_id) const;

    CommentsResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& comment_id) const;

    CommentsResource_InsertMethod* NewInsertMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const Comment& _content_) const;

    CommentsResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id) const;

    CommentsResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id) const;

    CommentsResource_PatchMethod* NewPatchMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& comment_id,
        const Comment& _content_) const;

    CommentsResource_UpdateMethod* NewUpdateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& comment_id,
        const Comment& _content_) const;

   private:
    DriveService* service_;

    DISALLOW_COPY_AND_ASSIGN(CommentsResource);
  };

  class DrivesResource {
   public:
    explicit DrivesResource(DriveService* service);

    ~DrivesResource() {}


    DrivesResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& drive_id) const;

    DrivesResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& drive_id) const;

    DrivesResource_HideMethod* NewHideMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& drive_id) const;

    DrivesResource_InsertMethod* NewInsertMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& request_id,
        const Drive& _content_) const;

    DrivesResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_) const;

    DrivesResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_) const;

    DrivesResource_UnhideMethod* NewUnhideMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& drive_id) const;

    DrivesResource_UpdateMethod* NewUpdateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& drive_id,
        const Drive& _content_) const;

   private:
    DriveService* service_;

    DISALLOW_COPY_AND_ASSIGN(DrivesResource);
  };

  class FilesResource {
   public:
    explicit FilesResource(DriveService* service);

    ~FilesResource() {}


    FilesResource_CopyMethod* NewCopyMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const File& _content_) const;

    FilesResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id) const;

    FilesResource_EmptyTrashMethod* NewEmptyTrashMethod(
        client::AuthorizationCredential* _credential_) const;

    FilesResource_ExportMethod* NewExportMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& mime_type) const;

    FilesResource_GenerateIdsMethod* NewGenerateIdsMethod(
        client::AuthorizationCredential* _credential_) const;

    FilesResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id) const;


    FilesResource_InsertMethod* NewInsertMethod(
        client::AuthorizationCredential* _credential_) const;

    FilesResource_InsertMethod* NewInsertMethod(
        client::AuthorizationCredential* _credential_,
        const File* _metadata_,
        const StringPiece& _media_content_type_,
        client::DataReader* _media_content_reader_) const;

    FilesResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_) const;

    FilesResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_) const;

    FilesResource_PatchMethod* NewPatchMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const File& _content_) const;

    FilesResource_TouchMethod* NewTouchMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id) const;

    FilesResource_TrashMethod* NewTrashMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id) const;

    FilesResource_UntrashMethod* NewUntrashMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id) const;


    FilesResource_UpdateMethod* NewUpdateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id) const;

    FilesResource_UpdateMethod* NewUpdateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const File* _metadata_,
        const StringPiece& _media_content_type_,
        client::DataReader* _media_content_reader_) const;

    FilesResource_WatchMethod* NewWatchMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const Channel& _content_) const;

   private:
    DriveService* service_;

    DISALLOW_COPY_AND_ASSIGN(FilesResource);
  };

  class ParentsResource {
   public:
    explicit ParentsResource(DriveService* service);

    ~ParentsResource() {}


    ParentsResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& parent_id) const;

    ParentsResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& parent_id) const;

    ParentsResource_InsertMethod* NewInsertMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const ParentReference& _content_) const;

    ParentsResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id) const;

   private:
    DriveService* service_;

    DISALLOW_COPY_AND_ASSIGN(ParentsResource);
  };

  class PermissionsResource {
   public:
    explicit PermissionsResource(DriveService* service);

    ~PermissionsResource() {}


    PermissionsResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& permission_id) const;

    PermissionsResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& permission_id) const;

    PermissionsResource_GetIdForEmailMethod* NewGetIdForEmailMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& email) const;

    PermissionsResource_InsertMethod* NewInsertMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const Permission& _content_) const;

    PermissionsResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id) const;

    PermissionsResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id) const;

    PermissionsResource_PatchMethod* NewPatchMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& permission_id,
        const Permission& _content_) const;

    PermissionsResource_UpdateMethod* NewUpdateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& permission_id,
        const Permission& _content_) const;

   private:
    DriveService* service_;

    DISALLOW_COPY_AND_ASSIGN(PermissionsResource);
  };

  class PropertiesResource {
   public:
    explicit PropertiesResource(DriveService* service);

    ~PropertiesResource() {}


    PropertiesResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& property_key) const;

    PropertiesResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& property_key) const;

    PropertiesResource_InsertMethod* NewInsertMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const Property& _content_) const;

    PropertiesResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id) const;

    PropertiesResource_PatchMethod* NewPatchMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& property_key,
        const Property& _content_) const;

    PropertiesResource_UpdateMethod* NewUpdateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& property_key,
        const Property& _content_) const;

   private:
    DriveService* service_;

    DISALLOW_COPY_AND_ASSIGN(PropertiesResource);
  };

  class RepliesResource {
   public:
    explicit RepliesResource(DriveService* service);

    ~RepliesResource() {}


    RepliesResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& comment_id,
        const absl::string_view& reply_id) const;

    RepliesResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& comment_id,
        const absl::string_view& reply_id) const;

    RepliesResource_InsertMethod* NewInsertMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& comment_id,
        const CommentReply& _content_) const;

    RepliesResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& comment_id) const;

    RepliesResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& comment_id) const;

    RepliesResource_PatchMethod* NewPatchMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& comment_id,
        const absl::string_view& reply_id,
        const CommentReply& _content_) const;

    RepliesResource_UpdateMethod* NewUpdateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& comment_id,
        const absl::string_view& reply_id,
        const CommentReply& _content_) const;

   private:
    DriveService* service_;

    DISALLOW_COPY_AND_ASSIGN(RepliesResource);
  };

  class RevisionsResource {
   public:
    explicit RevisionsResource(DriveService* service);

    ~RevisionsResource() {}


    RevisionsResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& revision_id) const;

    RevisionsResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& revision_id) const;

    RevisionsResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id) const;

    RevisionsResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id) const;

    RevisionsResource_PatchMethod* NewPatchMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& revision_id,
        const Revision& _content_) const;

    RevisionsResource_UpdateMethod* NewUpdateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& file_id,
        const absl::string_view& revision_id,
        const Revision& _content_) const;

   private:
    DriveService* service_;

    DISALLOW_COPY_AND_ASSIGN(RevisionsResource);
  };

  class TeamdrivesResource {
   public:
    explicit TeamdrivesResource(DriveService* service);

    ~TeamdrivesResource() {}


    TeamdrivesResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& team_drive_id) const;

    TeamdrivesResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& team_drive_id) const;

    TeamdrivesResource_InsertMethod* NewInsertMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& request_id,
        const TeamDrive& _content_) const;

    TeamdrivesResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_) const;

    TeamdrivesResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_) const;

    TeamdrivesResource_UpdateMethod* NewUpdateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& team_drive_id,
        const TeamDrive& _content_) const;

   private:
    DriveService* service_;

    DISALLOW_COPY_AND_ASSIGN(TeamdrivesResource);
  };



  explicit DriveService(client::HttpTransport* transport);

  virtual ~DriveService();

  const AboutResource& get_about() const {
    return about_;
  }


  const AppsResource& get_apps() const {
    return apps_;
  }


  const ChangesResource& get_changes() const {
    return changes_;
  }


  const ChannelsResource& get_channels() const {
    return channels_;
  }


  const ChildrenResource& get_children() const {
    return children_;
  }


  const CommentsResource& get_comments() const {
    return comments_;
  }


  const DrivesResource& get_drives() const {
    return drives_;
  }


  const FilesResource& get_files() const {
    return files_;
  }


  const ParentsResource& get_parents() const {
    return parents_;
  }


  const PermissionsResource& get_permissions() const {
    return permissions_;
  }


  const PropertiesResource& get_properties() const {
    return properties_;
  }


  const RepliesResource& get_replies() const {
    return replies_;
  }


  const RevisionsResource& get_revisions() const {
    return revisions_;
  }


  const TeamdrivesResource& get_teamdrives() const {
    return teamdrives_;
  }

  class SCOPES {
   public:
    static const char DRIVE[];

    static const char DRIVE_APPDATA[];

    static const char DRIVE_APPS_READONLY[];

    static const char DRIVE_FILE[];

    static const char DRIVE_METADATA[];

    static const char DRIVE_METADATA_READONLY[];

    static const char DRIVE_PHOTOS_READONLY[];

    static const char DRIVE_READONLY[];

    static const char DRIVE_SCRIPTS[];

   private:
    SCOPES();  // Never instantiated.
    ~SCOPES();  // Never instantiated.
  };

 private:
  AboutResource about_;
  AppsResource apps_;
  ChangesResource changes_;
  ChannelsResource channels_;
  ChildrenResource children_;
  CommentsResource comments_;
  DrivesResource drives_;
  FilesResource files_;
  ParentsResource parents_;
  PermissionsResource permissions_;
  PropertiesResource properties_;
  RepliesResource replies_;
  RevisionsResource revisions_;
  TeamdrivesResource teamdrives_;

  DISALLOW_COPY_AND_ASSIGN(DriveService);
};


}  // namespace google_drive_api
#endif  // GOOGLE_DRIVE_API_DRIVE_SERVICE_H_