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

#ifndef PROTOBUF_C_Mumble_2eproto__INCLUDED
#define PROTOBUF_C_Mumble_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 1003003 < 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


typedef struct _MumbleProto__Version MumbleProto__Version;
typedef struct _MumbleProto__UDPTunnel MumbleProto__UDPTunnel;
typedef struct _MumbleProto__Authenticate MumbleProto__Authenticate;
typedef struct _MumbleProto__Ping MumbleProto__Ping;
typedef struct _MumbleProto__Reject MumbleProto__Reject;
typedef struct _MumbleProto__ServerConfig MumbleProto__ServerConfig;
typedef struct _MumbleProto__ServerSync MumbleProto__ServerSync;
typedef struct _MumbleProto__ChannelRemove MumbleProto__ChannelRemove;
typedef struct _MumbleProto__ChannelState MumbleProto__ChannelState;
typedef struct _MumbleProto__UserRemove MumbleProto__UserRemove;
typedef struct _MumbleProto__UserState MumbleProto__UserState;
typedef struct _MumbleProto__BanList MumbleProto__BanList;
typedef struct _MumbleProto__BanList__BanEntry MumbleProto__BanList__BanEntry;
typedef struct _MumbleProto__TextMessage MumbleProto__TextMessage;
typedef struct _MumbleProto__PermissionDenied MumbleProto__PermissionDenied;
typedef struct _MumbleProto__ACL MumbleProto__ACL;
typedef struct _MumbleProto__ACL__ChanGroup MumbleProto__ACL__ChanGroup;
typedef struct _MumbleProto__ACL__ChanACL MumbleProto__ACL__ChanACL;
typedef struct _MumbleProto__QueryUsers MumbleProto__QueryUsers;
typedef struct _MumbleProto__CryptSetup MumbleProto__CryptSetup;
typedef struct _MumbleProto__ContextActionModify MumbleProto__ContextActionModify;
typedef struct _MumbleProto__ContextAction MumbleProto__ContextAction;
typedef struct _MumbleProto__UserList MumbleProto__UserList;
typedef struct _MumbleProto__UserList__User MumbleProto__UserList__User;
typedef struct _MumbleProto__VoiceTarget MumbleProto__VoiceTarget;
typedef struct _MumbleProto__VoiceTarget__Target MumbleProto__VoiceTarget__Target;
typedef struct _MumbleProto__PermissionQuery MumbleProto__PermissionQuery;
typedef struct _MumbleProto__CodecVersion MumbleProto__CodecVersion;
typedef struct _MumbleProto__UserStats MumbleProto__UserStats;
typedef struct _MumbleProto__UserStats__Stats MumbleProto__UserStats__Stats;
typedef struct _MumbleProto__SuggestConfig MumbleProto__SuggestConfig;
typedef struct _MumbleProto__RequestBlob MumbleProto__RequestBlob;


/* --- enums --- */

typedef enum _MumbleProto__Reject__RejectType {
  MUMBLE_PROTO__REJECT__REJECT_TYPE__None = 0,
  MUMBLE_PROTO__REJECT__REJECT_TYPE__WrongVersion = 1,
  MUMBLE_PROTO__REJECT__REJECT_TYPE__InvalidUsername = 2,
  MUMBLE_PROTO__REJECT__REJECT_TYPE__WrongUserPW = 3,
  MUMBLE_PROTO__REJECT__REJECT_TYPE__WrongServerPW = 4,
  MUMBLE_PROTO__REJECT__REJECT_TYPE__UsernameInUse = 5,
  MUMBLE_PROTO__REJECT__REJECT_TYPE__ServerFull = 6,
  MUMBLE_PROTO__REJECT__REJECT_TYPE__NoCertificate = 7
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MUMBLE_PROTO__REJECT__REJECT_TYPE)
} MumbleProto__Reject__RejectType;
typedef enum _MumbleProto__PermissionDenied__DenyType {
  MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__Text = 0,
  MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__Permission = 1,
  MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__SuperUser = 2,
  MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__ChannelName = 3,
  MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TextTooLong = 4,
  MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__H9K = 5,
  MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TemporaryChannel = 6,
  MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__MissingCertificate = 7,
  MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__UserName = 8,
  MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__ChannelFull = 9,
  MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__NestingLimit = 10
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE)
} MumbleProto__PermissionDenied__DenyType;
typedef enum _MumbleProto__ContextActionModify__Context {
  MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__CONTEXT__Server = 1,
  MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__CONTEXT__Channel = 2,
  MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__CONTEXT__User = 4
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__CONTEXT)
} MumbleProto__ContextActionModify__Context;
typedef enum _MumbleProto__ContextActionModify__Operation {
  MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__OPERATION__Add = 0,
  MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__OPERATION__Remove = 1
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__OPERATION)
} MumbleProto__ContextActionModify__Operation;

/* --- messages --- */

struct  _MumbleProto__Version
{
  ProtobufCMessage base;
  protobuf_c_boolean has_version;
  uint32_t version;
  char *release;
  char *os;
  char *os_version;
};
#define MUMBLE_PROTO__VERSION__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__version__descriptor) \
    , 0, 0, NULL, NULL, NULL }


struct  _MumbleProto__UDPTunnel
{
  ProtobufCMessage base;
  ProtobufCBinaryData packet;
};
#define MUMBLE_PROTO__UDPTUNNEL__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__udptunnel__descriptor) \
    , {0,NULL} }


struct  _MumbleProto__Authenticate
{
  ProtobufCMessage base;
  char *username;
  char *password;
  size_t n_tokens;
  char **tokens;
  size_t n_celt_versions;
  int32_t *celt_versions;
  protobuf_c_boolean has_opus;
  protobuf_c_boolean opus;
};
#define MUMBLE_PROTO__AUTHENTICATE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__authenticate__descriptor) \
    , NULL, NULL, 0,NULL, 0,NULL, 0, 0 }


struct  _MumbleProto__Ping
{
  ProtobufCMessage base;
  protobuf_c_boolean has_timestamp;
  uint64_t timestamp;
  protobuf_c_boolean has_good;
  uint32_t good;
  protobuf_c_boolean has_late;
  uint32_t late;
  protobuf_c_boolean has_lost;
  uint32_t lost;
  protobuf_c_boolean has_resync;
  uint32_t resync;
  protobuf_c_boolean has_udp_packets;
  uint32_t udp_packets;
  protobuf_c_boolean has_tcp_packets;
  uint32_t tcp_packets;
  protobuf_c_boolean has_udp_ping_avg;
  float udp_ping_avg;
  protobuf_c_boolean has_udp_ping_var;
  float udp_ping_var;
  protobuf_c_boolean has_tcp_ping_avg;
  float tcp_ping_avg;
  protobuf_c_boolean has_tcp_ping_var;
  float tcp_ping_var;
};
#define MUMBLE_PROTO__PING__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__ping__descriptor) \
    , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }


struct  _MumbleProto__Reject
{
  ProtobufCMessage base;
  protobuf_c_boolean has_type;
  MumbleProto__Reject__RejectType type;
  char *reason;
};
#define MUMBLE_PROTO__REJECT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__reject__descriptor) \
    , 0, MUMBLE_PROTO__REJECT__REJECT_TYPE__None, NULL }


struct  _MumbleProto__ServerConfig
{
  ProtobufCMessage base;
  protobuf_c_boolean has_max_bandwidth;
  uint32_t max_bandwidth;
  char *welcome_text;
  protobuf_c_boolean has_allow_html;
  protobuf_c_boolean allow_html;
  protobuf_c_boolean has_message_length;
  uint32_t message_length;
  protobuf_c_boolean has_image_message_length;
  uint32_t image_message_length;
};
#define MUMBLE_PROTO__SERVER_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__server_config__descriptor) \
    , 0, 0, NULL, 0, 0, 0, 0, 0, 0 }


struct  _MumbleProto__ServerSync
{
  ProtobufCMessage base;
  protobuf_c_boolean has_session;
  uint32_t session;
  protobuf_c_boolean has_max_bandwidth;
  uint32_t max_bandwidth;
  char *welcome_text;
  protobuf_c_boolean has_permissions;
  uint64_t permissions;
};
#define MUMBLE_PROTO__SERVER_SYNC__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__server_sync__descriptor) \
    , 0, 0, 0, 0, NULL, 0, 0 }


struct  _MumbleProto__ChannelRemove
{
  ProtobufCMessage base;
  uint32_t channel_id;
};
#define MUMBLE_PROTO__CHANNEL_REMOVE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__channel_remove__descriptor) \
    , 0 }


struct  _MumbleProto__ChannelState
{
  ProtobufCMessage base;
  protobuf_c_boolean has_channel_id;
  uint32_t channel_id;
  protobuf_c_boolean has_parent;
  uint32_t parent;
  char *name;
  size_t n_links;
  uint32_t *links;
  char *description;
  size_t n_links_add;
  uint32_t *links_add;
  size_t n_links_remove;
  uint32_t *links_remove;
  protobuf_c_boolean has_temporary;
  protobuf_c_boolean temporary;
  protobuf_c_boolean has_position;
  int32_t position;
  protobuf_c_boolean has_description_hash;
  ProtobufCBinaryData description_hash;
};
#define MUMBLE_PROTO__CHANNEL_STATE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__channel_state__descriptor) \
    , 0, 0, 0, 0, NULL, 0,NULL, NULL, 0,NULL, 0,NULL, 0, 0, 0, 0, 0, {0,NULL} }


struct  _MumbleProto__UserRemove
{
  ProtobufCMessage base;
  uint32_t session;
  protobuf_c_boolean has_actor;
  uint32_t actor;
  char *reason;
  protobuf_c_boolean has_ban;
  protobuf_c_boolean ban;
};
#define MUMBLE_PROTO__USER_REMOVE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__user_remove__descriptor) \
    , 0, 0, 0, NULL, 0, 0 }


struct  _MumbleProto__UserState
{
  ProtobufCMessage base;
  protobuf_c_boolean has_session;
  uint32_t session;
  protobuf_c_boolean has_actor;
  uint32_t actor;
  char *name;
  protobuf_c_boolean has_user_id;
  uint32_t user_id;
  protobuf_c_boolean has_channel_id;
  uint32_t channel_id;
  protobuf_c_boolean has_mute;
  protobuf_c_boolean mute;
  protobuf_c_boolean has_deaf;
  protobuf_c_boolean deaf;
  protobuf_c_boolean has_suppress;
  protobuf_c_boolean suppress;
  protobuf_c_boolean has_self_mute;
  protobuf_c_boolean self_mute;
  protobuf_c_boolean has_self_deaf;
  protobuf_c_boolean self_deaf;
  protobuf_c_boolean has_texture;
  ProtobufCBinaryData texture;
  protobuf_c_boolean has_plugin_context;
  ProtobufCBinaryData plugin_context;
  char *plugin_identity;
  char *comment;
  char *hash;
  protobuf_c_boolean has_comment_hash;
  ProtobufCBinaryData comment_hash;
  protobuf_c_boolean has_texture_hash;
  ProtobufCBinaryData texture_hash;
  protobuf_c_boolean has_priority_speaker;
  protobuf_c_boolean priority_speaker;
  protobuf_c_boolean has_recording;
  protobuf_c_boolean recording;
};
#define MUMBLE_PROTO__USER_STATE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__user_state__descriptor) \
    , 0, 0, 0, 0, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0,NULL}, 0, {0,NULL}, NULL, NULL, NULL, 0, {0,NULL}, 0, {0,NULL}, 0, 0, 0, 0 }


struct  _MumbleProto__BanList__BanEntry
{
  ProtobufCMessage base;
  ProtobufCBinaryData address;
  uint32_t mask;
  char *name;
  char *hash;
  char *reason;
  char *start;
  protobuf_c_boolean has_duration;
  uint32_t duration;
};
#define MUMBLE_PROTO__BAN_LIST__BAN_ENTRY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__ban_list__ban_entry__descriptor) \
    , {0,NULL}, 0, NULL, NULL, NULL, NULL, 0, 0 }


struct  _MumbleProto__BanList
{
  ProtobufCMessage base;
  size_t n_bans;
  MumbleProto__BanList__BanEntry **bans;
  protobuf_c_boolean has_query;
  protobuf_c_boolean query;
};
#define MUMBLE_PROTO__BAN_LIST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__ban_list__descriptor) \
    , 0,NULL, 0, 0 }


struct  _MumbleProto__TextMessage
{
  ProtobufCMessage base;
  protobuf_c_boolean has_actor;
  uint32_t actor;
  size_t n_session;
  uint32_t *session;
  size_t n_channel_id;
  uint32_t *channel_id;
  size_t n_tree_id;
  uint32_t *tree_id;
  char *message;
};
#define MUMBLE_PROTO__TEXT_MESSAGE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__text_message__descriptor) \
    , 0, 0, 0,NULL, 0,NULL, 0,NULL, NULL }


struct  _MumbleProto__PermissionDenied
{
  ProtobufCMessage base;
  protobuf_c_boolean has_permission;
  uint32_t permission;
  protobuf_c_boolean has_channel_id;
  uint32_t channel_id;
  protobuf_c_boolean has_session;
  uint32_t session;
  char *reason;
  protobuf_c_boolean has_type;
  MumbleProto__PermissionDenied__DenyType type;
  char *name;
};
#define MUMBLE_PROTO__PERMISSION_DENIED__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__permission_denied__descriptor) \
    , 0, 0, 0, 0, 0, 0, NULL, 0, MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__Text, NULL }


struct  _MumbleProto__ACL__ChanGroup
{
  ProtobufCMessage base;
  char *name;
  protobuf_c_boolean has_inherited;
  protobuf_c_boolean inherited;
  protobuf_c_boolean has_inherit;
  protobuf_c_boolean inherit;
  protobuf_c_boolean has_inheritable;
  protobuf_c_boolean inheritable;
  size_t n_add;
  uint32_t *add;
  size_t n_remove;
  uint32_t *remove;
  size_t n_inherited_members;
  uint32_t *inherited_members;
};
#define MUMBLE_PROTO__ACL__CHAN_GROUP__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__acl__chan_group__descriptor) \
    , NULL, 0, 1, 0, 1, 0, 1, 0,NULL, 0,NULL, 0,NULL }


struct  _MumbleProto__ACL__ChanACL
{
  ProtobufCMessage base;
  protobuf_c_boolean has_apply_here;
  protobuf_c_boolean apply_here;
  protobuf_c_boolean has_apply_subs;
  protobuf_c_boolean apply_subs;
  protobuf_c_boolean has_inherited;
  protobuf_c_boolean inherited;
  protobuf_c_boolean has_user_id;
  uint32_t user_id;
  char *group;
  protobuf_c_boolean has_grant;
  uint32_t grant;
  protobuf_c_boolean has_deny;
  uint32_t deny;
};
#define MUMBLE_PROTO__ACL__CHAN_ACL__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__acl__chan_acl__descriptor) \
    , 0, 1, 0, 1, 0, 1, 0, 0, NULL, 0, 0, 0, 0 }


struct  _MumbleProto__ACL
{
  ProtobufCMessage base;
  uint32_t channel_id;
  protobuf_c_boolean has_inherit_acls;
  protobuf_c_boolean inherit_acls;
  size_t n_groups;
  MumbleProto__ACL__ChanGroup **groups;
  size_t n_acls;
  MumbleProto__ACL__ChanACL **acls;
  protobuf_c_boolean has_query;
  protobuf_c_boolean query;
};
#define MUMBLE_PROTO__ACL__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__acl__descriptor) \
    , 0, 0, 1, 0,NULL, 0,NULL, 0, 0 }


struct  _MumbleProto__QueryUsers
{
  ProtobufCMessage base;
  size_t n_ids;
  uint32_t *ids;
  size_t n_names;
  char **names;
};
#define MUMBLE_PROTO__QUERY_USERS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__query_users__descriptor) \
    , 0,NULL, 0,NULL }


struct  _MumbleProto__CryptSetup
{
  ProtobufCMessage base;
  protobuf_c_boolean has_key;
  ProtobufCBinaryData key;
  protobuf_c_boolean has_client_nonce;
  ProtobufCBinaryData client_nonce;
  protobuf_c_boolean has_server_nonce;
  ProtobufCBinaryData server_nonce;
};
#define MUMBLE_PROTO__CRYPT_SETUP__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__crypt_setup__descriptor) \
    , 0, {0,NULL}, 0, {0,NULL}, 0, {0,NULL} }


struct  _MumbleProto__ContextActionModify
{
  ProtobufCMessage base;
  char *action;
  char *text;
  protobuf_c_boolean has_context;
  uint32_t context;
  protobuf_c_boolean has_operation;
  MumbleProto__ContextActionModify__Operation operation;
};
#define MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__context_action_modify__descriptor) \
    , NULL, NULL, 0, 0, 0, MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__OPERATION__Add }


struct  _MumbleProto__ContextAction
{
  ProtobufCMessage base;
  protobuf_c_boolean has_session;
  uint32_t session;
  protobuf_c_boolean has_channel_id;
  uint32_t channel_id;
  char *action;
};
#define MUMBLE_PROTO__CONTEXT_ACTION__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__context_action__descriptor) \
    , 0, 0, 0, 0, NULL }


struct  _MumbleProto__UserList__User
{
  ProtobufCMessage base;
  uint32_t user_id;
  char *name;
};
#define MUMBLE_PROTO__USER_LIST__USER__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__user_list__user__descriptor) \
    , 0, NULL }


struct  _MumbleProto__UserList
{
  ProtobufCMessage base;
  size_t n_users;
  MumbleProto__UserList__User **users;
};
#define MUMBLE_PROTO__USER_LIST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__user_list__descriptor) \
    , 0,NULL }


struct  _MumbleProto__VoiceTarget__Target
{
  ProtobufCMessage base;
  size_t n_session;
  uint32_t *session;
  protobuf_c_boolean has_channel_id;
  uint32_t channel_id;
  char *group;
  protobuf_c_boolean has_links;
  protobuf_c_boolean links;
  protobuf_c_boolean has_children;
  protobuf_c_boolean children;
};
#define MUMBLE_PROTO__VOICE_TARGET__TARGET__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__voice_target__target__descriptor) \
    , 0,NULL, 0, 0, NULL, 0, 0, 0, 0 }


struct  _MumbleProto__VoiceTarget
{
  ProtobufCMessage base;
  protobuf_c_boolean has_id;
  uint32_t id;
  size_t n_targets;
  MumbleProto__VoiceTarget__Target **targets;
};
#define MUMBLE_PROTO__VOICE_TARGET__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__voice_target__descriptor) \
    , 0, 0, 0,NULL }


struct  _MumbleProto__PermissionQuery
{
  ProtobufCMessage base;
  protobuf_c_boolean has_channel_id;
  uint32_t channel_id;
  protobuf_c_boolean has_permissions;
  uint32_t permissions;
  protobuf_c_boolean has_flush;
  protobuf_c_boolean flush;
};
#define MUMBLE_PROTO__PERMISSION_QUERY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__permission_query__descriptor) \
    , 0, 0, 0, 0, 0, 0 }


struct  _MumbleProto__CodecVersion
{
  ProtobufCMessage base;
  int32_t alpha;
  int32_t beta;
  protobuf_c_boolean prefer_alpha;
  protobuf_c_boolean has_opus;
  protobuf_c_boolean opus;
};
#define MUMBLE_PROTO__CODEC_VERSION__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__codec_version__descriptor) \
    , 0, 0, 1, 0, 0 }


struct  _MumbleProto__UserStats__Stats
{
  ProtobufCMessage base;
  protobuf_c_boolean has_good;
  uint32_t good;
  protobuf_c_boolean has_late;
  uint32_t late;
  protobuf_c_boolean has_lost;
  uint32_t lost;
  protobuf_c_boolean has_resync;
  uint32_t resync;
};
#define MUMBLE_PROTO__USER_STATS__STATS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__user_stats__stats__descriptor) \
    , 0, 0, 0, 0, 0, 0, 0, 0 }


struct  _MumbleProto__UserStats
{
  ProtobufCMessage base;
  protobuf_c_boolean has_session;
  uint32_t session;
  protobuf_c_boolean has_stats_only;
  protobuf_c_boolean stats_only;
  size_t n_certificates;
  ProtobufCBinaryData *certificates;
  MumbleProto__UserStats__Stats *from_client;
  MumbleProto__UserStats__Stats *from_server;
  protobuf_c_boolean has_udp_packets;
  uint32_t udp_packets;
  protobuf_c_boolean has_tcp_packets;
  uint32_t tcp_packets;
  protobuf_c_boolean has_udp_ping_avg;
  float udp_ping_avg;
  protobuf_c_boolean has_udp_ping_var;
  float udp_ping_var;
  protobuf_c_boolean has_tcp_ping_avg;
  float tcp_ping_avg;
  protobuf_c_boolean has_tcp_ping_var;
  float tcp_ping_var;
  MumbleProto__Version *version;
  size_t n_celt_versions;
  int32_t *celt_versions;
  protobuf_c_boolean has_address;
  ProtobufCBinaryData address;
  protobuf_c_boolean has_bandwidth;
  uint32_t bandwidth;
  protobuf_c_boolean has_onlinesecs;
  uint32_t onlinesecs;
  protobuf_c_boolean has_idlesecs;
  uint32_t idlesecs;
  protobuf_c_boolean has_strong_certificate;
  protobuf_c_boolean strong_certificate;
  protobuf_c_boolean has_opus;
  protobuf_c_boolean opus;
};
#define MUMBLE_PROTO__USER_STATS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__user_stats__descriptor) \
    , 0, 0, 0, 0, 0,NULL, NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, 0,NULL, 0, {0,NULL}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }


struct  _MumbleProto__SuggestConfig
{
  ProtobufCMessage base;
  protobuf_c_boolean has_version;
  uint32_t version;
  protobuf_c_boolean has_positional;
  protobuf_c_boolean positional;
  protobuf_c_boolean has_push_to_talk;
  protobuf_c_boolean push_to_talk;
};
#define MUMBLE_PROTO__SUGGEST_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__suggest_config__descriptor) \
    , 0, 0, 0, 0, 0, 0 }


struct  _MumbleProto__RequestBlob
{
  ProtobufCMessage base;
  size_t n_session_texture;
  uint32_t *session_texture;
  size_t n_session_comment;
  uint32_t *session_comment;
  size_t n_channel_description;
  uint32_t *channel_description;
};
#define MUMBLE_PROTO__REQUEST_BLOB__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__request_blob__descriptor) \
    , 0,NULL, 0,NULL, 0,NULL }


/* MumbleProto__Version methods */
void   mumble_proto__version__init
                     (MumbleProto__Version         *message);
size_t mumble_proto__version__get_packed_size
                     (const MumbleProto__Version   *message);
size_t mumble_proto__version__pack
                     (const MumbleProto__Version   *message,
                      uint8_t             *out);
size_t mumble_proto__version__pack_to_buffer
                     (const MumbleProto__Version   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__Version *
       mumble_proto__version__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__version__free_unpacked
                     (MumbleProto__Version *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__UDPTunnel methods */
void   mumble_proto__udptunnel__init
                     (MumbleProto__UDPTunnel         *message);
size_t mumble_proto__udptunnel__get_packed_size
                     (const MumbleProto__UDPTunnel   *message);
size_t mumble_proto__udptunnel__pack
                     (const MumbleProto__UDPTunnel   *message,
                      uint8_t             *out);
size_t mumble_proto__udptunnel__pack_to_buffer
                     (const MumbleProto__UDPTunnel   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__UDPTunnel *
       mumble_proto__udptunnel__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__udptunnel__free_unpacked
                     (MumbleProto__UDPTunnel *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__Authenticate methods */
void   mumble_proto__authenticate__init
                     (MumbleProto__Authenticate         *message);
size_t mumble_proto__authenticate__get_packed_size
                     (const MumbleProto__Authenticate   *message);
size_t mumble_proto__authenticate__pack
                     (const MumbleProto__Authenticate   *message,
                      uint8_t             *out);
size_t mumble_proto__authenticate__pack_to_buffer
                     (const MumbleProto__Authenticate   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__Authenticate *
       mumble_proto__authenticate__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__authenticate__free_unpacked
                     (MumbleProto__Authenticate *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__Ping methods */
void   mumble_proto__ping__init
                     (MumbleProto__Ping         *message);
size_t mumble_proto__ping__get_packed_size
                     (const MumbleProto__Ping   *message);
size_t mumble_proto__ping__pack
                     (const MumbleProto__Ping   *message,
                      uint8_t             *out);
size_t mumble_proto__ping__pack_to_buffer
                     (const MumbleProto__Ping   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__Ping *
       mumble_proto__ping__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__ping__free_unpacked
                     (MumbleProto__Ping *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__Reject methods */
void   mumble_proto__reject__init
                     (MumbleProto__Reject         *message);
size_t mumble_proto__reject__get_packed_size
                     (const MumbleProto__Reject   *message);
size_t mumble_proto__reject__pack
                     (const MumbleProto__Reject   *message,
                      uint8_t             *out);
size_t mumble_proto__reject__pack_to_buffer
                     (const MumbleProto__Reject   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__Reject *
       mumble_proto__reject__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__reject__free_unpacked
                     (MumbleProto__Reject *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__ServerConfig methods */
void   mumble_proto__server_config__init
                     (MumbleProto__ServerConfig         *message);
size_t mumble_proto__server_config__get_packed_size
                     (const MumbleProto__ServerConfig   *message);
size_t mumble_proto__server_config__pack
                     (const MumbleProto__ServerConfig   *message,
                      uint8_t             *out);
size_t mumble_proto__server_config__pack_to_buffer
                     (const MumbleProto__ServerConfig   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__ServerConfig *
       mumble_proto__server_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__server_config__free_unpacked
                     (MumbleProto__ServerConfig *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__ServerSync methods */
void   mumble_proto__server_sync__init
                     (MumbleProto__ServerSync         *message);
size_t mumble_proto__server_sync__get_packed_size
                     (const MumbleProto__ServerSync   *message);
size_t mumble_proto__server_sync__pack
                     (const MumbleProto__ServerSync   *message,
                      uint8_t             *out);
size_t mumble_proto__server_sync__pack_to_buffer
                     (const MumbleProto__ServerSync   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__ServerSync *
       mumble_proto__server_sync__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__server_sync__free_unpacked
                     (MumbleProto__ServerSync *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__ChannelRemove methods */
void   mumble_proto__channel_remove__init
                     (MumbleProto__ChannelRemove         *message);
size_t mumble_proto__channel_remove__get_packed_size
                     (const MumbleProto__ChannelRemove   *message);
size_t mumble_proto__channel_remove__pack
                     (const MumbleProto__ChannelRemove   *message,
                      uint8_t             *out);
size_t mumble_proto__channel_remove__pack_to_buffer
                     (const MumbleProto__ChannelRemove   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__ChannelRemove *
       mumble_proto__channel_remove__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__channel_remove__free_unpacked
                     (MumbleProto__ChannelRemove *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__ChannelState methods */
void   mumble_proto__channel_state__init
                     (MumbleProto__ChannelState         *message);
size_t mumble_proto__channel_state__get_packed_size
                     (const MumbleProto__ChannelState   *message);
size_t mumble_proto__channel_state__pack
                     (const MumbleProto__ChannelState   *message,
                      uint8_t             *out);
size_t mumble_proto__channel_state__pack_to_buffer
                     (const MumbleProto__ChannelState   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__ChannelState *
       mumble_proto__channel_state__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__channel_state__free_unpacked
                     (MumbleProto__ChannelState *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__UserRemove methods */
void   mumble_proto__user_remove__init
                     (MumbleProto__UserRemove         *message);
size_t mumble_proto__user_remove__get_packed_size
                     (const MumbleProto__UserRemove   *message);
size_t mumble_proto__user_remove__pack
                     (const MumbleProto__UserRemove   *message,
                      uint8_t             *out);
size_t mumble_proto__user_remove__pack_to_buffer
                     (const MumbleProto__UserRemove   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__UserRemove *
       mumble_proto__user_remove__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__user_remove__free_unpacked
                     (MumbleProto__UserRemove *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__UserState methods */
void   mumble_proto__user_state__init
                     (MumbleProto__UserState         *message);
size_t mumble_proto__user_state__get_packed_size
                     (const MumbleProto__UserState   *message);
size_t mumble_proto__user_state__pack
                     (const MumbleProto__UserState   *message,
                      uint8_t             *out);
size_t mumble_proto__user_state__pack_to_buffer
                     (const MumbleProto__UserState   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__UserState *
       mumble_proto__user_state__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__user_state__free_unpacked
                     (MumbleProto__UserState *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__BanList__BanEntry methods */
void   mumble_proto__ban_list__ban_entry__init
                     (MumbleProto__BanList__BanEntry         *message);
/* MumbleProto__BanList methods */
void   mumble_proto__ban_list__init
                     (MumbleProto__BanList         *message);
size_t mumble_proto__ban_list__get_packed_size
                     (const MumbleProto__BanList   *message);
size_t mumble_proto__ban_list__pack
                     (const MumbleProto__BanList   *message,
                      uint8_t             *out);
size_t mumble_proto__ban_list__pack_to_buffer
                     (const MumbleProto__BanList   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__BanList *
       mumble_proto__ban_list__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__ban_list__free_unpacked
                     (MumbleProto__BanList *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__TextMessage methods */
void   mumble_proto__text_message__init
                     (MumbleProto__TextMessage         *message);
size_t mumble_proto__text_message__get_packed_size
                     (const MumbleProto__TextMessage   *message);
size_t mumble_proto__text_message__pack
                     (const MumbleProto__TextMessage   *message,
                      uint8_t             *out);
size_t mumble_proto__text_message__pack_to_buffer
                     (const MumbleProto__TextMessage   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__TextMessage *
       mumble_proto__text_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__text_message__free_unpacked
                     (MumbleProto__TextMessage *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__PermissionDenied methods */
void   mumble_proto__permission_denied__init
                     (MumbleProto__PermissionDenied         *message);
size_t mumble_proto__permission_denied__get_packed_size
                     (const MumbleProto__PermissionDenied   *message);
size_t mumble_proto__permission_denied__pack
                     (const MumbleProto__PermissionDenied   *message,
                      uint8_t             *out);
size_t mumble_proto__permission_denied__pack_to_buffer
                     (const MumbleProto__PermissionDenied   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__PermissionDenied *
       mumble_proto__permission_denied__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__permission_denied__free_unpacked
                     (MumbleProto__PermissionDenied *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__ACL__ChanGroup methods */
void   mumble_proto__acl__chan_group__init
                     (MumbleProto__ACL__ChanGroup         *message);
/* MumbleProto__ACL__ChanACL methods */
void   mumble_proto__acl__chan_acl__init
                     (MumbleProto__ACL__ChanACL         *message);
/* MumbleProto__ACL methods */
void   mumble_proto__acl__init
                     (MumbleProto__ACL         *message);
size_t mumble_proto__acl__get_packed_size
                     (const MumbleProto__ACL   *message);
size_t mumble_proto__acl__pack
                     (const MumbleProto__ACL   *message,
                      uint8_t             *out);
size_t mumble_proto__acl__pack_to_buffer
                     (const MumbleProto__ACL   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__ACL *
       mumble_proto__acl__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__acl__free_unpacked
                     (MumbleProto__ACL *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__QueryUsers methods */
void   mumble_proto__query_users__init
                     (MumbleProto__QueryUsers         *message);
size_t mumble_proto__query_users__get_packed_size
                     (const MumbleProto__QueryUsers   *message);
size_t mumble_proto__query_users__pack
                     (const MumbleProto__QueryUsers   *message,
                      uint8_t             *out);
size_t mumble_proto__query_users__pack_to_buffer
                     (const MumbleProto__QueryUsers   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__QueryUsers *
       mumble_proto__query_users__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__query_users__free_unpacked
                     (MumbleProto__QueryUsers *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__CryptSetup methods */
void   mumble_proto__crypt_setup__init
                     (MumbleProto__CryptSetup         *message);
size_t mumble_proto__crypt_setup__get_packed_size
                     (const MumbleProto__CryptSetup   *message);
size_t mumble_proto__crypt_setup__pack
                     (const MumbleProto__CryptSetup   *message,
                      uint8_t             *out);
size_t mumble_proto__crypt_setup__pack_to_buffer
                     (const MumbleProto__CryptSetup   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__CryptSetup *
       mumble_proto__crypt_setup__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__crypt_setup__free_unpacked
                     (MumbleProto__CryptSetup *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__ContextActionModify methods */
void   mumble_proto__context_action_modify__init
                     (MumbleProto__ContextActionModify         *message);
size_t mumble_proto__context_action_modify__get_packed_size
                     (const MumbleProto__ContextActionModify   *message);
size_t mumble_proto__context_action_modify__pack
                     (const MumbleProto__ContextActionModify   *message,
                      uint8_t             *out);
size_t mumble_proto__context_action_modify__pack_to_buffer
                     (const MumbleProto__ContextActionModify   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__ContextActionModify *
       mumble_proto__context_action_modify__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__context_action_modify__free_unpacked
                     (MumbleProto__ContextActionModify *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__ContextAction methods */
void   mumble_proto__context_action__init
                     (MumbleProto__ContextAction         *message);
size_t mumble_proto__context_action__get_packed_size
                     (const MumbleProto__ContextAction   *message);
size_t mumble_proto__context_action__pack
                     (const MumbleProto__ContextAction   *message,
                      uint8_t             *out);
size_t mumble_proto__context_action__pack_to_buffer
                     (const MumbleProto__ContextAction   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__ContextAction *
       mumble_proto__context_action__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__context_action__free_unpacked
                     (MumbleProto__ContextAction *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__UserList__User methods */
void   mumble_proto__user_list__user__init
                     (MumbleProto__UserList__User         *message);
/* MumbleProto__UserList methods */
void   mumble_proto__user_list__init
                     (MumbleProto__UserList         *message);
size_t mumble_proto__user_list__get_packed_size
                     (const MumbleProto__UserList   *message);
size_t mumble_proto__user_list__pack
                     (const MumbleProto__UserList   *message,
                      uint8_t             *out);
size_t mumble_proto__user_list__pack_to_buffer
                     (const MumbleProto__UserList   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__UserList *
       mumble_proto__user_list__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__user_list__free_unpacked
                     (MumbleProto__UserList *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__VoiceTarget__Target methods */
void   mumble_proto__voice_target__target__init
                     (MumbleProto__VoiceTarget__Target         *message);
/* MumbleProto__VoiceTarget methods */
void   mumble_proto__voice_target__init
                     (MumbleProto__VoiceTarget         *message);
size_t mumble_proto__voice_target__get_packed_size
                     (const MumbleProto__VoiceTarget   *message);
size_t mumble_proto__voice_target__pack
                     (const MumbleProto__VoiceTarget   *message,
                      uint8_t             *out);
size_t mumble_proto__voice_target__pack_to_buffer
                     (const MumbleProto__VoiceTarget   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__VoiceTarget *
       mumble_proto__voice_target__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__voice_target__free_unpacked
                     (MumbleProto__VoiceTarget *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__PermissionQuery methods */
void   mumble_proto__permission_query__init
                     (MumbleProto__PermissionQuery         *message);
size_t mumble_proto__permission_query__get_packed_size
                     (const MumbleProto__PermissionQuery   *message);
size_t mumble_proto__permission_query__pack
                     (const MumbleProto__PermissionQuery   *message,
                      uint8_t             *out);
size_t mumble_proto__permission_query__pack_to_buffer
                     (const MumbleProto__PermissionQuery   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__PermissionQuery *
       mumble_proto__permission_query__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__permission_query__free_unpacked
                     (MumbleProto__PermissionQuery *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__CodecVersion methods */
void   mumble_proto__codec_version__init
                     (MumbleProto__CodecVersion         *message);
size_t mumble_proto__codec_version__get_packed_size
                     (const MumbleProto__CodecVersion   *message);
size_t mumble_proto__codec_version__pack
                     (const MumbleProto__CodecVersion   *message,
                      uint8_t             *out);
size_t mumble_proto__codec_version__pack_to_buffer
                     (const MumbleProto__CodecVersion   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__CodecVersion *
       mumble_proto__codec_version__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__codec_version__free_unpacked
                     (MumbleProto__CodecVersion *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__UserStats__Stats methods */
void   mumble_proto__user_stats__stats__init
                     (MumbleProto__UserStats__Stats         *message);
/* MumbleProto__UserStats methods */
void   mumble_proto__user_stats__init
                     (MumbleProto__UserStats         *message);
size_t mumble_proto__user_stats__get_packed_size
                     (const MumbleProto__UserStats   *message);
size_t mumble_proto__user_stats__pack
                     (const MumbleProto__UserStats   *message,
                      uint8_t             *out);
size_t mumble_proto__user_stats__pack_to_buffer
                     (const MumbleProto__UserStats   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__UserStats *
       mumble_proto__user_stats__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__user_stats__free_unpacked
                     (MumbleProto__UserStats *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__SuggestConfig methods */
void   mumble_proto__suggest_config__init
                     (MumbleProto__SuggestConfig         *message);
size_t mumble_proto__suggest_config__get_packed_size
                     (const MumbleProto__SuggestConfig   *message);
size_t mumble_proto__suggest_config__pack
                     (const MumbleProto__SuggestConfig   *message,
                      uint8_t             *out);
size_t mumble_proto__suggest_config__pack_to_buffer
                     (const MumbleProto__SuggestConfig   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__SuggestConfig *
       mumble_proto__suggest_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__suggest_config__free_unpacked
                     (MumbleProto__SuggestConfig *message,
                      ProtobufCAllocator *allocator);
/* MumbleProto__RequestBlob methods */
void   mumble_proto__request_blob__init
                     (MumbleProto__RequestBlob         *message);
size_t mumble_proto__request_blob__get_packed_size
                     (const MumbleProto__RequestBlob   *message);
size_t mumble_proto__request_blob__pack
                     (const MumbleProto__RequestBlob   *message,
                      uint8_t             *out);
size_t mumble_proto__request_blob__pack_to_buffer
                     (const MumbleProto__RequestBlob   *message,
                      ProtobufCBuffer     *buffer);
MumbleProto__RequestBlob *
       mumble_proto__request_blob__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mumble_proto__request_blob__free_unpacked
                     (MumbleProto__RequestBlob *message,
                      ProtobufCAllocator *allocator);
/* --- per-message closures --- */

typedef void (*MumbleProto__Version_Closure)
                 (const MumbleProto__Version *message,
                  void *closure_data);
typedef void (*MumbleProto__UDPTunnel_Closure)
                 (const MumbleProto__UDPTunnel *message,
                  void *closure_data);
typedef void (*MumbleProto__Authenticate_Closure)
                 (const MumbleProto__Authenticate *message,
                  void *closure_data);
typedef void (*MumbleProto__Ping_Closure)
                 (const MumbleProto__Ping *message,
                  void *closure_data);
typedef void (*MumbleProto__Reject_Closure)
                 (const MumbleProto__Reject *message,
                  void *closure_data);
typedef void (*MumbleProto__ServerConfig_Closure)
                 (const MumbleProto__ServerConfig *message,
                  void *closure_data);
typedef void (*MumbleProto__ServerSync_Closure)
                 (const MumbleProto__ServerSync *message,
                  void *closure_data);
typedef void (*MumbleProto__ChannelRemove_Closure)
                 (const MumbleProto__ChannelRemove *message,
                  void *closure_data);
typedef void (*MumbleProto__ChannelState_Closure)
                 (const MumbleProto__ChannelState *message,
                  void *closure_data);
typedef void (*MumbleProto__UserRemove_Closure)
                 (const MumbleProto__UserRemove *message,
                  void *closure_data);
typedef void (*MumbleProto__UserState_Closure)
                 (const MumbleProto__UserState *message,
                  void *closure_data);
typedef void (*MumbleProto__BanList__BanEntry_Closure)
                 (const MumbleProto__BanList__BanEntry *message,
                  void *closure_data);
typedef void (*MumbleProto__BanList_Closure)
                 (const MumbleProto__BanList *message,
                  void *closure_data);
typedef void (*MumbleProto__TextMessage_Closure)
                 (const MumbleProto__TextMessage *message,
                  void *closure_data);
typedef void (*MumbleProto__PermissionDenied_Closure)
                 (const MumbleProto__PermissionDenied *message,
                  void *closure_data);
typedef void (*MumbleProto__ACL__ChanGroup_Closure)
                 (const MumbleProto__ACL__ChanGroup *message,
                  void *closure_data);
typedef void (*MumbleProto__ACL__ChanACL_Closure)
                 (const MumbleProto__ACL__ChanACL *message,
                  void *closure_data);
typedef void (*MumbleProto__ACL_Closure)
                 (const MumbleProto__ACL *message,
                  void *closure_data);
typedef void (*MumbleProto__QueryUsers_Closure)
                 (const MumbleProto__QueryUsers *message,
                  void *closure_data);
typedef void (*MumbleProto__CryptSetup_Closure)
                 (const MumbleProto__CryptSetup *message,
                  void *closure_data);
typedef void (*MumbleProto__ContextActionModify_Closure)
                 (const MumbleProto__ContextActionModify *message,
                  void *closure_data);
typedef void (*MumbleProto__ContextAction_Closure)
                 (const MumbleProto__ContextAction *message,
                  void *closure_data);
typedef void (*MumbleProto__UserList__User_Closure)
                 (const MumbleProto__UserList__User *message,
                  void *closure_data);
typedef void (*MumbleProto__UserList_Closure)
                 (const MumbleProto__UserList *message,
                  void *closure_data);
typedef void (*MumbleProto__VoiceTarget__Target_Closure)
                 (const MumbleProto__VoiceTarget__Target *message,
                  void *closure_data);
typedef void (*MumbleProto__VoiceTarget_Closure)
                 (const MumbleProto__VoiceTarget *message,
                  void *closure_data);
typedef void (*MumbleProto__PermissionQuery_Closure)
                 (const MumbleProto__PermissionQuery *message,
                  void *closure_data);
typedef void (*MumbleProto__CodecVersion_Closure)
                 (const MumbleProto__CodecVersion *message,
                  void *closure_data);
typedef void (*MumbleProto__UserStats__Stats_Closure)
                 (const MumbleProto__UserStats__Stats *message,
                  void *closure_data);
typedef void (*MumbleProto__UserStats_Closure)
                 (const MumbleProto__UserStats *message,
                  void *closure_data);
typedef void (*MumbleProto__SuggestConfig_Closure)
                 (const MumbleProto__SuggestConfig *message,
                  void *closure_data);
typedef void (*MumbleProto__RequestBlob_Closure)
                 (const MumbleProto__RequestBlob *message,
                  void *closure_data);

/* --- services --- */


/* --- descriptors --- */

extern const ProtobufCMessageDescriptor mumble_proto__version__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__udptunnel__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__authenticate__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__ping__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__reject__descriptor;
extern const ProtobufCEnumDescriptor    mumble_proto__reject__reject_type__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__server_config__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__server_sync__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__channel_remove__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__channel_state__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__user_remove__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__user_state__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__ban_list__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__ban_list__ban_entry__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__text_message__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__permission_denied__descriptor;
extern const ProtobufCEnumDescriptor    mumble_proto__permission_denied__deny_type__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__acl__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__acl__chan_group__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__acl__chan_acl__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__query_users__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__crypt_setup__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__context_action_modify__descriptor;
extern const ProtobufCEnumDescriptor    mumble_proto__context_action_modify__context__descriptor;
extern const ProtobufCEnumDescriptor    mumble_proto__context_action_modify__operation__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__context_action__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__user_list__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__user_list__user__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__voice_target__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__voice_target__target__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__permission_query__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__codec_version__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__user_stats__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__user_stats__stats__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__suggest_config__descriptor;
extern const ProtobufCMessageDescriptor mumble_proto__request_blob__descriptor;

PROTOBUF_C__END_DECLS


#endif  /* PROTOBUF_C_Mumble_2eproto__INCLUDED */
