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