registration.hpp

Go to the documentation of this file.

/******************************************************************************
 * THIS FILE IS GENERATED - ANY EDITS WILL BE OVERWRITTEN
 */
 
#pragma once
 
#include "basejob.hpp"
#include "csapi/definitions/request_msisdn_validation.hpp"
#include "csapi/definitions/request_token_response.hpp"
#include "csapi/definitions/request_email_validation.hpp"
#include "csapi/definitions/auth_data.hpp"
 
namespace Kazv::Api {
 
class RegisterJob : public BaseJob {
public:
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
        
 
    
std::string userId() const;
 
    
std::optional<std::string> accessToken() const;
 
    
std::optional<std::string> refreshToken() const;
 
    
std::optional<int> expiresInMs() const;
 
    
std::optional<std::string> homeServer() const;
 
    
std::optional<std::string> deviceId() const;
 
};
          static constexpr auto needsAuth() {
          return 
            false;
              }
 
 
// Construction/destruction
 
    explicit RegisterJob(std::string serverUrl
    
      ,
        std::string kind  = std::string("user"), std::optional<AuthenticationData> auth  = std::nullopt, std::optional<std::string> username  = std::nullopt, std::optional<std::string> password  = std::nullopt, std::optional<std::string> deviceId  = std::nullopt, std::optional<std::string> initialDeviceDisplayName  = std::nullopt, std::optional<bool> inhibitLogin  = std::nullopt, std::optional<bool> refreshToken  = std::nullopt
        );
    
 
    static BaseJob::Query buildQuery(
    std::string kind);
 
      static BaseJob::Body buildBody(std::string kind, std::optional<AuthenticationData> auth, std::optional<std::string> username, std::optional<std::string> password, std::optional<std::string> deviceId, std::optional<std::string> initialDeviceDisplayName, std::optional<bool> inhibitLogin, std::optional<bool> refreshToken);
 
        
 
        
 
      RegisterJob withData(JsonWrap j) &&;
      RegisterJob withData(JsonWrap j) const &;
      };
      using RegisterResponse = RegisterJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
class RequestTokenToRegisterEmailJob : public BaseJob {
public:
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
 
    
    RequestTokenResponse data() const
    {
    return
      std::move(jsonBody().get()).get<RequestTokenResponse>()
    ;
    }
        
 
};
          static constexpr auto needsAuth() {
          return 
            false;
              }
 
 
// Construction/destruction
 
    explicit RequestTokenToRegisterEmailJob(std::string serverUrl
    
      ,
        EmailValidationData body 
        );
    
 
    static BaseJob::Query buildQuery(
    );
 
      static BaseJob::Body buildBody(EmailValidationData body);
 
        
 
        
 
      RequestTokenToRegisterEmailJob withData(JsonWrap j) &&;
      RequestTokenToRegisterEmailJob withData(JsonWrap j) const &;
      };
      using RequestTokenToRegisterEmailResponse = RequestTokenToRegisterEmailJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
class RequestTokenToRegisterMSISDNJob : public BaseJob {
public:
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
 
    
    RequestTokenResponse data() const
    {
    return
      std::move(jsonBody().get()).get<RequestTokenResponse>()
    ;
    }
        
 
};
          static constexpr auto needsAuth() {
          return 
            false;
              }
 
 
// Construction/destruction
 
    explicit RequestTokenToRegisterMSISDNJob(std::string serverUrl
    
      ,
        MsisdnValidationData body 
        );
    
 
    static BaseJob::Query buildQuery(
    );
 
      static BaseJob::Body buildBody(MsisdnValidationData body);
 
        
 
        
 
      RequestTokenToRegisterMSISDNJob withData(JsonWrap j) &&;
      RequestTokenToRegisterMSISDNJob withData(JsonWrap j) const &;
      };
      using RequestTokenToRegisterMSISDNResponse = RequestTokenToRegisterMSISDNJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
class ChangePasswordJob : public BaseJob {
public:
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit ChangePasswordJob(std::string serverUrl
    , std::string _accessToken
      ,
        std::string newPassword , std::optional<bool> logoutDevices  = std::nullopt, std::optional<AuthenticationData> auth  = std::nullopt
        );
    
 
    static BaseJob::Query buildQuery(
    );
 
      static BaseJob::Body buildBody(std::string newPassword, std::optional<bool> logoutDevices, std::optional<AuthenticationData> auth);
 
        
 
        
 
      ChangePasswordJob withData(JsonWrap j) &&;
      ChangePasswordJob withData(JsonWrap j) const &;
      };
      using ChangePasswordResponse = ChangePasswordJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
class RequestTokenToResetPasswordEmailJob : public BaseJob {
public:
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
 
    
    RequestTokenResponse data() const
    {
    return
      std::move(jsonBody().get()).get<RequestTokenResponse>()
    ;
    }
        
 
};
          static constexpr auto needsAuth() {
          return 
            false;
              }
 
 
// Construction/destruction
 
    explicit RequestTokenToResetPasswordEmailJob(std::string serverUrl
    
      ,
        EmailValidationData body 
        );
    
 
    static BaseJob::Query buildQuery(
    );
 
      static BaseJob::Body buildBody(EmailValidationData body);
 
        
 
        
 
      RequestTokenToResetPasswordEmailJob withData(JsonWrap j) &&;
      RequestTokenToResetPasswordEmailJob withData(JsonWrap j) const &;
      };
      using RequestTokenToResetPasswordEmailResponse = RequestTokenToResetPasswordEmailJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
class RequestTokenToResetPasswordMSISDNJob : public BaseJob {
public:
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
 
    
    RequestTokenResponse data() const
    {
    return
      std::move(jsonBody().get()).get<RequestTokenResponse>()
    ;
    }
        
 
};
          static constexpr auto needsAuth() {
          return 
            false;
              }
 
 
// Construction/destruction
 
    explicit RequestTokenToResetPasswordMSISDNJob(std::string serverUrl
    
      ,
        MsisdnValidationData body 
        );
    
 
    static BaseJob::Query buildQuery(
    );
 
      static BaseJob::Body buildBody(MsisdnValidationData body);
 
        
 
        
 
      RequestTokenToResetPasswordMSISDNJob withData(JsonWrap j) &&;
      RequestTokenToResetPasswordMSISDNJob withData(JsonWrap j) const &;
      };
      using RequestTokenToResetPasswordMSISDNResponse = RequestTokenToResetPasswordMSISDNJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
class DeactivateAccountJob : public BaseJob {
public:
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
        
 
    
std::string idServerUnbindResult() const;
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit DeactivateAccountJob(std::string serverUrl
    , std::string _accessToken
      ,
        std::optional<AuthenticationData> auth  = std::nullopt, std::optional<std::string> idServer  = std::nullopt
        );
    
 
    static BaseJob::Query buildQuery(
    );
 
      static BaseJob::Body buildBody(std::optional<AuthenticationData> auth, std::optional<std::string> idServer);
 
        
 
        
 
      DeactivateAccountJob withData(JsonWrap j) &&;
      DeactivateAccountJob withData(JsonWrap j) const &;
      };
      using DeactivateAccountResponse = DeactivateAccountJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
class CheckUsernameAvailabilityJob : public BaseJob {
public:
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
        
 
    
std::optional<bool> available() const;
 
};
          static constexpr auto needsAuth() {
          return 
            false;
              }
 
 
// Construction/destruction
 
    explicit CheckUsernameAvailabilityJob(std::string serverUrl
    
      ,
        std::string username 
        );
 
 
    static BaseJob::Query buildQuery(
    std::string username);
 
      static BaseJob::Body buildBody(std::string username);
 
        
 
        
 
      CheckUsernameAvailabilityJob withData(JsonWrap j) &&;
      CheckUsernameAvailabilityJob withData(JsonWrap j) const &;
      };
      using CheckUsernameAvailabilityResponse = CheckUsernameAvailabilityJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
} // namespace Kazv::Api