fitness_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-28, 03:09: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_FITNESS_API_FITNESS_SERVICE_H_
#define  GOOGLE_FITNESS_API_FITNESS_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/fitness_api/aggregate_request.h"
#include "google/fitness_api/aggregate_response.h"
#include "google/fitness_api/data_source.h"
#include "google/fitness_api/dataset.h"
#include "google/fitness_api/list_data_point_changes_response.h"
#include "google/fitness_api/list_data_sources_response.h"
#include "google/fitness_api/list_sessions_response.h"
#include "google/fitness_api/session.h"


namespace google_fitness_api {
using namespace googleapis;
class FitnessService;

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

  virtual ~FitnessServiceBaseRequest();


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






class UsersResource_DataSourcesResource_CreateMethod : public FitnessServiceBaseRequest {
 public:
  UsersResource_DataSourcesResource_CreateMethod(
      const FitnessService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_id,
      const DataSource& _content_);

  virtual ~UsersResource_DataSourcesResource_CreateMethod();


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


  util::Status ExecuteAndParseResponse(
      DataSource* data) {
    return FitnessServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_DataSourcesResource_CreateMethod);
};

class UsersResource_DataSourcesResource_DeleteMethod : public FitnessServiceBaseRequest {
 public:
  UsersResource_DataSourcesResource_DeleteMethod(
      const FitnessService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_id,
      const absl::string_view& data_source_id);

  virtual ~UsersResource_DataSourcesResource_DeleteMethod();


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


  util::Status ExecuteAndParseResponse(
      DataSource* data) {
    return FitnessServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_id_;
  string data_source_id_;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_DataSourcesResource_DeleteMethod);
};

class UsersResource_DataSourcesResource_GetMethod : public FitnessServiceBaseRequest {
 public:
  UsersResource_DataSourcesResource_GetMethod(
      const FitnessService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_id,
      const absl::string_view& data_source_id);

  virtual ~UsersResource_DataSourcesResource_GetMethod();


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


  util::Status ExecuteAndParseResponse(
      DataSource* data) {
    return FitnessServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_id_;
  string data_source_id_;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_DataSourcesResource_GetMethod);
};

class UsersResource_DataSourcesResource_ListMethod : public FitnessServiceBaseRequest {
 public:
  UsersResource_DataSourcesResource_ListMethod(
      const FitnessService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_id);

  virtual ~UsersResource_DataSourcesResource_ListMethod();


    void clear_data_type_name() {
      _have_data_type_name_ = false;
      client::ClearCppValueHelper(&data_type_name_);
    }


    const client::JsonCppArray<string >& get_data_type_name() const { return data_type_name_; }

    client::JsonCppArray<string >* mutable_dataTypeName() {
      _have_data_type_name_ = true;
      return &data_type_name_;
    }

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

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


  util::Status ExecuteAndParseResponse(
      ListDataSourcesResponse* data) {
    return FitnessServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_id_;
  client::JsonCppCapsule< client::JsonCppArray<string > > data_type_name_;
  bool _have_data_type_name_ : 1;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_DataSourcesResource_ListMethod);
};

class UsersResource_DataSourcesResource_UpdateMethod : public FitnessServiceBaseRequest {
 public:
  UsersResource_DataSourcesResource_UpdateMethod(
      const FitnessService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_id,
      const absl::string_view& data_source_id,
      const DataSource& _content_);

  virtual ~UsersResource_DataSourcesResource_UpdateMethod();


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


  util::Status ExecuteAndParseResponse(
      DataSource* data) {
    return FitnessServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_id_;
  string data_source_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_DataSourcesResource_UpdateMethod);
};




class UsersResource_DataSourcesResource_DataPointChangesResource_ListMethod : public FitnessServiceBaseRequest {
 public:
  UsersResource_DataSourcesResource_DataPointChangesResource_ListMethod(
      const FitnessService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_id,
      const absl::string_view& data_source_id);

  virtual ~UsersResource_DataSourcesResource_DataPointChangesResource_ListMethod();


    void clear_limit() {
      _have_limit_ = false;
      client::ClearCppValueHelper(&limit_);
    }


    int32 get_limit() const { return limit_; }

    void set_limit(int32 value) {
      _have_limit_ = true;
      limit_ = 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(
      ListDataPointChangesResponse* data) {
    return FitnessServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_id_;
  string data_source_id_;
  int32 limit_;
  string page_token_;
  bool _have_limit_ : 1;
  bool _have_page_token_ : 1;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_DataSourcesResource_DataPointChangesResource_ListMethod);
};

typedef client::ServiceRequestPager<
            UsersResource_DataSourcesResource_DataPointChangesResource_ListMethod,
            ListDataPointChangesResponse>
        UsersResource_DataSourcesResource_DataPointChangesResource_ListMethodPager;


class UsersResource_DataSourcesResource_DatasetsResource_DeleteMethod : public FitnessServiceBaseRequest {
 public:
  UsersResource_DataSourcesResource_DatasetsResource_DeleteMethod(
      const FitnessService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_id,
      const absl::string_view& data_source_id,
      const absl::string_view& dataset_id);

  virtual ~UsersResource_DataSourcesResource_DatasetsResource_DeleteMethod();


    void clear_current_time_millis() {
      _have_current_time_millis_ = false;
      client::ClearCppValueHelper(&current_time_millis_);
    }


    int64 get_current_time_millis() const { return current_time_millis_; }

    void set_current_time_millis(int64 value) {
      _have_current_time_millis_ = true;
      current_time_millis_ = value;
    }

    void clear_modified_time_millis() {
      _have_modified_time_millis_ = false;
      client::ClearCppValueHelper(&modified_time_millis_);
    }


    int64 get_modified_time_millis() const { return modified_time_millis_; }

    void set_modified_time_millis(int64 value) {
      _have_modified_time_millis_ = true;
      modified_time_millis_ = value;
    }

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

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


 private:
  string user_id_;
  string data_source_id_;
  string dataset_id_;
  int64 current_time_millis_;
  int64 modified_time_millis_;
  bool _have_current_time_millis_ : 1;
  bool _have_modified_time_millis_ : 1;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_DataSourcesResource_DatasetsResource_DeleteMethod);
};

class UsersResource_DataSourcesResource_DatasetsResource_GetMethod : public FitnessServiceBaseRequest {
 public:
  UsersResource_DataSourcesResource_DatasetsResource_GetMethod(
      const FitnessService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_id,
      const absl::string_view& data_source_id,
      const absl::string_view& dataset_id);

  virtual ~UsersResource_DataSourcesResource_DatasetsResource_GetMethod();


    void clear_limit() {
      _have_limit_ = false;
      client::ClearCppValueHelper(&limit_);
    }


    int32 get_limit() const { return limit_; }

    void set_limit(int32 value) {
      _have_limit_ = true;
      limit_ = 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(
      Dataset* data) {
    return FitnessServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_id_;
  string data_source_id_;
  string dataset_id_;
  int32 limit_;
  string page_token_;
  bool _have_limit_ : 1;
  bool _have_page_token_ : 1;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_DataSourcesResource_DatasetsResource_GetMethod);
};

typedef client::ServiceRequestPager<
            UsersResource_DataSourcesResource_DatasetsResource_GetMethod,
            Dataset>
        UsersResource_DataSourcesResource_DatasetsResource_GetMethodPager;

class UsersResource_DataSourcesResource_DatasetsResource_PatchMethod : public FitnessServiceBaseRequest {
 public:
  UsersResource_DataSourcesResource_DatasetsResource_PatchMethod(
      const FitnessService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_id,
      const absl::string_view& data_source_id,
      const absl::string_view& dataset_id,
      const Dataset& _content_);

  virtual ~UsersResource_DataSourcesResource_DatasetsResource_PatchMethod();


    void clear_current_time_millis() {
      _have_current_time_millis_ = false;
      client::ClearCppValueHelper(&current_time_millis_);
    }


    int64 get_current_time_millis() const { return current_time_millis_; }

    void set_current_time_millis(int64 value) {
      _have_current_time_millis_ = true;
      current_time_millis_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      Dataset* data) {
    return FitnessServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_id_;
  string data_source_id_;
  string dataset_id_;
  int64 current_time_millis_;
  bool _have_current_time_millis_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_DataSourcesResource_DatasetsResource_PatchMethod);
};

typedef client::ServiceRequestPager<
            UsersResource_DataSourcesResource_DatasetsResource_PatchMethod,
            Dataset>
        UsersResource_DataSourcesResource_DatasetsResource_PatchMethodPager;


class UsersResource_DatasetResource_AggregateMethod : public FitnessServiceBaseRequest {
 public:
  UsersResource_DatasetResource_AggregateMethod(
      const FitnessService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_id,
      const AggregateRequest& _content_);

  virtual ~UsersResource_DatasetResource_AggregateMethod();


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


  util::Status ExecuteAndParseResponse(
      AggregateResponse* data) {
    return FitnessServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_id_;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_DatasetResource_AggregateMethod);
};


class UsersResource_SessionsResource_DeleteMethod : public FitnessServiceBaseRequest {
 public:
  UsersResource_SessionsResource_DeleteMethod(
      const FitnessService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_id,
      const absl::string_view& session_id);

  virtual ~UsersResource_SessionsResource_DeleteMethod();


    void clear_current_time_millis() {
      _have_current_time_millis_ = false;
      client::ClearCppValueHelper(&current_time_millis_);
    }


    int64 get_current_time_millis() const { return current_time_millis_; }

    void set_current_time_millis(int64 value) {
      _have_current_time_millis_ = true;
      current_time_millis_ = value;
    }

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

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


 private:
  string user_id_;
  string session_id_;
  int64 current_time_millis_;
  bool _have_current_time_millis_ : 1;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_SessionsResource_DeleteMethod);
};

class UsersResource_SessionsResource_ListMethod : public FitnessServiceBaseRequest {
 public:
  UsersResource_SessionsResource_ListMethod(
      const FitnessService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_id);

  virtual ~UsersResource_SessionsResource_ListMethod();


    void clear_activity_type() {
      _have_activity_type_ = false;
      client::ClearCppValueHelper(&activity_type_);
    }


    const client::JsonCppArray<int32 >& get_activity_type() const { return activity_type_; }

    client::JsonCppArray<int32 >* mutable_activityType() {
      _have_activity_type_ = true;
      return &activity_type_;
    }



    void clear_end_time() {
      _have_end_time_ = false;
      client::ClearCppValueHelper(&end_time_);
    }


    const string& get_end_time() const { return end_time_; }

    string* mutable_endTime() {
      _have_end_time_ = true;
      return &end_time_;
    }


    void set_end_time(const string& value) {
      _have_end_time_ = true;
      end_time_ = 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_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_start_time() {
      _have_start_time_ = false;
      client::ClearCppValueHelper(&start_time_);
    }


    const string& get_start_time() const { return start_time_; }

    string* mutable_startTime() {
      _have_start_time_ = true;
      return &start_time_;
    }


    void set_start_time(const string& value) {
      _have_start_time_ = true;
      start_time_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      ListSessionsResponse* data) {
    return FitnessServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_id_;
  client::JsonCppCapsule< client::JsonCppArray<int32 > > activity_type_;
  string end_time_;
  bool include_deleted_;
  string page_token_;
  string start_time_;
  bool _have_activity_type_ : 1;
  bool _have_end_time_ : 1;
  bool _have_include_deleted_ : 1;
  bool _have_page_token_ : 1;
  bool _have_start_time_ : 1;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_SessionsResource_ListMethod);
};

typedef client::ServiceRequestPager<
            UsersResource_SessionsResource_ListMethod,
            ListSessionsResponse>
        UsersResource_SessionsResource_ListMethodPager;

class UsersResource_SessionsResource_UpdateMethod : public FitnessServiceBaseRequest {
 public:
  UsersResource_SessionsResource_UpdateMethod(
      const FitnessService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& user_id,
      const absl::string_view& session_id,
      const Session& _content_);

  virtual ~UsersResource_SessionsResource_UpdateMethod();


    void clear_current_time_millis() {
      _have_current_time_millis_ = false;
      client::ClearCppValueHelper(&current_time_millis_);
    }


    int64 get_current_time_millis() const { return current_time_millis_; }

    void set_current_time_millis(int64 value) {
      _have_current_time_millis_ = true;
      current_time_millis_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      Session* data) {
    return FitnessServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string user_id_;
  string session_id_;
  int64 current_time_millis_;
  bool _have_current_time_millis_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(UsersResource_SessionsResource_UpdateMethod);
};



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

  static const char googleapis_API_VERSION[];

  static const char googleapis_API_GENERATOR[];


  class UsersResource {
   public:
    explicit UsersResource(FitnessService* service);

    ~UsersResource() {}

    class DataSourcesResource {
     public:
      explicit DataSourcesResource(FitnessService* service);

      ~DataSourcesResource() {}

      class DataPointChangesResource {
       public:
        explicit DataPointChangesResource(FitnessService* service);

        ~DataPointChangesResource() {}


        UsersResource_DataSourcesResource_DataPointChangesResource_ListMethod* NewListMethod(
            client::AuthorizationCredential* _credential_,
            const absl::string_view& user_id,
            const absl::string_view& data_source_id) const;

        UsersResource_DataSourcesResource_DataPointChangesResource_ListMethodPager* NewListMethodPager(
            client::AuthorizationCredential* _credential_,
            const absl::string_view& user_id,
            const absl::string_view& data_source_id) const;

       private:
        FitnessService* service_;

        DISALLOW_COPY_AND_ASSIGN(DataPointChangesResource);
      };
      const DataPointChangesResource& get_data_point_changes() const {
        return data_point_changes_;
      }


      class DatasetsResource {
       public:
        explicit DatasetsResource(FitnessService* service);

        ~DatasetsResource() {}


        UsersResource_DataSourcesResource_DatasetsResource_DeleteMethod* NewDeleteMethod(
            client::AuthorizationCredential* _credential_,
            const absl::string_view& user_id,
            const absl::string_view& data_source_id,
            const absl::string_view& dataset_id) const;

        UsersResource_DataSourcesResource_DatasetsResource_GetMethod* NewGetMethod(
            client::AuthorizationCredential* _credential_,
            const absl::string_view& user_id,
            const absl::string_view& data_source_id,
            const absl::string_view& dataset_id) const;

        UsersResource_DataSourcesResource_DatasetsResource_GetMethodPager* NewGetMethodPager(
            client::AuthorizationCredential* _credential_,
            const absl::string_view& user_id,
            const absl::string_view& data_source_id,
            const absl::string_view& dataset_id) const;

        UsersResource_DataSourcesResource_DatasetsResource_PatchMethod* NewPatchMethod(
            client::AuthorizationCredential* _credential_,
            const absl::string_view& user_id,
            const absl::string_view& data_source_id,
            const absl::string_view& dataset_id,
            const Dataset& _content_) const;

        UsersResource_DataSourcesResource_DatasetsResource_PatchMethodPager* NewPatchMethodPager(
            client::AuthorizationCredential* _credential_,
            const absl::string_view& user_id,
            const absl::string_view& data_source_id,
            const absl::string_view& dataset_id,
            const Dataset& _content_) const;

       private:
        FitnessService* service_;

        DISALLOW_COPY_AND_ASSIGN(DatasetsResource);
      };
      const DatasetsResource& get_datasets() const {
        return datasets_;
      }



      UsersResource_DataSourcesResource_CreateMethod* NewCreateMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& user_id,
          const DataSource& _content_) const;

      UsersResource_DataSourcesResource_DeleteMethod* NewDeleteMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& user_id,
          const absl::string_view& data_source_id) const;

      UsersResource_DataSourcesResource_GetMethod* NewGetMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& user_id,
          const absl::string_view& data_source_id) const;

      UsersResource_DataSourcesResource_ListMethod* NewListMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& user_id) const;

      UsersResource_DataSourcesResource_UpdateMethod* NewUpdateMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& user_id,
          const absl::string_view& data_source_id,
          const DataSource& _content_) const;

     private:
      FitnessService* service_;
      DataPointChangesResource data_point_changes_;
      DatasetsResource datasets_;

      DISALLOW_COPY_AND_ASSIGN(DataSourcesResource);
    };
    const DataSourcesResource& get_data_sources() const {
      return data_sources_;
    }


    class DatasetResource {
     public:
      explicit DatasetResource(FitnessService* service);

      ~DatasetResource() {}


      UsersResource_DatasetResource_AggregateMethod* NewAggregateMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& user_id,
          const AggregateRequest& _content_) const;

     private:
      FitnessService* service_;

      DISALLOW_COPY_AND_ASSIGN(DatasetResource);
    };
    const DatasetResource& get_dataset() const {
      return dataset_;
    }


    class SessionsResource {
     public:
      explicit SessionsResource(FitnessService* service);

      ~SessionsResource() {}


      UsersResource_SessionsResource_DeleteMethod* NewDeleteMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& user_id,
          const absl::string_view& session_id) const;

      UsersResource_SessionsResource_ListMethod* NewListMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& user_id) const;

      UsersResource_SessionsResource_ListMethodPager* NewListMethodPager(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& user_id) const;

      UsersResource_SessionsResource_UpdateMethod* NewUpdateMethod(
          client::AuthorizationCredential* _credential_,
          const absl::string_view& user_id,
          const absl::string_view& session_id,
          const Session& _content_) const;

     private:
      FitnessService* service_;

      DISALLOW_COPY_AND_ASSIGN(SessionsResource);
    };
    const SessionsResource& get_sessions() const {
      return sessions_;
    }



   private:
    FitnessService* service_;
    DataSourcesResource data_sources_;
    DatasetResource dataset_;
    SessionsResource sessions_;

    DISALLOW_COPY_AND_ASSIGN(UsersResource);
  };



  explicit FitnessService(client::HttpTransport* transport);

  virtual ~FitnessService();

  const UsersResource& get_users() const {
    return users_;
  }

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

    static const char FITNESS_ACTIVITY_WRITE[];

    static const char FITNESS_BLOOD_GLUCOSE_READ[];

    static const char FITNESS_BLOOD_GLUCOSE_WRITE[];

    static const char FITNESS_BLOOD_PRESSURE_READ[];

    static const char FITNESS_BLOOD_PRESSURE_WRITE[];

    static const char FITNESS_BODY_READ[];

    static const char FITNESS_BODY_WRITE[];

    static const char FITNESS_BODY_TEMPERATURE_READ[];

    static const char FITNESS_BODY_TEMPERATURE_WRITE[];

    static const char FITNESS_LOCATION_READ[];

    static const char FITNESS_LOCATION_WRITE[];

    static const char FITNESS_NUTRITION_READ[];

    static const char FITNESS_NUTRITION_WRITE[];

    static const char FITNESS_OXYGEN_SATURATION_READ[];

    static const char FITNESS_OXYGEN_SATURATION_WRITE[];

    static const char FITNESS_REPRODUCTIVE_HEALTH_READ[];

    static const char FITNESS_REPRODUCTIVE_HEALTH_WRITE[];

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

 private:
  UsersResource users_;

  DISALLOW_COPY_AND_ASSIGN(FitnessService);
};


}  // namespace google_fitness_api
#endif  // GOOGLE_FITNESS_API_FITNESS_SERVICE_H_