src/Mumble.pb-c.h

   1 /* Generated by the protocol buffer compiler.  DO NOT EDIT! */
   2
   3 #ifndef PROTOBUF_C_Mumble_2eproto__INCLUDED
   4 #define PROTOBUF_C_Mumble_2eproto__INCLUDED
   5
   6 #include <google/protobuf-c/protobuf-c.h>
   7
   8 PROTOBUF_C_BEGIN_DECLS
   9
  10
  11 typedef struct _MumbleProto__Version MumbleProto__Version;
  12 typedef struct _MumbleProto__UDPTunnel MumbleProto__UDPTunnel;
  13 typedef struct _MumbleProto__Authenticate MumbleProto__Authenticate;
  14 typedef struct _MumbleProto__Ping MumbleProto__Ping;
  15 typedef struct _MumbleProto__Reject MumbleProto__Reject;
  16 typedef struct _MumbleProto__ServerSync MumbleProto__ServerSync;
  17 typedef struct _MumbleProto__ChannelRemove MumbleProto__ChannelRemove;
  18 typedef struct _MumbleProto__ChannelState MumbleProto__ChannelState;
  19 typedef struct _MumbleProto__UserRemove MumbleProto__UserRemove;
  20 typedef struct _MumbleProto__UserState MumbleProto__UserState;
  21 typedef struct _MumbleProto__BanList MumbleProto__BanList;
  22 typedef struct _MumbleProto__BanList__BanEntry MumbleProto__BanList__BanEntry;
  23 typedef struct _MumbleProto__TextMessage MumbleProto__TextMessage;
  24 typedef struct _MumbleProto__PermissionDenied MumbleProto__PermissionDenied;
  25 typedef struct _MumbleProto__ACL MumbleProto__ACL;
  26 typedef struct _MumbleProto__ACL__ChanGroup MumbleProto__ACL__ChanGroup;
  27 typedef struct _MumbleProto__ACL__ChanACL MumbleProto__ACL__ChanACL;
  28 typedef struct _MumbleProto__QueryUsers MumbleProto__QueryUsers;
  29 typedef struct _MumbleProto__CryptSetup MumbleProto__CryptSetup;
  30 typedef struct _MumbleProto__ContextActionAdd MumbleProto__ContextActionAdd;
  31 typedef struct _MumbleProto__ContextAction MumbleProto__ContextAction;
  32 typedef struct _MumbleProto__UserList MumbleProto__UserList;
  33 typedef struct _MumbleProto__UserList__User MumbleProto__UserList__User;
  34 typedef struct _MumbleProto__VoiceTarget MumbleProto__VoiceTarget;
  35 typedef struct _MumbleProto__VoiceTarget__Target MumbleProto__VoiceTarget__Target;
  36 typedef struct _MumbleProto__PermissionQuery MumbleProto__PermissionQuery;
  37 typedef struct _MumbleProto__CodecVersion MumbleProto__CodecVersion;
  38
  39
  40 /* --- enums --- */
  41
  42 typedef enum _MumbleProto__Reject__RejectType {
  43   MUMBLE_PROTO__REJECT__REJECT_TYPE__None = 0,
  44   MUMBLE_PROTO__REJECT__REJECT_TYPE__WrongVersion = 1,
  45   MUMBLE_PROTO__REJECT__REJECT_TYPE__InvalidUsername = 2,
  46   MUMBLE_PROTO__REJECT__REJECT_TYPE__WrongUserPW = 3,
  47   MUMBLE_PROTO__REJECT__REJECT_TYPE__WrongServerPW = 4,
  48   MUMBLE_PROTO__REJECT__REJECT_TYPE__UsernameInUse = 5,
  49   MUMBLE_PROTO__REJECT__REJECT_TYPE__ServerFull = 6,
  50   MUMBLE_PROTO__REJECT__REJECT_TYPE__NoCertificate = 7
  51 } MumbleProto__Reject__RejectType;
  52 typedef enum _MumbleProto__PermissionDenied__DenyType {
  53   MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__Text = 0,
  54   MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__Permission = 1,
  55   MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__SuperUser = 2,
  56   MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__ChannelName = 3,
  57   MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TextTooLong = 4,
  58   MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__H9K = 5,
  59   MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TemporaryChannel = 6,
  60   MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__MissingCertificate = 7
  61 } MumbleProto__PermissionDenied__DenyType;
  62 typedef enum _MumbleProto__ContextActionAdd__Context {
  63   MUMBLE_PROTO__CONTEXT_ACTION_ADD__CONTEXT__Server = 1,
  64   MUMBLE_PROTO__CONTEXT_ACTION_ADD__CONTEXT__Channel = 2,
  65   MUMBLE_PROTO__CONTEXT_ACTION_ADD__CONTEXT__User = 4
  66 } MumbleProto__ContextActionAdd__Context;
  67
  68 /* --- messages --- */
  69
  70 struct  _MumbleProto__Version
  71 {
  72   ProtobufCMessage base;
  73   protobuf_c_boolean has_version;
  74   uint32_t version;
  75   char *release;
  76   char *os;
  77   char *os_version;
  78 };
  79 #define MUMBLE_PROTO__VERSION__INIT \
  80  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__version__descriptor) \
  81     , 0,0, NULL, NULL, NULL }
  82
  83
  84 struct  _MumbleProto__UDPTunnel
  85 {
  86   ProtobufCMessage base;
  87   ProtobufCBinaryData packet;
  88 };
  89 #define MUMBLE_PROTO__UDPTUNNEL__INIT \
  90  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__udptunnel__descriptor) \
  91     , {0,NULL} }
  92
  93
  94 struct  _MumbleProto__Authenticate
  95 {
  96   ProtobufCMessage base;
  97   char *username;
  98   char *password;
  99   size_t n_tokens;
 100   char **tokens;
 101   size_t n_celt_versions;
 102   int32_t *celt_versions;
 103 };
 104 #define MUMBLE_PROTO__AUTHENTICATE__INIT \
 105  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__authenticate__descriptor) \
 106     , NULL, NULL, 0,NULL, 0,NULL }
 107
 108
 109 struct  _MumbleProto__Ping
 110 {
 111   ProtobufCMessage base;
 112   protobuf_c_boolean has_timestamp;
 113   uint64_t timestamp;
 114   protobuf_c_boolean has_good;
 115   uint32_t good;
 116   protobuf_c_boolean has_late;
 117   uint32_t late;
 118   protobuf_c_boolean has_lost;
 119   uint32_t lost;
 120   protobuf_c_boolean has_resync;
 121   uint32_t resync;
 122   protobuf_c_boolean has_udp_packets;
 123   uint32_t udp_packets;
 124   protobuf_c_boolean has_tcp_packets;
 125   uint32_t tcp_packets;
 126   protobuf_c_boolean has_udp_ping_avg;
 127   float udp_ping_avg;
 128   protobuf_c_boolean has_udp_ping_var;
 129   float udp_ping_var;
 130   protobuf_c_boolean has_tcp_ping_avg;
 131   float tcp_ping_avg;
 132   protobuf_c_boolean has_tcp_ping_var;
 133   float tcp_ping_var;
 134 };
 135 #define MUMBLE_PROTO__PING__INIT \
 136  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__ping__descriptor) \
 137     , 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0 }
 138
 139
 140 struct  _MumbleProto__Reject
 141 {
 142   ProtobufCMessage base;
 143   protobuf_c_boolean has_type;
 144   MumbleProto__Reject__RejectType type;
 145   char *reason;
 146 };
 147 #define MUMBLE_PROTO__REJECT__INIT \
 148  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__reject__descriptor) \
 149     , 0,0, NULL }
 150
 151
 152 struct  _MumbleProto__ServerSync
 153 {
 154   ProtobufCMessage base;
 155   protobuf_c_boolean has_session;
 156   uint32_t session;
 157   protobuf_c_boolean has_max_bandwidth;
 158   uint32_t max_bandwidth;
 159   char *welcome_text;
 160   protobuf_c_boolean has_permissions;
 161   uint64_t permissions;
 162   protobuf_c_boolean has_allow_html;
 163   protobuf_c_boolean allow_html;
 164 };
 165 #define MUMBLE_PROTO__SERVER_SYNC__INIT \
 166  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__server_sync__descriptor) \
 167     , 0,0, 0,0, NULL, 0,0, 0,1 }
 168
 169
 170 struct  _MumbleProto__ChannelRemove
 171 {
 172   ProtobufCMessage base;
 173   uint32_t channel_id;
 174 };
 175 #define MUMBLE_PROTO__CHANNEL_REMOVE__INIT \
 176  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__channel_remove__descriptor) \
 177     , 0 }
 178
 179
 180 struct  _MumbleProto__ChannelState
 181 {
 182   ProtobufCMessage base;
 183   protobuf_c_boolean has_channel_id;
 184   uint32_t channel_id;
 185   protobuf_c_boolean has_parent;
 186   uint32_t parent;
 187   char *name;
 188   size_t n_links;
 189   uint32_t *links;
 190   char *description;
 191   size_t n_links_add;
 192   uint32_t *links_add;
 193   size_t n_links_remove;
 194   uint32_t *links_remove;
 195   protobuf_c_boolean has_temporary;
 196   protobuf_c_boolean temporary;
 197   protobuf_c_boolean has_position;
 198   int32_t position;
 199 };
 200 #define MUMBLE_PROTO__CHANNEL_STATE__INIT \
 201  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__channel_state__descriptor) \
 202     , 0,0, 0,0, NULL, 0,NULL, NULL, 0,NULL, 0,NULL, 0,0, 0,0 }
 203
 204
 205 struct  _MumbleProto__UserRemove
 206 {
 207   ProtobufCMessage base;
 208   uint32_t session;
 209   protobuf_c_boolean has_actor;
 210   uint32_t actor;
 211   char *reason;
 212   protobuf_c_boolean has_ban;
 213   protobuf_c_boolean ban;
 214 };
 215 #define MUMBLE_PROTO__USER_REMOVE__INIT \
 216  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__user_remove__descriptor) \
 217     , 0, 0,0, NULL, 0,0 }
 218
 219
 220 struct  _MumbleProto__UserState
 221 {
 222   ProtobufCMessage base;
 223   protobuf_c_boolean has_session;
 224   uint32_t session;
 225   protobuf_c_boolean has_actor;
 226   uint32_t actor;
 227   char *name;
 228   protobuf_c_boolean has_user_id;
 229   uint32_t user_id;
 230   protobuf_c_boolean has_channel_id;
 231   uint32_t channel_id;
 232   protobuf_c_boolean has_mute;
 233   protobuf_c_boolean mute;
 234   protobuf_c_boolean has_deaf;
 235   protobuf_c_boolean deaf;
 236   protobuf_c_boolean has_suppress;
 237   protobuf_c_boolean suppress;
 238   protobuf_c_boolean has_self_mute;
 239   protobuf_c_boolean self_mute;
 240   protobuf_c_boolean has_self_deaf;
 241   protobuf_c_boolean self_deaf;
 242   protobuf_c_boolean has_texture;
 243   ProtobufCBinaryData texture;
 244   char *plugin_context;
 245   char *plugin_identity;
 246   char *comment;
 247   char *hash;
 248 };
 249 #define MUMBLE_PROTO__USER_STATE__INIT \
 250  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__user_state__descriptor) \
 251     , 0,0, 0,0, NULL, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,{0,NULL}, NULL, NULL, NULL, NULL }
 252
 253
 254 struct  _MumbleProto__BanList__BanEntry
 255 {
 256   ProtobufCMessage base;
 257   ProtobufCBinaryData address;
 258   uint32_t mask;
 259   char *name;
 260   char *hash;
 261   char *reason;
 262   char *start;
 263   protobuf_c_boolean has_duration;
 264   uint32_t duration;
 265 };
 266 #define MUMBLE_PROTO__BAN_LIST__BAN_ENTRY__INIT \
 267  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__ban_list__ban_entry__descriptor) \
 268     , {0,NULL}, 0, NULL, NULL, NULL, NULL, 0,0 }
 269
 270
 271 struct  _MumbleProto__BanList
 272 {
 273   ProtobufCMessage base;
 274   size_t n_bans;
 275   MumbleProto__BanList__BanEntry **bans;
 276   protobuf_c_boolean has_query;
 277   protobuf_c_boolean query;
 278 };
 279 #define MUMBLE_PROTO__BAN_LIST__INIT \
 280  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__ban_list__descriptor) \
 281     , 0,NULL, 0,0 }
 282
 283
 284 struct  _MumbleProto__TextMessage
 285 {
 286   ProtobufCMessage base;
 287   protobuf_c_boolean has_actor;
 288   uint32_t actor;
 289   size_t n_session;
 290   uint32_t *session;
 291   size_t n_channel_id;
 292   uint32_t *channel_id;
 293   size_t n_tree_id;
 294   uint32_t *tree_id;
 295   char *message;
 296 };
 297 #define MUMBLE_PROTO__TEXT_MESSAGE__INIT \
 298  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__text_message__descriptor) \
 299     , 0,0, 0,NULL, 0,NULL, 0,NULL, NULL }
 300
 301
 302 struct  _MumbleProto__PermissionDenied
 303 {
 304   ProtobufCMessage base;
 305   protobuf_c_boolean has_permission;
 306   uint32_t permission;
 307   protobuf_c_boolean has_channel_id;
 308   uint32_t channel_id;
 309   protobuf_c_boolean has_session;
 310   uint32_t session;
 311   char *reason;
 312   protobuf_c_boolean has_type;
 313   MumbleProto__PermissionDenied__DenyType type;
 314 };
 315 #define MUMBLE_PROTO__PERMISSION_DENIED__INIT \
 316  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__permission_denied__descriptor) \
 317     , 0,0, 0,0, 0,0, NULL, 0,0 }
 318
 319
 320 struct  _MumbleProto__ACL__ChanGroup
 321 {
 322   ProtobufCMessage base;
 323   char *name;
 324   protobuf_c_boolean has_inherited;
 325   protobuf_c_boolean inherited;
 326   protobuf_c_boolean has_inherit;
 327   protobuf_c_boolean inherit;
 328   protobuf_c_boolean has_inheritable;
 329   protobuf_c_boolean inheritable;
 330   size_t n_add;
 331   uint32_t *add;
 332   size_t n_remove;
 333   uint32_t *remove;
 334   size_t n_inherited_members;
 335   uint32_t *inherited_members;
 336 };
 337 #define MUMBLE_PROTO__ACL__CHAN_GROUP__INIT \
 338  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__acl__chan_group__descriptor) \
 339     , NULL, 0,1, 0,1, 0,1, 0,NULL, 0,NULL, 0,NULL }
 340
 341
 342 struct  _MumbleProto__ACL__ChanACL
 343 {
 344   ProtobufCMessage base;
 345   protobuf_c_boolean has_apply_here;
 346   protobuf_c_boolean apply_here;
 347   protobuf_c_boolean has_apply_subs;
 348   protobuf_c_boolean apply_subs;
 349   protobuf_c_boolean has_inherited;
 350   protobuf_c_boolean inherited;
 351   protobuf_c_boolean has_user_id;
 352   uint32_t user_id;
 353   char *group;
 354   protobuf_c_boolean has_grant;
 355   uint32_t grant;
 356   protobuf_c_boolean has_deny;
 357   uint32_t deny;
 358 };
 359 #define MUMBLE_PROTO__ACL__CHAN_ACL__INIT \
 360  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__acl__chan_acl__descriptor) \
 361     , 0,1, 0,1, 0,1, 0,0, NULL, 0,0, 0,0 }
 362
 363
 364 struct  _MumbleProto__ACL
 365 {
 366   ProtobufCMessage base;
 367   uint32_t channel_id;
 368   protobuf_c_boolean has_inherit_acls;
 369   protobuf_c_boolean inherit_acls;
 370   size_t n_groups;
 371   MumbleProto__ACL__ChanGroup **groups;
 372   size_t n_acls;
 373   MumbleProto__ACL__ChanACL **acls;
 374   protobuf_c_boolean has_query;
 375   protobuf_c_boolean query;
 376 };
 377 #define MUMBLE_PROTO__ACL__INIT \
 378  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__acl__descriptor) \
 379     , 0, 0,1, 0,NULL, 0,NULL, 0,0 }
 380
 381
 382 struct  _MumbleProto__QueryUsers
 383 {
 384   ProtobufCMessage base;
 385   size_t n_ids;
 386   uint32_t *ids;
 387   size_t n_names;
 388   char **names;
 389 };
 390 #define MUMBLE_PROTO__QUERY_USERS__INIT \
 391  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__query_users__descriptor) \
 392     , 0,NULL, 0,NULL }
 393
 394
 395 struct  _MumbleProto__CryptSetup
 396 {
 397   ProtobufCMessage base;
 398   protobuf_c_boolean has_key;
 399   ProtobufCBinaryData key;
 400   protobuf_c_boolean has_client_nonce;
 401   ProtobufCBinaryData client_nonce;
 402   protobuf_c_boolean has_server_nonce;
 403   ProtobufCBinaryData server_nonce;
 404 };
 405 #define MUMBLE_PROTO__CRYPT_SETUP__INIT \
 406  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__crypt_setup__descriptor) \
 407     , 0,{0,NULL}, 0,{0,NULL}, 0,{0,NULL} }
 408
 409
 410 struct  _MumbleProto__ContextActionAdd
 411 {
 412   ProtobufCMessage base;
 413   char *action;
 414   char *text;
 415   protobuf_c_boolean has_context;
 416   uint32_t context;
 417 };
 418 #define MUMBLE_PROTO__CONTEXT_ACTION_ADD__INIT \
 419  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__context_action_add__descriptor) \
 420     , NULL, NULL, 0,0 }
 421
 422
 423 struct  _MumbleProto__ContextAction
 424 {
 425   ProtobufCMessage base;
 426   protobuf_c_boolean has_session;
 427   uint32_t session;
 428   protobuf_c_boolean has_channel_id;
 429   uint32_t channel_id;
 430   char *action;
 431 };
 432 #define MUMBLE_PROTO__CONTEXT_ACTION__INIT \
 433  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__context_action__descriptor) \
 434     , 0,0, 0,0, NULL }
 435
 436
 437 struct  _MumbleProto__UserList__User
 438 {
 439   ProtobufCMessage base;
 440   uint32_t user_id;
 441   char *name;
 442 };
 443 #define MUMBLE_PROTO__USER_LIST__USER__INIT \
 444  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__user_list__user__descriptor) \
 445     , 0, NULL }
 446
 447
 448 struct  _MumbleProto__UserList
 449 {
 450   ProtobufCMessage base;
 451   size_t n_users;
 452   MumbleProto__UserList__User **users;
 453 };
 454 #define MUMBLE_PROTO__USER_LIST__INIT \
 455  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__user_list__descriptor) \
 456     , 0,NULL }
 457
 458
 459 struct  _MumbleProto__VoiceTarget__Target
 460 {
 461   ProtobufCMessage base;
 462   size_t n_session;
 463   uint32_t *session;
 464   protobuf_c_boolean has_channel_id;
 465   uint32_t channel_id;
 466   char *group;
 467   protobuf_c_boolean has_links;
 468   protobuf_c_boolean links;
 469   protobuf_c_boolean has_children;
 470   protobuf_c_boolean children;
 471 };
 472 #define MUMBLE_PROTO__VOICE_TARGET__TARGET__INIT \
 473  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__voice_target__target__descriptor) \
 474     , 0,NULL, 0,0, NULL, 0,0, 0,0 }
 475
 476
 477 struct  _MumbleProto__VoiceTarget
 478 {
 479   ProtobufCMessage base;
 480   protobuf_c_boolean has_id;
 481   uint32_t id;
 482   size_t n_targets;
 483   MumbleProto__VoiceTarget__Target **targets;
 484 };
 485 #define MUMBLE_PROTO__VOICE_TARGET__INIT \
 486  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__voice_target__descriptor) \
 487     , 0,0, 0,NULL }
 488
 489
 490 struct  _MumbleProto__PermissionQuery
 491 {
 492   ProtobufCMessage base;
 493   protobuf_c_boolean has_channel_id;
 494   uint32_t channel_id;
 495   protobuf_c_boolean has_permissions;
 496   uint32_t permissions;
 497   protobuf_c_boolean has_flush;
 498   protobuf_c_boolean flush;
 499 };
 500 #define MUMBLE_PROTO__PERMISSION_QUERY__INIT \
 501  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__permission_query__descriptor) \
 502     , 0,0, 0,0, 0,0 }
 503
 504
 505 struct  _MumbleProto__CodecVersion
 506 {
 507   ProtobufCMessage base;
 508   int32_t alpha;
 509   int32_t beta;
 510   protobuf_c_boolean prefer_alpha;
 511 };
 512 #define MUMBLE_PROTO__CODEC_VERSION__INIT \
 513  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__codec_version__descriptor) \
 514     , 0, 0, 1 }
 515
 516
 517 /* MumbleProto__Version methods */
 518 void   mumble_proto__version__init
 519                      (MumbleProto__Version         *message);
 520 size_t mumble_proto__version__get_packed_size
 521                      (const MumbleProto__Version   *message);
 522 size_t mumble_proto__version__pack
 523                      (const MumbleProto__Version   *message,
 524                       uint8_t             *out);
 525 size_t mumble_proto__version__pack_to_buffer
 526                      (const MumbleProto__Version   *message,
 527                       ProtobufCBuffer     *buffer);
 528 MumbleProto__Version *
 529        mumble_proto__version__unpack
 530                      (ProtobufCAllocator  *allocator,
 531                       size_t               len,
 532                       const uint8_t       *data);
 533 void   mumble_proto__version__free_unpacked
 534                      (MumbleProto__Version *message,
 535                       ProtobufCAllocator *allocator);
 536 /* MumbleProto__UDPTunnel methods */
 537 void   mumble_proto__udptunnel__init
 538                      (MumbleProto__UDPTunnel         *message);
 539 size_t mumble_proto__udptunnel__get_packed_size
 540                      (const MumbleProto__UDPTunnel   *message);
 541 size_t mumble_proto__udptunnel__pack
 542                      (const MumbleProto__UDPTunnel   *message,
 543                       uint8_t             *out);
 544 size_t mumble_proto__udptunnel__pack_to_buffer
 545                      (const MumbleProto__UDPTunnel   *message,
 546                       ProtobufCBuffer     *buffer);
 547 MumbleProto__UDPTunnel *
 548        mumble_proto__udptunnel__unpack
 549                      (ProtobufCAllocator  *allocator,
 550                       size_t               len,
 551                       const uint8_t       *data);
 552 void   mumble_proto__udptunnel__free_unpacked
 553                      (MumbleProto__UDPTunnel *message,
 554                       ProtobufCAllocator *allocator);
 555 /* MumbleProto__Authenticate methods */
 556 void   mumble_proto__authenticate__init
 557                      (MumbleProto__Authenticate         *message);
 558 size_t mumble_proto__authenticate__get_packed_size
 559                      (const MumbleProto__Authenticate   *message);
 560 size_t mumble_proto__authenticate__pack
 561                      (const MumbleProto__Authenticate   *message,
 562                       uint8_t             *out);
 563 size_t mumble_proto__authenticate__pack_to_buffer
 564                      (const MumbleProto__Authenticate   *message,
 565                       ProtobufCBuffer     *buffer);
 566 MumbleProto__Authenticate *
 567        mumble_proto__authenticate__unpack
 568                      (ProtobufCAllocator  *allocator,
 569                       size_t               len,
 570                       const uint8_t       *data);
 571 void   mumble_proto__authenticate__free_unpacked
 572                      (MumbleProto__Authenticate *message,
 573                       ProtobufCAllocator *allocator);
 574 /* MumbleProto__Ping methods */
 575 void   mumble_proto__ping__init
 576                      (MumbleProto__Ping         *message);
 577 size_t mumble_proto__ping__get_packed_size
 578                      (const MumbleProto__Ping   *message);
 579 size_t mumble_proto__ping__pack
 580                      (const MumbleProto__Ping   *message,
 581                       uint8_t             *out);
 582 size_t mumble_proto__ping__pack_to_buffer
 583                      (const MumbleProto__Ping   *message,
 584                       ProtobufCBuffer     *buffer);
 585 MumbleProto__Ping *
 586        mumble_proto__ping__unpack
 587                      (ProtobufCAllocator  *allocator,
 588                       size_t               len,
 589                       const uint8_t       *data);
 590 void   mumble_proto__ping__free_unpacked
 591                      (MumbleProto__Ping *message,
 592                       ProtobufCAllocator *allocator);
 593 /* MumbleProto__Reject methods */
 594 void   mumble_proto__reject__init
 595                      (MumbleProto__Reject         *message);
 596 size_t mumble_proto__reject__get_packed_size
 597                      (const MumbleProto__Reject   *message);
 598 size_t mumble_proto__reject__pack
 599                      (const MumbleProto__Reject   *message,
 600                       uint8_t             *out);
 601 size_t mumble_proto__reject__pack_to_buffer
 602                      (const MumbleProto__Reject   *message,
 603                       ProtobufCBuffer     *buffer);
 604 MumbleProto__Reject *
 605        mumble_proto__reject__unpack
 606                      (ProtobufCAllocator  *allocator,
 607                       size_t               len,
 608                       const uint8_t       *data);
 609 void   mumble_proto__reject__free_unpacked
 610                      (MumbleProto__Reject *message,
 611                       ProtobufCAllocator *allocator);
 612 /* MumbleProto__ServerSync methods */
 613 void   mumble_proto__server_sync__init
 614                      (MumbleProto__ServerSync         *message);
 615 size_t mumble_proto__server_sync__get_packed_size
 616                      (const MumbleProto__ServerSync   *message);
 617 size_t mumble_proto__server_sync__pack
 618                      (const MumbleProto__ServerSync   *message,
 619                       uint8_t             *out);
 620 size_t mumble_proto__server_sync__pack_to_buffer
 621                      (const MumbleProto__ServerSync   *message,
 622                       ProtobufCBuffer     *buffer);
 623 MumbleProto__ServerSync *
 624        mumble_proto__server_sync__unpack
 625                      (ProtobufCAllocator  *allocator,
 626                       size_t               len,
 627                       const uint8_t       *data);
 628 void   mumble_proto__server_sync__free_unpacked
 629                      (MumbleProto__ServerSync *message,
 630                       ProtobufCAllocator *allocator);
 631 /* MumbleProto__ChannelRemove methods */
 632 void   mumble_proto__channel_remove__init
 633                      (MumbleProto__ChannelRemove         *message);
 634 size_t mumble_proto__channel_remove__get_packed_size
 635                      (const MumbleProto__ChannelRemove   *message);
 636 size_t mumble_proto__channel_remove__pack
 637                      (const MumbleProto__ChannelRemove   *message,
 638                       uint8_t             *out);
 639 size_t mumble_proto__channel_remove__pack_to_buffer
 640                      (const MumbleProto__ChannelRemove   *message,
 641                       ProtobufCBuffer     *buffer);
 642 MumbleProto__ChannelRemove *
 643        mumble_proto__channel_remove__unpack
 644                      (ProtobufCAllocator  *allocator,
 645                       size_t               len,
 646                       const uint8_t       *data);
 647 void   mumble_proto__channel_remove__free_unpacked
 648                      (MumbleProto__ChannelRemove *message,
 649                       ProtobufCAllocator *allocator);
 650 /* MumbleProto__ChannelState methods */
 651 void   mumble_proto__channel_state__init
 652                      (MumbleProto__ChannelState         *message);
 653 size_t mumble_proto__channel_state__get_packed_size
 654                      (const MumbleProto__ChannelState   *message);
 655 size_t mumble_proto__channel_state__pack
 656                      (const MumbleProto__ChannelState   *message,
 657                       uint8_t             *out);
 658 size_t mumble_proto__channel_state__pack_to_buffer
 659                      (const MumbleProto__ChannelState   *message,
 660                       ProtobufCBuffer     *buffer);
 661 MumbleProto__ChannelState *
 662        mumble_proto__channel_state__unpack
 663                      (ProtobufCAllocator  *allocator,
 664                       size_t               len,
 665                       const uint8_t       *data);
 666 void   mumble_proto__channel_state__free_unpacked
 667                      (MumbleProto__ChannelState *message,
 668                       ProtobufCAllocator *allocator);
 669 /* MumbleProto__UserRemove methods */
 670 void   mumble_proto__user_remove__init
 671                      (MumbleProto__UserRemove         *message);
 672 size_t mumble_proto__user_remove__get_packed_size
 673                      (const MumbleProto__UserRemove   *message);
 674 size_t mumble_proto__user_remove__pack
 675                      (const MumbleProto__UserRemove   *message,
 676                       uint8_t             *out);
 677 size_t mumble_proto__user_remove__pack_to_buffer
 678                      (const MumbleProto__UserRemove   *message,
 679                       ProtobufCBuffer     *buffer);
 680 MumbleProto__UserRemove *
 681        mumble_proto__user_remove__unpack
 682                      (ProtobufCAllocator  *allocator,
 683                       size_t               len,
 684                       const uint8_t       *data);
 685 void   mumble_proto__user_remove__free_unpacked
 686                      (MumbleProto__UserRemove *message,
 687                       ProtobufCAllocator *allocator);
 688 /* MumbleProto__UserState methods */
 689 void   mumble_proto__user_state__init
 690                      (MumbleProto__UserState         *message);
 691 size_t mumble_proto__user_state__get_packed_size
 692                      (const MumbleProto__UserState   *message);
 693 size_t mumble_proto__user_state__pack
 694                      (const MumbleProto__UserState   *message,
 695                       uint8_t             *out);
 696 size_t mumble_proto__user_state__pack_to_buffer
 697                      (const MumbleProto__UserState   *message,
 698                       ProtobufCBuffer     *buffer);
 699 MumbleProto__UserState *
 700        mumble_proto__user_state__unpack
 701                      (ProtobufCAllocator  *allocator,
 702                       size_t               len,
 703                       const uint8_t       *data);
 704 void   mumble_proto__user_state__free_unpacked
 705                      (MumbleProto__UserState *message,
 706                       ProtobufCAllocator *allocator);
 707 /* MumbleProto__BanList__BanEntry methods */
 708 void   mumble_proto__ban_list__ban_entry__init
 709                      (MumbleProto__BanList__BanEntry         *message);
 710 /* MumbleProto__BanList methods */
 711 void   mumble_proto__ban_list__init
 712                      (MumbleProto__BanList         *message);
 713 size_t mumble_proto__ban_list__get_packed_size
 714                      (const MumbleProto__BanList   *message);
 715 size_t mumble_proto__ban_list__pack
 716                      (const MumbleProto__BanList   *message,
 717                       uint8_t             *out);
 718 size_t mumble_proto__ban_list__pack_to_buffer
 719                      (const MumbleProto__BanList   *message,
 720                       ProtobufCBuffer     *buffer);
 721 MumbleProto__BanList *
 722        mumble_proto__ban_list__unpack
 723                      (ProtobufCAllocator  *allocator,
 724                       size_t               len,
 725                       const uint8_t       *data);
 726 void   mumble_proto__ban_list__free_unpacked
 727                      (MumbleProto__BanList *message,
 728                       ProtobufCAllocator *allocator);
 729 /* MumbleProto__TextMessage methods */
 730 void   mumble_proto__text_message__init
 731                      (MumbleProto__TextMessage         *message);
 732 size_t mumble_proto__text_message__get_packed_size
 733                      (const MumbleProto__TextMessage   *message);
 734 size_t mumble_proto__text_message__pack
 735                      (const MumbleProto__TextMessage   *message,
 736                       uint8_t             *out);
 737 size_t mumble_proto__text_message__pack_to_buffer
 738                      (const MumbleProto__TextMessage   *message,
 739                       ProtobufCBuffer     *buffer);
 740 MumbleProto__TextMessage *
 741        mumble_proto__text_message__unpack
 742                      (ProtobufCAllocator  *allocator,
 743                       size_t               len,
 744                       const uint8_t       *data);
 745 void   mumble_proto__text_message__free_unpacked
 746                      (MumbleProto__TextMessage *message,
 747                       ProtobufCAllocator *allocator);
 748 /* MumbleProto__PermissionDenied methods */
 749 void   mumble_proto__permission_denied__init
 750                      (MumbleProto__PermissionDenied         *message);
 751 size_t mumble_proto__permission_denied__get_packed_size
 752                      (const MumbleProto__PermissionDenied   *message);
 753 size_t mumble_proto__permission_denied__pack
 754                      (const MumbleProto__PermissionDenied   *message,
 755                       uint8_t             *out);
 756 size_t mumble_proto__permission_denied__pack_to_buffer
 757                      (const MumbleProto__PermissionDenied   *message,
 758                       ProtobufCBuffer     *buffer);
 759 MumbleProto__PermissionDenied *
 760        mumble_proto__permission_denied__unpack
 761                      (ProtobufCAllocator  *allocator,
 762                       size_t               len,
 763                       const uint8_t       *data);
 764 void   mumble_proto__permission_denied__free_unpacked
 765                      (MumbleProto__PermissionDenied *message,
 766                       ProtobufCAllocator *allocator);
 767 /* MumbleProto__ACL__ChanGroup methods */
 768 void   mumble_proto__acl__chan_group__init
 769                      (MumbleProto__ACL__ChanGroup         *message);
 770 /* MumbleProto__ACL__ChanACL methods */
 771 void   mumble_proto__acl__chan_acl__init
 772                      (MumbleProto__ACL__ChanACL         *message);
 773 /* MumbleProto__ACL methods */
 774 void   mumble_proto__acl__init
 775                      (MumbleProto__ACL         *message);
 776 size_t mumble_proto__acl__get_packed_size
 777                      (const MumbleProto__ACL   *message);
 778 size_t mumble_proto__acl__pack
 779                      (const MumbleProto__ACL   *message,
 780                       uint8_t             *out);
 781 size_t mumble_proto__acl__pack_to_buffer
 782                      (const MumbleProto__ACL   *message,
 783                       ProtobufCBuffer     *buffer);
 784 MumbleProto__ACL *
 785        mumble_proto__acl__unpack
 786                      (ProtobufCAllocator  *allocator,
 787                       size_t               len,
 788                       const uint8_t       *data);
 789 void   mumble_proto__acl__free_unpacked
 790                      (MumbleProto__ACL *message,
 791                       ProtobufCAllocator *allocator);
 792 /* MumbleProto__QueryUsers methods */
 793 void   mumble_proto__query_users__init
 794                      (MumbleProto__QueryUsers         *message);
 795 size_t mumble_proto__query_users__get_packed_size
 796                      (const MumbleProto__QueryUsers   *message);
 797 size_t mumble_proto__query_users__pack
 798                      (const MumbleProto__QueryUsers   *message,
 799                       uint8_t             *out);
 800 size_t mumble_proto__query_users__pack_to_buffer
 801                      (const MumbleProto__QueryUsers   *message,
 802                       ProtobufCBuffer     *buffer);
 803 MumbleProto__QueryUsers *
 804        mumble_proto__query_users__unpack
 805                      (ProtobufCAllocator  *allocator,
 806                       size_t               len,
 807                       const uint8_t       *data);
 808 void   mumble_proto__query_users__free_unpacked
 809                      (MumbleProto__QueryUsers *message,
 810                       ProtobufCAllocator *allocator);
 811 /* MumbleProto__CryptSetup methods */
 812 void   mumble_proto__crypt_setup__init
 813                      (MumbleProto__CryptSetup         *message);
 814 size_t mumble_proto__crypt_setup__get_packed_size
 815                      (const MumbleProto__CryptSetup   *message);
 816 size_t mumble_proto__crypt_setup__pack
 817                      (const MumbleProto__CryptSetup   *message,
 818                       uint8_t             *out);
 819 size_t mumble_proto__crypt_setup__pack_to_buffer
 820                      (const MumbleProto__CryptSetup   *message,
 821                       ProtobufCBuffer     *buffer);
 822 MumbleProto__CryptSetup *
 823        mumble_proto__crypt_setup__unpack
 824                      (ProtobufCAllocator  *allocator,
 825                       size_t               len,
 826                       const uint8_t       *data);
 827 void   mumble_proto__crypt_setup__free_unpacked
 828                      (MumbleProto__CryptSetup *message,
 829                       ProtobufCAllocator *allocator);
 830 /* MumbleProto__ContextActionAdd methods */
 831 void   mumble_proto__context_action_add__init
 832                      (MumbleProto__ContextActionAdd         *message);
 833 size_t mumble_proto__context_action_add__get_packed_size
 834                      (const MumbleProto__ContextActionAdd   *message);
 835 size_t mumble_proto__context_action_add__pack
 836                      (const MumbleProto__ContextActionAdd   *message,
 837                       uint8_t             *out);
 838 size_t mumble_proto__context_action_add__pack_to_buffer
 839                      (const MumbleProto__ContextActionAdd   *message,
 840                       ProtobufCBuffer     *buffer);
 841 MumbleProto__ContextActionAdd *
 842        mumble_proto__context_action_add__unpack
 843                      (ProtobufCAllocator  *allocator,
 844                       size_t               len,
 845                       const uint8_t       *data);
 846 void   mumble_proto__context_action_add__free_unpacked
 847                      (MumbleProto__ContextActionAdd *message,
 848                       ProtobufCAllocator *allocator);
 849 /* MumbleProto__ContextAction methods */
 850 void   mumble_proto__context_action__init
 851                      (MumbleProto__ContextAction         *message);
 852 size_t mumble_proto__context_action__get_packed_size
 853                      (const MumbleProto__ContextAction   *message);
 854 size_t mumble_proto__context_action__pack
 855                      (const MumbleProto__ContextAction   *message,
 856                       uint8_t             *out);
 857 size_t mumble_proto__context_action__pack_to_buffer
 858                      (const MumbleProto__ContextAction   *message,
 859                       ProtobufCBuffer     *buffer);
 860 MumbleProto__ContextAction *
 861        mumble_proto__context_action__unpack
 862                      (ProtobufCAllocator  *allocator,
 863                       size_t               len,
 864                       const uint8_t       *data);
 865 void   mumble_proto__context_action__free_unpacked
 866                      (MumbleProto__ContextAction *message,
 867                       ProtobufCAllocator *allocator);
 868 /* MumbleProto__UserList__User methods */
 869 void   mumble_proto__user_list__user__init
 870                      (MumbleProto__UserList__User         *message);
 871 /* MumbleProto__UserList methods */
 872 void   mumble_proto__user_list__init
 873                      (MumbleProto__UserList         *message);
 874 size_t mumble_proto__user_list__get_packed_size
 875                      (const MumbleProto__UserList   *message);
 876 size_t mumble_proto__user_list__pack
 877                      (const MumbleProto__UserList   *message,
 878                       uint8_t             *out);
 879 size_t mumble_proto__user_list__pack_to_buffer
 880                      (const MumbleProto__UserList   *message,
 881                       ProtobufCBuffer     *buffer);
 882 MumbleProto__UserList *
 883        mumble_proto__user_list__unpack
 884                      (ProtobufCAllocator  *allocator,
 885                       size_t               len,
 886                       const uint8_t       *data);
 887 void   mumble_proto__user_list__free_unpacked
 888                      (MumbleProto__UserList *message,
 889                       ProtobufCAllocator *allocator);
 890 /* MumbleProto__VoiceTarget__Target methods */
 891 void   mumble_proto__voice_target__target__init
 892                      (MumbleProto__VoiceTarget__Target         *message);
 893 /* MumbleProto__VoiceTarget methods */
 894 void   mumble_proto__voice_target__init
 895                      (MumbleProto__VoiceTarget         *message);
 896 size_t mumble_proto__voice_target__get_packed_size
 897                      (const MumbleProto__VoiceTarget   *message);
 898 size_t mumble_proto__voice_target__pack
 899                      (const MumbleProto__VoiceTarget   *message,
 900                       uint8_t             *out);
 901 size_t mumble_proto__voice_target__pack_to_buffer
 902                      (const MumbleProto__VoiceTarget   *message,
 903                       ProtobufCBuffer     *buffer);
 904 MumbleProto__VoiceTarget *
 905        mumble_proto__voice_target__unpack
 906                      (ProtobufCAllocator  *allocator,
 907                       size_t               len,
 908                       const uint8_t       *data);
 909 void   mumble_proto__voice_target__free_unpacked
 910                      (MumbleProto__VoiceTarget *message,
 911                       ProtobufCAllocator *allocator);
 912 /* MumbleProto__PermissionQuery methods */
 913 void   mumble_proto__permission_query__init
 914                      (MumbleProto__PermissionQuery         *message);
 915 size_t mumble_proto__permission_query__get_packed_size
 916                      (const MumbleProto__PermissionQuery   *message);
 917 size_t mumble_proto__permission_query__pack
 918                      (const MumbleProto__PermissionQuery   *message,
 919                       uint8_t             *out);
 920 size_t mumble_proto__permission_query__pack_to_buffer
 921                      (const MumbleProto__PermissionQuery   *message,
 922                       ProtobufCBuffer     *buffer);
 923 MumbleProto__PermissionQuery *
 924        mumble_proto__permission_query__unpack
 925                      (ProtobufCAllocator  *allocator,
 926                       size_t               len,
 927                       const uint8_t       *data);
 928 void   mumble_proto__permission_query__free_unpacked
 929                      (MumbleProto__PermissionQuery *message,
 930                       ProtobufCAllocator *allocator);
 931 /* MumbleProto__CodecVersion methods */
 932 void   mumble_proto__codec_version__init
 933                      (MumbleProto__CodecVersion         *message);
 934 size_t mumble_proto__codec_version__get_packed_size
 935                      (const MumbleProto__CodecVersion   *message);
 936 size_t mumble_proto__codec_version__pack
 937                      (const MumbleProto__CodecVersion   *message,
 938                       uint8_t             *out);
 939 size_t mumble_proto__codec_version__pack_to_buffer
 940                      (const MumbleProto__CodecVersion   *message,
 941                       ProtobufCBuffer     *buffer);
 942 MumbleProto__CodecVersion *
 943        mumble_proto__codec_version__unpack
 944                      (ProtobufCAllocator  *allocator,
 945                       size_t               len,
 946                       const uint8_t       *data);
 947 void   mumble_proto__codec_version__free_unpacked
 948                      (MumbleProto__CodecVersion *message,
 949                       ProtobufCAllocator *allocator);
 950 /* --- per-message closures --- */
 951
 952 typedef void (*MumbleProto__Version_Closure)
 953                  (const MumbleProto__Version *message,
 954                   void *closure_data);
 955 typedef void (*MumbleProto__UDPTunnel_Closure)
 956                  (const MumbleProto__UDPTunnel *message,
 957                   void *closure_data);
 958 typedef void (*MumbleProto__Authenticate_Closure)
 959                  (const MumbleProto__Authenticate *message,
 960                   void *closure_data);
 961 typedef void (*MumbleProto__Ping_Closure)
 962                  (const MumbleProto__Ping *message,
 963                   void *closure_data);
 964 typedef void (*MumbleProto__Reject_Closure)
 965                  (const MumbleProto__Reject *message,
 966                   void *closure_data);
 967 typedef void (*MumbleProto__ServerSync_Closure)
 968                  (const MumbleProto__ServerSync *message,
 969                   void *closure_data);
 970 typedef void (*MumbleProto__ChannelRemove_Closure)
 971                  (const MumbleProto__ChannelRemove *message,
 972                   void *closure_data);
 973 typedef void (*MumbleProto__ChannelState_Closure)
 974                  (const MumbleProto__ChannelState *message,
 975                   void *closure_data);
 976 typedef void (*MumbleProto__UserRemove_Closure)
 977                  (const MumbleProto__UserRemove *message,
 978                   void *closure_data);
 979 typedef void (*MumbleProto__UserState_Closure)
 980                  (const MumbleProto__UserState *message,
 981                   void *closure_data);
 982 typedef void (*MumbleProto__BanList__BanEntry_Closure)
 983                  (const MumbleProto__BanList__BanEntry *message,
 984                   void *closure_data);
 985 typedef void (*MumbleProto__BanList_Closure)
 986                  (const MumbleProto__BanList *message,
 987                   void *closure_data);
 988 typedef void (*MumbleProto__TextMessage_Closure)
 989                  (const MumbleProto__TextMessage *message,
 990                   void *closure_data);
 991 typedef void (*MumbleProto__PermissionDenied_Closure)
 992                  (const MumbleProto__PermissionDenied *message,
 993                   void *closure_data);
 994 typedef void (*MumbleProto__ACL__ChanGroup_Closure)
 995                  (const MumbleProto__ACL__ChanGroup *message,
 996                   void *closure_data);
 997 typedef void (*MumbleProto__ACL__ChanACL_Closure)
 998                  (const MumbleProto__ACL__ChanACL *message,
 999                   void *closure_data);
1000 typedef void (*MumbleProto__ACL_Closure)
1001                  (const MumbleProto__ACL *message,
1002                   void *closure_data);
1003 typedef void (*MumbleProto__QueryUsers_Closure)
1004                  (const MumbleProto__QueryUsers *message,
1005                   void *closure_data);
1006 typedef void (*MumbleProto__CryptSetup_Closure)
1007                  (const MumbleProto__CryptSetup *message,
1008                   void *closure_data);
1009 typedef void (*MumbleProto__ContextActionAdd_Closure)
1010                  (const MumbleProto__ContextActionAdd *message,
1011                   void *closure_data);
1012 typedef void (*MumbleProto__ContextAction_Closure)
1013                  (const MumbleProto__ContextAction *message,
1014                   void *closure_data);
1015 typedef void (*MumbleProto__UserList__User_Closure)
1016                  (const MumbleProto__UserList__User *message,
1017                   void *closure_data);
1018 typedef void (*MumbleProto__UserList_Closure)
1019                  (const MumbleProto__UserList *message,
1020                   void *closure_data);
1021 typedef void (*MumbleProto__VoiceTarget__Target_Closure)
1022                  (const MumbleProto__VoiceTarget__Target *message,
1023                   void *closure_data);
1024 typedef void (*MumbleProto__VoiceTarget_Closure)
1025                  (const MumbleProto__VoiceTarget *message,
1026                   void *closure_data);
1027 typedef void (*MumbleProto__PermissionQuery_Closure)
1028                  (const MumbleProto__PermissionQuery *message,
1029                   void *closure_data);
1030 typedef void (*MumbleProto__CodecVersion_Closure)
1031                  (const MumbleProto__CodecVersion *message,
1032                   void *closure_data);
1033
1034 /* --- services --- */
1035
1036
1037 /* --- descriptors --- */
1038
1039 extern const ProtobufCMessageDescriptor mumble_proto__version__descriptor;
1040 extern const ProtobufCMessageDescriptor mumble_proto__udptunnel__descriptor;
1041 extern const ProtobufCMessageDescriptor mumble_proto__authenticate__descriptor;
1042 extern const ProtobufCMessageDescriptor mumble_proto__ping__descriptor;
1043 extern const ProtobufCMessageDescriptor mumble_proto__reject__descriptor;
1044 extern const ProtobufCEnumDescriptor    mumble_proto__reject__reject_type__descriptor;
1045 extern const ProtobufCMessageDescriptor mumble_proto__server_sync__descriptor;
1046 extern const ProtobufCMessageDescriptor mumble_proto__channel_remove__descriptor;
1047 extern const ProtobufCMessageDescriptor mumble_proto__channel_state__descriptor;
1048 extern const ProtobufCMessageDescriptor mumble_proto__user_remove__descriptor;
1049 extern const ProtobufCMessageDescriptor mumble_proto__user_state__descriptor;
1050 extern const ProtobufCMessageDescriptor mumble_proto__ban_list__descriptor;
1051 extern const ProtobufCMessageDescriptor mumble_proto__ban_list__ban_entry__descriptor;
1052 extern const ProtobufCMessageDescriptor mumble_proto__text_message__descriptor;
1053 extern const ProtobufCMessageDescriptor mumble_proto__permission_denied__descriptor;
1054 extern const ProtobufCEnumDescriptor    mumble_proto__permission_denied__deny_type__descriptor;
1055 extern const ProtobufCMessageDescriptor mumble_proto__acl__descriptor;
1056 extern const ProtobufCMessageDescriptor mumble_proto__acl__chan_group__descriptor;
1057 extern const ProtobufCMessageDescriptor mumble_proto__acl__chan_acl__descriptor;
1058 extern const ProtobufCMessageDescriptor mumble_proto__query_users__descriptor;
1059 extern const ProtobufCMessageDescriptor mumble_proto__crypt_setup__descriptor;
1060 extern const ProtobufCMessageDescriptor mumble_proto__context_action_add__descriptor;
1061 extern const ProtobufCEnumDescriptor    mumble_proto__context_action_add__context__descriptor;
1062 extern const ProtobufCMessageDescriptor mumble_proto__context_action__descriptor;
1063 extern const ProtobufCMessageDescriptor mumble_proto__user_list__descriptor;
1064 extern const ProtobufCMessageDescriptor mumble_proto__user_list__user__descriptor;
1065 extern const ProtobufCMessageDescriptor mumble_proto__voice_target__descriptor;
1066 extern const ProtobufCMessageDescriptor mumble_proto__voice_target__target__descriptor;
1067 extern const ProtobufCMessageDescriptor mumble_proto__permission_query__descriptor;
1068 extern const ProtobufCMessageDescriptor mumble_proto__codec_version__descriptor;
1069
1070 PROTOBUF_C_END_DECLS
1071
1072
1073 #endif  /* PROTOBUF_Mumble_2eproto__INCLUDED */