src/Mumble.pb-c.h

   1 /* Generated by the protocol buffer compiler.  DO NOT EDIT! */
   2 /* Generated from: Mumble.proto */
   3
   4 #ifndef PROTOBUF_C_Mumble_2eproto__INCLUDED
   5 #define PROTOBUF_C_Mumble_2eproto__INCLUDED
   6
   7 #include <protobuf-c/protobuf-c.h>
   8
   9 PROTOBUF_C__BEGIN_DECLS
  10
  11 #if PROTOBUF_C_VERSION_NUMBER < 1000000
  12 # error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
  13 #elif 1000000 < PROTOBUF_C_MIN_COMPILER_VERSION
  14 # 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.
  15 #endif
  16
  17
  18 typedef struct _MumbleProto__Version MumbleProto__Version;
  19 typedef struct _MumbleProto__UDPTunnel MumbleProto__UDPTunnel;
  20 typedef struct _MumbleProto__Authenticate MumbleProto__Authenticate;
  21 typedef struct _MumbleProto__Ping MumbleProto__Ping;
  22 typedef struct _MumbleProto__Reject MumbleProto__Reject;
  23 typedef struct _MumbleProto__ServerConfig MumbleProto__ServerConfig;
  24 typedef struct _MumbleProto__ServerSync MumbleProto__ServerSync;
  25 typedef struct _MumbleProto__ChannelRemove MumbleProto__ChannelRemove;
  26 typedef struct _MumbleProto__ChannelState MumbleProto__ChannelState;
  27 typedef struct _MumbleProto__UserRemove MumbleProto__UserRemove;
  28 typedef struct _MumbleProto__UserState MumbleProto__UserState;
  29 typedef struct _MumbleProto__BanList MumbleProto__BanList;
  30 typedef struct _MumbleProto__BanList__BanEntry MumbleProto__BanList__BanEntry;
  31 typedef struct _MumbleProto__TextMessage MumbleProto__TextMessage;
  32 typedef struct _MumbleProto__PermissionDenied MumbleProto__PermissionDenied;
  33 typedef struct _MumbleProto__ACL MumbleProto__ACL;
  34 typedef struct _MumbleProto__ACL__ChanGroup MumbleProto__ACL__ChanGroup;
  35 typedef struct _MumbleProto__ACL__ChanACL MumbleProto__ACL__ChanACL;
  36 typedef struct _MumbleProto__QueryUsers MumbleProto__QueryUsers;
  37 typedef struct _MumbleProto__CryptSetup MumbleProto__CryptSetup;
  38 typedef struct _MumbleProto__ContextActionModify MumbleProto__ContextActionModify;
  39 typedef struct _MumbleProto__ContextAction MumbleProto__ContextAction;
  40 typedef struct _MumbleProto__UserList MumbleProto__UserList;
  41 typedef struct _MumbleProto__UserList__User MumbleProto__UserList__User;
  42 typedef struct _MumbleProto__VoiceTarget MumbleProto__VoiceTarget;
  43 typedef struct _MumbleProto__VoiceTarget__Target MumbleProto__VoiceTarget__Target;
  44 typedef struct _MumbleProto__PermissionQuery MumbleProto__PermissionQuery;
  45 typedef struct _MumbleProto__CodecVersion MumbleProto__CodecVersion;
  46 typedef struct _MumbleProto__UserStats MumbleProto__UserStats;
  47 typedef struct _MumbleProto__UserStats__Stats MumbleProto__UserStats__Stats;
  48 typedef struct _MumbleProto__SuggestConfig MumbleProto__SuggestConfig;
  49 typedef struct _MumbleProto__RequestBlob MumbleProto__RequestBlob;
  50
  51
  52 /* --- enums --- */
  53
  54 typedef enum _MumbleProto__Reject__RejectType {
  55   MUMBLE_PROTO__REJECT__REJECT_TYPE__None = 0,
  56   MUMBLE_PROTO__REJECT__REJECT_TYPE__WrongVersion = 1,
  57   MUMBLE_PROTO__REJECT__REJECT_TYPE__InvalidUsername = 2,
  58   MUMBLE_PROTO__REJECT__REJECT_TYPE__WrongUserPW = 3,
  59   MUMBLE_PROTO__REJECT__REJECT_TYPE__WrongServerPW = 4,
  60   MUMBLE_PROTO__REJECT__REJECT_TYPE__UsernameInUse = 5,
  61   MUMBLE_PROTO__REJECT__REJECT_TYPE__ServerFull = 6,
  62   MUMBLE_PROTO__REJECT__REJECT_TYPE__NoCertificate = 7
  63     PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MUMBLE_PROTO__REJECT__REJECT_TYPE)
  64 } MumbleProto__Reject__RejectType;
  65 typedef enum _MumbleProto__PermissionDenied__DenyType {
  66   MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__Text = 0,
  67   MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__Permission = 1,
  68   MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__SuperUser = 2,
  69   MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__ChannelName = 3,
  70   MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TextTooLong = 4,
  71   MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__H9K = 5,
  72   MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TemporaryChannel = 6,
  73   MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__MissingCertificate = 7,
  74   MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__UserName = 8,
  75   MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__ChannelFull = 9,
  76   MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__NestingLimit = 10
  77     PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE)
  78 } MumbleProto__PermissionDenied__DenyType;
  79 typedef enum _MumbleProto__ContextActionModify__Context {
  80   MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__CONTEXT__Server = 1,
  81   MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__CONTEXT__Channel = 2,
  82   MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__CONTEXT__User = 4
  83     PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__CONTEXT)
  84 } MumbleProto__ContextActionModify__Context;
  85 typedef enum _MumbleProto__ContextActionModify__Operation {
  86   MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__OPERATION__Add = 0,
  87   MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__OPERATION__Remove = 1
  88     PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__OPERATION)
  89 } MumbleProto__ContextActionModify__Operation;
  90
  91 /* --- messages --- */
  92
  93 struct  _MumbleProto__Version
  94 {
  95   ProtobufCMessage base;
  96   protobuf_c_boolean has_version;
  97   uint32_t version;
  98   char *release;
  99   char *os;
 100   char *os_version;
 101 };
 102 #define MUMBLE_PROTO__VERSION__INIT \
 103  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__version__descriptor) \
 104     , 0,0, NULL, NULL, NULL }
 105
 106
 107 struct  _MumbleProto__UDPTunnel
 108 {
 109   ProtobufCMessage base;
 110   ProtobufCBinaryData packet;
 111 };
 112 #define MUMBLE_PROTO__UDPTUNNEL__INIT \
 113  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__udptunnel__descriptor) \
 114     , {0,NULL} }
 115
 116
 117 struct  _MumbleProto__Authenticate
 118 {
 119   ProtobufCMessage base;
 120   char *username;
 121   char *password;
 122   size_t n_tokens;
 123   char **tokens;
 124   size_t n_celt_versions;
 125   int32_t *celt_versions;
 126   protobuf_c_boolean has_opus;
 127   protobuf_c_boolean opus;
 128 };
 129 #define MUMBLE_PROTO__AUTHENTICATE__INIT \
 130  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__authenticate__descriptor) \
 131     , NULL, NULL, 0,NULL, 0,NULL, 0,0 }
 132
 133
 134 struct  _MumbleProto__Ping
 135 {
 136   ProtobufCMessage base;
 137   protobuf_c_boolean has_timestamp;
 138   uint64_t timestamp;
 139   protobuf_c_boolean has_good;
 140   uint32_t good;
 141   protobuf_c_boolean has_late;
 142   uint32_t late;
 143   protobuf_c_boolean has_lost;
 144   uint32_t lost;
 145   protobuf_c_boolean has_resync;
 146   uint32_t resync;
 147   protobuf_c_boolean has_udp_packets;
 148   uint32_t udp_packets;
 149   protobuf_c_boolean has_tcp_packets;
 150   uint32_t tcp_packets;
 151   protobuf_c_boolean has_udp_ping_avg;
 152   float udp_ping_avg;
 153   protobuf_c_boolean has_udp_ping_var;
 154   float udp_ping_var;
 155   protobuf_c_boolean has_tcp_ping_avg;
 156   float tcp_ping_avg;
 157   protobuf_c_boolean has_tcp_ping_var;
 158   float tcp_ping_var;
 159 };
 160 #define MUMBLE_PROTO__PING__INIT \
 161  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__ping__descriptor) \
 162     , 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0 }
 163
 164
 165 struct  _MumbleProto__Reject
 166 {
 167   ProtobufCMessage base;
 168   protobuf_c_boolean has_type;
 169   MumbleProto__Reject__RejectType type;
 170   char *reason;
 171 };
 172 #define MUMBLE_PROTO__REJECT__INIT \
 173  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__reject__descriptor) \
 174     , 0,0, NULL }
 175
 176
 177 struct  _MumbleProto__ServerConfig
 178 {
 179   ProtobufCMessage base;
 180   protobuf_c_boolean has_max_bandwidth;
 181   uint32_t max_bandwidth;
 182   char *welcome_text;
 183   protobuf_c_boolean has_allow_html;
 184   protobuf_c_boolean allow_html;
 185   protobuf_c_boolean has_message_length;
 186   uint32_t message_length;
 187   protobuf_c_boolean has_image_message_length;
 188   uint32_t image_message_length;
 189 };
 190 #define MUMBLE_PROTO__SERVER_CONFIG__INIT \
 191  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__server_config__descriptor) \
 192     , 0,0, NULL, 0,0, 0,0, 0,0 }
 193
 194
 195 struct  _MumbleProto__ServerSync
 196 {
 197   ProtobufCMessage base;
 198   protobuf_c_boolean has_session;
 199   uint32_t session;
 200   protobuf_c_boolean has_max_bandwidth;
 201   uint32_t max_bandwidth;
 202   char *welcome_text;
 203   protobuf_c_boolean has_permissions;
 204   uint64_t permissions;
 205 };
 206 #define MUMBLE_PROTO__SERVER_SYNC__INIT \
 207  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__server_sync__descriptor) \
 208     , 0,0, 0,0, NULL, 0,0 }
 209
 210
 211 struct  _MumbleProto__ChannelRemove
 212 {
 213   ProtobufCMessage base;
 214   uint32_t channel_id;
 215 };
 216 #define MUMBLE_PROTO__CHANNEL_REMOVE__INIT \
 217  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__channel_remove__descriptor) \
 218     , 0 }
 219
 220
 221 struct  _MumbleProto__ChannelState
 222 {
 223   ProtobufCMessage base;
 224   protobuf_c_boolean has_channel_id;
 225   uint32_t channel_id;
 226   protobuf_c_boolean has_parent;
 227   uint32_t parent;
 228   char *name;
 229   size_t n_links;
 230   uint32_t *links;
 231   char *description;
 232   size_t n_links_add;
 233   uint32_t *links_add;
 234   size_t n_links_remove;
 235   uint32_t *links_remove;
 236   protobuf_c_boolean has_temporary;
 237   protobuf_c_boolean temporary;
 238   protobuf_c_boolean has_position;
 239   int32_t position;
 240   protobuf_c_boolean has_description_hash;
 241   ProtobufCBinaryData description_hash;
 242 };
 243 #define MUMBLE_PROTO__CHANNEL_STATE__INIT \
 244  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__channel_state__descriptor) \
 245     , 0,0, 0,0, NULL, 0,NULL, NULL, 0,NULL, 0,NULL, 0,0, 0,0, 0,{0,NULL} }
 246
 247
 248 struct  _MumbleProto__UserRemove
 249 {
 250   ProtobufCMessage base;
 251   uint32_t session;
 252   protobuf_c_boolean has_actor;
 253   uint32_t actor;
 254   char *reason;
 255   protobuf_c_boolean has_ban;
 256   protobuf_c_boolean ban;
 257 };
 258 #define MUMBLE_PROTO__USER_REMOVE__INIT \
 259  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__user_remove__descriptor) \
 260     , 0, 0,0, NULL, 0,0 }
 261
 262
 263 struct  _MumbleProto__UserState
 264 {
 265   ProtobufCMessage base;
 266   protobuf_c_boolean has_session;
 267   uint32_t session;
 268   protobuf_c_boolean has_actor;
 269   uint32_t actor;
 270   char *name;
 271   protobuf_c_boolean has_user_id;
 272   uint32_t user_id;
 273   protobuf_c_boolean has_channel_id;
 274   uint32_t channel_id;
 275   protobuf_c_boolean has_mute;
 276   protobuf_c_boolean mute;
 277   protobuf_c_boolean has_deaf;
 278   protobuf_c_boolean deaf;
 279   protobuf_c_boolean has_suppress;
 280   protobuf_c_boolean suppress;
 281   protobuf_c_boolean has_self_mute;
 282   protobuf_c_boolean self_mute;
 283   protobuf_c_boolean has_self_deaf;
 284   protobuf_c_boolean self_deaf;
 285   protobuf_c_boolean has_texture;
 286   ProtobufCBinaryData texture;
 287   protobuf_c_boolean has_plugin_context;
 288   ProtobufCBinaryData plugin_context;
 289   char *plugin_identity;
 290   char *comment;
 291   char *hash;
 292   protobuf_c_boolean has_comment_hash;
 293   ProtobufCBinaryData comment_hash;
 294   protobuf_c_boolean has_texture_hash;
 295   ProtobufCBinaryData texture_hash;
 296   protobuf_c_boolean has_priority_speaker;
 297   protobuf_c_boolean priority_speaker;
 298   protobuf_c_boolean has_recording;
 299   protobuf_c_boolean recording;
 300 };
 301 #define MUMBLE_PROTO__USER_STATE__INIT \
 302  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__user_state__descriptor) \
 303     , 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 }
 304
 305
 306 struct  _MumbleProto__BanList__BanEntry
 307 {
 308   ProtobufCMessage base;
 309   ProtobufCBinaryData address;
 310   uint32_t mask;
 311   char *name;
 312   char *hash;
 313   char *reason;
 314   char *start;
 315   protobuf_c_boolean has_duration;
 316   uint32_t duration;
 317 };
 318 #define MUMBLE_PROTO__BAN_LIST__BAN_ENTRY__INIT \
 319  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__ban_list__ban_entry__descriptor) \
 320     , {0,NULL}, 0, NULL, NULL, NULL, NULL, 0,0 }
 321
 322
 323 struct  _MumbleProto__BanList
 324 {
 325   ProtobufCMessage base;
 326   size_t n_bans;
 327   MumbleProto__BanList__BanEntry **bans;
 328   protobuf_c_boolean has_query;
 329   protobuf_c_boolean query;
 330 };
 331 #define MUMBLE_PROTO__BAN_LIST__INIT \
 332  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__ban_list__descriptor) \
 333     , 0,NULL, 0,0 }
 334
 335
 336 struct  _MumbleProto__TextMessage
 337 {
 338   ProtobufCMessage base;
 339   protobuf_c_boolean has_actor;
 340   uint32_t actor;
 341   size_t n_session;
 342   uint32_t *session;
 343   size_t n_channel_id;
 344   uint32_t *channel_id;
 345   size_t n_tree_id;
 346   uint32_t *tree_id;
 347   char *message;
 348 };
 349 #define MUMBLE_PROTO__TEXT_MESSAGE__INIT \
 350  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__text_message__descriptor) \
 351     , 0,0, 0,NULL, 0,NULL, 0,NULL, NULL }
 352
 353
 354 struct  _MumbleProto__PermissionDenied
 355 {
 356   ProtobufCMessage base;
 357   protobuf_c_boolean has_permission;
 358   uint32_t permission;
 359   protobuf_c_boolean has_channel_id;
 360   uint32_t channel_id;
 361   protobuf_c_boolean has_session;
 362   uint32_t session;
 363   char *reason;
 364   protobuf_c_boolean has_type;
 365   MumbleProto__PermissionDenied__DenyType type;
 366   char *name;
 367 };
 368 #define MUMBLE_PROTO__PERMISSION_DENIED__INIT \
 369  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__permission_denied__descriptor) \
 370     , 0,0, 0,0, 0,0, NULL, 0,0, NULL }
 371
 372
 373 struct  _MumbleProto__ACL__ChanGroup
 374 {
 375   ProtobufCMessage base;
 376   char *name;
 377   protobuf_c_boolean has_inherited;
 378   protobuf_c_boolean inherited;
 379   protobuf_c_boolean has_inherit;
 380   protobuf_c_boolean inherit;
 381   protobuf_c_boolean has_inheritable;
 382   protobuf_c_boolean inheritable;
 383   size_t n_add;
 384   uint32_t *add;
 385   size_t n_remove;
 386   uint32_t *remove;
 387   size_t n_inherited_members;
 388   uint32_t *inherited_members;
 389 };
 390 #define MUMBLE_PROTO__ACL__CHAN_GROUP__INIT \
 391  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__acl__chan_group__descriptor) \
 392     , NULL, 0,1, 0,1, 0,1, 0,NULL, 0,NULL, 0,NULL }
 393
 394
 395 struct  _MumbleProto__ACL__ChanACL
 396 {
 397   ProtobufCMessage base;
 398   protobuf_c_boolean has_apply_here;
 399   protobuf_c_boolean apply_here;
 400   protobuf_c_boolean has_apply_subs;
 401   protobuf_c_boolean apply_subs;
 402   protobuf_c_boolean has_inherited;
 403   protobuf_c_boolean inherited;
 404   protobuf_c_boolean has_user_id;
 405   uint32_t user_id;
 406   char *group;
 407   protobuf_c_boolean has_grant;
 408   uint32_t grant;
 409   protobuf_c_boolean has_deny;
 410   uint32_t deny;
 411 };
 412 #define MUMBLE_PROTO__ACL__CHAN_ACL__INIT \
 413  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__acl__chan_acl__descriptor) \
 414     , 0,1, 0,1, 0,1, 0,0, NULL, 0,0, 0,0 }
 415
 416
 417 struct  _MumbleProto__ACL
 418 {
 419   ProtobufCMessage base;
 420   uint32_t channel_id;
 421   protobuf_c_boolean has_inherit_acls;
 422   protobuf_c_boolean inherit_acls;
 423   size_t n_groups;
 424   MumbleProto__ACL__ChanGroup **groups;
 425   size_t n_acls;
 426   MumbleProto__ACL__ChanACL **acls;
 427   protobuf_c_boolean has_query;
 428   protobuf_c_boolean query;
 429 };
 430 #define MUMBLE_PROTO__ACL__INIT \
 431  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__acl__descriptor) \
 432     , 0, 0,1, 0,NULL, 0,NULL, 0,0 }
 433
 434
 435 struct  _MumbleProto__QueryUsers
 436 {
 437   ProtobufCMessage base;
 438   size_t n_ids;
 439   uint32_t *ids;
 440   size_t n_names;
 441   char **names;
 442 };
 443 #define MUMBLE_PROTO__QUERY_USERS__INIT \
 444  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__query_users__descriptor) \
 445     , 0,NULL, 0,NULL }
 446
 447
 448 struct  _MumbleProto__CryptSetup
 449 {
 450   ProtobufCMessage base;
 451   protobuf_c_boolean has_key;
 452   ProtobufCBinaryData key;
 453   protobuf_c_boolean has_client_nonce;
 454   ProtobufCBinaryData client_nonce;
 455   protobuf_c_boolean has_server_nonce;
 456   ProtobufCBinaryData server_nonce;
 457 };
 458 #define MUMBLE_PROTO__CRYPT_SETUP__INIT \
 459  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__crypt_setup__descriptor) \
 460     , 0,{0,NULL}, 0,{0,NULL}, 0,{0,NULL} }
 461
 462
 463 struct  _MumbleProto__ContextActionModify
 464 {
 465   ProtobufCMessage base;
 466   char *action;
 467   char *text;
 468   protobuf_c_boolean has_context;
 469   uint32_t context;
 470   protobuf_c_boolean has_operation;
 471   MumbleProto__ContextActionModify__Operation operation;
 472 };
 473 #define MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__INIT \
 474  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__context_action_modify__descriptor) \
 475     , NULL, NULL, 0,0, 0,0 }
 476
 477
 478 struct  _MumbleProto__ContextAction
 479 {
 480   ProtobufCMessage base;
 481   protobuf_c_boolean has_session;
 482   uint32_t session;
 483   protobuf_c_boolean has_channel_id;
 484   uint32_t channel_id;
 485   char *action;
 486 };
 487 #define MUMBLE_PROTO__CONTEXT_ACTION__INIT \
 488  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__context_action__descriptor) \
 489     , 0,0, 0,0, NULL }
 490
 491
 492 struct  _MumbleProto__UserList__User
 493 {
 494   ProtobufCMessage base;
 495   uint32_t user_id;
 496   char *name;
 497 };
 498 #define MUMBLE_PROTO__USER_LIST__USER__INIT \
 499  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__user_list__user__descriptor) \
 500     , 0, NULL }
 501
 502
 503 struct  _MumbleProto__UserList
 504 {
 505   ProtobufCMessage base;
 506   size_t n_users;
 507   MumbleProto__UserList__User **users;
 508 };
 509 #define MUMBLE_PROTO__USER_LIST__INIT \
 510  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__user_list__descriptor) \
 511     , 0,NULL }
 512
 513
 514 struct  _MumbleProto__VoiceTarget__Target
 515 {
 516   ProtobufCMessage base;
 517   size_t n_session;
 518   uint32_t *session;
 519   protobuf_c_boolean has_channel_id;
 520   uint32_t channel_id;
 521   char *group;
 522   protobuf_c_boolean has_links;
 523   protobuf_c_boolean links;
 524   protobuf_c_boolean has_children;
 525   protobuf_c_boolean children;
 526 };
 527 #define MUMBLE_PROTO__VOICE_TARGET__TARGET__INIT \
 528  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__voice_target__target__descriptor) \
 529     , 0,NULL, 0,0, NULL, 0,0, 0,0 }
 530
 531
 532 struct  _MumbleProto__VoiceTarget
 533 {
 534   ProtobufCMessage base;
 535   protobuf_c_boolean has_id;
 536   uint32_t id;
 537   size_t n_targets;
 538   MumbleProto__VoiceTarget__Target **targets;
 539 };
 540 #define MUMBLE_PROTO__VOICE_TARGET__INIT \
 541  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__voice_target__descriptor) \
 542     , 0,0, 0,NULL }
 543
 544
 545 struct  _MumbleProto__PermissionQuery
 546 {
 547   ProtobufCMessage base;
 548   protobuf_c_boolean has_channel_id;
 549   uint32_t channel_id;
 550   protobuf_c_boolean has_permissions;
 551   uint32_t permissions;
 552   protobuf_c_boolean has_flush;
 553   protobuf_c_boolean flush;
 554 };
 555 #define MUMBLE_PROTO__PERMISSION_QUERY__INIT \
 556  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__permission_query__descriptor) \
 557     , 0,0, 0,0, 0,0 }
 558
 559
 560 struct  _MumbleProto__CodecVersion
 561 {
 562   ProtobufCMessage base;
 563   int32_t alpha;
 564   int32_t beta;
 565   protobuf_c_boolean prefer_alpha;
 566   protobuf_c_boolean has_opus;
 567   protobuf_c_boolean opus;
 568 };
 569 #define MUMBLE_PROTO__CODEC_VERSION__INIT \
 570  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__codec_version__descriptor) \
 571     , 0, 0, 1, 0,0 }
 572
 573
 574 struct  _MumbleProto__UserStats__Stats
 575 {
 576   ProtobufCMessage base;
 577   protobuf_c_boolean has_good;
 578   uint32_t good;
 579   protobuf_c_boolean has_late;
 580   uint32_t late;
 581   protobuf_c_boolean has_lost;
 582   uint32_t lost;
 583   protobuf_c_boolean has_resync;
 584   uint32_t resync;
 585 };
 586 #define MUMBLE_PROTO__USER_STATS__STATS__INIT \
 587  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__user_stats__stats__descriptor) \
 588     , 0,0, 0,0, 0,0, 0,0 }
 589
 590
 591 struct  _MumbleProto__UserStats
 592 {
 593   ProtobufCMessage base;
 594   protobuf_c_boolean has_session;
 595   uint32_t session;
 596   protobuf_c_boolean has_stats_only;
 597   protobuf_c_boolean stats_only;
 598   size_t n_certificates;
 599   ProtobufCBinaryData *certificates;
 600   MumbleProto__UserStats__Stats *from_client;
 601   MumbleProto__UserStats__Stats *from_server;
 602   protobuf_c_boolean has_udp_packets;
 603   uint32_t udp_packets;
 604   protobuf_c_boolean has_tcp_packets;
 605   uint32_t tcp_packets;
 606   protobuf_c_boolean has_udp_ping_avg;
 607   float udp_ping_avg;
 608   protobuf_c_boolean has_udp_ping_var;
 609   float udp_ping_var;
 610   protobuf_c_boolean has_tcp_ping_avg;
 611   float tcp_ping_avg;
 612   protobuf_c_boolean has_tcp_ping_var;
 613   float tcp_ping_var;
 614   MumbleProto__Version *version;
 615   size_t n_celt_versions;
 616   int32_t *celt_versions;
 617   protobuf_c_boolean has_address;
 618   ProtobufCBinaryData address;
 619   protobuf_c_boolean has_bandwidth;
 620   uint32_t bandwidth;
 621   protobuf_c_boolean has_onlinesecs;
 622   uint32_t onlinesecs;
 623   protobuf_c_boolean has_idlesecs;
 624   uint32_t idlesecs;
 625   protobuf_c_boolean has_strong_certificate;
 626   protobuf_c_boolean strong_certificate;
 627   protobuf_c_boolean has_opus;
 628   protobuf_c_boolean opus;
 629 };
 630 #define MUMBLE_PROTO__USER_STATS__INIT \
 631  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__user_stats__descriptor) \
 632     , 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 }
 633
 634
 635 struct  _MumbleProto__SuggestConfig
 636 {
 637   ProtobufCMessage base;
 638   protobuf_c_boolean has_version;
 639   uint32_t version;
 640   protobuf_c_boolean has_positional;
 641   protobuf_c_boolean positional;
 642   protobuf_c_boolean has_push_to_talk;
 643   protobuf_c_boolean push_to_talk;
 644 };
 645 #define MUMBLE_PROTO__SUGGEST_CONFIG__INIT \
 646  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__suggest_config__descriptor) \
 647     , 0,0, 0,0, 0,0 }
 648
 649
 650 struct  _MumbleProto__RequestBlob
 651 {
 652   ProtobufCMessage base;
 653   size_t n_session_texture;
 654   uint32_t *session_texture;
 655   size_t n_session_comment;
 656   uint32_t *session_comment;
 657   size_t n_channel_description;
 658   uint32_t *channel_description;
 659 };
 660 #define MUMBLE_PROTO__REQUEST_BLOB__INIT \
 661  { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__request_blob__descriptor) \
 662     , 0,NULL, 0,NULL, 0,NULL }
 663
 664
 665 /* MumbleProto__Version methods */
 666 void   mumble_proto__version__init
 667                      (MumbleProto__Version         *message);
 668 size_t mumble_proto__version__get_packed_size
 669                      (const MumbleProto__Version   *message);
 670 size_t mumble_proto__version__pack
 671                      (const MumbleProto__Version   *message,
 672                       uint8_t             *out);
 673 size_t mumble_proto__version__pack_to_buffer
 674                      (const MumbleProto__Version   *message,
 675                       ProtobufCBuffer     *buffer);
 676 MumbleProto__Version *
 677        mumble_proto__version__unpack
 678                      (ProtobufCAllocator  *allocator,
 679                       size_t               len,
 680                       const uint8_t       *data);
 681 void   mumble_proto__version__free_unpacked
 682                      (MumbleProto__Version *message,
 683                       ProtobufCAllocator *allocator);
 684 /* MumbleProto__UDPTunnel methods */
 685 void   mumble_proto__udptunnel__init
 686                      (MumbleProto__UDPTunnel         *message);
 687 size_t mumble_proto__udptunnel__get_packed_size
 688                      (const MumbleProto__UDPTunnel   *message);
 689 size_t mumble_proto__udptunnel__pack
 690                      (const MumbleProto__UDPTunnel   *message,
 691                       uint8_t             *out);
 692 size_t mumble_proto__udptunnel__pack_to_buffer
 693                      (const MumbleProto__UDPTunnel   *message,
 694                       ProtobufCBuffer     *buffer);
 695 MumbleProto__UDPTunnel *
 696        mumble_proto__udptunnel__unpack
 697                      (ProtobufCAllocator  *allocator,
 698                       size_t               len,
 699                       const uint8_t       *data);
 700 void   mumble_proto__udptunnel__free_unpacked
 701                      (MumbleProto__UDPTunnel *message,
 702                       ProtobufCAllocator *allocator);
 703 /* MumbleProto__Authenticate methods */
 704 void   mumble_proto__authenticate__init
 705                      (MumbleProto__Authenticate         *message);
 706 size_t mumble_proto__authenticate__get_packed_size
 707                      (const MumbleProto__Authenticate   *message);
 708 size_t mumble_proto__authenticate__pack
 709                      (const MumbleProto__Authenticate   *message,
 710                       uint8_t             *out);
 711 size_t mumble_proto__authenticate__pack_to_buffer
 712                      (const MumbleProto__Authenticate   *message,
 713                       ProtobufCBuffer     *buffer);
 714 MumbleProto__Authenticate *
 715        mumble_proto__authenticate__unpack
 716                      (ProtobufCAllocator  *allocator,
 717                       size_t               len,
 718                       const uint8_t       *data);
 719 void   mumble_proto__authenticate__free_unpacked
 720                      (MumbleProto__Authenticate *message,
 721                       ProtobufCAllocator *allocator);
 722 /* MumbleProto__Ping methods */
 723 void   mumble_proto__ping__init
 724                      (MumbleProto__Ping         *message);
 725 size_t mumble_proto__ping__get_packed_size
 726                      (const MumbleProto__Ping   *message);
 727 size_t mumble_proto__ping__pack
 728                      (const MumbleProto__Ping   *message,
 729                       uint8_t             *out);
 730 size_t mumble_proto__ping__pack_to_buffer
 731                      (const MumbleProto__Ping   *message,
 732                       ProtobufCBuffer     *buffer);
 733 MumbleProto__Ping *
 734        mumble_proto__ping__unpack
 735                      (ProtobufCAllocator  *allocator,
 736                       size_t               len,
 737                       const uint8_t       *data);
 738 void   mumble_proto__ping__free_unpacked
 739                      (MumbleProto__Ping *message,
 740                       ProtobufCAllocator *allocator);
 741 /* MumbleProto__Reject methods */
 742 void   mumble_proto__reject__init
 743                      (MumbleProto__Reject         *message);
 744 size_t mumble_proto__reject__get_packed_size
 745                      (const MumbleProto__Reject   *message);
 746 size_t mumble_proto__reject__pack
 747                      (const MumbleProto__Reject   *message,
 748                       uint8_t             *out);
 749 size_t mumble_proto__reject__pack_to_buffer
 750                      (const MumbleProto__Reject   *message,
 751                       ProtobufCBuffer     *buffer);
 752 MumbleProto__Reject *
 753        mumble_proto__reject__unpack
 754                      (ProtobufCAllocator  *allocator,
 755                       size_t               len,
 756                       const uint8_t       *data);
 757 void   mumble_proto__reject__free_unpacked
 758                      (MumbleProto__Reject *message,
 759                       ProtobufCAllocator *allocator);
 760 /* MumbleProto__ServerConfig methods */
 761 void   mumble_proto__server_config__init
 762                      (MumbleProto__ServerConfig         *message);
 763 size_t mumble_proto__server_config__get_packed_size
 764                      (const MumbleProto__ServerConfig   *message);
 765 size_t mumble_proto__server_config__pack
 766                      (const MumbleProto__ServerConfig   *message,
 767                       uint8_t             *out);
 768 size_t mumble_proto__server_config__pack_to_buffer
 769                      (const MumbleProto__ServerConfig   *message,
 770                       ProtobufCBuffer     *buffer);
 771 MumbleProto__ServerConfig *
 772        mumble_proto__server_config__unpack
 773                      (ProtobufCAllocator  *allocator,
 774                       size_t               len,
 775                       const uint8_t       *data);
 776 void   mumble_proto__server_config__free_unpacked
 777                      (MumbleProto__ServerConfig *message,
 778                       ProtobufCAllocator *allocator);
 779 /* MumbleProto__ServerSync methods */
 780 void   mumble_proto__server_sync__init
 781                      (MumbleProto__ServerSync         *message);
 782 size_t mumble_proto__server_sync__get_packed_size
 783                      (const MumbleProto__ServerSync   *message);
 784 size_t mumble_proto__server_sync__pack
 785                      (const MumbleProto__ServerSync   *message,
 786                       uint8_t             *out);
 787 size_t mumble_proto__server_sync__pack_to_buffer
 788                      (const MumbleProto__ServerSync   *message,
 789                       ProtobufCBuffer     *buffer);
 790 MumbleProto__ServerSync *
 791        mumble_proto__server_sync__unpack
 792                      (ProtobufCAllocator  *allocator,
 793                       size_t               len,
 794                       const uint8_t       *data);
 795 void   mumble_proto__server_sync__free_unpacked
 796                      (MumbleProto__ServerSync *message,
 797                       ProtobufCAllocator *allocator);
 798 /* MumbleProto__ChannelRemove methods */
 799 void   mumble_proto__channel_remove__init
 800                      (MumbleProto__ChannelRemove         *message);
 801 size_t mumble_proto__channel_remove__get_packed_size
 802                      (const MumbleProto__ChannelRemove   *message);
 803 size_t mumble_proto__channel_remove__pack
 804                      (const MumbleProto__ChannelRemove   *message,
 805                       uint8_t             *out);
 806 size_t mumble_proto__channel_remove__pack_to_buffer
 807                      (const MumbleProto__ChannelRemove   *message,
 808                       ProtobufCBuffer     *buffer);
 809 MumbleProto__ChannelRemove *
 810        mumble_proto__channel_remove__unpack
 811                      (ProtobufCAllocator  *allocator,
 812                       size_t               len,
 813                       const uint8_t       *data);
 814 void   mumble_proto__channel_remove__free_unpacked
 815                      (MumbleProto__ChannelRemove *message,
 816                       ProtobufCAllocator *allocator);
 817 /* MumbleProto__ChannelState methods */
 818 void   mumble_proto__channel_state__init
 819                      (MumbleProto__ChannelState         *message);
 820 size_t mumble_proto__channel_state__get_packed_size
 821                      (const MumbleProto__ChannelState   *message);
 822 size_t mumble_proto__channel_state__pack
 823                      (const MumbleProto__ChannelState   *message,
 824                       uint8_t             *out);
 825 size_t mumble_proto__channel_state__pack_to_buffer
 826                      (const MumbleProto__ChannelState   *message,
 827                       ProtobufCBuffer     *buffer);
 828 MumbleProto__ChannelState *
 829        mumble_proto__channel_state__unpack
 830                      (ProtobufCAllocator  *allocator,
 831                       size_t               len,
 832                       const uint8_t       *data);
 833 void   mumble_proto__channel_state__free_unpacked
 834                      (MumbleProto__ChannelState *message,
 835                       ProtobufCAllocator *allocator);
 836 /* MumbleProto__UserRemove methods */
 837 void   mumble_proto__user_remove__init
 838                      (MumbleProto__UserRemove         *message);
 839 size_t mumble_proto__user_remove__get_packed_size
 840                      (const MumbleProto__UserRemove   *message);
 841 size_t mumble_proto__user_remove__pack
 842                      (const MumbleProto__UserRemove   *message,
 843                       uint8_t             *out);
 844 size_t mumble_proto__user_remove__pack_to_buffer
 845                      (const MumbleProto__UserRemove   *message,
 846                       ProtobufCBuffer     *buffer);
 847 MumbleProto__UserRemove *
 848        mumble_proto__user_remove__unpack
 849                      (ProtobufCAllocator  *allocator,
 850                       size_t               len,
 851                       const uint8_t       *data);
 852 void   mumble_proto__user_remove__free_unpacked
 853                      (MumbleProto__UserRemove *message,
 854                       ProtobufCAllocator *allocator);
 855 /* MumbleProto__UserState methods */
 856 void   mumble_proto__user_state__init
 857                      (MumbleProto__UserState         *message);
 858 size_t mumble_proto__user_state__get_packed_size
 859                      (const MumbleProto__UserState   *message);
 860 size_t mumble_proto__user_state__pack
 861                      (const MumbleProto__UserState   *message,
 862                       uint8_t             *out);
 863 size_t mumble_proto__user_state__pack_to_buffer
 864                      (const MumbleProto__UserState   *message,
 865                       ProtobufCBuffer     *buffer);
 866 MumbleProto__UserState *
 867        mumble_proto__user_state__unpack
 868                      (ProtobufCAllocator  *allocator,
 869                       size_t               len,
 870                       const uint8_t       *data);
 871 void   mumble_proto__user_state__free_unpacked
 872                      (MumbleProto__UserState *message,
 873                       ProtobufCAllocator *allocator);
 874 /* MumbleProto__BanList__BanEntry methods */
 875 void   mumble_proto__ban_list__ban_entry__init
 876                      (MumbleProto__BanList__BanEntry         *message);
 877 /* MumbleProto__BanList methods */
 878 void   mumble_proto__ban_list__init
 879                      (MumbleProto__BanList         *message);
 880 size_t mumble_proto__ban_list__get_packed_size
 881                      (const MumbleProto__BanList   *message);
 882 size_t mumble_proto__ban_list__pack
 883                      (const MumbleProto__BanList   *message,
 884                       uint8_t             *out);
 885 size_t mumble_proto__ban_list__pack_to_buffer
 886                      (const MumbleProto__BanList   *message,
 887                       ProtobufCBuffer     *buffer);
 888 MumbleProto__BanList *
 889        mumble_proto__ban_list__unpack
 890                      (ProtobufCAllocator  *allocator,
 891                       size_t               len,
 892                       const uint8_t       *data);
 893 void   mumble_proto__ban_list__free_unpacked
 894                      (MumbleProto__BanList *message,
 895                       ProtobufCAllocator *allocator);
 896 /* MumbleProto__TextMessage methods */
 897 void   mumble_proto__text_message__init
 898                      (MumbleProto__TextMessage         *message);
 899 size_t mumble_proto__text_message__get_packed_size
 900                      (const MumbleProto__TextMessage   *message);
 901 size_t mumble_proto__text_message__pack
 902                      (const MumbleProto__TextMessage   *message,
 903                       uint8_t             *out);
 904 size_t mumble_proto__text_message__pack_to_buffer
 905                      (const MumbleProto__TextMessage   *message,
 906                       ProtobufCBuffer     *buffer);
 907 MumbleProto__TextMessage *
 908        mumble_proto__text_message__unpack
 909                      (ProtobufCAllocator  *allocator,
 910                       size_t               len,
 911                       const uint8_t       *data);
 912 void   mumble_proto__text_message__free_unpacked
 913                      (MumbleProto__TextMessage *message,
 914                       ProtobufCAllocator *allocator);
 915 /* MumbleProto__PermissionDenied methods */
 916 void   mumble_proto__permission_denied__init
 917                      (MumbleProto__PermissionDenied         *message);
 918 size_t mumble_proto__permission_denied__get_packed_size
 919                      (const MumbleProto__PermissionDenied   *message);
 920 size_t mumble_proto__permission_denied__pack
 921                      (const MumbleProto__PermissionDenied   *message,
 922                       uint8_t             *out);
 923 size_t mumble_proto__permission_denied__pack_to_buffer
 924                      (const MumbleProto__PermissionDenied   *message,
 925                       ProtobufCBuffer     *buffer);
 926 MumbleProto__PermissionDenied *
 927        mumble_proto__permission_denied__unpack
 928                      (ProtobufCAllocator  *allocator,
 929                       size_t               len,
 930                       const uint8_t       *data);
 931 void   mumble_proto__permission_denied__free_unpacked
 932                      (MumbleProto__PermissionDenied *message,
 933                       ProtobufCAllocator *allocator);
 934 /* MumbleProto__ACL__ChanGroup methods */
 935 void   mumble_proto__acl__chan_group__init
 936                      (MumbleProto__ACL__ChanGroup         *message);
 937 /* MumbleProto__ACL__ChanACL methods */
 938 void   mumble_proto__acl__chan_acl__init
 939                      (MumbleProto__ACL__ChanACL         *message);
 940 /* MumbleProto__ACL methods */
 941 void   mumble_proto__acl__init
 942                      (MumbleProto__ACL         *message);
 943 size_t mumble_proto__acl__get_packed_size
 944                      (const MumbleProto__ACL   *message);
 945 size_t mumble_proto__acl__pack
 946                      (const MumbleProto__ACL   *message,
 947                       uint8_t             *out);
 948 size_t mumble_proto__acl__pack_to_buffer
 949                      (const MumbleProto__ACL   *message,
 950                       ProtobufCBuffer     *buffer);
 951 MumbleProto__ACL *
 952        mumble_proto__acl__unpack
 953                      (ProtobufCAllocator  *allocator,
 954                       size_t               len,
 955                       const uint8_t       *data);
 956 void   mumble_proto__acl__free_unpacked
 957                      (MumbleProto__ACL *message,
 958                       ProtobufCAllocator *allocator);
 959 /* MumbleProto__QueryUsers methods */
 960 void   mumble_proto__query_users__init
 961                      (MumbleProto__QueryUsers         *message);
 962 size_t mumble_proto__query_users__get_packed_size
 963                      (const MumbleProto__QueryUsers   *message);
 964 size_t mumble_proto__query_users__pack
 965                      (const MumbleProto__QueryUsers   *message,
 966                       uint8_t             *out);
 967 size_t mumble_proto__query_users__pack_to_buffer
 968                      (const MumbleProto__QueryUsers   *message,
 969                       ProtobufCBuffer     *buffer);
 970 MumbleProto__QueryUsers *
 971        mumble_proto__query_users__unpack
 972                      (ProtobufCAllocator  *allocator,
 973                       size_t               len,
 974                       const uint8_t       *data);
 975 void   mumble_proto__query_users__free_unpacked
 976                      (MumbleProto__QueryUsers *message,
 977                       ProtobufCAllocator *allocator);
 978 /* MumbleProto__CryptSetup methods */
 979 void   mumble_proto__crypt_setup__init
 980                      (MumbleProto__CryptSetup         *message);
 981 size_t mumble_proto__crypt_setup__get_packed_size
 982                      (const MumbleProto__CryptSetup   *message);
 983 size_t mumble_proto__crypt_setup__pack
 984                      (const MumbleProto__CryptSetup   *message,
 985                       uint8_t             *out);
 986 size_t mumble_proto__crypt_setup__pack_to_buffer
 987                      (const MumbleProto__CryptSetup   *message,
 988                       ProtobufCBuffer     *buffer);
 989 MumbleProto__CryptSetup *
 990        mumble_proto__crypt_setup__unpack
 991                      (ProtobufCAllocator  *allocator,
 992                       size_t               len,
 993                       const uint8_t       *data);
 994 void   mumble_proto__crypt_setup__free_unpacked
 995                      (MumbleProto__CryptSetup *message,
 996                       ProtobufCAllocator *allocator);
 997 /* MumbleProto__ContextActionModify methods */
 998 void   mumble_proto__context_action_modify__init
 999                      (MumbleProto__ContextActionModify         *message);
1000 size_t mumble_proto__context_action_modify__get_packed_size
1001                      (const MumbleProto__ContextActionModify   *message);
1002 size_t mumble_proto__context_action_modify__pack
1003                      (const MumbleProto__ContextActionModify   *message,
1004                       uint8_t             *out);
1005 size_t mumble_proto__context_action_modify__pack_to_buffer
1006                      (const MumbleProto__ContextActionModify   *message,
1007                       ProtobufCBuffer     *buffer);
1008 MumbleProto__ContextActionModify *
1009        mumble_proto__context_action_modify__unpack
1010                      (ProtobufCAllocator  *allocator,
1011                       size_t               len,
1012                       const uint8_t       *data);
1013 void   mumble_proto__context_action_modify__free_unpacked
1014                      (MumbleProto__ContextActionModify *message,
1015                       ProtobufCAllocator *allocator);
1016 /* MumbleProto__ContextAction methods */
1017 void   mumble_proto__context_action__init
1018                      (MumbleProto__ContextAction         *message);
1019 size_t mumble_proto__context_action__get_packed_size
1020                      (const MumbleProto__ContextAction   *message);
1021 size_t mumble_proto__context_action__pack
1022                      (const MumbleProto__ContextAction   *message,
1023                       uint8_t             *out);
1024 size_t mumble_proto__context_action__pack_to_buffer
1025                      (const MumbleProto__ContextAction   *message,
1026                       ProtobufCBuffer     *buffer);
1027 MumbleProto__ContextAction *
1028        mumble_proto__context_action__unpack
1029                      (ProtobufCAllocator  *allocator,
1030                       size_t               len,
1031                       const uint8_t       *data);
1032 void   mumble_proto__context_action__free_unpacked
1033                      (MumbleProto__ContextAction *message,
1034                       ProtobufCAllocator *allocator);
1035 /* MumbleProto__UserList__User methods */
1036 void   mumble_proto__user_list__user__init
1037                      (MumbleProto__UserList__User         *message);
1038 /* MumbleProto__UserList methods */
1039 void   mumble_proto__user_list__init
1040                      (MumbleProto__UserList         *message);
1041 size_t mumble_proto__user_list__get_packed_size
1042                      (const MumbleProto__UserList   *message);
1043 size_t mumble_proto__user_list__pack
1044                      (const MumbleProto__UserList   *message,
1045                       uint8_t             *out);
1046 size_t mumble_proto__user_list__pack_to_buffer
1047                      (const MumbleProto__UserList   *message,
1048                       ProtobufCBuffer     *buffer);
1049 MumbleProto__UserList *
1050        mumble_proto__user_list__unpack
1051                      (ProtobufCAllocator  *allocator,
1052                       size_t               len,
1053                       const uint8_t       *data);
1054 void   mumble_proto__user_list__free_unpacked
1055                      (MumbleProto__UserList *message,
1056                       ProtobufCAllocator *allocator);
1057 /* MumbleProto__VoiceTarget__Target methods */
1058 void   mumble_proto__voice_target__target__init
1059                      (MumbleProto__VoiceTarget__Target         *message);
1060 /* MumbleProto__VoiceTarget methods */
1061 void   mumble_proto__voice_target__init
1062                      (MumbleProto__VoiceTarget         *message);
1063 size_t mumble_proto__voice_target__get_packed_size
1064                      (const MumbleProto__VoiceTarget   *message);
1065 size_t mumble_proto__voice_target__pack
1066                      (const MumbleProto__VoiceTarget   *message,
1067                       uint8_t             *out);
1068 size_t mumble_proto__voice_target__pack_to_buffer
1069                      (const MumbleProto__VoiceTarget   *message,
1070                       ProtobufCBuffer     *buffer);
1071 MumbleProto__VoiceTarget *
1072        mumble_proto__voice_target__unpack
1073                      (ProtobufCAllocator  *allocator,
1074                       size_t               len,
1075                       const uint8_t       *data);
1076 void   mumble_proto__voice_target__free_unpacked
1077                      (MumbleProto__VoiceTarget *message,
1078                       ProtobufCAllocator *allocator);
1079 /* MumbleProto__PermissionQuery methods */
1080 void   mumble_proto__permission_query__init
1081                      (MumbleProto__PermissionQuery         *message);
1082 size_t mumble_proto__permission_query__get_packed_size
1083                      (const MumbleProto__PermissionQuery   *message);
1084 size_t mumble_proto__permission_query__pack
1085                      (const MumbleProto__PermissionQuery   *message,
1086                       uint8_t             *out);
1087 size_t mumble_proto__permission_query__pack_to_buffer
1088                      (const MumbleProto__PermissionQuery   *message,
1089                       ProtobufCBuffer     *buffer);
1090 MumbleProto__PermissionQuery *
1091        mumble_proto__permission_query__unpack
1092                      (ProtobufCAllocator  *allocator,
1093                       size_t               len,
1094                       const uint8_t       *data);
1095 void   mumble_proto__permission_query__free_unpacked
1096                      (MumbleProto__PermissionQuery *message,
1097                       ProtobufCAllocator *allocator);
1098 /* MumbleProto__CodecVersion methods */
1099 void   mumble_proto__codec_version__init
1100                      (MumbleProto__CodecVersion         *message);
1101 size_t mumble_proto__codec_version__get_packed_size
1102                      (const MumbleProto__CodecVersion   *message);
1103 size_t mumble_proto__codec_version__pack
1104                      (const MumbleProto__CodecVersion   *message,
1105                       uint8_t             *out);
1106 size_t mumble_proto__codec_version__pack_to_buffer
1107                      (const MumbleProto__CodecVersion   *message,
1108                       ProtobufCBuffer     *buffer);
1109 MumbleProto__CodecVersion *
1110        mumble_proto__codec_version__unpack
1111                      (ProtobufCAllocator  *allocator,
1112                       size_t               len,
1113                       const uint8_t       *data);
1114 void   mumble_proto__codec_version__free_unpacked
1115                      (MumbleProto__CodecVersion *message,
1116                       ProtobufCAllocator *allocator);
1117 /* MumbleProto__UserStats__Stats methods */
1118 void   mumble_proto__user_stats__stats__init
1119                      (MumbleProto__UserStats__Stats         *message);
1120 /* MumbleProto__UserStats methods */
1121 void   mumble_proto__user_stats__init
1122                      (MumbleProto__UserStats         *message);
1123 size_t mumble_proto__user_stats__get_packed_size
1124                      (const MumbleProto__UserStats   *message);
1125 size_t mumble_proto__user_stats__pack
1126                      (const MumbleProto__UserStats   *message,
1127                       uint8_t             *out);
1128 size_t mumble_proto__user_stats__pack_to_buffer
1129                      (const MumbleProto__UserStats   *message,
1130                       ProtobufCBuffer     *buffer);
1131 MumbleProto__UserStats *
1132        mumble_proto__user_stats__unpack
1133                      (ProtobufCAllocator  *allocator,
1134                       size_t               len,
1135                       const uint8_t       *data);
1136 void   mumble_proto__user_stats__free_unpacked
1137                      (MumbleProto__UserStats *message,
1138                       ProtobufCAllocator *allocator);
1139 /* MumbleProto__SuggestConfig methods */
1140 void   mumble_proto__suggest_config__init
1141                      (MumbleProto__SuggestConfig         *message);
1142 size_t mumble_proto__suggest_config__get_packed_size
1143                      (const MumbleProto__SuggestConfig   *message);
1144 size_t mumble_proto__suggest_config__pack
1145                      (const MumbleProto__SuggestConfig   *message,
1146                       uint8_t             *out);
1147 size_t mumble_proto__suggest_config__pack_to_buffer
1148                      (const MumbleProto__SuggestConfig   *message,
1149                       ProtobufCBuffer     *buffer);
1150 MumbleProto__SuggestConfig *
1151        mumble_proto__suggest_config__unpack
1152                      (ProtobufCAllocator  *allocator,
1153                       size_t               len,
1154                       const uint8_t       *data);
1155 void   mumble_proto__suggest_config__free_unpacked
1156                      (MumbleProto__SuggestConfig *message,
1157                       ProtobufCAllocator *allocator);
1158 /* MumbleProto__RequestBlob methods */
1159 void   mumble_proto__request_blob__init
1160                      (MumbleProto__RequestBlob         *message);
1161 size_t mumble_proto__request_blob__get_packed_size
1162                      (const MumbleProto__RequestBlob   *message);
1163 size_t mumble_proto__request_blob__pack
1164                      (const MumbleProto__RequestBlob   *message,
1165                       uint8_t             *out);
1166 size_t mumble_proto__request_blob__pack_to_buffer
1167                      (const MumbleProto__RequestBlob   *message,
1168                       ProtobufCBuffer     *buffer);
1169 MumbleProto__RequestBlob *
1170        mumble_proto__request_blob__unpack
1171                      (ProtobufCAllocator  *allocator,
1172                       size_t               len,
1173                       const uint8_t       *data);
1174 void   mumble_proto__request_blob__free_unpacked
1175                      (MumbleProto__RequestBlob *message,
1176                       ProtobufCAllocator *allocator);
1177 /* --- per-message closures --- */
1178
1179 typedef void (*MumbleProto__Version_Closure)
1180                  (const MumbleProto__Version *message,
1181                   void *closure_data);
1182 typedef void (*MumbleProto__UDPTunnel_Closure)
1183                  (const MumbleProto__UDPTunnel *message,
1184                   void *closure_data);
1185 typedef void (*MumbleProto__Authenticate_Closure)
1186                  (const MumbleProto__Authenticate *message,
1187                   void *closure_data);
1188 typedef void (*MumbleProto__Ping_Closure)
1189                  (const MumbleProto__Ping *message,
1190                   void *closure_data);
1191 typedef void (*MumbleProto__Reject_Closure)
1192                  (const MumbleProto__Reject *message,
1193                   void *closure_data);
1194 typedef void (*MumbleProto__ServerConfig_Closure)
1195                  (const MumbleProto__ServerConfig *message,
1196                   void *closure_data);
1197 typedef void (*MumbleProto__ServerSync_Closure)
1198                  (const MumbleProto__ServerSync *message,
1199                   void *closure_data);
1200 typedef void (*MumbleProto__ChannelRemove_Closure)
1201                  (const MumbleProto__ChannelRemove *message,
1202                   void *closure_data);
1203 typedef void (*MumbleProto__ChannelState_Closure)
1204                  (const MumbleProto__ChannelState *message,
1205                   void *closure_data);
1206 typedef void (*MumbleProto__UserRemove_Closure)
1207                  (const MumbleProto__UserRemove *message,
1208                   void *closure_data);
1209 typedef void (*MumbleProto__UserState_Closure)
1210                  (const MumbleProto__UserState *message,
1211                   void *closure_data);
1212 typedef void (*MumbleProto__BanList__BanEntry_Closure)
1213                  (const MumbleProto__BanList__BanEntry *message,
1214                   void *closure_data);
1215 typedef void (*MumbleProto__BanList_Closure)
1216                  (const MumbleProto__BanList *message,
1217                   void *closure_data);
1218 typedef void (*MumbleProto__TextMessage_Closure)
1219                  (const MumbleProto__TextMessage *message,
1220                   void *closure_data);
1221 typedef void (*MumbleProto__PermissionDenied_Closure)
1222                  (const MumbleProto__PermissionDenied *message,
1223                   void *closure_data);
1224 typedef void (*MumbleProto__ACL__ChanGroup_Closure)
1225                  (const MumbleProto__ACL__ChanGroup *message,
1226                   void *closure_data);
1227 typedef void (*MumbleProto__ACL__ChanACL_Closure)
1228                  (const MumbleProto__ACL__ChanACL *message,
1229                   void *closure_data);
1230 typedef void (*MumbleProto__ACL_Closure)
1231                  (const MumbleProto__ACL *message,
1232                   void *closure_data);
1233 typedef void (*MumbleProto__QueryUsers_Closure)
1234                  (const MumbleProto__QueryUsers *message,
1235                   void *closure_data);
1236 typedef void (*MumbleProto__CryptSetup_Closure)
1237                  (const MumbleProto__CryptSetup *message,
1238                   void *closure_data);
1239 typedef void (*MumbleProto__ContextActionModify_Closure)
1240                  (const MumbleProto__ContextActionModify *message,
1241                   void *closure_data);
1242 typedef void (*MumbleProto__ContextAction_Closure)
1243                  (const MumbleProto__ContextAction *message,
1244                   void *closure_data);
1245 typedef void (*MumbleProto__UserList__User_Closure)
1246                  (const MumbleProto__UserList__User *message,
1247                   void *closure_data);
1248 typedef void (*MumbleProto__UserList_Closure)
1249                  (const MumbleProto__UserList *message,
1250                   void *closure_data);
1251 typedef void (*MumbleProto__VoiceTarget__Target_Closure)
1252                  (const MumbleProto__VoiceTarget__Target *message,
1253                   void *closure_data);
1254 typedef void (*MumbleProto__VoiceTarget_Closure)
1255                  (const MumbleProto__VoiceTarget *message,
1256                   void *closure_data);
1257 typedef void (*MumbleProto__PermissionQuery_Closure)
1258                  (const MumbleProto__PermissionQuery *message,
1259                   void *closure_data);
1260 typedef void (*MumbleProto__CodecVersion_Closure)
1261                  (const MumbleProto__CodecVersion *message,
1262                   void *closure_data);
1263 typedef void (*MumbleProto__UserStats__Stats_Closure)
1264                  (const MumbleProto__UserStats__Stats *message,
1265                   void *closure_data);
1266 typedef void (*MumbleProto__UserStats_Closure)
1267                  (const MumbleProto__UserStats *message,
1268                   void *closure_data);
1269 typedef void (*MumbleProto__SuggestConfig_Closure)
1270                  (const MumbleProto__SuggestConfig *message,
1271                   void *closure_data);
1272 typedef void (*MumbleProto__RequestBlob_Closure)
1273                  (const MumbleProto__RequestBlob *message,
1274                   void *closure_data);
1275
1276 /* --- services --- */
1277
1278
1279 /* --- descriptors --- */
1280
1281 extern const ProtobufCMessageDescriptor mumble_proto__version__descriptor;
1282 extern const ProtobufCMessageDescriptor mumble_proto__udptunnel__descriptor;
1283 extern const ProtobufCMessageDescriptor mumble_proto__authenticate__descriptor;
1284 extern const ProtobufCMessageDescriptor mumble_proto__ping__descriptor;
1285 extern const ProtobufCMessageDescriptor mumble_proto__reject__descriptor;
1286 extern const ProtobufCEnumDescriptor    mumble_proto__reject__reject_type__descriptor;
1287 extern const ProtobufCMessageDescriptor mumble_proto__server_config__descriptor;
1288 extern const ProtobufCMessageDescriptor mumble_proto__server_sync__descriptor;
1289 extern const ProtobufCMessageDescriptor mumble_proto__channel_remove__descriptor;
1290 extern const ProtobufCMessageDescriptor mumble_proto__channel_state__descriptor;
1291 extern const ProtobufCMessageDescriptor mumble_proto__user_remove__descriptor;
1292 extern const ProtobufCMessageDescriptor mumble_proto__user_state__descriptor;
1293 extern const ProtobufCMessageDescriptor mumble_proto__ban_list__descriptor;
1294 extern const ProtobufCMessageDescriptor mumble_proto__ban_list__ban_entry__descriptor;
1295 extern const ProtobufCMessageDescriptor mumble_proto__text_message__descriptor;
1296 extern const ProtobufCMessageDescriptor mumble_proto__permission_denied__descriptor;
1297 extern const ProtobufCEnumDescriptor    mumble_proto__permission_denied__deny_type__descriptor;
1298 extern const ProtobufCMessageDescriptor mumble_proto__acl__descriptor;
1299 extern const ProtobufCMessageDescriptor mumble_proto__acl__chan_group__descriptor;
1300 extern const ProtobufCMessageDescriptor mumble_proto__acl__chan_acl__descriptor;
1301 extern const ProtobufCMessageDescriptor mumble_proto__query_users__descriptor;
1302 extern const ProtobufCMessageDescriptor mumble_proto__crypt_setup__descriptor;
1303 extern const ProtobufCMessageDescriptor mumble_proto__context_action_modify__descriptor;
1304 extern const ProtobufCEnumDescriptor    mumble_proto__context_action_modify__context__descriptor;
1305 extern const ProtobufCEnumDescriptor    mumble_proto__context_action_modify__operation__descriptor;
1306 extern const ProtobufCMessageDescriptor mumble_proto__context_action__descriptor;
1307 extern const ProtobufCMessageDescriptor mumble_proto__user_list__descriptor;
1308 extern const ProtobufCMessageDescriptor mumble_proto__user_list__user__descriptor;
1309 extern const ProtobufCMessageDescriptor mumble_proto__voice_target__descriptor;
1310 extern const ProtobufCMessageDescriptor mumble_proto__voice_target__target__descriptor;
1311 extern const ProtobufCMessageDescriptor mumble_proto__permission_query__descriptor;
1312 extern const ProtobufCMessageDescriptor mumble_proto__codec_version__descriptor;
1313 extern const ProtobufCMessageDescriptor mumble_proto__user_stats__descriptor;
1314 extern const ProtobufCMessageDescriptor mumble_proto__user_stats__stats__descriptor;
1315 extern const ProtobufCMessageDescriptor mumble_proto__suggest_config__descriptor;
1316 extern const ProtobufCMessageDescriptor mumble_proto__request_blob__descriptor;
1317
1318 PROTOBUF_C__END_DECLS
1319
1320
1321 #endif  /* PROTOBUF_C_Mumble_2eproto__INCLUDED */