keys.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/cross_signing_key.hpp"
#include "csapi/definitions/device_keys.hpp"
 
namespace Kazv::Api {
 
class UploadKeysJob : public BaseJob {
public:
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
        
 
    
immer::map<std::string, int> oneTimeKeyCounts() const;
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit UploadKeysJob(std::string serverUrl
    , std::string _accessToken
      ,
        std::optional<DeviceKeys> deviceKeys  = std::nullopt, JsonWrap oneTimeKeys  = {}, JsonWrap fallbackKeys  = {}
        );
    
 
    static BaseJob::Query buildQuery(
    );
 
      static BaseJob::Body buildBody(std::optional<DeviceKeys> deviceKeys, JsonWrap oneTimeKeys, JsonWrap fallbackKeys);
 
        
 
        
 
      UploadKeysJob withData(JsonWrap j) &&;
      UploadKeysJob withData(JsonWrap j) const &;
      };
      using UploadKeysResponse = UploadKeysJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
class QueryKeysJob : public BaseJob {
public:
  // Inner data structures
 
    struct UnsignedDeviceInfo
        {
          std::optional<std::string> deviceDisplayName;
        
        };
 
    struct DeviceInformation :
      DeviceKeys
        {
          std::optional<UnsignedDeviceInfo> unsignedData;
        
        };
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
        
 
    
immer::map<std::string, JsonWrap> failures() const;
 
    
immer::map<std::string, immer::map<std::string, DeviceInformation>> deviceKeys() const;
 
    
immer::map<std::string, CrossSigningKey> masterKeys() const;
 
    
immer::map<std::string, CrossSigningKey> selfSigningKeys() const;
 
    
immer::map<std::string, CrossSigningKey> userSigningKeys() const;
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit QueryKeysJob(std::string serverUrl
    , std::string _accessToken
      ,
        immer::map<std::string, immer::array<std::string>> deviceKeys , std::optional<int> timeout  = std::nullopt, std::optional<std::string> token  = std::nullopt
        );
    
 
    static BaseJob::Query buildQuery(
    );
 
      static BaseJob::Body buildBody(immer::map<std::string, immer::array<std::string>> deviceKeys, std::optional<int> timeout, std::optional<std::string> token);
 
        
 
        
 
      QueryKeysJob withData(JsonWrap j) &&;
      QueryKeysJob withData(JsonWrap j) const &;
      };
      using QueryKeysResponse = QueryKeysJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
      template<>
      struct adl_serializer<QueryKeysJob::UnsignedDeviceInfo> {
 
  static void to_json(json& jo, const QueryKeysJob::UnsignedDeviceInfo &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "device_display_name"s, pod.deviceDisplayName);
  }
 
  static void from_json(const json &jo, QueryKeysJob::UnsignedDeviceInfo& result)
  {
  
    if (jo.contains("device_display_name"s)) {
      result.deviceDisplayName = jo.at("device_display_name"s);
    }
  
  }
 
};
      template<>
      struct adl_serializer<QueryKeysJob::DeviceInformation> {
 
  static void to_json(json& jo, const QueryKeysJob::DeviceInformation &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
    jo = static_cast<const DeviceKeys &>(pod);
    //nlohmann::to_json(jo, static_cast<const DeviceKeys &>(pod));
  
    
    addToJsonIfNeeded(jo, "unsigned"s, pod.unsignedData);
  }
 
  static void from_json(const json &jo, QueryKeysJob::DeviceInformation& result)
  {
    static_cast<DeviceKeys &>(result) = jo;
    //nlohmann::from_json(jo, static_cast<const DeviceKeys &>(result));
    if (jo.contains("unsigned"s)) {
      result.unsignedData = jo.at("unsigned"s);
    }
  
  }
 
};
    }
 
    namespace Kazv::Api
    {
 
class ClaimKeysJob : public BaseJob {
public:
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
        
 
    
immer::map<std::string, JsonWrap> failures() const;
 
    
immer::map<std::string, immer::map<std::string, JsonWrap>> oneTimeKeys() const;
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit ClaimKeysJob(std::string serverUrl
    , std::string _accessToken
      ,
        immer::map<std::string, immer::map<std::string, std::string>> oneTimeKeys , std::optional<int> timeout  = std::nullopt
        );
    
 
    static BaseJob::Query buildQuery(
    );
 
      static BaseJob::Body buildBody(immer::map<std::string, immer::map<std::string, std::string>> oneTimeKeys, std::optional<int> timeout);
 
        
 
        
 
      ClaimKeysJob withData(JsonWrap j) &&;
      ClaimKeysJob withData(JsonWrap j) const &;
      };
      using ClaimKeysResponse = ClaimKeysJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
class GetKeysChangesJob : public BaseJob {
public:
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
        
 
    
immer::array<std::string> changed() const;
 
    
immer::array<std::string> left() const;
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit GetKeysChangesJob(std::string serverUrl
    , std::string _accessToken
      ,
        std::string from , std::string to 
        );
 
 
    static BaseJob::Query buildQuery(
    std::string from, std::string to);
 
      static BaseJob::Body buildBody(std::string from, std::string to);
 
        
 
        
 
      GetKeysChangesJob withData(JsonWrap j) &&;
      GetKeysChangesJob withData(JsonWrap j) const &;
      };
      using GetKeysChangesResponse = GetKeysChangesJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
} // namespace Kazv::Api