tasks_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-02-15, 11:16:04 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_TASKS_API_TASKS_SERVICE_H_
#define  GOOGLE_TASKS_API_TASKS_SERVICE_H_

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

#include "google/tasks_api/task.h"
#include "google/tasks_api/task_list.h"
#include "google/tasks_api/task_lists.h"
#include "google/tasks_api/tasks.h"


namespace google_tasks_api {
using namespace googleapis;
class TasksService;

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

  virtual ~TasksServiceBaseRequest();


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



class TasklistsResource_DeleteMethod : public TasksServiceBaseRequest {
 public:
  TasklistsResource_DeleteMethod(
      const TasksService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& tasklist);

  virtual ~TasklistsResource_DeleteMethod();


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


 private:
  string tasklist_;
  DISALLOW_COPY_AND_ASSIGN(TasklistsResource_DeleteMethod);
};

class TasklistsResource_GetMethod : public TasksServiceBaseRequest {
 public:
  TasklistsResource_GetMethod(
      const TasksService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& tasklist);

  virtual ~TasklistsResource_GetMethod();


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


  util::Status ExecuteAndParseResponse(
      TaskList* data) {
    return TasksServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string tasklist_;
  DISALLOW_COPY_AND_ASSIGN(TasklistsResource_GetMethod);
};

class TasklistsResource_InsertMethod : public TasksServiceBaseRequest {
 public:
  TasklistsResource_InsertMethod(
      const TasksService* _service_,
      client::AuthorizationCredential* _credential_,
      const TaskList& _content_);

  virtual ~TasklistsResource_InsertMethod();

  util::Status ExecuteAndParseResponse(
      TaskList* data) {
    return TasksServiceBaseRequest::ExecuteAndParseResponse(data);
  }

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

class TasklistsResource_ListMethod : public TasksServiceBaseRequest {
 public:
  TasklistsResource_ListMethod(
      const TasksService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~TasklistsResource_ListMethod();


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


    int64 get_max_results() const { return max_results_; }

    void set_max_results(int64 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(
      TaskLists* data) {
    return TasksServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  int64 max_results_;
  string page_token_;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  DISALLOW_COPY_AND_ASSIGN(TasklistsResource_ListMethod);
};

typedef client::ServiceRequestPager<
            TasklistsResource_ListMethod,
            TaskLists>
        TasklistsResource_ListMethodPager;

class TasklistsResource_PatchMethod : public TasksServiceBaseRequest {
 public:
  TasklistsResource_PatchMethod(
      const TasksService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& tasklist,
      const TaskList& _content_);

  virtual ~TasklistsResource_PatchMethod();


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


  util::Status ExecuteAndParseResponse(
      TaskList* data) {
    return TasksServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string tasklist_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(TasklistsResource_PatchMethod);
};

class TasklistsResource_UpdateMethod : public TasksServiceBaseRequest {
 public:
  TasklistsResource_UpdateMethod(
      const TasksService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& tasklist,
      const TaskList& _content_);

  virtual ~TasklistsResource_UpdateMethod();


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


  util::Status ExecuteAndParseResponse(
      TaskList* data) {
    return TasksServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string tasklist_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(TasklistsResource_UpdateMethod);
};



class TasksResource_ClearMethod : public TasksServiceBaseRequest {
 public:
  TasksResource_ClearMethod(
      const TasksService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& tasklist);

  virtual ~TasksResource_ClearMethod();


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


 private:
  string tasklist_;
  DISALLOW_COPY_AND_ASSIGN(TasksResource_ClearMethod);
};

class TasksResource_DeleteMethod : public TasksServiceBaseRequest {
 public:
  TasksResource_DeleteMethod(
      const TasksService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& tasklist,
      const absl::string_view& task);

  virtual ~TasksResource_DeleteMethod();


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


 private:
  string tasklist_;
  string task_;
  DISALLOW_COPY_AND_ASSIGN(TasksResource_DeleteMethod);
};

class TasksResource_GetMethod : public TasksServiceBaseRequest {
 public:
  TasksResource_GetMethod(
      const TasksService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& tasklist,
      const absl::string_view& task);

  virtual ~TasksResource_GetMethod();


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


  util::Status ExecuteAndParseResponse(
      Task* data) {
    return TasksServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string tasklist_;
  string task_;
  DISALLOW_COPY_AND_ASSIGN(TasksResource_GetMethod);
};

class TasksResource_InsertMethod : public TasksServiceBaseRequest {
 public:
  TasksResource_InsertMethod(
      const TasksService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& tasklist,
      const Task& _content_);

  virtual ~TasksResource_InsertMethod();


    void clear_parent() {
      _have_parent_ = false;
      client::ClearCppValueHelper(&parent_);
    }


    const string& get_parent() const { return parent_; }

    string* mutable_parent() {
      _have_parent_ = true;
      return &parent_;
    }


    void set_parent(const string& value) {
      _have_parent_ = true;
      parent_ = value;
    }



    void clear_previous() {
      _have_previous_ = false;
      client::ClearCppValueHelper(&previous_);
    }


    const string& get_previous() const { return previous_; }

    string* mutable_previous() {
      _have_previous_ = true;
      return &previous_;
    }


    void set_previous(const string& value) {
      _have_previous_ = true;
      previous_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      Task* data) {
    return TasksServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string tasklist_;
  string parent_;
  string previous_;
  bool _have_parent_ : 1;
  bool _have_previous_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(TasksResource_InsertMethod);
};

class TasksResource_ListMethod : public TasksServiceBaseRequest {
 public:
  TasksResource_ListMethod(
      const TasksService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& tasklist);

  virtual ~TasksResource_ListMethod();


    void clear_completed_max() {
      _have_completed_max_ = false;
      client::ClearCppValueHelper(&completed_max_);
    }


    const string& get_completed_max() const { return completed_max_; }

    string* mutable_completedMax() {
      _have_completed_max_ = true;
      return &completed_max_;
    }


    void set_completed_max(const string& value) {
      _have_completed_max_ = true;
      completed_max_ = value;
    }



    void clear_completed_min() {
      _have_completed_min_ = false;
      client::ClearCppValueHelper(&completed_min_);
    }


    const string& get_completed_min() const { return completed_min_; }

    string* mutable_completedMin() {
      _have_completed_min_ = true;
      return &completed_min_;
    }


    void set_completed_min(const string& value) {
      _have_completed_min_ = true;
      completed_min_ = value;
    }



    void clear_due_max() {
      _have_due_max_ = false;
      client::ClearCppValueHelper(&due_max_);
    }


    const string& get_due_max() const { return due_max_; }

    string* mutable_dueMax() {
      _have_due_max_ = true;
      return &due_max_;
    }


    void set_due_max(const string& value) {
      _have_due_max_ = true;
      due_max_ = value;
    }



    void clear_due_min() {
      _have_due_min_ = false;
      client::ClearCppValueHelper(&due_min_);
    }


    const string& get_due_min() const { return due_min_; }

    string* mutable_dueMin() {
      _have_due_min_ = true;
      return &due_min_;
    }


    void set_due_min(const string& value) {
      _have_due_min_ = true;
      due_min_ = value;
    }



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


    int64 get_max_results() const { return max_results_; }

    void set_max_results(int64 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_show_completed() {
      _have_show_completed_ = false;
      client::ClearCppValueHelper(&show_completed_);
    }


    bool get_show_completed() const { return show_completed_; }

    void set_show_completed(bool value) {
      _have_show_completed_ = true;
      show_completed_ = value;
    }

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


    bool get_show_deleted() const { return show_deleted_; }

    void set_show_deleted(bool value) {
      _have_show_deleted_ = true;
      show_deleted_ = value;
    }

    void clear_show_hidden() {
      _have_show_hidden_ = false;
      client::ClearCppValueHelper(&show_hidden_);
    }


    bool get_show_hidden() const { return show_hidden_; }

    void set_show_hidden(bool value) {
      _have_show_hidden_ = true;
      show_hidden_ = 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(
      Tasks* data) {
    return TasksServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string tasklist_;
  string completed_max_;
  string completed_min_;
  string due_max_;
  string due_min_;
  int64 max_results_;
  string page_token_;
  bool show_completed_;
  bool show_deleted_;
  bool show_hidden_;
  string updated_min_;
  bool _have_completed_max_ : 1;
  bool _have_completed_min_ : 1;
  bool _have_due_max_ : 1;
  bool _have_due_min_ : 1;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  bool _have_show_completed_ : 1;
  bool _have_show_deleted_ : 1;
  bool _have_show_hidden_ : 1;
  bool _have_updated_min_ : 1;
  DISALLOW_COPY_AND_ASSIGN(TasksResource_ListMethod);
};

typedef client::ServiceRequestPager<
            TasksResource_ListMethod,
            Tasks>
        TasksResource_ListMethodPager;

class TasksResource_MoveMethod : public TasksServiceBaseRequest {
 public:
  TasksResource_MoveMethod(
      const TasksService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& tasklist,
      const absl::string_view& task);

  virtual ~TasksResource_MoveMethod();


    void clear_parent() {
      _have_parent_ = false;
      client::ClearCppValueHelper(&parent_);
    }


    const string& get_parent() const { return parent_; }

    string* mutable_parent() {
      _have_parent_ = true;
      return &parent_;
    }


    void set_parent(const string& value) {
      _have_parent_ = true;
      parent_ = value;
    }



    void clear_previous() {
      _have_previous_ = false;
      client::ClearCppValueHelper(&previous_);
    }


    const string& get_previous() const { return previous_; }

    string* mutable_previous() {
      _have_previous_ = true;
      return &previous_;
    }


    void set_previous(const string& value) {
      _have_previous_ = true;
      previous_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      Task* data) {
    return TasksServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string tasklist_;
  string task_;
  string parent_;
  string previous_;
  bool _have_parent_ : 1;
  bool _have_previous_ : 1;
  DISALLOW_COPY_AND_ASSIGN(TasksResource_MoveMethod);
};

class TasksResource_PatchMethod : public TasksServiceBaseRequest {
 public:
  TasksResource_PatchMethod(
      const TasksService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& tasklist,
      const absl::string_view& task,
      const Task& _content_);

  virtual ~TasksResource_PatchMethod();


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


  util::Status ExecuteAndParseResponse(
      Task* data) {
    return TasksServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string tasklist_;
  string task_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(TasksResource_PatchMethod);
};

class TasksResource_UpdateMethod : public TasksServiceBaseRequest {
 public:
  TasksResource_UpdateMethod(
      const TasksService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& tasklist,
      const absl::string_view& task,
      const Task& _content_);

  virtual ~TasksResource_UpdateMethod();


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


  util::Status ExecuteAndParseResponse(
      Task* data) {
    return TasksServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string tasklist_;
  string task_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(TasksResource_UpdateMethod);
};



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

  static const char googleapis_API_VERSION[];

  static const char googleapis_API_GENERATOR[];


  class TasklistsResource {
   public:
    explicit TasklistsResource(TasksService* service);

    ~TasklistsResource() {}


    TasklistsResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& tasklist) const;

    TasklistsResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& tasklist) const;

    TasklistsResource_InsertMethod* NewInsertMethod(
        client::AuthorizationCredential* _credential_,
        const TaskList& _content_) const;

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

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

    TasklistsResource_PatchMethod* NewPatchMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& tasklist,
        const TaskList& _content_) const;

    TasklistsResource_UpdateMethod* NewUpdateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& tasklist,
        const TaskList& _content_) const;

   private:
    TasksService* service_;

    DISALLOW_COPY_AND_ASSIGN(TasklistsResource);
  };

  class TasksResource {
   public:
    explicit TasksResource(TasksService* service);

    ~TasksResource() {}


    TasksResource_ClearMethod* NewClearMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& tasklist) const;

    TasksResource_DeleteMethod* NewDeleteMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& tasklist,
        const absl::string_view& task) const;

    TasksResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& tasklist,
        const absl::string_view& task) const;

    TasksResource_InsertMethod* NewInsertMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& tasklist,
        const Task& _content_) const;

    TasksResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& tasklist) const;

    TasksResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& tasklist) const;

    TasksResource_MoveMethod* NewMoveMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& tasklist,
        const absl::string_view& task) const;

    TasksResource_PatchMethod* NewPatchMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& tasklist,
        const absl::string_view& task,
        const Task& _content_) const;

    TasksResource_UpdateMethod* NewUpdateMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& tasklist,
        const absl::string_view& task,
        const Task& _content_) const;

   private:
    TasksService* service_;

    DISALLOW_COPY_AND_ASSIGN(TasksResource);
  };



  explicit TasksService(client::HttpTransport* transport);

  virtual ~TasksService();

  const TasklistsResource& get_tasklists() const {
    return tasklists_;
  }


  const TasksResource& get_tasks() const {
    return tasks_;
  }

  class SCOPES {
   public:
    static const char TASKS[];

    static const char TASKS_READONLY[];

   private:
    SCOPES();  // Never instantiated.
    ~SCOPES();  // Never instantiated.
  };

 private:
  TasklistsResource tasklists_;
  TasksResource tasks_;

  DISALLOW_COPY_AND_ASSIGN(TasksService);
};


}  // namespace google_tasks_api
#endif  // GOOGLE_TASKS_API_TASKS_SERVICE_H_