hyperswarm-peer / swarmd / schema / swarmd_schema.h

// This file is autogenerated by hyperschema-c
// !!DO NOT EDIT!!
// Schema Version: 1

#ifndef SWARMD_SCHEMA_H
#define SWARMD_SCHEMA_H

#include <compact.h>
#include <stdbool.h>

// @swarmd/hello-request
typedef struct swarmd_hello_request_s {
  utf8_string_view_t name; /* borrows from decode buffer */
  uint8_t app_identity[32];
  uint64_t version;
} swarmd_hello_request_t;

int
swarmd_hello_request_preencode (compact_state_t *state, const swarmd_hello_request_t *value);

int
swarmd_hello_request_encode (compact_state_t *state, const swarmd_hello_request_t *value);

int
swarmd_hello_request_decode (compact_state_t *state, swarmd_hello_request_t *result);

void
swarmd_hello_request_destroy (swarmd_hello_request_t *result);

// @swarmd/hello-response
typedef struct swarmd_hello_response_s {
  uint64_t client_id;
  uint8_t daemon_pubkey[32];
} swarmd_hello_response_t;

int
swarmd_hello_response_preencode (compact_state_t *state, const swarmd_hello_response_t *value);

int
swarmd_hello_response_encode (compact_state_t *state, const swarmd_hello_response_t *value);

int
swarmd_hello_response_decode (compact_state_t *state, swarmd_hello_response_t *result);

void
swarmd_hello_response_destroy (swarmd_hello_response_t *result);

// @swarmd/status
typedef struct swarmd_status_s {
  uint64_t dht_state;
  bool bootstrapped;
  uint64_t peers_known;
  uint64_t peers_connected;
  uint64_t connecting;
  uint64_t queued;
  uint64_t local_clients;
} swarmd_status_t;

int
swarmd_status_preencode (compact_state_t *state, const swarmd_status_t *value);

int
swarmd_status_encode (compact_state_t *state, const swarmd_status_t *value);

int
swarmd_status_decode (compact_state_t *state, swarmd_status_t *result);

void
swarmd_status_destroy (swarmd_status_t *result);

// @swarmd/ok
typedef struct swarmd_ok_s {
  bool ok;
} swarmd_ok_t;

int
swarmd_ok_preencode (compact_state_t *state, const swarmd_ok_t *value);

int
swarmd_ok_encode (compact_state_t *state, const swarmd_ok_t *value);

int
swarmd_ok_decode (compact_state_t *state, swarmd_ok_t *result);

void
swarmd_ok_destroy (swarmd_ok_t *result);

// @swarmd/none
typedef struct swarmd_none_s {
  uint64_t reserved;
} swarmd_none_t;

int
swarmd_none_preencode (compact_state_t *state, const swarmd_none_t *value);

int
swarmd_none_encode (compact_state_t *state, const swarmd_none_t *value);

int
swarmd_none_decode (compact_state_t *state, swarmd_none_t *result);

void
swarmd_none_destroy (swarmd_none_t *result);

// @swarmd/swarm-join
typedef struct swarmd_swarm_join_s {
  uint8_t topic[32];
  bool server;
  bool client;
} swarmd_swarm_join_t;

int
swarmd_swarm_join_preencode (compact_state_t *state, const swarmd_swarm_join_t *value);

int
swarmd_swarm_join_encode (compact_state_t *state, const swarmd_swarm_join_t *value);

int
swarmd_swarm_join_decode (compact_state_t *state, swarmd_swarm_join_t *result);

void
swarmd_swarm_join_destroy (swarmd_swarm_join_t *result);

// @swarmd/topic-ref
typedef struct swarmd_topic_ref_s {
  uint8_t topic[32];
} swarmd_topic_ref_t;

int
swarmd_topic_ref_preencode (compact_state_t *state, const swarmd_topic_ref_t *value);

int
swarmd_topic_ref_encode (compact_state_t *state, const swarmd_topic_ref_t *value);

int
swarmd_topic_ref_decode (compact_state_t *state, swarmd_topic_ref_t *result);

void
swarmd_topic_ref_destroy (swarmd_topic_ref_t *result);

// @swarmd/peer-key
typedef struct swarmd_peer_key_s {
  uint8_t pubkey[32];
} swarmd_peer_key_t;

int
swarmd_peer_key_preencode (compact_state_t *state, const swarmd_peer_key_t *value);

int
swarmd_peer_key_encode (compact_state_t *state, const swarmd_peer_key_t *value);

int
swarmd_peer_key_decode (compact_state_t *state, swarmd_peer_key_t *result);

void
swarmd_peer_key_destroy (swarmd_peer_key_t *result);

// @swarmd/channel-open
typedef struct swarmd_channel_open_s {
  utf8_string_view_t protocol; /* borrows from decode buffer */
  uint8_t *id; /* borrows from decode buffer */
  size_t id_len;
  uint64_t slots;
} swarmd_channel_open_t;

int
swarmd_channel_open_preencode (compact_state_t *state, const swarmd_channel_open_t *value);

int
swarmd_channel_open_encode (compact_state_t *state, const swarmd_channel_open_t *value);

int
swarmd_channel_open_decode (compact_state_t *state, swarmd_channel_open_t *result);

void
swarmd_channel_open_destroy (swarmd_channel_open_t *result);

// @swarmd/channel-ref
typedef struct swarmd_channel_ref_s {
  uint64_t channel;
} swarmd_channel_ref_t;

int
swarmd_channel_ref_preencode (compact_state_t *state, const swarmd_channel_ref_t *value);

int
swarmd_channel_ref_encode (compact_state_t *state, const swarmd_channel_ref_t *value);

int
swarmd_channel_ref_decode (compact_state_t *state, swarmd_channel_ref_t *result);

void
swarmd_channel_ref_destroy (swarmd_channel_ref_t *result);

// @swarmd/send-request
typedef struct swarmd_send_request_s {
  uint64_t channel;
  uint64_t slot;
  uint64_t target;
  uint8_t *bytes; /* borrows from decode buffer */
  size_t bytes_len;
} swarmd_send_request_t;

int
swarmd_send_request_preencode (compact_state_t *state, const swarmd_send_request_t *value);

int
swarmd_send_request_encode (compact_state_t *state, const swarmd_send_request_t *value);

int
swarmd_send_request_decode (compact_state_t *state, swarmd_send_request_t *result);

void
swarmd_send_request_destroy (swarmd_send_request_t *result);

// @swarmd/send-result
typedef struct swarmd_send_result_s {
  bool accepted;
  bool writable;
} swarmd_send_result_t;

int
swarmd_send_result_preencode (compact_state_t *state, const swarmd_send_result_t *value);

int
swarmd_send_result_encode (compact_state_t *state, const swarmd_send_result_t *value);

int
swarmd_send_result_decode (compact_state_t *state, swarmd_send_result_t *result);

void
swarmd_send_result_destroy (swarmd_send_result_t *result);

// @swarmd/path
typedef struct swarmd_path_s {
  utf8_string_view_t path; /* borrows from decode buffer */
} swarmd_path_t;

int
swarmd_path_preencode (compact_state_t *state, const swarmd_path_t *value);

int
swarmd_path_encode (compact_state_t *state, const swarmd_path_t *value);

int
swarmd_path_decode (compact_state_t *state, swarmd_path_t *result);

void
swarmd_path_destroy (swarmd_path_t *result);

// @swarmd/hash
typedef struct swarmd_hash_s {
  uint8_t hash[32];
} swarmd_hash_t;

int
swarmd_hash_preencode (compact_state_t *state, const swarmd_hash_t *value);

int
swarmd_hash_encode (compact_state_t *state, const swarmd_hash_t *value);

int
swarmd_hash_decode (compact_state_t *state, swarmd_hash_t *result);

void
swarmd_hash_destroy (swarmd_hash_t *result);

// @swarmd/content-serve
typedef struct swarmd_content_serve_s {
  uint8_t hash[32];
  utf8_string_view_t path; /* borrows from decode buffer */
} swarmd_content_serve_t;

int
swarmd_content_serve_preencode (compact_state_t *state, const swarmd_content_serve_t *value);

int
swarmd_content_serve_encode (compact_state_t *state, const swarmd_content_serve_t *value);

int
swarmd_content_serve_decode (compact_state_t *state, swarmd_content_serve_t *result);

void
swarmd_content_serve_destroy (swarmd_content_serve_t *result);

// @swarmd/content-fetch
typedef struct swarmd_content_fetch_s {
  uint8_t hash[32];
  utf8_string_view_t dest_path; /* borrows from decode buffer */
} swarmd_content_fetch_t;

int
swarmd_content_fetch_preencode (compact_state_t *state, const swarmd_content_fetch_t *value);

int
swarmd_content_fetch_encode (compact_state_t *state, const swarmd_content_fetch_t *value);

int
swarmd_content_fetch_decode (compact_state_t *state, swarmd_content_fetch_t *result);

void
swarmd_content_fetch_destroy (swarmd_content_fetch_t *result);

// @swarmd/content-cancel
typedef struct swarmd_content_cancel_s {
  uint8_t hash[32];
  bool discard;
} swarmd_content_cancel_t;

int
swarmd_content_cancel_preencode (compact_state_t *state, const swarmd_content_cancel_t *value);

int
swarmd_content_cancel_encode (compact_state_t *state, const swarmd_content_cancel_t *value);

int
swarmd_content_cancel_decode (compact_state_t *state, swarmd_content_cancel_t *result);

void
swarmd_content_cancel_destroy (swarmd_content_cancel_t *result);

// @swarmd/content-progress
typedef struct swarmd_content_progress_s {
  uint8_t hash[32];
  uint64_t received;
  uint64_t total;
} swarmd_content_progress_t;

int
swarmd_content_progress_preencode (compact_state_t *state, const swarmd_content_progress_t *value);

int
swarmd_content_progress_encode (compact_state_t *state, const swarmd_content_progress_t *value);

int
swarmd_content_progress_decode (compact_state_t *state, swarmd_content_progress_t *result);

void
swarmd_content_progress_destroy (swarmd_content_progress_t *result);

// @swarmd/content-done
typedef struct swarmd_content_done_s {
  uint8_t hash[32];
  utf8_string_view_t path; /* borrows from decode buffer */
} swarmd_content_done_t;

int
swarmd_content_done_preencode (compact_state_t *state, const swarmd_content_done_t *value);

int
swarmd_content_done_encode (compact_state_t *state, const swarmd_content_done_t *value);

int
swarmd_content_done_decode (compact_state_t *state, swarmd_content_done_t *result);

void
swarmd_content_done_destroy (swarmd_content_done_t *result);

// @swarmd/content-failed
typedef struct swarmd_content_failed_s {
  uint8_t hash[32];
  utf8_string_view_t reason; /* borrows from decode buffer */
} swarmd_content_failed_t;

int
swarmd_content_failed_preencode (compact_state_t *state, const swarmd_content_failed_t *value);

int
swarmd_content_failed_encode (compact_state_t *state, const swarmd_content_failed_t *value);

int
swarmd_content_failed_decode (compact_state_t *state, swarmd_content_failed_t *result);

void
swarmd_content_failed_destroy (swarmd_content_failed_t *result);

// @swarmd/peer-up
typedef struct swarmd_peer_up_s {
  uint64_t peer;
  uint8_t pubkey[32];
} swarmd_peer_up_t;

int
swarmd_peer_up_preencode (compact_state_t *state, const swarmd_peer_up_t *value);

int
swarmd_peer_up_encode (compact_state_t *state, const swarmd_peer_up_t *value);

int
swarmd_peer_up_decode (compact_state_t *state, swarmd_peer_up_t *result);

void
swarmd_peer_up_destroy (swarmd_peer_up_t *result);

// @swarmd/peer-down
typedef struct swarmd_peer_down_s {
  uint64_t peer;
} swarmd_peer_down_t;

int
swarmd_peer_down_preencode (compact_state_t *state, const swarmd_peer_down_t *value);

int
swarmd_peer_down_encode (compact_state_t *state, const swarmd_peer_down_t *value);

int
swarmd_peer_down_decode (compact_state_t *state, swarmd_peer_down_t *result);

void
swarmd_peer_down_destroy (swarmd_peer_down_t *result);

// @swarmd/message
typedef struct swarmd_message_s {
  uint64_t channel;
  uint64_t slot;
  uint64_t origin_kind;
  uint64_t origin_id;
  uint8_t *bytes; /* borrows from decode buffer */
  size_t bytes_len;
} swarmd_message_t;

int
swarmd_message_preencode (compact_state_t *state, const swarmd_message_t *value);

int
swarmd_message_encode (compact_state_t *state, const swarmd_message_t *value);

int
swarmd_message_decode (compact_state_t *state, swarmd_message_t *result);

void
swarmd_message_destroy (swarmd_message_t *result);

#endif // SWARMD_SCHEMA_H