games_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-07, 08:12:42 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_GAMES_API_GAMES_SERVICE_H_
#define  GOOGLE_GAMES_API_GAMES_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/games_api/achievement_definitions_list_response.h"
#include "google/games_api/achievement_increment_response.h"
#include "google/games_api/achievement_reveal_response.h"
#include "google/games_api/achievement_set_steps_at_least_response.h"
#include "google/games_api/achievement_unlock_response.h"
#include "google/games_api/achievement_update_multiple_request.h"
#include "google/games_api/achievement_update_multiple_response.h"
#include "google/games_api/application.h"
#include "google/games_api/application_verify_response.h"
#include "google/games_api/category_list_response.h"
#include "google/games_api/event_definition_list_response.h"
#include "google/games_api/event_record_request.h"
#include "google/games_api/event_update_response.h"
#include "google/games_api/leaderboard.h"
#include "google/games_api/leaderboard_list_response.h"
#include "google/games_api/leaderboard_scores.h"
#include "google/games_api/metagame_config.h"
#include "google/games_api/player.h"
#include "google/games_api/player_achievement_list_response.h"
#include "google/games_api/player_event_list_response.h"
#include "google/games_api/player_leaderboard_score_list_response.h"
#include "google/games_api/player_list_response.h"
#include "google/games_api/player_score_list_response.h"
#include "google/games_api/player_score_response.h"
#include "google/games_api/player_score_submission_list.h"
#include "google/games_api/push_token.h"
#include "google/games_api/push_token_id.h"
#include "google/games_api/revision_check_response.h"
#include "google/games_api/room.h"
#include "google/games_api/room_create_request.h"
#include "google/games_api/room_join_request.h"
#include "google/games_api/room_leave_request.h"
#include "google/games_api/room_list.h"
#include "google/games_api/room_p2_ps_tatuses.h"
#include "google/games_api/room_status.h"
#include "google/games_api/snapshot.h"
#include "google/games_api/snapshot_list_response.h"
#include "google/games_api/turn_based_match.h"
#include "google/games_api/turn_based_match_create_request.h"
#include "google/games_api/turn_based_match_list.h"
#include "google/games_api/turn_based_match_rematch.h"
#include "google/games_api/turn_based_match_results.h"
#include "google/games_api/turn_based_match_sync.h"
#include "google/games_api/turn_based_match_turn.h"


namespace google_games_api {
using namespace googleapis;
class GamesService;

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

  virtual ~GamesServiceBaseRequest();


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



class AchievementDefinitionsResource_ListMethod : public GamesServiceBaseRequest {
 public:
  AchievementDefinitionsResource_ListMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~AchievementDefinitionsResource_ListMethod();


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


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

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


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



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


    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(
      AchievementDefinitionsListResponse* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string language_;
  int32 max_results_;
  string page_token_;
  bool _have_language_ : 1;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  DISALLOW_COPY_AND_ASSIGN(AchievementDefinitionsResource_ListMethod);
};

typedef client::ServiceRequestPager<
            AchievementDefinitionsResource_ListMethod,
            AchievementDefinitionsListResponse>
        AchievementDefinitionsResource_ListMethodPager;



class AchievementsResource_IncrementMethod : public GamesServiceBaseRequest {
 public:
  AchievementsResource_IncrementMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& achievement_id,
      const int32& steps_to_increment);

  virtual ~AchievementsResource_IncrementMethod();


    void clear_request_id() {
      _have_request_id_ = false;
      client::ClearCppValueHelper(&request_id_);
    }


    int64 get_request_id() const { return request_id_; }

    void set_request_id(int64 value) {
      _have_request_id_ = true;
      request_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(
      AchievementIncrementResponse* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string achievement_id_;
  int32 steps_to_increment_;
  int64 request_id_;
  bool _have_request_id_ : 1;
  DISALLOW_COPY_AND_ASSIGN(AchievementsResource_IncrementMethod);
};

class AchievementsResource_ListMethod : public GamesServiceBaseRequest {
 public:
  AchievementsResource_ListMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& player_id);

  virtual ~AchievementsResource_ListMethod();


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


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

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


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



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


    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_state() {
      _have_state_ = false;
      client::ClearCppValueHelper(&state_);
    }


    const string& get_state() const { return state_; }

    string* mutable_state() {
      _have_state_ = true;
      return &state_;
    }


    void set_state(const string& value) {
      _have_state_ = true;
      state_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      PlayerAchievementListResponse* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string player_id_;
  string language_;
  int32 max_results_;
  string page_token_;
  string state_;
  bool _have_language_ : 1;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  bool _have_state_ : 1;
  DISALLOW_COPY_AND_ASSIGN(AchievementsResource_ListMethod);
};

typedef client::ServiceRequestPager<
            AchievementsResource_ListMethod,
            PlayerAchievementListResponse>
        AchievementsResource_ListMethodPager;

class AchievementsResource_RevealMethod : public GamesServiceBaseRequest {
 public:
  AchievementsResource_RevealMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& achievement_id);

  virtual ~AchievementsResource_RevealMethod();


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


  util::Status ExecuteAndParseResponse(
      AchievementRevealResponse* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string achievement_id_;
  DISALLOW_COPY_AND_ASSIGN(AchievementsResource_RevealMethod);
};

class AchievementsResource_SetStepsAtLeastMethod : public GamesServiceBaseRequest {
 public:
  AchievementsResource_SetStepsAtLeastMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& achievement_id,
      const int32& steps);

  virtual ~AchievementsResource_SetStepsAtLeastMethod();


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

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


  util::Status ExecuteAndParseResponse(
      AchievementSetStepsAtLeastResponse* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string achievement_id_;
  int32 steps_;
  DISALLOW_COPY_AND_ASSIGN(AchievementsResource_SetStepsAtLeastMethod);
};

class AchievementsResource_UnlockMethod : public GamesServiceBaseRequest {
 public:
  AchievementsResource_UnlockMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& achievement_id);

  virtual ~AchievementsResource_UnlockMethod();


    void clear_builtin_game_id() {
      _have_builtin_game_id_ = false;
      client::ClearCppValueHelper(&builtin_game_id_);
    }


    const string& get_builtin_game_id() const { return builtin_game_id_; }

    string* mutable_builtinGameId() {
      _have_builtin_game_id_ = true;
      return &builtin_game_id_;
    }


    void set_builtin_game_id(const string& value) {
      _have_builtin_game_id_ = true;
      builtin_game_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(
      AchievementUnlockResponse* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string achievement_id_;
  string builtin_game_id_;
  bool _have_builtin_game_id_ : 1;
  DISALLOW_COPY_AND_ASSIGN(AchievementsResource_UnlockMethod);
};

class AchievementsResource_UpdateMultipleMethod : public GamesServiceBaseRequest {
 public:
  AchievementsResource_UpdateMultipleMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const AchievementUpdateMultipleRequest& _content_);

  virtual ~AchievementsResource_UpdateMultipleMethod();


    void clear_builtin_game_id() {
      _have_builtin_game_id_ = false;
      client::ClearCppValueHelper(&builtin_game_id_);
    }


    const string& get_builtin_game_id() const { return builtin_game_id_; }

    string* mutable_builtinGameId() {
      _have_builtin_game_id_ = true;
      return &builtin_game_id_;
    }


    void set_builtin_game_id(const string& value) {
      _have_builtin_game_id_ = true;
      builtin_game_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(
      AchievementUpdateMultipleResponse* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string builtin_game_id_;
  bool _have_builtin_game_id_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(AchievementsResource_UpdateMultipleMethod);
};



class ApplicationsResource_GetMethod : public GamesServiceBaseRequest {
 public:
  ApplicationsResource_GetMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& application_id);

  virtual ~ApplicationsResource_GetMethod();


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


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

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


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



    void clear_platform_type() {
      _have_platform_type_ = false;
      client::ClearCppValueHelper(&platform_type_);
    }


    const string& get_platform_type() const { return platform_type_; }

    string* mutable_platformType() {
      _have_platform_type_ = true;
      return &platform_type_;
    }


    void set_platform_type(const string& value) {
      _have_platform_type_ = true;
      platform_type_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      Application* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string application_id_;
  string language_;
  string platform_type_;
  bool _have_language_ : 1;
  bool _have_platform_type_ : 1;
  DISALLOW_COPY_AND_ASSIGN(ApplicationsResource_GetMethod);
};

class ApplicationsResource_PlayedMethod : public GamesServiceBaseRequest {
 public:
  ApplicationsResource_PlayedMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~ApplicationsResource_PlayedMethod();


    void clear_builtin_game_id() {
      _have_builtin_game_id_ = false;
      client::ClearCppValueHelper(&builtin_game_id_);
    }


    const string& get_builtin_game_id() const { return builtin_game_id_; }

    string* mutable_builtinGameId() {
      _have_builtin_game_id_ = true;
      return &builtin_game_id_;
    }


    void set_builtin_game_id(const string& value) {
      _have_builtin_game_id_ = true;
      builtin_game_id_ = value;
    }

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

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


 private:
  string builtin_game_id_;
  bool _have_builtin_game_id_ : 1;
  DISALLOW_COPY_AND_ASSIGN(ApplicationsResource_PlayedMethod);
};

class ApplicationsResource_VerifyMethod : public GamesServiceBaseRequest {
 public:
  ApplicationsResource_VerifyMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& application_id);

  virtual ~ApplicationsResource_VerifyMethod();


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


  util::Status ExecuteAndParseResponse(
      ApplicationVerifyResponse* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string application_id_;
  DISALLOW_COPY_AND_ASSIGN(ApplicationsResource_VerifyMethod);
};



class EventsResource_ListByPlayerMethod : public GamesServiceBaseRequest {
 public:
  EventsResource_ListByPlayerMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~EventsResource_ListByPlayerMethod();


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


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

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


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



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


    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(
      PlayerEventListResponse* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string language_;
  int32 max_results_;
  string page_token_;
  bool _have_language_ : 1;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  DISALLOW_COPY_AND_ASSIGN(EventsResource_ListByPlayerMethod);
};

typedef client::ServiceRequestPager<
            EventsResource_ListByPlayerMethod,
            PlayerEventListResponse>
        EventsResource_ListByPlayerMethodPager;

class EventsResource_ListDefinitionsMethod : public GamesServiceBaseRequest {
 public:
  EventsResource_ListDefinitionsMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~EventsResource_ListDefinitionsMethod();


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


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

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


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



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


    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(
      EventDefinitionListResponse* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string language_;
  int32 max_results_;
  string page_token_;
  bool _have_language_ : 1;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  DISALLOW_COPY_AND_ASSIGN(EventsResource_ListDefinitionsMethod);
};

typedef client::ServiceRequestPager<
            EventsResource_ListDefinitionsMethod,
            EventDefinitionListResponse>
        EventsResource_ListDefinitionsMethodPager;

class EventsResource_RecordMethod : public GamesServiceBaseRequest {
 public:
  EventsResource_RecordMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const EventRecordRequest& _content_);

  virtual ~EventsResource_RecordMethod();


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


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

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


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

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

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


  util::Status ExecuteAndParseResponse(
      EventUpdateResponse* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string language_;
  bool _have_language_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(EventsResource_RecordMethod);
};



class LeaderboardsResource_GetMethod : public GamesServiceBaseRequest {
 public:
  LeaderboardsResource_GetMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& leaderboard_id);

  virtual ~LeaderboardsResource_GetMethod();


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


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

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


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

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

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


  util::Status ExecuteAndParseResponse(
      Leaderboard* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string leaderboard_id_;
  string language_;
  bool _have_language_ : 1;
  DISALLOW_COPY_AND_ASSIGN(LeaderboardsResource_GetMethod);
};

class LeaderboardsResource_ListMethod : public GamesServiceBaseRequest {
 public:
  LeaderboardsResource_ListMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~LeaderboardsResource_ListMethod();


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


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

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


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



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


    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(
      LeaderboardListResponse* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string language_;
  int32 max_results_;
  string page_token_;
  bool _have_language_ : 1;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  DISALLOW_COPY_AND_ASSIGN(LeaderboardsResource_ListMethod);
};

typedef client::ServiceRequestPager<
            LeaderboardsResource_ListMethod,
            LeaderboardListResponse>
        LeaderboardsResource_ListMethodPager;



class MetagameResource_GetMetagameConfigMethod : public GamesServiceBaseRequest {
 public:
  MetagameResource_GetMetagameConfigMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~MetagameResource_GetMetagameConfigMethod();

  util::Status ExecuteAndParseResponse(
      MetagameConfig* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  DISALLOW_COPY_AND_ASSIGN(MetagameResource_GetMetagameConfigMethod);
};

class MetagameResource_ListCategoriesByPlayerMethod : public GamesServiceBaseRequest {
 public:
  MetagameResource_ListCategoriesByPlayerMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& player_id,
      const absl::string_view& collection);

  virtual ~MetagameResource_ListCategoriesByPlayerMethod();


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


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

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


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



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


    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(
      CategoryListResponse* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string player_id_;
  string collection_;
  string language_;
  int32 max_results_;
  string page_token_;
  bool _have_language_ : 1;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  DISALLOW_COPY_AND_ASSIGN(MetagameResource_ListCategoriesByPlayerMethod);
};

typedef client::ServiceRequestPager<
            MetagameResource_ListCategoriesByPlayerMethod,
            CategoryListResponse>
        MetagameResource_ListCategoriesByPlayerMethodPager;



class PlayersResource_GetMethod : public GamesServiceBaseRequest {
 public:
  PlayersResource_GetMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& player_id);

  virtual ~PlayersResource_GetMethod();


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


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

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


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

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

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


  util::Status ExecuteAndParseResponse(
      Player* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string player_id_;
  string language_;
  bool _have_language_ : 1;
  DISALLOW_COPY_AND_ASSIGN(PlayersResource_GetMethod);
};

class PlayersResource_ListMethod : public GamesServiceBaseRequest {
 public:
  PlayersResource_ListMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& collection);

  virtual ~PlayersResource_ListMethod();


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


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

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


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



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


    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(
      PlayerListResponse* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string collection_;
  string language_;
  int32 max_results_;
  string page_token_;
  bool _have_language_ : 1;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  DISALLOW_COPY_AND_ASSIGN(PlayersResource_ListMethod);
};

typedef client::ServiceRequestPager<
            PlayersResource_ListMethod,
            PlayerListResponse>
        PlayersResource_ListMethodPager;



class PushtokensResource_RemoveMethod : public GamesServiceBaseRequest {
 public:
  PushtokensResource_RemoveMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const PushTokenId& _content_);

  virtual ~PushtokensResource_RemoveMethod();

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

class PushtokensResource_UpdateMethod : public GamesServiceBaseRequest {
 public:
  PushtokensResource_UpdateMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const PushToken& _content_);

  virtual ~PushtokensResource_UpdateMethod();

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



class RevisionsResource_CheckMethod : public GamesServiceBaseRequest {
 public:
  RevisionsResource_CheckMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& client_revision);

  virtual ~RevisionsResource_CheckMethod();


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

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


  util::Status ExecuteAndParseResponse(
      RevisionCheckResponse* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string client_revision_;
  DISALLOW_COPY_AND_ASSIGN(RevisionsResource_CheckMethod);
};



class RoomsResource_CreateMethod : public GamesServiceBaseRequest {
 public:
  RoomsResource_CreateMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const RoomCreateRequest& _content_);

  virtual ~RoomsResource_CreateMethod();


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


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

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


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

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

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


  util::Status ExecuteAndParseResponse(
      Room* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string language_;
  bool _have_language_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(RoomsResource_CreateMethod);
};

class RoomsResource_DeclineMethod : public GamesServiceBaseRequest {
 public:
  RoomsResource_DeclineMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& room_id);

  virtual ~RoomsResource_DeclineMethod();


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


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

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


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

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

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


  util::Status ExecuteAndParseResponse(
      Room* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string room_id_;
  string language_;
  bool _have_language_ : 1;
  DISALLOW_COPY_AND_ASSIGN(RoomsResource_DeclineMethod);
};

class RoomsResource_DismissMethod : public GamesServiceBaseRequest {
 public:
  RoomsResource_DismissMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& room_id);

  virtual ~RoomsResource_DismissMethod();


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


 private:
  string room_id_;
  DISALLOW_COPY_AND_ASSIGN(RoomsResource_DismissMethod);
};

class RoomsResource_GetMethod : public GamesServiceBaseRequest {
 public:
  RoomsResource_GetMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& room_id);

  virtual ~RoomsResource_GetMethod();


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


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

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


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

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

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


  util::Status ExecuteAndParseResponse(
      Room* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string room_id_;
  string language_;
  bool _have_language_ : 1;
  DISALLOW_COPY_AND_ASSIGN(RoomsResource_GetMethod);
};

class RoomsResource_JoinMethod : public GamesServiceBaseRequest {
 public:
  RoomsResource_JoinMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& room_id,
      const RoomJoinRequest& _content_);

  virtual ~RoomsResource_JoinMethod();


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


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

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


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

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

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


  util::Status ExecuteAndParseResponse(
      Room* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string room_id_;
  string language_;
  bool _have_language_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(RoomsResource_JoinMethod);
};

class RoomsResource_LeaveMethod : public GamesServiceBaseRequest {
 public:
  RoomsResource_LeaveMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& room_id,
      const RoomLeaveRequest& _content_);

  virtual ~RoomsResource_LeaveMethod();


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


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

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


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

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

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


  util::Status ExecuteAndParseResponse(
      Room* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string room_id_;
  string language_;
  bool _have_language_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(RoomsResource_LeaveMethod);
};

class RoomsResource_ListMethod : public GamesServiceBaseRequest {
 public:
  RoomsResource_ListMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~RoomsResource_ListMethod();


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


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

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


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



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


    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(
      RoomList* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string language_;
  int32 max_results_;
  string page_token_;
  bool _have_language_ : 1;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  DISALLOW_COPY_AND_ASSIGN(RoomsResource_ListMethod);
};

typedef client::ServiceRequestPager<
            RoomsResource_ListMethod,
            RoomList>
        RoomsResource_ListMethodPager;

class RoomsResource_ReportStatusMethod : public GamesServiceBaseRequest {
 public:
  RoomsResource_ReportStatusMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& room_id,
      const RoomP2PStatuses& _content_);

  virtual ~RoomsResource_ReportStatusMethod();


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


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

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


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

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

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


  util::Status ExecuteAndParseResponse(
      RoomStatus* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string room_id_;
  string language_;
  bool _have_language_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(RoomsResource_ReportStatusMethod);
};



class ScoresResource_GetMethod : public GamesServiceBaseRequest {
 public:
  ScoresResource_GetMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& player_id,
      const absl::string_view& leaderboard_id,
      const absl::string_view& time_span);

  virtual ~ScoresResource_GetMethod();


    void clear_include_rank_type() {
      _have_include_rank_type_ = false;
      client::ClearCppValueHelper(&include_rank_type_);
    }


    const string& get_include_rank_type() const { return include_rank_type_; }

    string* mutable_includeRankType() {
      _have_include_rank_type_ = true;
      return &include_rank_type_;
    }


    void set_include_rank_type(const string& value) {
      _have_include_rank_type_ = true;
      include_rank_type_ = value;
    }



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


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

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


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



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


    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(
      PlayerLeaderboardScoreListResponse* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string player_id_;
  string leaderboard_id_;
  string time_span_;
  string include_rank_type_;
  string language_;
  int32 max_results_;
  string page_token_;
  bool _have_include_rank_type_ : 1;
  bool _have_language_ : 1;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  DISALLOW_COPY_AND_ASSIGN(ScoresResource_GetMethod);
};

typedef client::ServiceRequestPager<
            ScoresResource_GetMethod,
            PlayerLeaderboardScoreListResponse>
        ScoresResource_GetMethodPager;

class ScoresResource_ListMethod : public GamesServiceBaseRequest {
 public:
  ScoresResource_ListMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& leaderboard_id,
      const absl::string_view& collection,
      const absl::string_view& time_span);

  virtual ~ScoresResource_ListMethod();


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


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

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


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



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


    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(
      LeaderboardScores* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string leaderboard_id_;
  string collection_;
  string time_span_;
  string language_;
  int32 max_results_;
  string page_token_;
  bool _have_language_ : 1;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  DISALLOW_COPY_AND_ASSIGN(ScoresResource_ListMethod);
};

typedef client::ServiceRequestPager<
            ScoresResource_ListMethod,
            LeaderboardScores>
        ScoresResource_ListMethodPager;

class ScoresResource_ListWindowMethod : public GamesServiceBaseRequest {
 public:
  ScoresResource_ListWindowMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& leaderboard_id,
      const absl::string_view& collection,
      const absl::string_view& time_span);

  virtual ~ScoresResource_ListWindowMethod();


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


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

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


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



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


    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_results_above() {
      _have_results_above_ = false;
      client::ClearCppValueHelper(&results_above_);
    }


    int32 get_results_above() const { return results_above_; }

    void set_results_above(int32 value) {
      _have_results_above_ = true;
      results_above_ = value;
    }

    void clear_return_top_if_absent() {
      _have_return_top_if_absent_ = false;
      client::ClearCppValueHelper(&return_top_if_absent_);
    }


    bool get_return_top_if_absent() const { return return_top_if_absent_; }

    void set_return_top_if_absent(bool value) {
      _have_return_top_if_absent_ = true;
      return_top_if_absent_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      LeaderboardScores* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string leaderboard_id_;
  string collection_;
  string time_span_;
  string language_;
  int32 max_results_;
  string page_token_;
  int32 results_above_;
  bool return_top_if_absent_;
  bool _have_language_ : 1;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  bool _have_results_above_ : 1;
  bool _have_return_top_if_absent_ : 1;
  DISALLOW_COPY_AND_ASSIGN(ScoresResource_ListWindowMethod);
};

typedef client::ServiceRequestPager<
            ScoresResource_ListWindowMethod,
            LeaderboardScores>
        ScoresResource_ListWindowMethodPager;

class ScoresResource_SubmitMethod : public GamesServiceBaseRequest {
 public:
  ScoresResource_SubmitMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& leaderboard_id,
      const int64& score);

  virtual ~ScoresResource_SubmitMethod();


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


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

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


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



    void clear_score_tag() {
      _have_score_tag_ = false;
      client::ClearCppValueHelper(&score_tag_);
    }


    const string& get_score_tag() const { return score_tag_; }

    string* mutable_scoreTag() {
      _have_score_tag_ = true;
      return &score_tag_;
    }


    void set_score_tag(const string& value) {
      _have_score_tag_ = true;
      score_tag_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      PlayerScoreResponse* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string leaderboard_id_;
  int64 score_;
  string language_;
  string score_tag_;
  bool _have_language_ : 1;
  bool _have_score_tag_ : 1;
  DISALLOW_COPY_AND_ASSIGN(ScoresResource_SubmitMethod);
};

class ScoresResource_SubmitMultipleMethod : public GamesServiceBaseRequest {
 public:
  ScoresResource_SubmitMultipleMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const PlayerScoreSubmissionList& _content_);

  virtual ~ScoresResource_SubmitMultipleMethod();


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


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

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


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

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

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


  util::Status ExecuteAndParseResponse(
      PlayerScoreListResponse* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string language_;
  bool _have_language_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(ScoresResource_SubmitMultipleMethod);
};



class SnapshotsResource_GetMethod : public GamesServiceBaseRequest {
 public:
  SnapshotsResource_GetMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& snapshot_id);

  virtual ~SnapshotsResource_GetMethod();


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


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

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


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

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

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


  util::Status ExecuteAndParseResponse(
      Snapshot* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string snapshot_id_;
  string language_;
  bool _have_language_ : 1;
  DISALLOW_COPY_AND_ASSIGN(SnapshotsResource_GetMethod);
};

class SnapshotsResource_ListMethod : public GamesServiceBaseRequest {
 public:
  SnapshotsResource_ListMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& player_id);

  virtual ~SnapshotsResource_ListMethod();


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


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

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


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



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


    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(
      SnapshotListResponse* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string player_id_;
  string language_;
  int32 max_results_;
  string page_token_;
  bool _have_language_ : 1;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  DISALLOW_COPY_AND_ASSIGN(SnapshotsResource_ListMethod);
};

typedef client::ServiceRequestPager<
            SnapshotsResource_ListMethod,
            SnapshotListResponse>
        SnapshotsResource_ListMethodPager;



class TurnBasedMatchesResource_CancelMethod : public GamesServiceBaseRequest {
 public:
  TurnBasedMatchesResource_CancelMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& match_id);

  virtual ~TurnBasedMatchesResource_CancelMethod();


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


 private:
  string match_id_;
  DISALLOW_COPY_AND_ASSIGN(TurnBasedMatchesResource_CancelMethod);
};

class TurnBasedMatchesResource_CreateMethod : public GamesServiceBaseRequest {
 public:
  TurnBasedMatchesResource_CreateMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const TurnBasedMatchCreateRequest& _content_);

  virtual ~TurnBasedMatchesResource_CreateMethod();


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


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

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


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

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

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


  util::Status ExecuteAndParseResponse(
      TurnBasedMatch* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string language_;
  bool _have_language_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(TurnBasedMatchesResource_CreateMethod);
};

class TurnBasedMatchesResource_DeclineMethod : public GamesServiceBaseRequest {
 public:
  TurnBasedMatchesResource_DeclineMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& match_id);

  virtual ~TurnBasedMatchesResource_DeclineMethod();


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


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

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


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

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

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


  util::Status ExecuteAndParseResponse(
      TurnBasedMatch* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string match_id_;
  string language_;
  bool _have_language_ : 1;
  DISALLOW_COPY_AND_ASSIGN(TurnBasedMatchesResource_DeclineMethod);
};

class TurnBasedMatchesResource_DismissMethod : public GamesServiceBaseRequest {
 public:
  TurnBasedMatchesResource_DismissMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& match_id);

  virtual ~TurnBasedMatchesResource_DismissMethod();


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


 private:
  string match_id_;
  DISALLOW_COPY_AND_ASSIGN(TurnBasedMatchesResource_DismissMethod);
};

class TurnBasedMatchesResource_FinishMethod : public GamesServiceBaseRequest {
 public:
  TurnBasedMatchesResource_FinishMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& match_id,
      const TurnBasedMatchResults& _content_);

  virtual ~TurnBasedMatchesResource_FinishMethod();


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


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

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


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

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

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


  util::Status ExecuteAndParseResponse(
      TurnBasedMatch* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string match_id_;
  string language_;
  bool _have_language_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(TurnBasedMatchesResource_FinishMethod);
};

class TurnBasedMatchesResource_GetMethod : public GamesServiceBaseRequest {
 public:
  TurnBasedMatchesResource_GetMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& match_id);

  virtual ~TurnBasedMatchesResource_GetMethod();


    void clear_include_match_data() {
      _have_include_match_data_ = false;
      client::ClearCppValueHelper(&include_match_data_);
    }


    bool get_include_match_data() const { return include_match_data_; }

    void set_include_match_data(bool value) {
      _have_include_match_data_ = true;
      include_match_data_ = value;
    }

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


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

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


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

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

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


  util::Status ExecuteAndParseResponse(
      TurnBasedMatch* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string match_id_;
  bool include_match_data_;
  string language_;
  bool _have_include_match_data_ : 1;
  bool _have_language_ : 1;
  DISALLOW_COPY_AND_ASSIGN(TurnBasedMatchesResource_GetMethod);
};

class TurnBasedMatchesResource_JoinMethod : public GamesServiceBaseRequest {
 public:
  TurnBasedMatchesResource_JoinMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& match_id);

  virtual ~TurnBasedMatchesResource_JoinMethod();


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


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

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


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

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

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


  util::Status ExecuteAndParseResponse(
      TurnBasedMatch* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string match_id_;
  string language_;
  bool _have_language_ : 1;
  DISALLOW_COPY_AND_ASSIGN(TurnBasedMatchesResource_JoinMethod);
};

class TurnBasedMatchesResource_LeaveMethod : public GamesServiceBaseRequest {
 public:
  TurnBasedMatchesResource_LeaveMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& match_id);

  virtual ~TurnBasedMatchesResource_LeaveMethod();


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


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

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


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

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

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


  util::Status ExecuteAndParseResponse(
      TurnBasedMatch* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string match_id_;
  string language_;
  bool _have_language_ : 1;
  DISALLOW_COPY_AND_ASSIGN(TurnBasedMatchesResource_LeaveMethod);
};

class TurnBasedMatchesResource_LeaveTurnMethod : public GamesServiceBaseRequest {
 public:
  TurnBasedMatchesResource_LeaveTurnMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& match_id,
      const int32& match_version);

  virtual ~TurnBasedMatchesResource_LeaveTurnMethod();


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


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

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


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



    void clear_pending_participant_id() {
      _have_pending_participant_id_ = false;
      client::ClearCppValueHelper(&pending_participant_id_);
    }


    const string& get_pending_participant_id() const { return pending_participant_id_; }

    string* mutable_pendingParticipantId() {
      _have_pending_participant_id_ = true;
      return &pending_participant_id_;
    }


    void set_pending_participant_id(const string& value) {
      _have_pending_participant_id_ = true;
      pending_participant_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(
      TurnBasedMatch* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string match_id_;
  int32 match_version_;
  string language_;
  string pending_participant_id_;
  bool _have_language_ : 1;
  bool _have_pending_participant_id_ : 1;
  DISALLOW_COPY_AND_ASSIGN(TurnBasedMatchesResource_LeaveTurnMethod);
};

class TurnBasedMatchesResource_ListMethod : public GamesServiceBaseRequest {
 public:
  TurnBasedMatchesResource_ListMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~TurnBasedMatchesResource_ListMethod();


    void clear_include_match_data() {
      _have_include_match_data_ = false;
      client::ClearCppValueHelper(&include_match_data_);
    }


    bool get_include_match_data() const { return include_match_data_; }

    void set_include_match_data(bool value) {
      _have_include_match_data_ = true;
      include_match_data_ = value;
    }

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


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

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


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



    void clear_max_completed_matches() {
      _have_max_completed_matches_ = false;
      client::ClearCppValueHelper(&max_completed_matches_);
    }


    int32 get_max_completed_matches() const { return max_completed_matches_; }

    void set_max_completed_matches(int32 value) {
      _have_max_completed_matches_ = true;
      max_completed_matches_ = 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(
      TurnBasedMatchList* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  bool include_match_data_;
  string language_;
  int32 max_completed_matches_;
  int32 max_results_;
  string page_token_;
  bool _have_include_match_data_ : 1;
  bool _have_language_ : 1;
  bool _have_max_completed_matches_ : 1;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  DISALLOW_COPY_AND_ASSIGN(TurnBasedMatchesResource_ListMethod);
};

typedef client::ServiceRequestPager<
            TurnBasedMatchesResource_ListMethod,
            TurnBasedMatchList>
        TurnBasedMatchesResource_ListMethodPager;

class TurnBasedMatchesResource_RematchMethod : public GamesServiceBaseRequest {
 public:
  TurnBasedMatchesResource_RematchMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& match_id);

  virtual ~TurnBasedMatchesResource_RematchMethod();


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


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

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


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



    void clear_request_id() {
      _have_request_id_ = false;
      client::ClearCppValueHelper(&request_id_);
    }


    int64 get_request_id() const { return request_id_; }

    void set_request_id(int64 value) {
      _have_request_id_ = true;
      request_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(
      TurnBasedMatchRematch* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string match_id_;
  string language_;
  int64 request_id_;
  bool _have_language_ : 1;
  bool _have_request_id_ : 1;
  DISALLOW_COPY_AND_ASSIGN(TurnBasedMatchesResource_RematchMethod);
};

class TurnBasedMatchesResource_SyncMethod : public GamesServiceBaseRequest {
 public:
  TurnBasedMatchesResource_SyncMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~TurnBasedMatchesResource_SyncMethod();


    void clear_include_match_data() {
      _have_include_match_data_ = false;
      client::ClearCppValueHelper(&include_match_data_);
    }


    bool get_include_match_data() const { return include_match_data_; }

    void set_include_match_data(bool value) {
      _have_include_match_data_ = true;
      include_match_data_ = value;
    }

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


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

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


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



    void clear_max_completed_matches() {
      _have_max_completed_matches_ = false;
      client::ClearCppValueHelper(&max_completed_matches_);
    }


    int32 get_max_completed_matches() const { return max_completed_matches_; }

    void set_max_completed_matches(int32 value) {
      _have_max_completed_matches_ = true;
      max_completed_matches_ = 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(
      TurnBasedMatchSync* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  bool include_match_data_;
  string language_;
  int32 max_completed_matches_;
  int32 max_results_;
  string page_token_;
  bool _have_include_match_data_ : 1;
  bool _have_language_ : 1;
  bool _have_max_completed_matches_ : 1;
  bool _have_max_results_ : 1;
  bool _have_page_token_ : 1;
  DISALLOW_COPY_AND_ASSIGN(TurnBasedMatchesResource_SyncMethod);
};

typedef client::ServiceRequestPager<
            TurnBasedMatchesResource_SyncMethod,
            TurnBasedMatchSync>
        TurnBasedMatchesResource_SyncMethodPager;

class TurnBasedMatchesResource_TakeTurnMethod : public GamesServiceBaseRequest {
 public:
  TurnBasedMatchesResource_TakeTurnMethod(
      const GamesService* _service_,
      client::AuthorizationCredential* _credential_,
      const absl::string_view& match_id,
      const TurnBasedMatchTurn& _content_);

  virtual ~TurnBasedMatchesResource_TakeTurnMethod();


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


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

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


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

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

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


  util::Status ExecuteAndParseResponse(
      TurnBasedMatch* data) {
    return GamesServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string match_id_;
  string language_;
  bool _have_language_ : 1;  string _content_;
  DISALLOW_COPY_AND_ASSIGN(TurnBasedMatchesResource_TakeTurnMethod);
};



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

  static const char googleapis_API_VERSION[];

  static const char googleapis_API_GENERATOR[];


  class AchievementDefinitionsResource {
   public:
    explicit AchievementDefinitionsResource(GamesService* service);

    ~AchievementDefinitionsResource() {}


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

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

   private:
    GamesService* service_;

    DISALLOW_COPY_AND_ASSIGN(AchievementDefinitionsResource);
  };

  class AchievementsResource {
   public:
    explicit AchievementsResource(GamesService* service);

    ~AchievementsResource() {}


    AchievementsResource_IncrementMethod* NewIncrementMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& achievement_id,
        const int32& steps_to_increment) const;

    AchievementsResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& player_id) const;

    AchievementsResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& player_id) const;

    AchievementsResource_RevealMethod* NewRevealMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& achievement_id) const;

    AchievementsResource_SetStepsAtLeastMethod* NewSetStepsAtLeastMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& achievement_id,
        const int32& steps) const;

    AchievementsResource_UnlockMethod* NewUnlockMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& achievement_id) const;

    AchievementsResource_UpdateMultipleMethod* NewUpdateMultipleMethod(
        client::AuthorizationCredential* _credential_,
        const AchievementUpdateMultipleRequest& _content_) const;

   private:
    GamesService* service_;

    DISALLOW_COPY_AND_ASSIGN(AchievementsResource);
  };

  class ApplicationsResource {
   public:
    explicit ApplicationsResource(GamesService* service);

    ~ApplicationsResource() {}


    ApplicationsResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& application_id) const;

    ApplicationsResource_PlayedMethod* NewPlayedMethod(
        client::AuthorizationCredential* _credential_) const;

    ApplicationsResource_VerifyMethod* NewVerifyMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& application_id) const;

   private:
    GamesService* service_;

    DISALLOW_COPY_AND_ASSIGN(ApplicationsResource);
  };

  class EventsResource {
   public:
    explicit EventsResource(GamesService* service);

    ~EventsResource() {}


    EventsResource_ListByPlayerMethod* NewListByPlayerMethod(
        client::AuthorizationCredential* _credential_) const;

    EventsResource_ListByPlayerMethodPager* NewListByPlayerMethodPager(
        client::AuthorizationCredential* _credential_) const;

    EventsResource_ListDefinitionsMethod* NewListDefinitionsMethod(
        client::AuthorizationCredential* _credential_) const;

    EventsResource_ListDefinitionsMethodPager* NewListDefinitionsMethodPager(
        client::AuthorizationCredential* _credential_) const;

    EventsResource_RecordMethod* NewRecordMethod(
        client::AuthorizationCredential* _credential_,
        const EventRecordRequest& _content_) const;

   private:
    GamesService* service_;

    DISALLOW_COPY_AND_ASSIGN(EventsResource);
  };

  class LeaderboardsResource {
   public:
    explicit LeaderboardsResource(GamesService* service);

    ~LeaderboardsResource() {}


    LeaderboardsResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& leaderboard_id) const;

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

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

   private:
    GamesService* service_;

    DISALLOW_COPY_AND_ASSIGN(LeaderboardsResource);
  };

  class MetagameResource {
   public:
    explicit MetagameResource(GamesService* service);

    ~MetagameResource() {}


    MetagameResource_GetMetagameConfigMethod* NewGetMetagameConfigMethod(
        client::AuthorizationCredential* _credential_) const;

    MetagameResource_ListCategoriesByPlayerMethod* NewListCategoriesByPlayerMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& player_id,
        const absl::string_view& collection) const;

    MetagameResource_ListCategoriesByPlayerMethodPager* NewListCategoriesByPlayerMethodPager(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& player_id,
        const absl::string_view& collection) const;

   private:
    GamesService* service_;

    DISALLOW_COPY_AND_ASSIGN(MetagameResource);
  };

  class PlayersResource {
   public:
    explicit PlayersResource(GamesService* service);

    ~PlayersResource() {}


    PlayersResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& player_id) const;

    PlayersResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& collection) const;

    PlayersResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& collection) const;

   private:
    GamesService* service_;

    DISALLOW_COPY_AND_ASSIGN(PlayersResource);
  };

  class PushtokensResource {
   public:
    explicit PushtokensResource(GamesService* service);

    ~PushtokensResource() {}


    PushtokensResource_RemoveMethod* NewRemoveMethod(
        client::AuthorizationCredential* _credential_,
        const PushTokenId& _content_) const;

    PushtokensResource_UpdateMethod* NewUpdateMethod(
        client::AuthorizationCredential* _credential_,
        const PushToken& _content_) const;

   private:
    GamesService* service_;

    DISALLOW_COPY_AND_ASSIGN(PushtokensResource);
  };

  class RevisionsResource {
   public:
    explicit RevisionsResource(GamesService* service);

    ~RevisionsResource() {}


    RevisionsResource_CheckMethod* NewCheckMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& client_revision) const;

   private:
    GamesService* service_;

    DISALLOW_COPY_AND_ASSIGN(RevisionsResource);
  };

  class RoomsResource {
   public:
    explicit RoomsResource(GamesService* service);

    ~RoomsResource() {}


    RoomsResource_CreateMethod* NewCreateMethod(
        client::AuthorizationCredential* _credential_,
        const RoomCreateRequest& _content_) const;

    RoomsResource_DeclineMethod* NewDeclineMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& room_id) const;

    RoomsResource_DismissMethod* NewDismissMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& room_id) const;

    RoomsResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& room_id) const;

    RoomsResource_JoinMethod* NewJoinMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& room_id,
        const RoomJoinRequest& _content_) const;

    RoomsResource_LeaveMethod* NewLeaveMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& room_id,
        const RoomLeaveRequest& _content_) const;

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

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

    RoomsResource_ReportStatusMethod* NewReportStatusMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& room_id,
        const RoomP2PStatuses& _content_) const;

   private:
    GamesService* service_;

    DISALLOW_COPY_AND_ASSIGN(RoomsResource);
  };

  class ScoresResource {
   public:
    explicit ScoresResource(GamesService* service);

    ~ScoresResource() {}


    ScoresResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& player_id,
        const absl::string_view& leaderboard_id,
        const absl::string_view& time_span) const;

    ScoresResource_GetMethodPager* NewGetMethodPager(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& player_id,
        const absl::string_view& leaderboard_id,
        const absl::string_view& time_span) const;

    ScoresResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& leaderboard_id,
        const absl::string_view& collection,
        const absl::string_view& time_span) const;

    ScoresResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& leaderboard_id,
        const absl::string_view& collection,
        const absl::string_view& time_span) const;

    ScoresResource_ListWindowMethod* NewListWindowMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& leaderboard_id,
        const absl::string_view& collection,
        const absl::string_view& time_span) const;

    ScoresResource_ListWindowMethodPager* NewListWindowMethodPager(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& leaderboard_id,
        const absl::string_view& collection,
        const absl::string_view& time_span) const;

    ScoresResource_SubmitMethod* NewSubmitMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& leaderboard_id,
        const int64& score) const;

    ScoresResource_SubmitMultipleMethod* NewSubmitMultipleMethod(
        client::AuthorizationCredential* _credential_,
        const PlayerScoreSubmissionList& _content_) const;

   private:
    GamesService* service_;

    DISALLOW_COPY_AND_ASSIGN(ScoresResource);
  };

  class SnapshotsResource {
   public:
    explicit SnapshotsResource(GamesService* service);

    ~SnapshotsResource() {}


    SnapshotsResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& snapshot_id) const;

    SnapshotsResource_ListMethod* NewListMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& player_id) const;

    SnapshotsResource_ListMethodPager* NewListMethodPager(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& player_id) const;

   private:
    GamesService* service_;

    DISALLOW_COPY_AND_ASSIGN(SnapshotsResource);
  };

  class TurnBasedMatchesResource {
   public:
    explicit TurnBasedMatchesResource(GamesService* service);

    ~TurnBasedMatchesResource() {}


    TurnBasedMatchesResource_CancelMethod* NewCancelMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& match_id) const;

    TurnBasedMatchesResource_CreateMethod* NewCreateMethod(
        client::AuthorizationCredential* _credential_,
        const TurnBasedMatchCreateRequest& _content_) const;

    TurnBasedMatchesResource_DeclineMethod* NewDeclineMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& match_id) const;

    TurnBasedMatchesResource_DismissMethod* NewDismissMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& match_id) const;

    TurnBasedMatchesResource_FinishMethod* NewFinishMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& match_id,
        const TurnBasedMatchResults& _content_) const;

    TurnBasedMatchesResource_GetMethod* NewGetMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& match_id) const;

    TurnBasedMatchesResource_JoinMethod* NewJoinMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& match_id) const;

    TurnBasedMatchesResource_LeaveMethod* NewLeaveMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& match_id) const;

    TurnBasedMatchesResource_LeaveTurnMethod* NewLeaveTurnMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& match_id,
        const int32& match_version) const;

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

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

    TurnBasedMatchesResource_RematchMethod* NewRematchMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& match_id) const;

    TurnBasedMatchesResource_SyncMethod* NewSyncMethod(
        client::AuthorizationCredential* _credential_) const;

    TurnBasedMatchesResource_SyncMethodPager* NewSyncMethodPager(
        client::AuthorizationCredential* _credential_) const;

    TurnBasedMatchesResource_TakeTurnMethod* NewTakeTurnMethod(
        client::AuthorizationCredential* _credential_,
        const absl::string_view& match_id,
        const TurnBasedMatchTurn& _content_) const;

   private:
    GamesService* service_;

    DISALLOW_COPY_AND_ASSIGN(TurnBasedMatchesResource);
  };



  explicit GamesService(client::HttpTransport* transport);

  virtual ~GamesService();

  const AchievementDefinitionsResource& get_achievement_definitions() const {
    return achievement_definitions_;
  }


  const AchievementsResource& get_achievements() const {
    return achievements_;
  }


  const ApplicationsResource& get_applications() const {
    return applications_;
  }


  const EventsResource& get_events() const {
    return events_;
  }


  const LeaderboardsResource& get_leaderboards() const {
    return leaderboards_;
  }


  const MetagameResource& get_metagame() const {
    return metagame_;
  }


  const PlayersResource& get_players() const {
    return players_;
  }


  const PushtokensResource& get_pushtokens() const {
    return pushtokens_;
  }


  const RevisionsResource& get_revisions() const {
    return revisions_;
  }


  const RoomsResource& get_rooms() const {
    return rooms_;
  }


  const ScoresResource& get_scores() const {
    return scores_;
  }


  const SnapshotsResource& get_snapshots() const {
    return snapshots_;
  }


  const TurnBasedMatchesResource& get_turn_based_matches() const {
    return turn_based_matches_;
  }

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

    static const char GAMES[];

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

 private:
  AchievementDefinitionsResource achievement_definitions_;
  AchievementsResource achievements_;
  ApplicationsResource applications_;
  EventsResource events_;
  LeaderboardsResource leaderboards_;
  MetagameResource metagame_;
  PlayersResource players_;
  PushtokensResource pushtokens_;
  RevisionsResource revisions_;
  RoomsResource rooms_;
  ScoresResource scores_;
  SnapshotsResource snapshots_;
  TurnBasedMatchesResource turn_based_matches_;

  DISALLOW_COPY_AND_ASSIGN(GamesService);
};


}  // namespace google_games_api
#endif  // GOOGLE_GAMES_API_GAMES_SERVICE_H_