identity_toolkit_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-04-06, 12:09:29 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_IDENTITYTOOLKIT_API_IDENTITY_TOOLKIT_SERVICE_H_
#define  GOOGLE_IDENTITYTOOLKIT_API_IDENTITY_TOOLKIT_SERVICE_H_

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

#include "google/identitytoolkit_api/create_auth_uri_response.h"
#include "google/identitytoolkit_api/delete_account_response.h"
#include "google/identitytoolkit_api/download_account_response.h"
#include "google/identitytoolkit_api/email_link_signin_response.h"
#include "google/identitytoolkit_api/get_account_info_response.h"
#include "google/identitytoolkit_api/get_oob_confirmation_code_response.h"
#include "google/identitytoolkit_api/get_recaptcha_param_response.h"
#include "google/identitytoolkit_api/identitytoolkit_relyingparty_create_auth_uri_request.h"
#include "google/identitytoolkit_api/identitytoolkit_relyingparty_delete_account_request.h"
#include "google/identitytoolkit_api/identitytoolkit_relyingparty_download_account_request.h"
#include "google/identitytoolkit_api/identitytoolkit_relyingparty_email_link_signin_request.h"
#include "google/identitytoolkit_api/identitytoolkit_relyingparty_get_account_info_request.h"
#include "google/identitytoolkit_api/identitytoolkit_relyingparty_get_project_config_response.h"
#include "google/identitytoolkit_api/identitytoolkit_relyingparty_reset_password_request.h"
#include "google/identitytoolkit_api/identitytoolkit_relyingparty_send_verification_code_request.h"
#include "google/identitytoolkit_api/identitytoolkit_relyingparty_send_verification_code_response.h"
#include "google/identitytoolkit_api/identitytoolkit_relyingparty_set_account_info_request.h"
#include "google/identitytoolkit_api/identitytoolkit_relyingparty_set_project_config_request.h"
#include "google/identitytoolkit_api/identitytoolkit_relyingparty_set_project_config_response.h"
#include "google/identitytoolkit_api/identitytoolkit_relyingparty_sign_out_user_request.h"
#include "google/identitytoolkit_api/identitytoolkit_relyingparty_sign_out_user_response.h"
#include "google/identitytoolkit_api/identitytoolkit_relyingparty_signup_new_user_request.h"
#include "google/identitytoolkit_api/identitytoolkit_relyingparty_upload_account_request.h"
#include "google/identitytoolkit_api/identitytoolkit_relyingparty_verify_assertion_request.h"
#include "google/identitytoolkit_api/identitytoolkit_relyingparty_verify_custom_token_request.h"
#include "google/identitytoolkit_api/identitytoolkit_relyingparty_verify_password_request.h"
#include "google/identitytoolkit_api/identitytoolkit_relyingparty_verify_phone_number_request.h"
#include "google/identitytoolkit_api/identitytoolkit_relyingparty_verify_phone_number_response.h"
#include "google/identitytoolkit_api/relyingparty.h"
#include "google/identitytoolkit_api/reset_password_response.h"
#include "google/identitytoolkit_api/set_account_info_response.h"
#include "google/identitytoolkit_api/signup_new_user_response.h"
#include "google/identitytoolkit_api/upload_account_response.h"
#include "google/identitytoolkit_api/verify_assertion_response.h"
#include "google/identitytoolkit_api/verify_custom_token_response.h"
#include "google/identitytoolkit_api/verify_password_response.h"


namespace google_identitytoolkit_api {
using namespace googleapis;
class IdentityToolkitService;

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

  virtual ~IdentityToolkitServiceBaseRequest();


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



class RelyingpartyResource_CreateAuthUriMethod : public IdentityToolkitServiceBaseRequest {
 public:
  RelyingpartyResource_CreateAuthUriMethod(
      const IdentityToolkitService* _service_,
      client::AuthorizationCredential* _credential_,
      const IdentitytoolkitRelyingpartyCreateAuthUriRequest& _content_);

  virtual ~RelyingpartyResource_CreateAuthUriMethod();

  util::Status ExecuteAndParseResponse(
      CreateAuthUriResponse* data) {
    return IdentityToolkitServiceBaseRequest::ExecuteAndParseResponse(data);
  }

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

class RelyingpartyResource_DeleteAccountMethod : public IdentityToolkitServiceBaseRequest {
 public:
  RelyingpartyResource_DeleteAccountMethod(
      const IdentityToolkitService* _service_,
      client::AuthorizationCredential* _credential_,
      const IdentitytoolkitRelyingpartyDeleteAccountRequest& _content_);

  virtual ~RelyingpartyResource_DeleteAccountMethod();

  util::Status ExecuteAndParseResponse(
      DeleteAccountResponse* data) {
    return IdentityToolkitServiceBaseRequest::ExecuteAndParseResponse(data);
  }

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

class RelyingpartyResource_DownloadAccountMethod : public IdentityToolkitServiceBaseRequest {
 public:
  RelyingpartyResource_DownloadAccountMethod(
      const IdentityToolkitService* _service_,
      client::AuthorizationCredential* _credential_,
      const IdentitytoolkitRelyingpartyDownloadAccountRequest& _content_);

  virtual ~RelyingpartyResource_DownloadAccountMethod();

  util::Status ExecuteAndParseResponse(
      DownloadAccountResponse* data) {
    return IdentityToolkitServiceBaseRequest::ExecuteAndParseResponse(data);
  }

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

typedef client::ServiceRequestPager<
            RelyingpartyResource_DownloadAccountMethod,
            DownloadAccountResponse>
        RelyingpartyResource_DownloadAccountMethodPager;

class RelyingpartyResource_EmailLinkSigninMethod : public IdentityToolkitServiceBaseRequest {
 public:
  RelyingpartyResource_EmailLinkSigninMethod(
      const IdentityToolkitService* _service_,
      client::AuthorizationCredential* _credential_,
      const IdentitytoolkitRelyingpartyEmailLinkSigninRequest& _content_);

  virtual ~RelyingpartyResource_EmailLinkSigninMethod();

  util::Status ExecuteAndParseResponse(
      EmailLinkSigninResponse* data) {
    return IdentityToolkitServiceBaseRequest::ExecuteAndParseResponse(data);
  }

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

class RelyingpartyResource_GetAccountInfoMethod : public IdentityToolkitServiceBaseRequest {
 public:
  RelyingpartyResource_GetAccountInfoMethod(
      const IdentityToolkitService* _service_,
      client::AuthorizationCredential* _credential_,
      const IdentitytoolkitRelyingpartyGetAccountInfoRequest& _content_);

  virtual ~RelyingpartyResource_GetAccountInfoMethod();

  util::Status ExecuteAndParseResponse(
      GetAccountInfoResponse* data) {
    return IdentityToolkitServiceBaseRequest::ExecuteAndParseResponse(data);
  }

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

class RelyingpartyResource_GetOobConfirmationCodeMethod : public IdentityToolkitServiceBaseRequest {
 public:
  RelyingpartyResource_GetOobConfirmationCodeMethod(
      const IdentityToolkitService* _service_,
      client::AuthorizationCredential* _credential_,
      const Relyingparty& _content_);

  virtual ~RelyingpartyResource_GetOobConfirmationCodeMethod();

  util::Status ExecuteAndParseResponse(
      GetOobConfirmationCodeResponse* data) {
    return IdentityToolkitServiceBaseRequest::ExecuteAndParseResponse(data);
  }

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

class RelyingpartyResource_GetProjectConfigMethod : public IdentityToolkitServiceBaseRequest {
 public:
  RelyingpartyResource_GetProjectConfigMethod(
      const IdentityToolkitService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~RelyingpartyResource_GetProjectConfigMethod();


    void clear_project_number() {
      _have_project_number_ = false;
      client::ClearCppValueHelper(&project_number_);
    }


    const string& get_project_number() const { return project_number_; }

    string* mutable_projectNumber() {
      _have_project_number_ = true;
      return &project_number_;
    }


    void set_project_number(const string& value) {
      _have_project_number_ = true;
      project_number_ = value;
    }



    void clear_delegated_project_number() {
      _have_delegated_project_number_ = false;
      client::ClearCppValueHelper(&delegated_project_number_);
    }


    const string& get_delegated_project_number() const { return delegated_project_number_; }

    string* mutable_delegatedProjectNumber() {
      _have_delegated_project_number_ = true;
      return &delegated_project_number_;
    }


    void set_delegated_project_number(const string& value) {
      _have_delegated_project_number_ = true;
      delegated_project_number_ = value;
    }

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

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


  util::Status ExecuteAndParseResponse(
      IdentitytoolkitRelyingpartyGetProjectConfigResponse* data) {
    return IdentityToolkitServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  string project_number_;
  string delegated_project_number_;
  bool _have_project_number_ : 1;
  bool _have_delegated_project_number_ : 1;
  DISALLOW_COPY_AND_ASSIGN(RelyingpartyResource_GetProjectConfigMethod);
};

class RelyingpartyResource_GetPublicKeysMethod : public IdentityToolkitServiceBaseRequest {
 public:
  RelyingpartyResource_GetPublicKeysMethod(
      const IdentityToolkitService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~RelyingpartyResource_GetPublicKeysMethod();

  util::Status ExecuteAndParseResponse(
      IdentitytoolkitRelyingpartyGetPublicKeysResponse* data) {
    return IdentityToolkitServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  DISALLOW_COPY_AND_ASSIGN(RelyingpartyResource_GetPublicKeysMethod);
};

class RelyingpartyResource_GetRecaptchaParamMethod : public IdentityToolkitServiceBaseRequest {
 public:
  RelyingpartyResource_GetRecaptchaParamMethod(
      const IdentityToolkitService* _service_,
      client::AuthorizationCredential* _credential_);

  virtual ~RelyingpartyResource_GetRecaptchaParamMethod();

  util::Status ExecuteAndParseResponse(
      GetRecaptchaParamResponse* data) {
    return IdentityToolkitServiceBaseRequest::ExecuteAndParseResponse(data);
  }

 private:
  DISALLOW_COPY_AND_ASSIGN(RelyingpartyResource_GetRecaptchaParamMethod);
};

class RelyingpartyResource_ResetPasswordMethod : public IdentityToolkitServiceBaseRequest {
 public:
  RelyingpartyResource_ResetPasswordMethod(
      const IdentityToolkitService* _service_,
      client::AuthorizationCredential* _credential_,
      const IdentitytoolkitRelyingpartyResetPasswordRequest& _content_);

  virtual ~RelyingpartyResource_ResetPasswordMethod();

  util::Status ExecuteAndParseResponse(
      ResetPasswordResponse* data) {
    return IdentityToolkitServiceBaseRequest::ExecuteAndParseResponse(data);
  }

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

class RelyingpartyResource_SendVerificationCodeMethod : public IdentityToolkitServiceBaseRequest {
 public:
  RelyingpartyResource_SendVerificationCodeMethod(
      const IdentityToolkitService* _service_,
      client::AuthorizationCredential* _credential_,
      const IdentitytoolkitRelyingpartySendVerificationCodeRequest& _content_);

  virtual ~RelyingpartyResource_SendVerificationCodeMethod();

  util::Status ExecuteAndParseResponse(
      IdentitytoolkitRelyingpartySendVerificationCodeResponse* data) {
    return IdentityToolkitServiceBaseRequest::ExecuteAndParseResponse(data);
  }

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

class RelyingpartyResource_SetAccountInfoMethod : public IdentityToolkitServiceBaseRequest {
 public:
  RelyingpartyResource_SetAccountInfoMethod(
      const IdentityToolkitService* _service_,
      client::AuthorizationCredential* _credential_,
      const IdentitytoolkitRelyingpartySetAccountInfoRequest& _content_);

  virtual ~RelyingpartyResource_SetAccountInfoMethod();

  util::Status ExecuteAndParseResponse(
      SetAccountInfoResponse* data) {
    return IdentityToolkitServiceBaseRequest::ExecuteAndParseResponse(data);
  }

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

class RelyingpartyResource_SetProjectConfigMethod : public IdentityToolkitServiceBaseRequest {
 public:
  RelyingpartyResource_SetProjectConfigMethod(
      const IdentityToolkitService* _service_,
      client::AuthorizationCredential* _credential_,
      const IdentitytoolkitRelyingpartySetProjectConfigRequest& _content_);

  virtual ~RelyingpartyResource_SetProjectConfigMethod();

  util::Status ExecuteAndParseResponse(
      IdentitytoolkitRelyingpartySetProjectConfigResponse* data) {
    return IdentityToolkitServiceBaseRequest::ExecuteAndParseResponse(data);
  }

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

class RelyingpartyResource_SignOutUserMethod : public IdentityToolkitServiceBaseRequest {
 public:
  RelyingpartyResource_SignOutUserMethod(
      const IdentityToolkitService* _service_,
      client::AuthorizationCredential* _credential_,
      const IdentitytoolkitRelyingpartySignOutUserRequest& _content_);

  virtual ~RelyingpartyResource_SignOutUserMethod();

  util::Status ExecuteAndParseResponse(
      IdentitytoolkitRelyingpartySignOutUserResponse* data) {
    return IdentityToolkitServiceBaseRequest::ExecuteAndParseResponse(data);
  }

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

class RelyingpartyResource_SignupNewUserMethod : public IdentityToolkitServiceBaseRequest {
 public:
  RelyingpartyResource_SignupNewUserMethod(
      const IdentityToolkitService* _service_,
      client::AuthorizationCredential* _credential_,
      const IdentitytoolkitRelyingpartySignupNewUserRequest& _content_);

  virtual ~RelyingpartyResource_SignupNewUserMethod();

  util::Status ExecuteAndParseResponse(
      SignupNewUserResponse* data) {
    return IdentityToolkitServiceBaseRequest::ExecuteAndParseResponse(data);
  }

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

class RelyingpartyResource_UploadAccountMethod : public IdentityToolkitServiceBaseRequest {
 public:
  RelyingpartyResource_UploadAccountMethod(
      const IdentityToolkitService* _service_,
      client::AuthorizationCredential* _credential_,
      const IdentitytoolkitRelyingpartyUploadAccountRequest& _content_);

  virtual ~RelyingpartyResource_UploadAccountMethod();

  util::Status ExecuteAndParseResponse(
      UploadAccountResponse* data) {
    return IdentityToolkitServiceBaseRequest::ExecuteAndParseResponse(data);
  }

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

class RelyingpartyResource_VerifyAssertionMethod : public IdentityToolkitServiceBaseRequest {
 public:
  RelyingpartyResource_VerifyAssertionMethod(
      const IdentityToolkitService* _service_,
      client::AuthorizationCredential* _credential_,
      const IdentitytoolkitRelyingpartyVerifyAssertionRequest& _content_);

  virtual ~RelyingpartyResource_VerifyAssertionMethod();

  util::Status ExecuteAndParseResponse(
      VerifyAssertionResponse* data) {
    return IdentityToolkitServiceBaseRequest::ExecuteAndParseResponse(data);
  }

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

class RelyingpartyResource_VerifyCustomTokenMethod : public IdentityToolkitServiceBaseRequest {
 public:
  RelyingpartyResource_VerifyCustomTokenMethod(
      const IdentityToolkitService* _service_,
      client::AuthorizationCredential* _credential_,
      const IdentitytoolkitRelyingpartyVerifyCustomTokenRequest& _content_);

  virtual ~RelyingpartyResource_VerifyCustomTokenMethod();

  util::Status ExecuteAndParseResponse(
      VerifyCustomTokenResponse* data) {
    return IdentityToolkitServiceBaseRequest::ExecuteAndParseResponse(data);
  }

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

class RelyingpartyResource_VerifyPasswordMethod : public IdentityToolkitServiceBaseRequest {
 public:
  RelyingpartyResource_VerifyPasswordMethod(
      const IdentityToolkitService* _service_,
      client::AuthorizationCredential* _credential_,
      const IdentitytoolkitRelyingpartyVerifyPasswordRequest& _content_);

  virtual ~RelyingpartyResource_VerifyPasswordMethod();

  util::Status ExecuteAndParseResponse(
      VerifyPasswordResponse* data) {
    return IdentityToolkitServiceBaseRequest::ExecuteAndParseResponse(data);
  }

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

class RelyingpartyResource_VerifyPhoneNumberMethod : public IdentityToolkitServiceBaseRequest {
 public:
  RelyingpartyResource_VerifyPhoneNumberMethod(
      const IdentityToolkitService* _service_,
      client::AuthorizationCredential* _credential_,
      const IdentitytoolkitRelyingpartyVerifyPhoneNumberRequest& _content_);

  virtual ~RelyingpartyResource_VerifyPhoneNumberMethod();

  util::Status ExecuteAndParseResponse(
      IdentitytoolkitRelyingpartyVerifyPhoneNumberResponse* data) {
    return IdentityToolkitServiceBaseRequest::ExecuteAndParseResponse(data);
  }

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



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

  static const char googleapis_API_VERSION[];

  static const char googleapis_API_GENERATOR[];


  class RelyingpartyResource {
   public:
    explicit RelyingpartyResource(IdentityToolkitService* service);

    ~RelyingpartyResource() {}


    RelyingpartyResource_CreateAuthUriMethod* NewCreateAuthUriMethod(
        client::AuthorizationCredential* _credential_,
        const IdentitytoolkitRelyingpartyCreateAuthUriRequest& _content_) const;

    RelyingpartyResource_DeleteAccountMethod* NewDeleteAccountMethod(
        client::AuthorizationCredential* _credential_,
        const IdentitytoolkitRelyingpartyDeleteAccountRequest& _content_) const;

    RelyingpartyResource_DownloadAccountMethod* NewDownloadAccountMethod(
        client::AuthorizationCredential* _credential_,
        const IdentitytoolkitRelyingpartyDownloadAccountRequest& _content_) const;

    RelyingpartyResource_DownloadAccountMethodPager* NewDownloadAccountMethodPager(
        client::AuthorizationCredential* _credential_,
        const IdentitytoolkitRelyingpartyDownloadAccountRequest& _content_) const;

    RelyingpartyResource_EmailLinkSigninMethod* NewEmailLinkSigninMethod(
        client::AuthorizationCredential* _credential_,
        const IdentitytoolkitRelyingpartyEmailLinkSigninRequest& _content_) const;

    RelyingpartyResource_GetAccountInfoMethod* NewGetAccountInfoMethod(
        client::AuthorizationCredential* _credential_,
        const IdentitytoolkitRelyingpartyGetAccountInfoRequest& _content_) const;

    RelyingpartyResource_GetOobConfirmationCodeMethod* NewGetOobConfirmationCodeMethod(
        client::AuthorizationCredential* _credential_,
        const Relyingparty& _content_) const;

    RelyingpartyResource_GetProjectConfigMethod* NewGetProjectConfigMethod(
        client::AuthorizationCredential* _credential_) const;

    RelyingpartyResource_GetPublicKeysMethod* NewGetPublicKeysMethod(
        client::AuthorizationCredential* _credential_) const;

    RelyingpartyResource_GetRecaptchaParamMethod* NewGetRecaptchaParamMethod(
        client::AuthorizationCredential* _credential_) const;

    RelyingpartyResource_ResetPasswordMethod* NewResetPasswordMethod(
        client::AuthorizationCredential* _credential_,
        const IdentitytoolkitRelyingpartyResetPasswordRequest& _content_) const;

    RelyingpartyResource_SendVerificationCodeMethod* NewSendVerificationCodeMethod(
        client::AuthorizationCredential* _credential_,
        const IdentitytoolkitRelyingpartySendVerificationCodeRequest& _content_) const;

    RelyingpartyResource_SetAccountInfoMethod* NewSetAccountInfoMethod(
        client::AuthorizationCredential* _credential_,
        const IdentitytoolkitRelyingpartySetAccountInfoRequest& _content_) const;

    RelyingpartyResource_SetProjectConfigMethod* NewSetProjectConfigMethod(
        client::AuthorizationCredential* _credential_,
        const IdentitytoolkitRelyingpartySetProjectConfigRequest& _content_) const;

    RelyingpartyResource_SignOutUserMethod* NewSignOutUserMethod(
        client::AuthorizationCredential* _credential_,
        const IdentitytoolkitRelyingpartySignOutUserRequest& _content_) const;

    RelyingpartyResource_SignupNewUserMethod* NewSignupNewUserMethod(
        client::AuthorizationCredential* _credential_,
        const IdentitytoolkitRelyingpartySignupNewUserRequest& _content_) const;

    RelyingpartyResource_UploadAccountMethod* NewUploadAccountMethod(
        client::AuthorizationCredential* _credential_,
        const IdentitytoolkitRelyingpartyUploadAccountRequest& _content_) const;

    RelyingpartyResource_VerifyAssertionMethod* NewVerifyAssertionMethod(
        client::AuthorizationCredential* _credential_,
        const IdentitytoolkitRelyingpartyVerifyAssertionRequest& _content_) const;

    RelyingpartyResource_VerifyCustomTokenMethod* NewVerifyCustomTokenMethod(
        client::AuthorizationCredential* _credential_,
        const IdentitytoolkitRelyingpartyVerifyCustomTokenRequest& _content_) const;

    RelyingpartyResource_VerifyPasswordMethod* NewVerifyPasswordMethod(
        client::AuthorizationCredential* _credential_,
        const IdentitytoolkitRelyingpartyVerifyPasswordRequest& _content_) const;

    RelyingpartyResource_VerifyPhoneNumberMethod* NewVerifyPhoneNumberMethod(
        client::AuthorizationCredential* _credential_,
        const IdentitytoolkitRelyingpartyVerifyPhoneNumberRequest& _content_) const;

   private:
    IdentityToolkitService* service_;

    DISALLOW_COPY_AND_ASSIGN(RelyingpartyResource);
  };



  explicit IdentityToolkitService(client::HttpTransport* transport);

  virtual ~IdentityToolkitService();

  const RelyingpartyResource& get_relyingparty() const {
    return relyingparty_;
  }

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

    static const char FIREBASE[];

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

 private:
  RelyingpartyResource relyingparty_;

  DISALLOW_COPY_AND_ASSIGN(IdentityToolkitService);
};


}  // namespace google_identitytoolkit_api
#endif  // GOOGLE_IDENTITYTOOLKIT_API_IDENTITY_TOOLKIT_SERVICE_H_