/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
/* Generated from: token/prover.proto */

#ifndef PROTOBUF_C_token_2fprover_2eproto__INCLUDED
#define PROTOBUF_C_token_2fprover_2eproto__INCLUDED

#include <protobuf-c/protobuf-c.h>

PROTOBUF_C__BEGIN_DECLS

#if PROTOBUF_C_VERSION_NUMBER < 1000000
# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
#elif 1002001 < PROTOBUF_C_MIN_COMPILER_VERSION
# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
#endif

#include "google/protobuf/timestamp.pb-c.h"
#include "token/expectations.pb-c.h"
#include "token/transaction.pb-c.h"

typedef struct _Protos__TokenToIssue Protos__TokenToIssue;
typedef struct _Protos__RecipientTransferShare Protos__RecipientTransferShare;
typedef struct _Protos__TokenOutput Protos__TokenOutput;
typedef struct _Protos__UnspentTokens Protos__UnspentTokens;
typedef struct _Protos__ListRequest Protos__ListRequest;
typedef struct _Protos__ImportRequest Protos__ImportRequest;
typedef struct _Protos__TransferRequest Protos__TransferRequest;
typedef struct _Protos__RedeemRequest Protos__RedeemRequest;
typedef struct _Protos__AllowanceRecipientShare Protos__AllowanceRecipientShare;
typedef struct _Protos__ApproveRequest Protos__ApproveRequest;
typedef struct _Protos__ExpectationRequest Protos__ExpectationRequest;
typedef struct _Protos__Header Protos__Header;
typedef struct _Protos__Command Protos__Command;
typedef struct _Protos__SignedCommand Protos__SignedCommand;
typedef struct _Protos__CommandResponseHeader Protos__CommandResponseHeader;
typedef struct _Protos__Error Protos__Error;
typedef struct _Protos__CommandResponse Protos__CommandResponse;
typedef struct _Protos__SignedCommandResponse Protos__SignedCommandResponse;


/* --- enums --- */


/* --- messages --- */

/*
 * TokenToIssue describes a token to be issued in the system
 */
struct  _Protos__TokenToIssue
{
  ProtobufCMessage base;
  /*
   * Recipient refers to the owner of the token to be issued
   */
  protobuf_c_boolean has_recipient;
  ProtobufCBinaryData recipient;
  /*
   * Type refers to the token type
   */
  char *type;
  /*
   * Quantity refers to the number of token units to be issued
   */
  protobuf_c_boolean has_quantity;
  uint64_t quantity;
};
#define PROTOS__TOKEN_TO_ISSUE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&protos__token_to_issue__descriptor) \
    , 0,{0,NULL}, NULL, 0,0 }


/*
 * RecipientTransferShare describes how much a recipient will receive in a token transfer
 */
struct  _Protos__RecipientTransferShare
{
  ProtobufCMessage base;
  /*
   * Recipient refers to the prospective owner of a transferred token
   */
  protobuf_c_boolean has_recipient;
  ProtobufCBinaryData recipient;
  /*
   * Quantity refers to the number of token units to be transferred to the recipient
   */
  protobuf_c_boolean has_quantity;
  uint64_t quantity;
};
#define PROTOS__RECIPIENT_TRANSFER_SHARE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&protos__recipient_transfer_share__descriptor) \
    , 0,{0,NULL}, 0,0 }


/*
 * TokenOutput is used to specify a token returned by ListRequest
 */
struct  _Protos__TokenOutput
{
  ProtobufCMessage base;
  /*
   * ID is used to uniquely identify the token
   */
  protobuf_c_boolean has_id;
  ProtobufCBinaryData id;
  /*
   * Type is the type of the token
   */
  char *type;
  /*
   * Quantity represents the number for this type of token
   */
  protobuf_c_boolean has_quantity;
  uint64_t quantity;
};
#define PROTOS__TOKEN_OUTPUT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&protos__token_output__descriptor) \
    , 0,{0,NULL}, NULL, 0,0 }


/*
 * UnspentTokens is used to hold the output of listRequest
 */
struct  _Protos__UnspentTokens
{
  ProtobufCMessage base;
  size_t n_tokens;
  Protos__TokenOutput **tokens;
};
#define PROTOS__UNSPENT_TOKENS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&protos__unspent_tokens__descriptor) \
    , 0,NULL }


/*
 * ListRequest is used to request a list of unspent tokens
 */
struct  _Protos__ListRequest
{
  ProtobufCMessage base;
  protobuf_c_boolean has_credential;
  ProtobufCBinaryData credential;
};
#define PROTOS__LIST_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&protos__list_request__descriptor) \
    , 0,{0,NULL} }


/*
 * ImportRequest is used to request creation of imports
 */
struct  _Protos__ImportRequest
{
  ProtobufCMessage base;
  /*
   * Credential contains information about the party who is requesting the operation
   * the content of this field depends on the charateristic of the token manager system used.
   */
  protobuf_c_boolean has_credential;
  ProtobufCBinaryData credential;
  /*
   * TokenToIssue contains the information about the tokens to be issued
   */
  size_t n_tokens_to_issue;
  Protos__TokenToIssue **tokens_to_issue;
};
#define PROTOS__IMPORT_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&protos__import_request__descriptor) \
    , 0,{0,NULL}, 0,NULL }


/*
 * RequestTransfer is used to request creation of transfers
 */
struct  _Protos__TransferRequest
{
  ProtobufCMessage base;
  protobuf_c_boolean has_credential;
  ProtobufCBinaryData credential;
  size_t n_token_ids;
  ProtobufCBinaryData *token_ids;
  size_t n_shares;
  Protos__RecipientTransferShare **shares;
};
#define PROTOS__TRANSFER_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&protos__transfer_request__descriptor) \
    , 0,{0,NULL}, 0,NULL, 0,NULL }


/*
 * RedeemRequest is used to request token redemption
 */
struct  _Protos__RedeemRequest
{
  ProtobufCMessage base;
  /*
   * Credential contains information for the party who is requesting the operation
   * The content of this field depends on the characteristic of token manager system
   */
  protobuf_c_boolean has_credential;
  ProtobufCBinaryData credential;
  /*
   * token_ids specifies the ids for the tokens that will be redeemed
   */
  size_t n_token_ids;
  ProtobufCBinaryData *token_ids;
  /*
   * quantity refers to the number of units of a given token needs to be redeemed.
   */
  protobuf_c_boolean has_quantity_to_redeem;
  uint64_t quantity_to_redeem;
};
#define PROTOS__REDEEM_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&protos__redeem_request__descriptor) \
    , 0,{0,NULL}, 0,NULL, 0,0 }


/*
 * ALlowance defines how many and what tokens a recipient can transfer on behalf of their actual owner
 */
struct  _Protos__AllowanceRecipientShare
{
  ProtobufCMessage base;
  /*
   * Recipient refers to the entity allowed to spend the specified quantity from the tokens identified by token IDs
   */
  protobuf_c_boolean has_recipient;
  ProtobufCBinaryData recipient;
  /*
   * Quantity is how many tokens are delegated to the recipient
   */
  protobuf_c_boolean has_quantity;
  uint64_t quantity;
};
#define PROTOS__ALLOWANCE_RECIPIENT_SHARE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&protos__allowance_recipient_share__descriptor) \
    , 0,{0,NULL}, 0,0 }


/*
 * ApproveRequest is used to request the creation of allowance from one owner to another
 */
struct  _Protos__ApproveRequest
{
  ProtobufCMessage base;
  /*
   * Credential refers to the public credential of the request creator
   */
  protobuf_c_boolean has_credential;
  ProtobufCBinaryData credential;
  /*
   * Allowance describes the tokens the creator of the request is willing to delegate
   */
  size_t n_allowance_shares;
  Protos__AllowanceRecipientShare **allowance_shares;
  /*
   * TokenIds are the token identifiers used to create the allowance
   */
  size_t n_token_ids;
  ProtobufCBinaryData *token_ids;
};
#define PROTOS__APPROVE_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&protos__approve_request__descriptor) \
    , 0,{0,NULL}, 0,NULL, 0,NULL }


/*
 * ExpectationRequest is used to request indirect token import or transfer based on the token expectation
 */
struct  _Protos__ExpectationRequest
{
  ProtobufCMessage base;
  /*
   * credential contains information for the party who is requesting the operation
   * The content of this field depends on the characteristic of token manager system
   */
  protobuf_c_boolean has_credential;
  ProtobufCBinaryData credential;
  /*
   * expectation contains the expected outputs for token import or transfer
   */
  Protos__TokenExpectation *expectation;
  /*
   * TokenIds are the token identifiers used to fulfill the expectation
   */
  size_t n_token_ids;
  ProtobufCBinaryData *token_ids;
};
#define PROTOS__EXPECTATION_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&protos__expectation_request__descriptor) \
    , 0,{0,NULL}, NULL, 0,NULL }


/*
 * Header is a generic replay prevention and identity message to include in a signed command
 */
struct  _Protos__Header
{
  ProtobufCMessage base;
  /*
   * Timestamp is the local time when the message was created
   * by the sender
   */
  Google__Protobuf__Timestamp *timestamp;
  /*
   * ChannelId identifies the channel this message is bound for
   */
  char *channel_id;
  /*
   * Nonce is a sufficientley long random value
   * used to ensure the request has enough entropy.
   */
  protobuf_c_boolean has_nonce;
  ProtobufCBinaryData nonce;
  /*
   * Creator of the message.
   * Typically, a marshaled msp.SerializedIdentity
   */
  protobuf_c_boolean has_creator;
  ProtobufCBinaryData creator;
};
#define PROTOS__HEADER__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&protos__header__descriptor) \
    , NULL, NULL, 0,{0,NULL}, 0,{0,NULL} }


typedef enum {
  PROTOS__COMMAND__PAYLOAD__NOT_SET = 0,
  PROTOS__COMMAND__PAYLOAD_IMPORT_REQUEST = 2,
  PROTOS__COMMAND__PAYLOAD_TRANSFER_REQUEST = 3,
  PROTOS__COMMAND__PAYLOAD_LIST_REQUEST = 4,
  PROTOS__COMMAND__PAYLOAD_REDEEM_REQUEST = 5,
  PROTOS__COMMAND__PAYLOAD_APPROVE_REQUEST = 6,
  PROTOS__COMMAND__PAYLOAD_TRANSFER_FROM_REQUEST = 7,
  PROTOS__COMMAND__PAYLOAD_EXPECTATION_REQUEST = 8,
} Protos__Command__PayloadCase;

/*
 * Command describes the type of operation that a client is requesting.
 */
struct  _Protos__Command
{
  ProtobufCMessage base;
  /*
   * Header is the header of this command
   */
  Protos__Header *header;
  Protos__Command__PayloadCase payload_case;
  union {
    Protos__ImportRequest *import_request;
    Protos__TransferRequest *transfer_request;
    Protos__ListRequest *list_request;
    Protos__RedeemRequest *redeem_request;
    Protos__ApproveRequest *approve_request;
    Protos__TransferRequest *transfer_from_request;
    Protos__ExpectationRequest *expectation_request;
  };
};
#define PROTOS__COMMAND__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&protos__command__descriptor) \
    , NULL, PROTOS__COMMAND__PAYLOAD__NOT_SET, {0} }


/*
 * SignedCommand is a command that carries the signature of the command's creator.
 */
struct  _Protos__SignedCommand
{
  ProtobufCMessage base;
  /*
   * Command is the serialised version of a Command message
   */
  protobuf_c_boolean has_command;
  ProtobufCBinaryData command;
  /*
   * Signature is the signature over command
   */
  protobuf_c_boolean has_signature;
  ProtobufCBinaryData signature;
};
#define PROTOS__SIGNED_COMMAND__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&protos__signed_command__descriptor) \
    , 0,{0,NULL}, 0,{0,NULL} }


struct  _Protos__CommandResponseHeader
{
  ProtobufCMessage base;
  /*
   * Timestamp is the time that the message
   * was created as  defined by the sender
   */
  Google__Protobuf__Timestamp *timestamp;
  /*
   * CommandHash is the hash computed on the concatenation of the SignedCommand's command and signature fields.
   * If not specified differently, SHA256 is used
   * The hash is used to link a response with its request, both for bookeeping purposes on an
   * asynchronous system and for security reasons (accountability, non-repudiation)
   */
  protobuf_c_boolean has_command_hash;
  ProtobufCBinaryData command_hash;
  /*
   * Creator is the identity of the party creating this message
   */
  protobuf_c_boolean has_creator;
  ProtobufCBinaryData creator;
};
#define PROTOS__COMMAND_RESPONSE_HEADER__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&protos__command_response_header__descriptor) \
    , NULL, 0,{0,NULL}, 0,{0,NULL} }


/*
 * Error reports an application error
 */
struct  _Protos__Error
{
  ProtobufCMessage base;
  /*
   * Message associated with this response.
   */
  char *message;
  /*
   * Payload that can be used to include metadata with this response.
   */
  protobuf_c_boolean has_payload;
  ProtobufCBinaryData payload;
};
#define PROTOS__ERROR__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&protos__error__descriptor) \
    , NULL, 0,{0,NULL} }


typedef enum {
  PROTOS__COMMAND_RESPONSE__PAYLOAD__NOT_SET = 0,
  PROTOS__COMMAND_RESPONSE__PAYLOAD_ERR = 2,
  PROTOS__COMMAND_RESPONSE__PAYLOAD_TOKEN_TRANSACTION = 3,
  PROTOS__COMMAND_RESPONSE__PAYLOAD_UNSPENT_TOKENS = 4,
} Protos__CommandResponse__PayloadCase;

/*
 * A CommnandResponse is returned from a prover to the command submitter.
 */
struct  _Protos__CommandResponse
{
  ProtobufCMessage base;
  /*
   * Header of the response.
   */
  Protos__CommandResponseHeader *header;
  Protos__CommandResponse__PayloadCase payload_case;
  union {
    Protos__Error *err;
    TokenTransaction *token_transaction;
    Protos__UnspentTokens *unspent_tokens;
  };
};
#define PROTOS__COMMAND_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&protos__command_response__descriptor) \
    , NULL, PROTOS__COMMAND_RESPONSE__PAYLOAD__NOT_SET, {0} }


/*
 * SignedCommandResponse is a signed command response
 */
struct  _Protos__SignedCommandResponse
{
  ProtobufCMessage base;
  /*
   * Response is the serialised version of a CommandResponse message
   */
  protobuf_c_boolean has_response;
  ProtobufCBinaryData response;
  /*
   * Signature is the signature over command
   */
  protobuf_c_boolean has_signature;
  ProtobufCBinaryData signature;
};
#define PROTOS__SIGNED_COMMAND_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&protos__signed_command_response__descriptor) \
    , 0,{0,NULL}, 0,{0,NULL} }


/* Protos__TokenToIssue methods */
void   protos__token_to_issue__init
                     (Protos__TokenToIssue         *message);
size_t protos__token_to_issue__get_packed_size
                     (const Protos__TokenToIssue   *message);
size_t protos__token_to_issue__pack
                     (const Protos__TokenToIssue   *message,
                      uint8_t             *out);
size_t protos__token_to_issue__pack_to_buffer
                     (const Protos__TokenToIssue   *message,
                      ProtobufCBuffer     *buffer);
Protos__TokenToIssue *
       protos__token_to_issue__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   protos__token_to_issue__free_unpacked
                     (Protos__TokenToIssue *message,
                      ProtobufCAllocator *allocator);
/* Protos__RecipientTransferShare methods */
void   protos__recipient_transfer_share__init
                     (Protos__RecipientTransferShare         *message);
size_t protos__recipient_transfer_share__get_packed_size
                     (const Protos__RecipientTransferShare   *message);
size_t protos__recipient_transfer_share__pack
                     (const Protos__RecipientTransferShare   *message,
                      uint8_t             *out);
size_t protos__recipient_transfer_share__pack_to_buffer
                     (const Protos__RecipientTransferShare   *message,
                      ProtobufCBuffer     *buffer);
Protos__RecipientTransferShare *
       protos__recipient_transfer_share__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   protos__recipient_transfer_share__free_unpacked
                     (Protos__RecipientTransferShare *message,
                      ProtobufCAllocator *allocator);
/* Protos__TokenOutput methods */
void   protos__token_output__init
                     (Protos__TokenOutput         *message);
size_t protos__token_output__get_packed_size
                     (const Protos__TokenOutput   *message);
size_t protos__token_output__pack
                     (const Protos__TokenOutput   *message,
                      uint8_t             *out);
size_t protos__token_output__pack_to_buffer
                     (const Protos__TokenOutput   *message,
                      ProtobufCBuffer     *buffer);
Protos__TokenOutput *
       protos__token_output__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   protos__token_output__free_unpacked
                     (Protos__TokenOutput *message,
                      ProtobufCAllocator *allocator);
/* Protos__UnspentTokens methods */
void   protos__unspent_tokens__init
                     (Protos__UnspentTokens         *message);
size_t protos__unspent_tokens__get_packed_size
                     (const Protos__UnspentTokens   *message);
size_t protos__unspent_tokens__pack
                     (const Protos__UnspentTokens   *message,
                      uint8_t             *out);
size_t protos__unspent_tokens__pack_to_buffer
                     (const Protos__UnspentTokens   *message,
                      ProtobufCBuffer     *buffer);
Protos__UnspentTokens *
       protos__unspent_tokens__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   protos__unspent_tokens__free_unpacked
                     (Protos__UnspentTokens *message,
                      ProtobufCAllocator *allocator);
/* Protos__ListRequest methods */
void   protos__list_request__init
                     (Protos__ListRequest         *message);
size_t protos__list_request__get_packed_size
                     (const Protos__ListRequest   *message);
size_t protos__list_request__pack
                     (const Protos__ListRequest   *message,
                      uint8_t             *out);
size_t protos__list_request__pack_to_buffer
                     (const Protos__ListRequest   *message,
                      ProtobufCBuffer     *buffer);
Protos__ListRequest *
       protos__list_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   protos__list_request__free_unpacked
                     (Protos__ListRequest *message,
                      ProtobufCAllocator *allocator);
/* Protos__ImportRequest methods */
void   protos__import_request__init
                     (Protos__ImportRequest         *message);
size_t protos__import_request__get_packed_size
                     (const Protos__ImportRequest   *message);
size_t protos__import_request__pack
                     (const Protos__ImportRequest   *message,
                      uint8_t             *out);
size_t protos__import_request__pack_to_buffer
                     (const Protos__ImportRequest   *message,
                      ProtobufCBuffer     *buffer);
Protos__ImportRequest *
       protos__import_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   protos__import_request__free_unpacked
                     (Protos__ImportRequest *message,
                      ProtobufCAllocator *allocator);
/* Protos__TransferRequest methods */
void   protos__transfer_request__init
                     (Protos__TransferRequest         *message);
size_t protos__transfer_request__get_packed_size
                     (const Protos__TransferRequest   *message);
size_t protos__transfer_request__pack
                     (const Protos__TransferRequest   *message,
                      uint8_t             *out);
size_t protos__transfer_request__pack_to_buffer
                     (const Protos__TransferRequest   *message,
                      ProtobufCBuffer     *buffer);
Protos__TransferRequest *
       protos__transfer_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   protos__transfer_request__free_unpacked
                     (Protos__TransferRequest *message,
                      ProtobufCAllocator *allocator);
/* Protos__RedeemRequest methods */
void   protos__redeem_request__init
                     (Protos__RedeemRequest         *message);
size_t protos__redeem_request__get_packed_size
                     (const Protos__RedeemRequest   *message);
size_t protos__redeem_request__pack
                     (const Protos__RedeemRequest   *message,
                      uint8_t             *out);
size_t protos__redeem_request__pack_to_buffer
                     (const Protos__RedeemRequest   *message,
                      ProtobufCBuffer     *buffer);
Protos__RedeemRequest *
       protos__redeem_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   protos__redeem_request__free_unpacked
                     (Protos__RedeemRequest *message,
                      ProtobufCAllocator *allocator);
/* Protos__AllowanceRecipientShare methods */
void   protos__allowance_recipient_share__init
                     (Protos__AllowanceRecipientShare         *message);
size_t protos__allowance_recipient_share__get_packed_size
                     (const Protos__AllowanceRecipientShare   *message);
size_t protos__allowance_recipient_share__pack
                     (const Protos__AllowanceRecipientShare   *message,
                      uint8_t             *out);
size_t protos__allowance_recipient_share__pack_to_buffer
                     (const Protos__AllowanceRecipientShare   *message,
                      ProtobufCBuffer     *buffer);
Protos__AllowanceRecipientShare *
       protos__allowance_recipient_share__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   protos__allowance_recipient_share__free_unpacked
                     (Protos__AllowanceRecipientShare *message,
                      ProtobufCAllocator *allocator);
/* Protos__ApproveRequest methods */
void   protos__approve_request__init
                     (Protos__ApproveRequest         *message);
size_t protos__approve_request__get_packed_size
                     (const Protos__ApproveRequest   *message);
size_t protos__approve_request__pack
                     (const Protos__ApproveRequest   *message,
                      uint8_t             *out);
size_t protos__approve_request__pack_to_buffer
                     (const Protos__ApproveRequest   *message,
                      ProtobufCBuffer     *buffer);
Protos__ApproveRequest *
       protos__approve_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   protos__approve_request__free_unpacked
                     (Protos__ApproveRequest *message,
                      ProtobufCAllocator *allocator);
/* Protos__ExpectationRequest methods */
void   protos__expectation_request__init
                     (Protos__ExpectationRequest         *message);
size_t protos__expectation_request__get_packed_size
                     (const Protos__ExpectationRequest   *message);
size_t protos__expectation_request__pack
                     (const Protos__ExpectationRequest   *message,
                      uint8_t             *out);
size_t protos__expectation_request__pack_to_buffer
                     (const Protos__ExpectationRequest   *message,
                      ProtobufCBuffer     *buffer);
Protos__ExpectationRequest *
       protos__expectation_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   protos__expectation_request__free_unpacked
                     (Protos__ExpectationRequest *message,
                      ProtobufCAllocator *allocator);
/* Protos__Header methods */
void   protos__header__init
                     (Protos__Header         *message);
size_t protos__header__get_packed_size
                     (const Protos__Header   *message);
size_t protos__header__pack
                     (const Protos__Header   *message,
                      uint8_t             *out);
size_t protos__header__pack_to_buffer
                     (const Protos__Header   *message,
                      ProtobufCBuffer     *buffer);
Protos__Header *
       protos__header__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   protos__header__free_unpacked
                     (Protos__Header *message,
                      ProtobufCAllocator *allocator);
/* Protos__Command methods */
void   protos__command__init
                     (Protos__Command         *message);
size_t protos__command__get_packed_size
                     (const Protos__Command   *message);
size_t protos__command__pack
                     (const Protos__Command   *message,
                      uint8_t             *out);
size_t protos__command__pack_to_buffer
                     (const Protos__Command   *message,
                      ProtobufCBuffer     *buffer);
Protos__Command *
       protos__command__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   protos__command__free_unpacked
                     (Protos__Command *message,
                      ProtobufCAllocator *allocator);
/* Protos__SignedCommand methods */
void   protos__signed_command__init
                     (Protos__SignedCommand         *message);
size_t protos__signed_command__get_packed_size
                     (const Protos__SignedCommand   *message);
size_t protos__signed_command__pack
                     (const Protos__SignedCommand   *message,
                      uint8_t             *out);
size_t protos__signed_command__pack_to_buffer
                     (const Protos__SignedCommand   *message,
                      ProtobufCBuffer     *buffer);
Protos__SignedCommand *
       protos__signed_command__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   protos__signed_command__free_unpacked
                     (Protos__SignedCommand *message,
                      ProtobufCAllocator *allocator);
/* Protos__CommandResponseHeader methods */
void   protos__command_response_header__init
                     (Protos__CommandResponseHeader         *message);
size_t protos__command_response_header__get_packed_size
                     (const Protos__CommandResponseHeader   *message);
size_t protos__command_response_header__pack
                     (const Protos__CommandResponseHeader   *message,
                      uint8_t             *out);
size_t protos__command_response_header__pack_to_buffer
                     (const Protos__CommandResponseHeader   *message,
                      ProtobufCBuffer     *buffer);
Protos__CommandResponseHeader *
       protos__command_response_header__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   protos__command_response_header__free_unpacked
                     (Protos__CommandResponseHeader *message,
                      ProtobufCAllocator *allocator);
/* Protos__Error methods */
void   protos__error__init
                     (Protos__Error         *message);
size_t protos__error__get_packed_size
                     (const Protos__Error   *message);
size_t protos__error__pack
                     (const Protos__Error   *message,
                      uint8_t             *out);
size_t protos__error__pack_to_buffer
                     (const Protos__Error   *message,
                      ProtobufCBuffer     *buffer);
Protos__Error *
       protos__error__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   protos__error__free_unpacked
                     (Protos__Error *message,
                      ProtobufCAllocator *allocator);
/* Protos__CommandResponse methods */
void   protos__command_response__init
                     (Protos__CommandResponse         *message);
size_t protos__command_response__get_packed_size
                     (const Protos__CommandResponse   *message);
size_t protos__command_response__pack
                     (const Protos__CommandResponse   *message,
                      uint8_t             *out);
size_t protos__command_response__pack_to_buffer
                     (const Protos__CommandResponse   *message,
                      ProtobufCBuffer     *buffer);
Protos__CommandResponse *
       protos__command_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   protos__command_response__free_unpacked
                     (Protos__CommandResponse *message,
                      ProtobufCAllocator *allocator);
/* Protos__SignedCommandResponse methods */
void   protos__signed_command_response__init
                     (Protos__SignedCommandResponse         *message);
size_t protos__signed_command_response__get_packed_size
                     (const Protos__SignedCommandResponse   *message);
size_t protos__signed_command_response__pack
                     (const Protos__SignedCommandResponse   *message,
                      uint8_t             *out);
size_t protos__signed_command_response__pack_to_buffer
                     (const Protos__SignedCommandResponse   *message,
                      ProtobufCBuffer     *buffer);
Protos__SignedCommandResponse *
       protos__signed_command_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   protos__signed_command_response__free_unpacked
                     (Protos__SignedCommandResponse *message,
                      ProtobufCAllocator *allocator);
/* --- per-message closures --- */

typedef void (*Protos__TokenToIssue_Closure)
                 (const Protos__TokenToIssue *message,
                  void *closure_data);
typedef void (*Protos__RecipientTransferShare_Closure)
                 (const Protos__RecipientTransferShare *message,
                  void *closure_data);
typedef void (*Protos__TokenOutput_Closure)
                 (const Protos__TokenOutput *message,
                  void *closure_data);
typedef void (*Protos__UnspentTokens_Closure)
                 (const Protos__UnspentTokens *message,
                  void *closure_data);
typedef void (*Protos__ListRequest_Closure)
                 (const Protos__ListRequest *message,
                  void *closure_data);
typedef void (*Protos__ImportRequest_Closure)
                 (const Protos__ImportRequest *message,
                  void *closure_data);
typedef void (*Protos__TransferRequest_Closure)
                 (const Protos__TransferRequest *message,
                  void *closure_data);
typedef void (*Protos__RedeemRequest_Closure)
                 (const Protos__RedeemRequest *message,
                  void *closure_data);
typedef void (*Protos__AllowanceRecipientShare_Closure)
                 (const Protos__AllowanceRecipientShare *message,
                  void *closure_data);
typedef void (*Protos__ApproveRequest_Closure)
                 (const Protos__ApproveRequest *message,
                  void *closure_data);
typedef void (*Protos__ExpectationRequest_Closure)
                 (const Protos__ExpectationRequest *message,
                  void *closure_data);
typedef void (*Protos__Header_Closure)
                 (const Protos__Header *message,
                  void *closure_data);
typedef void (*Protos__Command_Closure)
                 (const Protos__Command *message,
                  void *closure_data);
typedef void (*Protos__SignedCommand_Closure)
                 (const Protos__SignedCommand *message,
                  void *closure_data);
typedef void (*Protos__CommandResponseHeader_Closure)
                 (const Protos__CommandResponseHeader *message,
                  void *closure_data);
typedef void (*Protos__Error_Closure)
                 (const Protos__Error *message,
                  void *closure_data);
typedef void (*Protos__CommandResponse_Closure)
                 (const Protos__CommandResponse *message,
                  void *closure_data);
typedef void (*Protos__SignedCommandResponse_Closure)
                 (const Protos__SignedCommandResponse *message,
                  void *closure_data);

/* --- services --- */

typedef struct _Protos__Prover_Service Protos__Prover_Service;
struct _Protos__Prover_Service
{
  ProtobufCService base;
  void (*process_command)(Protos__Prover_Service *service,
                          const Protos__SignedCommand *input,
                          Protos__SignedCommandResponse_Closure closure,
                          void *closure_data);
};
typedef void (*Protos__Prover_ServiceDestroy)(Protos__Prover_Service *);
void protos__prover__init (Protos__Prover_Service *service,
                           Protos__Prover_ServiceDestroy destroy);
#define PROTOS__PROVER__BASE_INIT \
    { &protos__prover__descriptor, protobuf_c_service_invoke_internal, NULL }
#define PROTOS__PROVER__INIT(function_prefix__) \
    { PROTOS__PROVER__BASE_INIT,\
      function_prefix__ ## process_command  }
void protos__prover__process_command(ProtobufCService *service,
                                     const Protos__SignedCommand *input,
                                     Protos__SignedCommandResponse_Closure closure,
                                     void *closure_data);

/* --- descriptors --- */

extern const ProtobufCMessageDescriptor protos__token_to_issue__descriptor;
extern const ProtobufCMessageDescriptor protos__recipient_transfer_share__descriptor;
extern const ProtobufCMessageDescriptor protos__token_output__descriptor;
extern const ProtobufCMessageDescriptor protos__unspent_tokens__descriptor;
extern const ProtobufCMessageDescriptor protos__list_request__descriptor;
extern const ProtobufCMessageDescriptor protos__import_request__descriptor;
extern const ProtobufCMessageDescriptor protos__transfer_request__descriptor;
extern const ProtobufCMessageDescriptor protos__redeem_request__descriptor;
extern const ProtobufCMessageDescriptor protos__allowance_recipient_share__descriptor;
extern const ProtobufCMessageDescriptor protos__approve_request__descriptor;
extern const ProtobufCMessageDescriptor protos__expectation_request__descriptor;
extern const ProtobufCMessageDescriptor protos__header__descriptor;
extern const ProtobufCMessageDescriptor protos__command__descriptor;
extern const ProtobufCMessageDescriptor protos__signed_command__descriptor;
extern const ProtobufCMessageDescriptor protos__command_response_header__descriptor;
extern const ProtobufCMessageDescriptor protos__error__descriptor;
extern const ProtobufCMessageDescriptor protos__command_response__descriptor;
extern const ProtobufCMessageDescriptor protos__signed_command_response__descriptor;
extern const ProtobufCServiceDescriptor protos__prover__descriptor;

PROTOBUF_C__END_DECLS


#endif  /* PROTOBUF_C_token_2fprover_2eproto__INCLUDED */
