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