administrative_contact.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 GetAccount3PIDsJob : public BaseJob {
public:
  // Inner data structures
 
    struct ThirdPartyIdentifier
        {
          std::string medium;
          std::string address;
          std::int_fast64_t validatedAt;
          std::int_fast64_t addedAt;
        
        };
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
        
 
    
immer::array<ThirdPartyIdentifier> threepids() const;
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit GetAccount3PIDsJob(std::string serverUrl
    , std::string _accessToken
      
        
        );
 
 
    static BaseJob::Query buildQuery(
    );
 
      static BaseJob::Body buildBody();
 
        
 
        
 
      GetAccount3PIDsJob withData(JsonWrap j) &&;
      GetAccount3PIDsJob withData(JsonWrap j) const &;
      };
      using GetAccount3PIDsResponse = GetAccount3PIDsJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
      template<>
      struct adl_serializer<GetAccount3PIDsJob::ThirdPartyIdentifier> {
 
  static void to_json(json& jo, const GetAccount3PIDsJob::ThirdPartyIdentifier &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    jo["medium"s] = pod.medium;
    
    jo["address"s] = pod.address;
    
    jo["validated_at"s] = pod.validatedAt;
    
    jo["added_at"s] = pod.addedAt;
    
  }
 
  static void from_json(const json &jo, GetAccount3PIDsJob::ThirdPartyIdentifier& result)
  {
  
    if (jo.contains("medium"s)) {
      result.medium = jo.at("medium"s);
    }
    if (jo.contains("address"s)) {
      result.address = jo.at("address"s);
    }
    if (jo.contains("validated_at"s)) {
      result.validatedAt = jo.at("validated_at"s);
    }
    if (jo.contains("added_at"s)) {
      result.addedAt = jo.at("added_at"s);
    }
  
  }
 
};
    }
 
    namespace Kazv::Api
    {
 
class Post3PIDsJob : public BaseJob {
public:
  // Inner data structures
 
    struct ThreePidCredentials
        {
          std::string clientSecret;
          std::string idServer;
          std::string idAccessToken;
          std::string sid;
        
        };
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
        
 
    
std::optional<std::string> submitUrl() const;
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit Post3PIDsJob(std::string serverUrl
    , std::string _accessToken
      ,
        ThreePidCredentials threePidCreds 
        );
    
 
    static BaseJob::Query buildQuery(
    );
 
      static BaseJob::Body buildBody(ThreePidCredentials threePidCreds);
 
        
 
        
 
      Post3PIDsJob withData(JsonWrap j) &&;
      Post3PIDsJob withData(JsonWrap j) const &;
      };
      using Post3PIDsResponse = Post3PIDsJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
      template<>
      struct adl_serializer<Post3PIDsJob::ThreePidCredentials> {
 
  static void to_json(json& jo, const Post3PIDsJob::ThreePidCredentials &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    jo["client_secret"s] = pod.clientSecret;
    
    jo["id_server"s] = pod.idServer;
    
    jo["id_access_token"s] = pod.idAccessToken;
    
    jo["sid"s] = pod.sid;
    
  }
 
  static void from_json(const json &jo, Post3PIDsJob::ThreePidCredentials& result)
  {
  
    if (jo.contains("client_secret"s)) {
      result.clientSecret = jo.at("client_secret"s);
    }
    if (jo.contains("id_server"s)) {
      result.idServer = jo.at("id_server"s);
    }
    if (jo.contains("id_access_token"s)) {
      result.idAccessToken = jo.at("id_access_token"s);
    }
    if (jo.contains("sid"s)) {
      result.sid = jo.at("sid"s);
    }
  
  }
 
};
    }
 
    namespace Kazv::Api
    {
 
class Add3PIDJob : public BaseJob {
public:
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit Add3PIDJob(std::string serverUrl
    , std::string _accessToken
      ,
        std::string clientSecret , std::string sid , std::optional<AuthenticationData> auth  = std::nullopt
        );
    
 
    static BaseJob::Query buildQuery(
    );
 
      static BaseJob::Body buildBody(std::string clientSecret, std::string sid, std::optional<AuthenticationData> auth);
 
        
 
        
 
      Add3PIDJob withData(JsonWrap j) &&;
      Add3PIDJob withData(JsonWrap j) const &;
      };
      using Add3PIDResponse = Add3PIDJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
class Bind3PIDJob : public BaseJob {
public:
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit Bind3PIDJob(std::string serverUrl
    , std::string _accessToken
      ,
        std::string clientSecret , std::string idServer , std::string idAccessToken , std::string sid 
        );
    
 
    static BaseJob::Query buildQuery(
    );
 
      static BaseJob::Body buildBody(std::string clientSecret, std::string idServer, std::string idAccessToken, std::string sid);
 
        
 
        
 
      Bind3PIDJob withData(JsonWrap j) &&;
      Bind3PIDJob withData(JsonWrap j) const &;
      };
      using Bind3PIDResponse = Bind3PIDJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
class Delete3pidFromAccountJob : 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 Delete3pidFromAccountJob(std::string serverUrl
    , std::string _accessToken
      ,
        std::string medium , std::string address , std::optional<std::string> idServer  = std::nullopt
        );
    
 
    static BaseJob::Query buildQuery(
    );
 
      static BaseJob::Body buildBody(std::string medium, std::string address, std::optional<std::string> idServer);
 
        
 
        
 
      Delete3pidFromAccountJob withData(JsonWrap j) &&;
      Delete3pidFromAccountJob withData(JsonWrap j) const &;
      };
      using Delete3pidFromAccountResponse = Delete3pidFromAccountJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
class Unbind3pidFromAccountJob : 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 Unbind3pidFromAccountJob(std::string serverUrl
    , std::string _accessToken
      ,
        std::string medium , std::string address , std::optional<std::string> idServer  = std::nullopt
        );
    
 
    static BaseJob::Query buildQuery(
    );
 
      static BaseJob::Body buildBody(std::string medium, std::string address, std::optional<std::string> idServer);
 
        
 
        
 
      Unbind3pidFromAccountJob withData(JsonWrap j) &&;
      Unbind3pidFromAccountJob withData(JsonWrap j) const &;
      };
      using Unbind3pidFromAccountResponse = Unbind3pidFromAccountJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
class RequestTokenTo3PIDEmailJob : 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 RequestTokenTo3PIDEmailJob(std::string serverUrl
    
      ,
        EmailValidationData body 
        );
    
 
    static BaseJob::Query buildQuery(
    );
 
      static BaseJob::Body buildBody(EmailValidationData body);
 
        
 
        
 
      RequestTokenTo3PIDEmailJob withData(JsonWrap j) &&;
      RequestTokenTo3PIDEmailJob withData(JsonWrap j) const &;
      };
      using RequestTokenTo3PIDEmailResponse = RequestTokenTo3PIDEmailJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
class RequestTokenTo3PIDMSISDNJob : 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 RequestTokenTo3PIDMSISDNJob(std::string serverUrl
    
      ,
        MsisdnValidationData body 
        );
    
 
    static BaseJob::Query buildQuery(
    );
 
      static BaseJob::Body buildBody(MsisdnValidationData body);
 
        
 
        
 
      RequestTokenTo3PIDMSISDNJob withData(JsonWrap j) &&;
      RequestTokenTo3PIDMSISDNJob withData(JsonWrap j) const &;
      };
      using RequestTokenTo3PIDMSISDNResponse = RequestTokenTo3PIDMSISDNJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
} // namespace Kazv::Api