third_party_lookup.hpp

Go to the documentation of this file.

/******************************************************************************
 * THIS FILE IS GENERATED - ANY EDITS WILL BE OVERWRITTEN
 */
 
#pragma once
 
#include "basejob.hpp"
#include "application-service/definitions/user.hpp"
#include "application-service/definitions/location.hpp"
#include "application-service/definitions/protocol.hpp"
 
namespace Kazv::Api {
 
class GetProtocolsJob : public BaseJob {
public:
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
 
    
    immer::map<std::string, ThirdPartyProtocol> data() const
    {
    return
      std::move(jsonBody().get()).get<immer::map<std::string, ThirdPartyProtocol>>()
    ;
    }
        
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit GetProtocolsJob(std::string serverUrl
    , std::string _accessToken
      
        
        );
 
 
    static BaseJob::Query buildQuery(
    );
 
      static BaseJob::Body buildBody();
 
        
 
        
 
      GetProtocolsJob withData(JsonWrap j) &&;
      GetProtocolsJob withData(JsonWrap j) const &;
      };
      using GetProtocolsResponse = GetProtocolsJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
class GetProtocolMetadataJob : public BaseJob {
public:
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
 
    
    ThirdPartyProtocol data() const
    {
    return
      std::move(jsonBody().get()).get<ThirdPartyProtocol>()
    ;
    }
        
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit GetProtocolMetadataJob(std::string serverUrl
    , std::string _accessToken
      ,
        std::string protocol 
        );
 
 
    static BaseJob::Query buildQuery(
    );
 
      static BaseJob::Body buildBody(std::string protocol);
 
        
 
        
 
      GetProtocolMetadataJob withData(JsonWrap j) &&;
      GetProtocolMetadataJob withData(JsonWrap j) const &;
      };
      using GetProtocolMetadataResponse = GetProtocolMetadataJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
class QueryLocationByProtocolJob : public BaseJob {
public:
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
 
    
    immer::array<ThirdPartyLocation> data() const
    {
    return
      std::move(jsonBody().get()).get<immer::array<ThirdPartyLocation>>()
    ;
    }
        
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit QueryLocationByProtocolJob(std::string serverUrl
    , std::string _accessToken
      ,
        std::string protocol , std::optional<std::string> searchFields  = std::nullopt
        );
 
 
    static BaseJob::Query buildQuery(
    std::optional<std::string> searchFields);
 
      static BaseJob::Body buildBody(std::string protocol, std::optional<std::string> searchFields);
 
        
 
        
 
      QueryLocationByProtocolJob withData(JsonWrap j) &&;
      QueryLocationByProtocolJob withData(JsonWrap j) const &;
      };
      using QueryLocationByProtocolResponse = QueryLocationByProtocolJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
class QueryUserByProtocolJob : public BaseJob {
public:
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
 
    
    immer::array<ThirdPartyUser> data() const
    {
    return
      std::move(jsonBody().get()).get<immer::array<ThirdPartyUser>>()
    ;
    }
        
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit QueryUserByProtocolJob(std::string serverUrl
    , std::string _accessToken
      ,
        std::string protocol , std::optional<std::string> fields  = std::nullopt
        );
 
 
    static BaseJob::Query buildQuery(
    std::optional<std::string> fields);
 
      static BaseJob::Body buildBody(std::string protocol, std::optional<std::string> fields);
 
        
 
        
 
      QueryUserByProtocolJob withData(JsonWrap j) &&;
      QueryUserByProtocolJob withData(JsonWrap j) const &;
      };
      using QueryUserByProtocolResponse = QueryUserByProtocolJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
class QueryLocationByAliasJob : public BaseJob {
public:
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
 
    
    immer::array<ThirdPartyLocation> data() const
    {
    return
      std::move(jsonBody().get()).get<immer::array<ThirdPartyLocation>>()
    ;
    }
        
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit QueryLocationByAliasJob(std::string serverUrl
    , std::string _accessToken
      ,
        std::string alias 
        );
 
 
    static BaseJob::Query buildQuery(
    std::string alias);
 
      static BaseJob::Body buildBody(std::string alias);
 
        
 
        
 
      QueryLocationByAliasJob withData(JsonWrap j) &&;
      QueryLocationByAliasJob withData(JsonWrap j) const &;
      };
      using QueryLocationByAliasResponse = QueryLocationByAliasJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
class QueryUserByIDJob : public BaseJob {
public:
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
 
    
    immer::array<ThirdPartyUser> data() const
    {
    return
      std::move(jsonBody().get()).get<immer::array<ThirdPartyUser>>()
    ;
    }
        
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit QueryUserByIDJob(std::string serverUrl
    , std::string _accessToken
      ,
        std::string userid 
        );
 
 
    static BaseJob::Query buildQuery(
    std::string userid);
 
      static BaseJob::Body buildBody(std::string userid);
 
        
 
        
 
      QueryUserByIDJob withData(JsonWrap j) &&;
      QueryUserByIDJob withData(JsonWrap j) const &;
      };
      using QueryUserByIDResponse = QueryUserByIDJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
    
    }
 
    namespace Kazv::Api
    {
 
} // namespace Kazv::Api