old_sync.hpp

Go to the documentation of this file.

/******************************************************************************
 * THIS FILE IS GENERATED - ANY EDITS WILL BE OVERWRITTEN
 */
 
#pragma once
 
#include "basejob.hpp"
 
 
namespace Kazv::Api {
 
class GetEventsJob : public BaseJob {
public:
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
        
 
    
std::optional<std::string> start() const;
 
    
std::optional<std::string> end() const;
 
    
EventList chunk() const;
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit GetEventsJob(std::string serverUrl
    , std::string _accessToken
      ,
        std::optional<std::string> from  = std::nullopt, std::optional<int> timeout  = std::nullopt
        );
 
 
    static BaseJob::Query buildQuery(
    std::optional<std::string> from, std::optional<int> timeout);
 
      static BaseJob::Body buildBody(std::optional<std::string> from, std::optional<int> timeout);
 
        
 
        
 
      GetEventsJob withData(JsonWrap j) &&;
      GetEventsJob withData(JsonWrap j) const &;
      };
      using GetEventsResponse = GetEventsJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
class InitialSyncJob : public BaseJob {
public:
  // Inner data structures
 
    struct PaginationChunk
        {
          std::string end;
          EventList chunk;
          std::optional<std::string> start;
        
        };
 
    struct RoomInfo
        {
          std::string roomId;
          std::string membership;
          JsonWrap invite;
          std::optional<PaginationChunk> messages;
          EventList state;
          std::optional<std::string> visibility;
          EventList accountData;
        
        };
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
        
 
    
std::string end() const;
 
    
EventList presence() const;
 
    
immer::array<RoomInfo> rooms() const;
 
    
EventList accountData() const;
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit InitialSyncJob(std::string serverUrl
    , std::string _accessToken
      ,
        std::optional<int> limit  = std::nullopt, std::optional<bool> archived  = std::nullopt
        );
 
 
    static BaseJob::Query buildQuery(
    std::optional<int> limit, std::optional<bool> archived);
 
      static BaseJob::Body buildBody(std::optional<int> limit, std::optional<bool> archived);
 
        
 
        
 
      InitialSyncJob withData(JsonWrap j) &&;
      InitialSyncJob withData(JsonWrap j) const &;
      };
      using InitialSyncResponse = InitialSyncJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
      template<>
      struct adl_serializer<InitialSyncJob::PaginationChunk> {
 
  static void to_json(json& jo, const InitialSyncJob::PaginationChunk &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    jo["end"s] = pod.end;
    
    jo["chunk"s] = pod.chunk;
    
    
    addToJsonIfNeeded(jo, "start"s, pod.start);
  }
 
  static void from_json(const json &jo, InitialSyncJob::PaginationChunk& result)
  {
  
    if (jo.contains("end"s)) {
      result.end = jo.at("end"s);
    }
    if (jo.contains("chunk"s)) {
      result.chunk = jo.at("chunk"s);
    }
    if (jo.contains("start"s)) {
      result.start = jo.at("start"s);
    }
  
  }
 
};
      template<>
      struct adl_serializer<InitialSyncJob::RoomInfo> {
 
  static void to_json(json& jo, const InitialSyncJob::RoomInfo &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    jo["room_id"s] = pod.roomId;
    
    jo["membership"s] = pod.membership;
    
    
    addToJsonIfNeeded(jo, "invite"s, pod.invite);
    
    addToJsonIfNeeded(jo, "messages"s, pod.messages);
    
    addToJsonIfNeeded(jo, "state"s, pod.state);
    
    addToJsonIfNeeded(jo, "visibility"s, pod.visibility);
    
    addToJsonIfNeeded(jo, "account_data"s, pod.accountData);
  }
 
  static void from_json(const json &jo, InitialSyncJob::RoomInfo& result)
  {
  
    if (jo.contains("room_id"s)) {
      result.roomId = jo.at("room_id"s);
    }
    if (jo.contains("membership"s)) {
      result.membership = jo.at("membership"s);
    }
    if (jo.contains("invite"s)) {
      result.invite = jo.at("invite"s);
    }
    if (jo.contains("messages"s)) {
      result.messages = jo.at("messages"s);
    }
    if (jo.contains("state"s)) {
      result.state = jo.at("state"s);
    }
    if (jo.contains("visibility"s)) {
      result.visibility = jo.at("visibility"s);
    }
    if (jo.contains("account_data"s)) {
      result.accountData = jo.at("account_data"s);
    }
  
  }
 
};
    }
 
    namespace Kazv::Api
    {
 
class GetOneEventJob : public BaseJob {
public:
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
 
    
    JsonWrap data() const
    {
    return
      std::move(jsonBody().get()).get<JsonWrap>()
    ;
    }
        
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit GetOneEventJob(std::string serverUrl
    , std::string _accessToken
      ,
        std::string eventId 
        );
 
 
    static BaseJob::Query buildQuery(
    );
 
      static BaseJob::Body buildBody(std::string eventId);
 
        
 
        
 
      GetOneEventJob withData(JsonWrap j) &&;
      GetOneEventJob withData(JsonWrap j) const &;
      };
      using GetOneEventResponse = GetOneEventJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
} // namespace Kazv::Api