sync_filter.hpp

Go to the documentation of this file.

/******************************************************************************
 * THIS FILE IS GENERATED - ANY EDITS WILL BE OVERWRITTEN
 */
 
#pragma once
 
#include "types.hpp"
#include "csapi/definitions/event_filter.hpp"
#include "csapi/definitions/room_event_filter.hpp"
 
namespace Kazv::Api {
struct RoomFilter
{       
 
    immer::array<std::string> notRooms;
 
    immer::array<std::string> rooms;
 
    RoomEventFilter ephemeral;
 
    std::optional<bool> includeLeave;
 
    RoomEventFilter state;
 
    RoomEventFilter timeline;
 
    RoomEventFilter accountData;
};
 
}
namespace nlohmann
{
using namespace Kazv;
using namespace Kazv::Api;
template<>
struct adl_serializer<RoomFilter> {
  static void to_json(json& jo, const RoomFilter &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "not_rooms"s, pod.notRooms);
    
    addToJsonIfNeeded(jo, "rooms"s, pod.rooms);
    
    addToJsonIfNeeded(jo, "ephemeral"s, pod.ephemeral);
    
    addToJsonIfNeeded(jo, "include_leave"s, pod.includeLeave);
    
    addToJsonIfNeeded(jo, "state"s, pod.state);
    
    addToJsonIfNeeded(jo, "timeline"s, pod.timeline);
    
    addToJsonIfNeeded(jo, "account_data"s, pod.accountData);
  }
  static void from_json(const json &jo, RoomFilter& result)
  {
  
    if (jo.contains("not_rooms"s)) {
      result.notRooms = jo.at("not_rooms"s);
    }
    if (jo.contains("rooms"s)) {
      result.rooms = jo.at("rooms"s);
    }
    if (jo.contains("ephemeral"s)) {
      result.ephemeral = jo.at("ephemeral"s);
    }
    if (jo.contains("include_leave"s)) {
      result.includeLeave = jo.at("include_leave"s);
    }
    if (jo.contains("state"s)) {
      result.state = jo.at("state"s);
    }
    if (jo.contains("timeline"s)) {
      result.timeline = jo.at("timeline"s);
    }
    if (jo.contains("account_data"s)) {
      result.accountData = jo.at("account_data"s);
    }
  
  }
};
    }
 
    namespace Kazv::Api
    {
 
struct Filter
{       
 
    immer::array<std::string> eventFields;
 
    std::optional<std::string> eventFormat;
 
    EventFilter presence;
 
    EventFilter accountData;
 
    RoomFilter room;
};
 
}
namespace nlohmann
{
using namespace Kazv;
using namespace Kazv::Api;
template<>
struct adl_serializer<Filter> {
  static void to_json(json& jo, const Filter &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "event_fields"s, pod.eventFields);
    
    addToJsonIfNeeded(jo, "event_format"s, pod.eventFormat);
    
    addToJsonIfNeeded(jo, "presence"s, pod.presence);
    
    addToJsonIfNeeded(jo, "account_data"s, pod.accountData);
    
    addToJsonIfNeeded(jo, "room"s, pod.room);
  }
  static void from_json(const json &jo, Filter& result)
  {
  
    if (jo.contains("event_fields"s)) {
      result.eventFields = jo.at("event_fields"s);
    }
    if (jo.contains("event_format"s)) {
      result.eventFormat = jo.at("event_format"s);
    }
    if (jo.contains("presence"s)) {
      result.presence = jo.at("presence"s);
    }
    if (jo.contains("account_data"s)) {
      result.accountData = jo.at("account_data"s);
    }
    if (jo.contains("room"s)) {
      result.room = jo.at("room"s);
    }
  
  }
};
    }
 
    namespace Kazv::Api
    {
} // namespace Kazv::Api