src/Mumble.pb-c.c

   1 /* Generated by the protocol buffer compiler.  DO NOT EDIT! */
   2
   3 /* Do not generate deprecated warnings for self */
   4 #ifndef PROTOBUF_C_NO_DEPRECATED
   5 #define PROTOBUF_C_NO_DEPRECATED
   6 #endif
   7
   8 #include "Mumble.pb-c.h"
   9 void   mumble_proto__version__init
  10                      (MumbleProto__Version         *message)
  11 {
  12   static MumbleProto__Version init_value = MUMBLE_PROTO__VERSION__INIT;
  13   *message = init_value;
  14 }
  15 size_t mumble_proto__version__get_packed_size
  16                      (const MumbleProto__Version *message)
  17 {
  18   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__version__descriptor);
  19   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  20 }
  21 size_t mumble_proto__version__pack
  22                      (const MumbleProto__Version *message,
  23                       uint8_t       *out)
  24 {
  25   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__version__descriptor);
  26   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  27 }
  28 size_t mumble_proto__version__pack_to_buffer
  29                      (const MumbleProto__Version *message,
  30                       ProtobufCBuffer *buffer)
  31 {
  32   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__version__descriptor);
  33   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  34 }
  35 MumbleProto__Version *
  36        mumble_proto__version__unpack
  37                      (ProtobufCAllocator  *allocator,
  38                       size_t               len,
  39                       const uint8_t       *data)
  40 {
  41   return (MumbleProto__Version *)
  42      protobuf_c_message_unpack (&mumble_proto__version__descriptor,
  43                                 allocator, len, data);
  44 }
  45 void   mumble_proto__version__free_unpacked
  46                      (MumbleProto__Version *message,
  47                       ProtobufCAllocator *allocator)
  48 {
  49   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__version__descriptor);
  50   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  51 }
  52 void   mumble_proto__udptunnel__init
  53                      (MumbleProto__UDPTunnel         *message)
  54 {
  55   static MumbleProto__UDPTunnel init_value = MUMBLE_PROTO__UDPTUNNEL__INIT;
  56   *message = init_value;
  57 }
  58 size_t mumble_proto__udptunnel__get_packed_size
  59                      (const MumbleProto__UDPTunnel *message)
  60 {
  61   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  62   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  63 }
  64 size_t mumble_proto__udptunnel__pack
  65                      (const MumbleProto__UDPTunnel *message,
  66                       uint8_t       *out)
  67 {
  68   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  69   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  70 }
  71 size_t mumble_proto__udptunnel__pack_to_buffer
  72                      (const MumbleProto__UDPTunnel *message,
  73                       ProtobufCBuffer *buffer)
  74 {
  75   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  76   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  77 }
  78 MumbleProto__UDPTunnel *
  79        mumble_proto__udptunnel__unpack
  80                      (ProtobufCAllocator  *allocator,
  81                       size_t               len,
  82                       const uint8_t       *data)
  83 {
  84   return (MumbleProto__UDPTunnel *)
  85      protobuf_c_message_unpack (&mumble_proto__udptunnel__descriptor,
  86                                 allocator, len, data);
  87 }
  88 void   mumble_proto__udptunnel__free_unpacked
  89                      (MumbleProto__UDPTunnel *message,
  90                       ProtobufCAllocator *allocator)
  91 {
  92   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  93   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  94 }
  95 void   mumble_proto__authenticate__init
  96                      (MumbleProto__Authenticate         *message)
  97 {
  98   static MumbleProto__Authenticate init_value = MUMBLE_PROTO__AUTHENTICATE__INIT;
  99   *message = init_value;
 100 }
 101 size_t mumble_proto__authenticate__get_packed_size
 102                      (const MumbleProto__Authenticate *message)
 103 {
 104   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__authenticate__descriptor);
 105   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 106 }
 107 size_t mumble_proto__authenticate__pack
 108                      (const MumbleProto__Authenticate *message,
 109                       uint8_t       *out)
 110 {
 111   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__authenticate__descriptor);
 112   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 113 }
 114 size_t mumble_proto__authenticate__pack_to_buffer
 115                      (const MumbleProto__Authenticate *message,
 116                       ProtobufCBuffer *buffer)
 117 {
 118   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__authenticate__descriptor);
 119   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 120 }
 121 MumbleProto__Authenticate *
 122        mumble_proto__authenticate__unpack
 123                      (ProtobufCAllocator  *allocator,
 124                       size_t               len,
 125                       const uint8_t       *data)
 126 {
 127   return (MumbleProto__Authenticate *)
 128      protobuf_c_message_unpack (&mumble_proto__authenticate__descriptor,
 129                                 allocator, len, data);
 130 }
 131 void   mumble_proto__authenticate__free_unpacked
 132                      (MumbleProto__Authenticate *message,
 133                       ProtobufCAllocator *allocator)
 134 {
 135   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__authenticate__descriptor);
 136   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 137 }
 138 void   mumble_proto__ping__init
 139                      (MumbleProto__Ping         *message)
 140 {
 141   static MumbleProto__Ping init_value = MUMBLE_PROTO__PING__INIT;
 142   *message = init_value;
 143 }
 144 size_t mumble_proto__ping__get_packed_size
 145                      (const MumbleProto__Ping *message)
 146 {
 147   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ping__descriptor);
 148   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 149 }
 150 size_t mumble_proto__ping__pack
 151                      (const MumbleProto__Ping *message,
 152                       uint8_t       *out)
 153 {
 154   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ping__descriptor);
 155   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 156 }
 157 size_t mumble_proto__ping__pack_to_buffer
 158                      (const MumbleProto__Ping *message,
 159                       ProtobufCBuffer *buffer)
 160 {
 161   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ping__descriptor);
 162   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 163 }
 164 MumbleProto__Ping *
 165        mumble_proto__ping__unpack
 166                      (ProtobufCAllocator  *allocator,
 167                       size_t               len,
 168                       const uint8_t       *data)
 169 {
 170   return (MumbleProto__Ping *)
 171      protobuf_c_message_unpack (&mumble_proto__ping__descriptor,
 172                                 allocator, len, data);
 173 }
 174 void   mumble_proto__ping__free_unpacked
 175                      (MumbleProto__Ping *message,
 176                       ProtobufCAllocator *allocator)
 177 {
 178   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ping__descriptor);
 179   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 180 }
 181 void   mumble_proto__reject__init
 182                      (MumbleProto__Reject         *message)
 183 {
 184   static MumbleProto__Reject init_value = MUMBLE_PROTO__REJECT__INIT;
 185   *message = init_value;
 186 }
 187 size_t mumble_proto__reject__get_packed_size
 188                      (const MumbleProto__Reject *message)
 189 {
 190   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__reject__descriptor);
 191   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 192 }
 193 size_t mumble_proto__reject__pack
 194                      (const MumbleProto__Reject *message,
 195                       uint8_t       *out)
 196 {
 197   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__reject__descriptor);
 198   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 199 }
 200 size_t mumble_proto__reject__pack_to_buffer
 201                      (const MumbleProto__Reject *message,
 202                       ProtobufCBuffer *buffer)
 203 {
 204   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__reject__descriptor);
 205   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 206 }
 207 MumbleProto__Reject *
 208        mumble_proto__reject__unpack
 209                      (ProtobufCAllocator  *allocator,
 210                       size_t               len,
 211                       const uint8_t       *data)
 212 {
 213   return (MumbleProto__Reject *)
 214      protobuf_c_message_unpack (&mumble_proto__reject__descriptor,
 215                                 allocator, len, data);
 216 }
 217 void   mumble_proto__reject__free_unpacked
 218                      (MumbleProto__Reject *message,
 219                       ProtobufCAllocator *allocator)
 220 {
 221   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__reject__descriptor);
 222   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 223 }
 224 void   mumble_proto__server_config__init
 225                      (MumbleProto__ServerConfig         *message)
 226 {
 227   static MumbleProto__ServerConfig init_value = MUMBLE_PROTO__SERVER_CONFIG__INIT;
 228   *message = init_value;
 229 }
 230 size_t mumble_proto__server_config__get_packed_size
 231                      (const MumbleProto__ServerConfig *message)
 232 {
 233   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_config__descriptor);
 234   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 235 }
 236 size_t mumble_proto__server_config__pack
 237                      (const MumbleProto__ServerConfig *message,
 238                       uint8_t       *out)
 239 {
 240   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_config__descriptor);
 241   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 242 }
 243 size_t mumble_proto__server_config__pack_to_buffer
 244                      (const MumbleProto__ServerConfig *message,
 245                       ProtobufCBuffer *buffer)
 246 {
 247   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_config__descriptor);
 248   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 249 }
 250 MumbleProto__ServerConfig *
 251        mumble_proto__server_config__unpack
 252                      (ProtobufCAllocator  *allocator,
 253                       size_t               len,
 254                       const uint8_t       *data)
 255 {
 256   return (MumbleProto__ServerConfig *)
 257      protobuf_c_message_unpack (&mumble_proto__server_config__descriptor,
 258                                 allocator, len, data);
 259 }
 260 void   mumble_proto__server_config__free_unpacked
 261                      (MumbleProto__ServerConfig *message,
 262                       ProtobufCAllocator *allocator)
 263 {
 264   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_config__descriptor);
 265   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 266 }
 267 void   mumble_proto__server_sync__init
 268                      (MumbleProto__ServerSync         *message)
 269 {
 270   static MumbleProto__ServerSync init_value = MUMBLE_PROTO__SERVER_SYNC__INIT;
 271   *message = init_value;
 272 }
 273 size_t mumble_proto__server_sync__get_packed_size
 274                      (const MumbleProto__ServerSync *message)
 275 {
 276   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_sync__descriptor);
 277   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 278 }
 279 size_t mumble_proto__server_sync__pack
 280                      (const MumbleProto__ServerSync *message,
 281                       uint8_t       *out)
 282 {
 283   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_sync__descriptor);
 284   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 285 }
 286 size_t mumble_proto__server_sync__pack_to_buffer
 287                      (const MumbleProto__ServerSync *message,
 288                       ProtobufCBuffer *buffer)
 289 {
 290   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_sync__descriptor);
 291   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 292 }
 293 MumbleProto__ServerSync *
 294        mumble_proto__server_sync__unpack
 295                      (ProtobufCAllocator  *allocator,
 296                       size_t               len,
 297                       const uint8_t       *data)
 298 {
 299   return (MumbleProto__ServerSync *)
 300      protobuf_c_message_unpack (&mumble_proto__server_sync__descriptor,
 301                                 allocator, len, data);
 302 }
 303 void   mumble_proto__server_sync__free_unpacked
 304                      (MumbleProto__ServerSync *message,
 305                       ProtobufCAllocator *allocator)
 306 {
 307   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_sync__descriptor);
 308   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 309 }
 310 void   mumble_proto__channel_remove__init
 311                      (MumbleProto__ChannelRemove         *message)
 312 {
 313   static MumbleProto__ChannelRemove init_value = MUMBLE_PROTO__CHANNEL_REMOVE__INIT;
 314   *message = init_value;
 315 }
 316 size_t mumble_proto__channel_remove__get_packed_size
 317                      (const MumbleProto__ChannelRemove *message)
 318 {
 319   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_remove__descriptor);
 320   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 321 }
 322 size_t mumble_proto__channel_remove__pack
 323                      (const MumbleProto__ChannelRemove *message,
 324                       uint8_t       *out)
 325 {
 326   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_remove__descriptor);
 327   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 328 }
 329 size_t mumble_proto__channel_remove__pack_to_buffer
 330                      (const MumbleProto__ChannelRemove *message,
 331                       ProtobufCBuffer *buffer)
 332 {
 333   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_remove__descriptor);
 334   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 335 }
 336 MumbleProto__ChannelRemove *
 337        mumble_proto__channel_remove__unpack
 338                      (ProtobufCAllocator  *allocator,
 339                       size_t               len,
 340                       const uint8_t       *data)
 341 {
 342   return (MumbleProto__ChannelRemove *)
 343      protobuf_c_message_unpack (&mumble_proto__channel_remove__descriptor,
 344                                 allocator, len, data);
 345 }
 346 void   mumble_proto__channel_remove__free_unpacked
 347                      (MumbleProto__ChannelRemove *message,
 348                       ProtobufCAllocator *allocator)
 349 {
 350   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_remove__descriptor);
 351   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 352 }
 353 void   mumble_proto__channel_state__init
 354                      (MumbleProto__ChannelState         *message)
 355 {
 356   static MumbleProto__ChannelState init_value = MUMBLE_PROTO__CHANNEL_STATE__INIT;
 357   *message = init_value;
 358 }
 359 size_t mumble_proto__channel_state__get_packed_size
 360                      (const MumbleProto__ChannelState *message)
 361 {
 362   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_state__descriptor);
 363   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 364 }
 365 size_t mumble_proto__channel_state__pack
 366                      (const MumbleProto__ChannelState *message,
 367                       uint8_t       *out)
 368 {
 369   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_state__descriptor);
 370   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 371 }
 372 size_t mumble_proto__channel_state__pack_to_buffer
 373                      (const MumbleProto__ChannelState *message,
 374                       ProtobufCBuffer *buffer)
 375 {
 376   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_state__descriptor);
 377   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 378 }
 379 MumbleProto__ChannelState *
 380        mumble_proto__channel_state__unpack
 381                      (ProtobufCAllocator  *allocator,
 382                       size_t               len,
 383                       const uint8_t       *data)
 384 {
 385   return (MumbleProto__ChannelState *)
 386      protobuf_c_message_unpack (&mumble_proto__channel_state__descriptor,
 387                                 allocator, len, data);
 388 }
 389 void   mumble_proto__channel_state__free_unpacked
 390                      (MumbleProto__ChannelState *message,
 391                       ProtobufCAllocator *allocator)
 392 {
 393   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_state__descriptor);
 394   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 395 }
 396 void   mumble_proto__user_remove__init
 397                      (MumbleProto__UserRemove         *message)
 398 {
 399   static MumbleProto__UserRemove init_value = MUMBLE_PROTO__USER_REMOVE__INIT;
 400   *message = init_value;
 401 }
 402 size_t mumble_proto__user_remove__get_packed_size
 403                      (const MumbleProto__UserRemove *message)
 404 {
 405   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_remove__descriptor);
 406   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 407 }
 408 size_t mumble_proto__user_remove__pack
 409                      (const MumbleProto__UserRemove *message,
 410                       uint8_t       *out)
 411 {
 412   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_remove__descriptor);
 413   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 414 }
 415 size_t mumble_proto__user_remove__pack_to_buffer
 416                      (const MumbleProto__UserRemove *message,
 417                       ProtobufCBuffer *buffer)
 418 {
 419   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_remove__descriptor);
 420   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 421 }
 422 MumbleProto__UserRemove *
 423        mumble_proto__user_remove__unpack
 424                      (ProtobufCAllocator  *allocator,
 425                       size_t               len,
 426                       const uint8_t       *data)
 427 {
 428   return (MumbleProto__UserRemove *)
 429      protobuf_c_message_unpack (&mumble_proto__user_remove__descriptor,
 430                                 allocator, len, data);
 431 }
 432 void   mumble_proto__user_remove__free_unpacked
 433                      (MumbleProto__UserRemove *message,
 434                       ProtobufCAllocator *allocator)
 435 {
 436   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_remove__descriptor);
 437   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 438 }
 439 void   mumble_proto__user_state__init
 440                      (MumbleProto__UserState         *message)
 441 {
 442   static MumbleProto__UserState init_value = MUMBLE_PROTO__USER_STATE__INIT;
 443   *message = init_value;
 444 }
 445 size_t mumble_proto__user_state__get_packed_size
 446                      (const MumbleProto__UserState *message)
 447 {
 448   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_state__descriptor);
 449   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 450 }
 451 size_t mumble_proto__user_state__pack
 452                      (const MumbleProto__UserState *message,
 453                       uint8_t       *out)
 454 {
 455   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_state__descriptor);
 456   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 457 }
 458 size_t mumble_proto__user_state__pack_to_buffer
 459                      (const MumbleProto__UserState *message,
 460                       ProtobufCBuffer *buffer)
 461 {
 462   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_state__descriptor);
 463   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 464 }
 465 MumbleProto__UserState *
 466        mumble_proto__user_state__unpack
 467                      (ProtobufCAllocator  *allocator,
 468                       size_t               len,
 469                       const uint8_t       *data)
 470 {
 471   return (MumbleProto__UserState *)
 472      protobuf_c_message_unpack (&mumble_proto__user_state__descriptor,
 473                                 allocator, len, data);
 474 }
 475 void   mumble_proto__user_state__free_unpacked
 476                      (MumbleProto__UserState *message,
 477                       ProtobufCAllocator *allocator)
 478 {
 479   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_state__descriptor);
 480   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 481 }
 482 void   mumble_proto__ban_list__ban_entry__init
 483                      (MumbleProto__BanList__BanEntry         *message)
 484 {
 485   static MumbleProto__BanList__BanEntry init_value = MUMBLE_PROTO__BAN_LIST__BAN_ENTRY__INIT;
 486   *message = init_value;
 487 }
 488 void   mumble_proto__ban_list__init
 489                      (MumbleProto__BanList         *message)
 490 {
 491   static MumbleProto__BanList init_value = MUMBLE_PROTO__BAN_LIST__INIT;
 492   *message = init_value;
 493 }
 494 size_t mumble_proto__ban_list__get_packed_size
 495                      (const MumbleProto__BanList *message)
 496 {
 497   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ban_list__descriptor);
 498   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 499 }
 500 size_t mumble_proto__ban_list__pack
 501                      (const MumbleProto__BanList *message,
 502                       uint8_t       *out)
 503 {
 504   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ban_list__descriptor);
 505   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 506 }
 507 size_t mumble_proto__ban_list__pack_to_buffer
 508                      (const MumbleProto__BanList *message,
 509                       ProtobufCBuffer *buffer)
 510 {
 511   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ban_list__descriptor);
 512   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 513 }
 514 MumbleProto__BanList *
 515        mumble_proto__ban_list__unpack
 516                      (ProtobufCAllocator  *allocator,
 517                       size_t               len,
 518                       const uint8_t       *data)
 519 {
 520   return (MumbleProto__BanList *)
 521      protobuf_c_message_unpack (&mumble_proto__ban_list__descriptor,
 522                                 allocator, len, data);
 523 }
 524 void   mumble_proto__ban_list__free_unpacked
 525                      (MumbleProto__BanList *message,
 526                       ProtobufCAllocator *allocator)
 527 {
 528   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ban_list__descriptor);
 529   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 530 }
 531 void   mumble_proto__text_message__init
 532                      (MumbleProto__TextMessage         *message)
 533 {
 534   static MumbleProto__TextMessage init_value = MUMBLE_PROTO__TEXT_MESSAGE__INIT;
 535   *message = init_value;
 536 }
 537 size_t mumble_proto__text_message__get_packed_size
 538                      (const MumbleProto__TextMessage *message)
 539 {
 540   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__text_message__descriptor);
 541   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 542 }
 543 size_t mumble_proto__text_message__pack
 544                      (const MumbleProto__TextMessage *message,
 545                       uint8_t       *out)
 546 {
 547   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__text_message__descriptor);
 548   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 549 }
 550 size_t mumble_proto__text_message__pack_to_buffer
 551                      (const MumbleProto__TextMessage *message,
 552                       ProtobufCBuffer *buffer)
 553 {
 554   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__text_message__descriptor);
 555   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 556 }
 557 MumbleProto__TextMessage *
 558        mumble_proto__text_message__unpack
 559                      (ProtobufCAllocator  *allocator,
 560                       size_t               len,
 561                       const uint8_t       *data)
 562 {
 563   return (MumbleProto__TextMessage *)
 564      protobuf_c_message_unpack (&mumble_proto__text_message__descriptor,
 565                                 allocator, len, data);
 566 }
 567 void   mumble_proto__text_message__free_unpacked
 568                      (MumbleProto__TextMessage *message,
 569                       ProtobufCAllocator *allocator)
 570 {
 571   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__text_message__descriptor);
 572   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 573 }
 574 void   mumble_proto__permission_denied__init
 575                      (MumbleProto__PermissionDenied         *message)
 576 {
 577   static MumbleProto__PermissionDenied init_value = MUMBLE_PROTO__PERMISSION_DENIED__INIT;
 578   *message = init_value;
 579 }
 580 size_t mumble_proto__permission_denied__get_packed_size
 581                      (const MumbleProto__PermissionDenied *message)
 582 {
 583   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_denied__descriptor);
 584   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 585 }
 586 size_t mumble_proto__permission_denied__pack
 587                      (const MumbleProto__PermissionDenied *message,
 588                       uint8_t       *out)
 589 {
 590   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_denied__descriptor);
 591   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 592 }
 593 size_t mumble_proto__permission_denied__pack_to_buffer
 594                      (const MumbleProto__PermissionDenied *message,
 595                       ProtobufCBuffer *buffer)
 596 {
 597   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_denied__descriptor);
 598   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 599 }
 600 MumbleProto__PermissionDenied *
 601        mumble_proto__permission_denied__unpack
 602                      (ProtobufCAllocator  *allocator,
 603                       size_t               len,
 604                       const uint8_t       *data)
 605 {
 606   return (MumbleProto__PermissionDenied *)
 607      protobuf_c_message_unpack (&mumble_proto__permission_denied__descriptor,
 608                                 allocator, len, data);
 609 }
 610 void   mumble_proto__permission_denied__free_unpacked
 611                      (MumbleProto__PermissionDenied *message,
 612                       ProtobufCAllocator *allocator)
 613 {
 614   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_denied__descriptor);
 615   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 616 }
 617 void   mumble_proto__acl__chan_group__init
 618                      (MumbleProto__ACL__ChanGroup         *message)
 619 {
 620   static MumbleProto__ACL__ChanGroup init_value = MUMBLE_PROTO__ACL__CHAN_GROUP__INIT;
 621   *message = init_value;
 622 }
 623 void   mumble_proto__acl__chan_acl__init
 624                      (MumbleProto__ACL__ChanACL         *message)
 625 {
 626   static MumbleProto__ACL__ChanACL init_value = MUMBLE_PROTO__ACL__CHAN_ACL__INIT;
 627   *message = init_value;
 628 }
 629 void   mumble_proto__acl__init
 630                      (MumbleProto__ACL         *message)
 631 {
 632   static MumbleProto__ACL init_value = MUMBLE_PROTO__ACL__INIT;
 633   *message = init_value;
 634 }
 635 size_t mumble_proto__acl__get_packed_size
 636                      (const MumbleProto__ACL *message)
 637 {
 638   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__acl__descriptor);
 639   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 640 }
 641 size_t mumble_proto__acl__pack
 642                      (const MumbleProto__ACL *message,
 643                       uint8_t       *out)
 644 {
 645   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__acl__descriptor);
 646   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 647 }
 648 size_t mumble_proto__acl__pack_to_buffer
 649                      (const MumbleProto__ACL *message,
 650                       ProtobufCBuffer *buffer)
 651 {
 652   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__acl__descriptor);
 653   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 654 }
 655 MumbleProto__ACL *
 656        mumble_proto__acl__unpack
 657                      (ProtobufCAllocator  *allocator,
 658                       size_t               len,
 659                       const uint8_t       *data)
 660 {
 661   return (MumbleProto__ACL *)
 662      protobuf_c_message_unpack (&mumble_proto__acl__descriptor,
 663                                 allocator, len, data);
 664 }
 665 void   mumble_proto__acl__free_unpacked
 666                      (MumbleProto__ACL *message,
 667                       ProtobufCAllocator *allocator)
 668 {
 669   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__acl__descriptor);
 670   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 671 }
 672 void   mumble_proto__query_users__init
 673                      (MumbleProto__QueryUsers         *message)
 674 {
 675   static MumbleProto__QueryUsers init_value = MUMBLE_PROTO__QUERY_USERS__INIT;
 676   *message = init_value;
 677 }
 678 size_t mumble_proto__query_users__get_packed_size
 679                      (const MumbleProto__QueryUsers *message)
 680 {
 681   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__query_users__descriptor);
 682   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 683 }
 684 size_t mumble_proto__query_users__pack
 685                      (const MumbleProto__QueryUsers *message,
 686                       uint8_t       *out)
 687 {
 688   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__query_users__descriptor);
 689   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 690 }
 691 size_t mumble_proto__query_users__pack_to_buffer
 692                      (const MumbleProto__QueryUsers *message,
 693                       ProtobufCBuffer *buffer)
 694 {
 695   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__query_users__descriptor);
 696   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 697 }
 698 MumbleProto__QueryUsers *
 699        mumble_proto__query_users__unpack
 700                      (ProtobufCAllocator  *allocator,
 701                       size_t               len,
 702                       const uint8_t       *data)
 703 {
 704   return (MumbleProto__QueryUsers *)
 705      protobuf_c_message_unpack (&mumble_proto__query_users__descriptor,
 706                                 allocator, len, data);
 707 }
 708 void   mumble_proto__query_users__free_unpacked
 709                      (MumbleProto__QueryUsers *message,
 710                       ProtobufCAllocator *allocator)
 711 {
 712   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__query_users__descriptor);
 713   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 714 }
 715 void   mumble_proto__crypt_setup__init
 716                      (MumbleProto__CryptSetup         *message)
 717 {
 718   static MumbleProto__CryptSetup init_value = MUMBLE_PROTO__CRYPT_SETUP__INIT;
 719   *message = init_value;
 720 }
 721 size_t mumble_proto__crypt_setup__get_packed_size
 722                      (const MumbleProto__CryptSetup *message)
 723 {
 724   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
 725   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 726 }
 727 size_t mumble_proto__crypt_setup__pack
 728                      (const MumbleProto__CryptSetup *message,
 729                       uint8_t       *out)
 730 {
 731   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
 732   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 733 }
 734 size_t mumble_proto__crypt_setup__pack_to_buffer
 735                      (const MumbleProto__CryptSetup *message,
 736                       ProtobufCBuffer *buffer)
 737 {
 738   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
 739   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 740 }
 741 MumbleProto__CryptSetup *
 742        mumble_proto__crypt_setup__unpack
 743                      (ProtobufCAllocator  *allocator,
 744                       size_t               len,
 745                       const uint8_t       *data)
 746 {
 747   return (MumbleProto__CryptSetup *)
 748      protobuf_c_message_unpack (&mumble_proto__crypt_setup__descriptor,
 749                                 allocator, len, data);
 750 }
 751 void   mumble_proto__crypt_setup__free_unpacked
 752                      (MumbleProto__CryptSetup *message,
 753                       ProtobufCAllocator *allocator)
 754 {
 755   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
 756   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 757 }
 758 void   mumble_proto__context_action_modify__init
 759                      (MumbleProto__ContextActionModify         *message)
 760 {
 761   static MumbleProto__ContextActionModify init_value = MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__INIT;
 762   *message = init_value;
 763 }
 764 size_t mumble_proto__context_action_modify__get_packed_size
 765                      (const MumbleProto__ContextActionModify *message)
 766 {
 767   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
 768   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 769 }
 770 size_t mumble_proto__context_action_modify__pack
 771                      (const MumbleProto__ContextActionModify *message,
 772                       uint8_t       *out)
 773 {
 774   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
 775   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 776 }
 777 size_t mumble_proto__context_action_modify__pack_to_buffer
 778                      (const MumbleProto__ContextActionModify *message,
 779                       ProtobufCBuffer *buffer)
 780 {
 781   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
 782   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 783 }
 784 MumbleProto__ContextActionModify *
 785        mumble_proto__context_action_modify__unpack
 786                      (ProtobufCAllocator  *allocator,
 787                       size_t               len,
 788                       const uint8_t       *data)
 789 {
 790   return (MumbleProto__ContextActionModify *)
 791      protobuf_c_message_unpack (&mumble_proto__context_action_modify__descriptor,
 792                                 allocator, len, data);
 793 }
 794 void   mumble_proto__context_action_modify__free_unpacked
 795                      (MumbleProto__ContextActionModify *message,
 796                       ProtobufCAllocator *allocator)
 797 {
 798   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
 799   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 800 }
 801 void   mumble_proto__context_action__init
 802                      (MumbleProto__ContextAction         *message)
 803 {
 804   static MumbleProto__ContextAction init_value = MUMBLE_PROTO__CONTEXT_ACTION__INIT;
 805   *message = init_value;
 806 }
 807 size_t mumble_proto__context_action__get_packed_size
 808                      (const MumbleProto__ContextAction *message)
 809 {
 810   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action__descriptor);
 811   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 812 }
 813 size_t mumble_proto__context_action__pack
 814                      (const MumbleProto__ContextAction *message,
 815                       uint8_t       *out)
 816 {
 817   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action__descriptor);
 818   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 819 }
 820 size_t mumble_proto__context_action__pack_to_buffer
 821                      (const MumbleProto__ContextAction *message,
 822                       ProtobufCBuffer *buffer)
 823 {
 824   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action__descriptor);
 825   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 826 }
 827 MumbleProto__ContextAction *
 828        mumble_proto__context_action__unpack
 829                      (ProtobufCAllocator  *allocator,
 830                       size_t               len,
 831                       const uint8_t       *data)
 832 {
 833   return (MumbleProto__ContextAction *)
 834      protobuf_c_message_unpack (&mumble_proto__context_action__descriptor,
 835                                 allocator, len, data);
 836 }
 837 void   mumble_proto__context_action__free_unpacked
 838                      (MumbleProto__ContextAction *message,
 839                       ProtobufCAllocator *allocator)
 840 {
 841   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action__descriptor);
 842   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 843 }
 844 void   mumble_proto__user_list__user__init
 845                      (MumbleProto__UserList__User         *message)
 846 {
 847   static MumbleProto__UserList__User init_value = MUMBLE_PROTO__USER_LIST__USER__INIT;
 848   *message = init_value;
 849 }
 850 void   mumble_proto__user_list__init
 851                      (MumbleProto__UserList         *message)
 852 {
 853   static MumbleProto__UserList init_value = MUMBLE_PROTO__USER_LIST__INIT;
 854   *message = init_value;
 855 }
 856 size_t mumble_proto__user_list__get_packed_size
 857                      (const MumbleProto__UserList *message)
 858 {
 859   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_list__descriptor);
 860   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 861 }
 862 size_t mumble_proto__user_list__pack
 863                      (const MumbleProto__UserList *message,
 864                       uint8_t       *out)
 865 {
 866   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_list__descriptor);
 867   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 868 }
 869 size_t mumble_proto__user_list__pack_to_buffer
 870                      (const MumbleProto__UserList *message,
 871                       ProtobufCBuffer *buffer)
 872 {
 873   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_list__descriptor);
 874   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 875 }
 876 MumbleProto__UserList *
 877        mumble_proto__user_list__unpack
 878                      (ProtobufCAllocator  *allocator,
 879                       size_t               len,
 880                       const uint8_t       *data)
 881 {
 882   return (MumbleProto__UserList *)
 883      protobuf_c_message_unpack (&mumble_proto__user_list__descriptor,
 884                                 allocator, len, data);
 885 }
 886 void   mumble_proto__user_list__free_unpacked
 887                      (MumbleProto__UserList *message,
 888                       ProtobufCAllocator *allocator)
 889 {
 890   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_list__descriptor);
 891   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 892 }
 893 void   mumble_proto__voice_target__target__init
 894                      (MumbleProto__VoiceTarget__Target         *message)
 895 {
 896   static MumbleProto__VoiceTarget__Target init_value = MUMBLE_PROTO__VOICE_TARGET__TARGET__INIT;
 897   *message = init_value;
 898 }
 899 void   mumble_proto__voice_target__init
 900                      (MumbleProto__VoiceTarget         *message)
 901 {
 902   static MumbleProto__VoiceTarget init_value = MUMBLE_PROTO__VOICE_TARGET__INIT;
 903   *message = init_value;
 904 }
 905 size_t mumble_proto__voice_target__get_packed_size
 906                      (const MumbleProto__VoiceTarget *message)
 907 {
 908   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__voice_target__descriptor);
 909   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 910 }
 911 size_t mumble_proto__voice_target__pack
 912                      (const MumbleProto__VoiceTarget *message,
 913                       uint8_t       *out)
 914 {
 915   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__voice_target__descriptor);
 916   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 917 }
 918 size_t mumble_proto__voice_target__pack_to_buffer
 919                      (const MumbleProto__VoiceTarget *message,
 920                       ProtobufCBuffer *buffer)
 921 {
 922   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__voice_target__descriptor);
 923   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 924 }
 925 MumbleProto__VoiceTarget *
 926        mumble_proto__voice_target__unpack
 927                      (ProtobufCAllocator  *allocator,
 928                       size_t               len,
 929                       const uint8_t       *data)
 930 {
 931   return (MumbleProto__VoiceTarget *)
 932      protobuf_c_message_unpack (&mumble_proto__voice_target__descriptor,
 933                                 allocator, len, data);
 934 }
 935 void   mumble_proto__voice_target__free_unpacked
 936                      (MumbleProto__VoiceTarget *message,
 937                       ProtobufCAllocator *allocator)
 938 {
 939   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__voice_target__descriptor);
 940   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 941 }
 942 void   mumble_proto__permission_query__init
 943                      (MumbleProto__PermissionQuery         *message)
 944 {
 945   static MumbleProto__PermissionQuery init_value = MUMBLE_PROTO__PERMISSION_QUERY__INIT;
 946   *message = init_value;
 947 }
 948 size_t mumble_proto__permission_query__get_packed_size
 949                      (const MumbleProto__PermissionQuery *message)
 950 {
 951   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_query__descriptor);
 952   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 953 }
 954 size_t mumble_proto__permission_query__pack
 955                      (const MumbleProto__PermissionQuery *message,
 956                       uint8_t       *out)
 957 {
 958   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_query__descriptor);
 959   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 960 }
 961 size_t mumble_proto__permission_query__pack_to_buffer
 962                      (const MumbleProto__PermissionQuery *message,
 963                       ProtobufCBuffer *buffer)
 964 {
 965   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_query__descriptor);
 966   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 967 }
 968 MumbleProto__PermissionQuery *
 969        mumble_proto__permission_query__unpack
 970                      (ProtobufCAllocator  *allocator,
 971                       size_t               len,
 972                       const uint8_t       *data)
 973 {
 974   return (MumbleProto__PermissionQuery *)
 975      protobuf_c_message_unpack (&mumble_proto__permission_query__descriptor,
 976                                 allocator, len, data);
 977 }
 978 void   mumble_proto__permission_query__free_unpacked
 979                      (MumbleProto__PermissionQuery *message,
 980                       ProtobufCAllocator *allocator)
 981 {
 982   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_query__descriptor);
 983   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 984 }
 985 void   mumble_proto__codec_version__init
 986                      (MumbleProto__CodecVersion         *message)
 987 {
 988   static MumbleProto__CodecVersion init_value = MUMBLE_PROTO__CODEC_VERSION__INIT;
 989   *message = init_value;
 990 }
 991 size_t mumble_proto__codec_version__get_packed_size
 992                      (const MumbleProto__CodecVersion *message)
 993 {
 994   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__codec_version__descriptor);
 995   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 996 }
 997 size_t mumble_proto__codec_version__pack
 998                      (const MumbleProto__CodecVersion *message,
 999                       uint8_t       *out)
1000 {
1001   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__codec_version__descriptor);
1002   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1003 }
1004 size_t mumble_proto__codec_version__pack_to_buffer
1005                      (const MumbleProto__CodecVersion *message,
1006                       ProtobufCBuffer *buffer)
1007 {
1008   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__codec_version__descriptor);
1009   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1010 }
1011 MumbleProto__CodecVersion *
1012        mumble_proto__codec_version__unpack
1013                      (ProtobufCAllocator  *allocator,
1014                       size_t               len,
1015                       const uint8_t       *data)
1016 {
1017   return (MumbleProto__CodecVersion *)
1018      protobuf_c_message_unpack (&mumble_proto__codec_version__descriptor,
1019                                 allocator, len, data);
1020 }
1021 void   mumble_proto__codec_version__free_unpacked
1022                      (MumbleProto__CodecVersion *message,
1023                       ProtobufCAllocator *allocator)
1024 {
1025   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__codec_version__descriptor);
1026   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1027 }
1028 void   mumble_proto__user_stats__stats__init
1029                      (MumbleProto__UserStats__Stats         *message)
1030 {
1031   static MumbleProto__UserStats__Stats init_value = MUMBLE_PROTO__USER_STATS__STATS__INIT;
1032   *message = init_value;
1033 }
1034 void   mumble_proto__user_stats__init
1035                      (MumbleProto__UserStats         *message)
1036 {
1037   static MumbleProto__UserStats init_value = MUMBLE_PROTO__USER_STATS__INIT;
1038   *message = init_value;
1039 }
1040 size_t mumble_proto__user_stats__get_packed_size
1041                      (const MumbleProto__UserStats *message)
1042 {
1043   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_stats__descriptor);
1044   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1045 }
1046 size_t mumble_proto__user_stats__pack
1047                      (const MumbleProto__UserStats *message,
1048                       uint8_t       *out)
1049 {
1050   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_stats__descriptor);
1051   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1052 }
1053 size_t mumble_proto__user_stats__pack_to_buffer
1054                      (const MumbleProto__UserStats *message,
1055                       ProtobufCBuffer *buffer)
1056 {
1057   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_stats__descriptor);
1058   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1059 }
1060 MumbleProto__UserStats *
1061        mumble_proto__user_stats__unpack
1062                      (ProtobufCAllocator  *allocator,
1063                       size_t               len,
1064                       const uint8_t       *data)
1065 {
1066   return (MumbleProto__UserStats *)
1067      protobuf_c_message_unpack (&mumble_proto__user_stats__descriptor,
1068                                 allocator, len, data);
1069 }
1070 void   mumble_proto__user_stats__free_unpacked
1071                      (MumbleProto__UserStats *message,
1072                       ProtobufCAllocator *allocator)
1073 {
1074   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_stats__descriptor);
1075   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1076 }
1077 void   mumble_proto__suggest_config__init
1078                      (MumbleProto__SuggestConfig         *message)
1079 {
1080   static MumbleProto__SuggestConfig init_value = MUMBLE_PROTO__SUGGEST_CONFIG__INIT;
1081   *message = init_value;
1082 }
1083 size_t mumble_proto__suggest_config__get_packed_size
1084                      (const MumbleProto__SuggestConfig *message)
1085 {
1086   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__suggest_config__descriptor);
1087   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1088 }
1089 size_t mumble_proto__suggest_config__pack
1090                      (const MumbleProto__SuggestConfig *message,
1091                       uint8_t       *out)
1092 {
1093   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__suggest_config__descriptor);
1094   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1095 }
1096 size_t mumble_proto__suggest_config__pack_to_buffer
1097                      (const MumbleProto__SuggestConfig *message,
1098                       ProtobufCBuffer *buffer)
1099 {
1100   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__suggest_config__descriptor);
1101   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1102 }
1103 MumbleProto__SuggestConfig *
1104        mumble_proto__suggest_config__unpack
1105                      (ProtobufCAllocator  *allocator,
1106                       size_t               len,
1107                       const uint8_t       *data)
1108 {
1109   return (MumbleProto__SuggestConfig *)
1110      protobuf_c_message_unpack (&mumble_proto__suggest_config__descriptor,
1111                                 allocator, len, data);
1112 }
1113 void   mumble_proto__suggest_config__free_unpacked
1114                      (MumbleProto__SuggestConfig *message,
1115                       ProtobufCAllocator *allocator)
1116 {
1117   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__suggest_config__descriptor);
1118   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1119 }
1120 void   mumble_proto__request_blob__init
1121                      (MumbleProto__RequestBlob         *message)
1122 {
1123   static MumbleProto__RequestBlob init_value = MUMBLE_PROTO__REQUEST_BLOB__INIT;
1124   *message = init_value;
1125 }
1126 size_t mumble_proto__request_blob__get_packed_size
1127                      (const MumbleProto__RequestBlob *message)
1128 {
1129   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__request_blob__descriptor);
1130   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1131 }
1132 size_t mumble_proto__request_blob__pack
1133                      (const MumbleProto__RequestBlob *message,
1134                       uint8_t       *out)
1135 {
1136   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__request_blob__descriptor);
1137   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1138 }
1139 size_t mumble_proto__request_blob__pack_to_buffer
1140                      (const MumbleProto__RequestBlob *message,
1141                       ProtobufCBuffer *buffer)
1142 {
1143   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__request_blob__descriptor);
1144   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1145 }
1146 MumbleProto__RequestBlob *
1147        mumble_proto__request_blob__unpack
1148                      (ProtobufCAllocator  *allocator,
1149                       size_t               len,
1150                       const uint8_t       *data)
1151 {
1152   return (MumbleProto__RequestBlob *)
1153      protobuf_c_message_unpack (&mumble_proto__request_blob__descriptor,
1154                                 allocator, len, data);
1155 }
1156 void   mumble_proto__request_blob__free_unpacked
1157                      (MumbleProto__RequestBlob *message,
1158                       ProtobufCAllocator *allocator)
1159 {
1160   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__request_blob__descriptor);
1161   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1162 }
1163 static const ProtobufCFieldDescriptor mumble_proto__version__field_descriptors[4] =
1164 {
1165   {
1166     "version",
1167     1,
1168     PROTOBUF_C_LABEL_OPTIONAL,
1169     PROTOBUF_C_TYPE_UINT32,
1170     PROTOBUF_C_OFFSETOF(MumbleProto__Version, has_version),
1171     PROTOBUF_C_OFFSETOF(MumbleProto__Version, version),
1172     NULL,
1173     NULL,
1174     0,            /* packed */
1175     0,NULL,NULL    /* reserved1,reserved2, etc */
1176   },
1177   {
1178     "release",
1179     2,
1180     PROTOBUF_C_LABEL_OPTIONAL,
1181     PROTOBUF_C_TYPE_STRING,
1182     0,   /* quantifier_offset */
1183     PROTOBUF_C_OFFSETOF(MumbleProto__Version, release),
1184     NULL,
1185     NULL,
1186     0,            /* packed */
1187     0,NULL,NULL    /* reserved1,reserved2, etc */
1188   },
1189   {
1190     "os",
1191     3,
1192     PROTOBUF_C_LABEL_OPTIONAL,
1193     PROTOBUF_C_TYPE_STRING,
1194     0,   /* quantifier_offset */
1195     PROTOBUF_C_OFFSETOF(MumbleProto__Version, os),
1196     NULL,
1197     NULL,
1198     0,            /* packed */
1199     0,NULL,NULL    /* reserved1,reserved2, etc */
1200   },
1201   {
1202     "os_version",
1203     4,
1204     PROTOBUF_C_LABEL_OPTIONAL,
1205     PROTOBUF_C_TYPE_STRING,
1206     0,   /* quantifier_offset */
1207     PROTOBUF_C_OFFSETOF(MumbleProto__Version, os_version),
1208     NULL,
1209     NULL,
1210     0,            /* packed */
1211     0,NULL,NULL    /* reserved1,reserved2, etc */
1212   },
1213 };
1214 static const unsigned mumble_proto__version__field_indices_by_name[] = {
1215   2,   /* field[2] = os */
1216   3,   /* field[3] = os_version */
1217   1,   /* field[1] = release */
1218   0,   /* field[0] = version */
1219 };
1220 static const ProtobufCIntRange mumble_proto__version__number_ranges[1 + 1] =
1221 {
1222   { 1, 0 },
1223   { 0, 4 }
1224 };
1225 const ProtobufCMessageDescriptor mumble_proto__version__descriptor =
1226 {
1227   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1228   "MumbleProto.Version",
1229   "Version",
1230   "MumbleProto__Version",
1231   "MumbleProto",
1232   sizeof(MumbleProto__Version),
1233   4,
1234   mumble_proto__version__field_descriptors,
1235   mumble_proto__version__field_indices_by_name,
1236   1,  mumble_proto__version__number_ranges,
1237   (ProtobufCMessageInit) mumble_proto__version__init,
1238   NULL,NULL,NULL    /* reserved[123] */
1239 };
1240 static const ProtobufCFieldDescriptor mumble_proto__udptunnel__field_descriptors[1] =
1241 {
1242   {
1243     "packet",
1244     1,
1245     PROTOBUF_C_LABEL_REQUIRED,
1246     PROTOBUF_C_TYPE_BYTES,
1247     0,   /* quantifier_offset */
1248     PROTOBUF_C_OFFSETOF(MumbleProto__UDPTunnel, packet),
1249     NULL,
1250     NULL,
1251     0,            /* packed */
1252     0,NULL,NULL    /* reserved1,reserved2, etc */
1253   },
1254 };
1255 static const unsigned mumble_proto__udptunnel__field_indices_by_name[] = {
1256   0,   /* field[0] = packet */
1257 };
1258 static const ProtobufCIntRange mumble_proto__udptunnel__number_ranges[1 + 1] =
1259 {
1260   { 1, 0 },
1261   { 0, 1 }
1262 };
1263 const ProtobufCMessageDescriptor mumble_proto__udptunnel__descriptor =
1264 {
1265   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1266   "MumbleProto.UDPTunnel",
1267   "UDPTunnel",
1268   "MumbleProto__UDPTunnel",
1269   "MumbleProto",
1270   sizeof(MumbleProto__UDPTunnel),
1271   1,
1272   mumble_proto__udptunnel__field_descriptors,
1273   mumble_proto__udptunnel__field_indices_by_name,
1274   1,  mumble_proto__udptunnel__number_ranges,
1275   (ProtobufCMessageInit) mumble_proto__udptunnel__init,
1276   NULL,NULL,NULL    /* reserved[123] */
1277 };
1278 static const protobuf_c_boolean mumble_proto__authenticate__opus__default_value = 0;
1279 static const ProtobufCFieldDescriptor mumble_proto__authenticate__field_descriptors[5] =
1280 {
1281   {
1282     "username",
1283     1,
1284     PROTOBUF_C_LABEL_OPTIONAL,
1285     PROTOBUF_C_TYPE_STRING,
1286     0,   /* quantifier_offset */
1287     PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, username),
1288     NULL,
1289     NULL,
1290     0,            /* packed */
1291     0,NULL,NULL    /* reserved1,reserved2, etc */
1292   },
1293   {
1294     "password",
1295     2,
1296     PROTOBUF_C_LABEL_OPTIONAL,
1297     PROTOBUF_C_TYPE_STRING,
1298     0,   /* quantifier_offset */
1299     PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, password),
1300     NULL,
1301     NULL,
1302     0,            /* packed */
1303     0,NULL,NULL    /* reserved1,reserved2, etc */
1304   },
1305   {
1306     "tokens",
1307     3,
1308     PROTOBUF_C_LABEL_REPEATED,
1309     PROTOBUF_C_TYPE_STRING,
1310     PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, n_tokens),
1311     PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, tokens),
1312     NULL,
1313     NULL,
1314     0,            /* packed */
1315     0,NULL,NULL    /* reserved1,reserved2, etc */
1316   },
1317   {
1318     "celt_versions",
1319     4,
1320     PROTOBUF_C_LABEL_REPEATED,
1321     PROTOBUF_C_TYPE_INT32,
1322     PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, n_celt_versions),
1323     PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, celt_versions),
1324     NULL,
1325     NULL,
1326     0,            /* packed */
1327     0,NULL,NULL    /* reserved1,reserved2, etc */
1328   },
1329   {
1330     "opus",
1331     5,
1332     PROTOBUF_C_LABEL_OPTIONAL,
1333     PROTOBUF_C_TYPE_BOOL,
1334     PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, has_opus),
1335     PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, opus),
1336     NULL,
1337     &mumble_proto__authenticate__opus__default_value,
1338     0,            /* packed */
1339     0,NULL,NULL    /* reserved1,reserved2, etc */
1340   },
1341 };
1342 static const unsigned mumble_proto__authenticate__field_indices_by_name[] = {
1343   3,   /* field[3] = celt_versions */
1344   4,   /* field[4] = opus */
1345   1,   /* field[1] = password */
1346   2,   /* field[2] = tokens */
1347   0,   /* field[0] = username */
1348 };
1349 static const ProtobufCIntRange mumble_proto__authenticate__number_ranges[1 + 1] =
1350 {
1351   { 1, 0 },
1352   { 0, 5 }
1353 };
1354 const ProtobufCMessageDescriptor mumble_proto__authenticate__descriptor =
1355 {
1356   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1357   "MumbleProto.Authenticate",
1358   "Authenticate",
1359   "MumbleProto__Authenticate",
1360   "MumbleProto",
1361   sizeof(MumbleProto__Authenticate),
1362   5,
1363   mumble_proto__authenticate__field_descriptors,
1364   mumble_proto__authenticate__field_indices_by_name,
1365   1,  mumble_proto__authenticate__number_ranges,
1366   (ProtobufCMessageInit) mumble_proto__authenticate__init,
1367   NULL,NULL,NULL    /* reserved[123] */
1368 };
1369 static const ProtobufCFieldDescriptor mumble_proto__ping__field_descriptors[11] =
1370 {
1371   {
1372     "timestamp",
1373     1,
1374     PROTOBUF_C_LABEL_OPTIONAL,
1375     PROTOBUF_C_TYPE_UINT64,
1376     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_timestamp),
1377     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, timestamp),
1378     NULL,
1379     NULL,
1380     0,            /* packed */
1381     0,NULL,NULL    /* reserved1,reserved2, etc */
1382   },
1383   {
1384     "good",
1385     2,
1386     PROTOBUF_C_LABEL_OPTIONAL,
1387     PROTOBUF_C_TYPE_UINT32,
1388     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_good),
1389     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, good),
1390     NULL,
1391     NULL,
1392     0,            /* packed */
1393     0,NULL,NULL    /* reserved1,reserved2, etc */
1394   },
1395   {
1396     "late",
1397     3,
1398     PROTOBUF_C_LABEL_OPTIONAL,
1399     PROTOBUF_C_TYPE_UINT32,
1400     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_late),
1401     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, late),
1402     NULL,
1403     NULL,
1404     0,            /* packed */
1405     0,NULL,NULL    /* reserved1,reserved2, etc */
1406   },
1407   {
1408     "lost",
1409     4,
1410     PROTOBUF_C_LABEL_OPTIONAL,
1411     PROTOBUF_C_TYPE_UINT32,
1412     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_lost),
1413     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, lost),
1414     NULL,
1415     NULL,
1416     0,            /* packed */
1417     0,NULL,NULL    /* reserved1,reserved2, etc */
1418   },
1419   {
1420     "resync",
1421     5,
1422     PROTOBUF_C_LABEL_OPTIONAL,
1423     PROTOBUF_C_TYPE_UINT32,
1424     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_resync),
1425     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, resync),
1426     NULL,
1427     NULL,
1428     0,            /* packed */
1429     0,NULL,NULL    /* reserved1,reserved2, etc */
1430   },
1431   {
1432     "udp_packets",
1433     6,
1434     PROTOBUF_C_LABEL_OPTIONAL,
1435     PROTOBUF_C_TYPE_UINT32,
1436     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_udp_packets),
1437     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, udp_packets),
1438     NULL,
1439     NULL,
1440     0,            /* packed */
1441     0,NULL,NULL    /* reserved1,reserved2, etc */
1442   },
1443   {
1444     "tcp_packets",
1445     7,
1446     PROTOBUF_C_LABEL_OPTIONAL,
1447     PROTOBUF_C_TYPE_UINT32,
1448     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_tcp_packets),
1449     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, tcp_packets),
1450     NULL,
1451     NULL,
1452     0,            /* packed */
1453     0,NULL,NULL    /* reserved1,reserved2, etc */
1454   },
1455   {
1456     "udp_ping_avg",
1457     8,
1458     PROTOBUF_C_LABEL_OPTIONAL,
1459     PROTOBUF_C_TYPE_FLOAT,
1460     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_udp_ping_avg),
1461     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, udp_ping_avg),
1462     NULL,
1463     NULL,
1464     0,            /* packed */
1465     0,NULL,NULL    /* reserved1,reserved2, etc */
1466   },
1467   {
1468     "udp_ping_var",
1469     9,
1470     PROTOBUF_C_LABEL_OPTIONAL,
1471     PROTOBUF_C_TYPE_FLOAT,
1472     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_udp_ping_var),
1473     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, udp_ping_var),
1474     NULL,
1475     NULL,
1476     0,            /* packed */
1477     0,NULL,NULL    /* reserved1,reserved2, etc */
1478   },
1479   {
1480     "tcp_ping_avg",
1481     10,
1482     PROTOBUF_C_LABEL_OPTIONAL,
1483     PROTOBUF_C_TYPE_FLOAT,
1484     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_tcp_ping_avg),
1485     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, tcp_ping_avg),
1486     NULL,
1487     NULL,
1488     0,            /* packed */
1489     0,NULL,NULL    /* reserved1,reserved2, etc */
1490   },
1491   {
1492     "tcp_ping_var",
1493     11,
1494     PROTOBUF_C_LABEL_OPTIONAL,
1495     PROTOBUF_C_TYPE_FLOAT,
1496     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_tcp_ping_var),
1497     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, tcp_ping_var),
1498     NULL,
1499     NULL,
1500     0,            /* packed */
1501     0,NULL,NULL    /* reserved1,reserved2, etc */
1502   },
1503 };
1504 static const unsigned mumble_proto__ping__field_indices_by_name[] = {
1505   1,   /* field[1] = good */
1506   2,   /* field[2] = late */
1507   3,   /* field[3] = lost */
1508   4,   /* field[4] = resync */
1509   6,   /* field[6] = tcp_packets */
1510   9,   /* field[9] = tcp_ping_avg */
1511   10,   /* field[10] = tcp_ping_var */
1512   0,   /* field[0] = timestamp */
1513   5,   /* field[5] = udp_packets */
1514   7,   /* field[7] = udp_ping_avg */
1515   8,   /* field[8] = udp_ping_var */
1516 };
1517 static const ProtobufCIntRange mumble_proto__ping__number_ranges[1 + 1] =
1518 {
1519   { 1, 0 },
1520   { 0, 11 }
1521 };
1522 const ProtobufCMessageDescriptor mumble_proto__ping__descriptor =
1523 {
1524   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1525   "MumbleProto.Ping",
1526   "Ping",
1527   "MumbleProto__Ping",
1528   "MumbleProto",
1529   sizeof(MumbleProto__Ping),
1530   11,
1531   mumble_proto__ping__field_descriptors,
1532   mumble_proto__ping__field_indices_by_name,
1533   1,  mumble_proto__ping__number_ranges,
1534   (ProtobufCMessageInit) mumble_proto__ping__init,
1535   NULL,NULL,NULL    /* reserved[123] */
1536 };
1537 const ProtobufCEnumValue mumble_proto__reject__reject_type__enum_values_by_number[8] =
1538 {
1539   { "None", "MUMBLE_PROTO__REJECT__REJECT_TYPE__NONE", 0 },
1540   { "WrongVersion", "MUMBLE_PROTO__REJECT__REJECT_TYPE__WRONGVERSION", 1 },
1541   { "InvalidUsername", "MUMBLE_PROTO__REJECT__REJECT_TYPE__INVALIDUSERNAME", 2 },
1542   { "WrongUserPW", "MUMBLE_PROTO__REJECT__REJECT_TYPE__WRONGUSERPW", 3 },
1543   { "WrongServerPW", "MUMBLE_PROTO__REJECT__REJECT_TYPE__WRONGSERVERPW", 4 },
1544   { "UsernameInUse", "MUMBLE_PROTO__REJECT__REJECT_TYPE__USERNAMEINUSE", 5 },
1545   { "ServerFull", "MUMBLE_PROTO__REJECT__REJECT_TYPE__SERVERFULL", 6 },
1546   { "NoCertificate", "MUMBLE_PROTO__REJECT__REJECT_TYPE__NOCERTIFICATE", 7 },
1547 };
1548 static const ProtobufCIntRange mumble_proto__reject__reject_type__value_ranges[] = {
1549 {0, 0},{0, 8}
1550 };
1551 const ProtobufCEnumValueIndex mumble_proto__reject__reject_type__enum_values_by_name[8] =
1552 {
1553   { "InvalidUsername", 2 },
1554   { "NoCertificate", 7 },
1555   { "None", 0 },
1556   { "ServerFull", 6 },
1557   { "UsernameInUse", 5 },
1558   { "WrongServerPW", 4 },
1559   { "WrongUserPW", 3 },
1560   { "WrongVersion", 1 },
1561 };
1562 const ProtobufCEnumDescriptor mumble_proto__reject__reject_type__descriptor =
1563 {
1564   PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC,
1565   "MumbleProto.Reject.RejectType",
1566   "RejectType",
1567   "MumbleProto__Reject__RejectType",
1568   "MumbleProto",
1569   8,
1570   mumble_proto__reject__reject_type__enum_values_by_number,
1571   8,
1572   mumble_proto__reject__reject_type__enum_values_by_name,
1573   1,
1574   mumble_proto__reject__reject_type__value_ranges,
1575   NULL,NULL,NULL,NULL   /* reserved[1234] */
1576 };
1577 static const ProtobufCFieldDescriptor mumble_proto__reject__field_descriptors[2] =
1578 {
1579   {
1580     "type",
1581     1,
1582     PROTOBUF_C_LABEL_OPTIONAL,
1583     PROTOBUF_C_TYPE_ENUM,
1584     PROTOBUF_C_OFFSETOF(MumbleProto__Reject, has_type),
1585     PROTOBUF_C_OFFSETOF(MumbleProto__Reject, type),
1586     &mumble_proto__reject__reject_type__descriptor,
1587     NULL,
1588     0,            /* packed */
1589     0,NULL,NULL    /* reserved1,reserved2, etc */
1590   },
1591   {
1592     "reason",
1593     2,
1594     PROTOBUF_C_LABEL_OPTIONAL,
1595     PROTOBUF_C_TYPE_STRING,
1596     0,   /* quantifier_offset */
1597     PROTOBUF_C_OFFSETOF(MumbleProto__Reject, reason),
1598     NULL,
1599     NULL,
1600     0,            /* packed */
1601     0,NULL,NULL    /* reserved1,reserved2, etc */
1602   },
1603 };
1604 static const unsigned mumble_proto__reject__field_indices_by_name[] = {
1605   1,   /* field[1] = reason */
1606   0,   /* field[0] = type */
1607 };
1608 static const ProtobufCIntRange mumble_proto__reject__number_ranges[1 + 1] =
1609 {
1610   { 1, 0 },
1611   { 0, 2 }
1612 };
1613 const ProtobufCMessageDescriptor mumble_proto__reject__descriptor =
1614 {
1615   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1616   "MumbleProto.Reject",
1617   "Reject",
1618   "MumbleProto__Reject",
1619   "MumbleProto",
1620   sizeof(MumbleProto__Reject),
1621   2,
1622   mumble_proto__reject__field_descriptors,
1623   mumble_proto__reject__field_indices_by_name,
1624   1,  mumble_proto__reject__number_ranges,
1625   (ProtobufCMessageInit) mumble_proto__reject__init,
1626   NULL,NULL,NULL    /* reserved[123] */
1627 };
1628 static const ProtobufCFieldDescriptor mumble_proto__server_config__field_descriptors[5] =
1629 {
1630   {
1631     "max_bandwidth",
1632     1,
1633     PROTOBUF_C_LABEL_OPTIONAL,
1634     PROTOBUF_C_TYPE_UINT32,
1635     PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, has_max_bandwidth),
1636     PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, max_bandwidth),
1637     NULL,
1638     NULL,
1639     0,            /* packed */
1640     0,NULL,NULL    /* reserved1,reserved2, etc */
1641   },
1642   {
1643     "welcome_text",
1644     2,
1645     PROTOBUF_C_LABEL_OPTIONAL,
1646     PROTOBUF_C_TYPE_STRING,
1647     0,   /* quantifier_offset */
1648     PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, welcome_text),
1649     NULL,
1650     NULL,
1651     0,            /* packed */
1652     0,NULL,NULL    /* reserved1,reserved2, etc */
1653   },
1654   {
1655     "allow_html",
1656     3,
1657     PROTOBUF_C_LABEL_OPTIONAL,
1658     PROTOBUF_C_TYPE_BOOL,
1659     PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, has_allow_html),
1660     PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, allow_html),
1661     NULL,
1662     NULL,
1663     0,            /* packed */
1664     0,NULL,NULL    /* reserved1,reserved2, etc */
1665   },
1666   {
1667     "message_length",
1668     4,
1669     PROTOBUF_C_LABEL_OPTIONAL,
1670     PROTOBUF_C_TYPE_UINT32,
1671     PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, has_message_length),
1672     PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, message_length),
1673     NULL,
1674     NULL,
1675     0,            /* packed */
1676     0,NULL,NULL    /* reserved1,reserved2, etc */
1677   },
1678   {
1679     "image_message_length",
1680     5,
1681     PROTOBUF_C_LABEL_OPTIONAL,
1682     PROTOBUF_C_TYPE_UINT32,
1683     PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, has_image_message_length),
1684     PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, image_message_length),
1685     NULL,
1686     NULL,
1687     0,            /* packed */
1688     0,NULL,NULL    /* reserved1,reserved2, etc */
1689   },
1690 };
1691 static const unsigned mumble_proto__server_config__field_indices_by_name[] = {
1692   2,   /* field[2] = allow_html */
1693   4,   /* field[4] = image_message_length */
1694   0,   /* field[0] = max_bandwidth */
1695   3,   /* field[3] = message_length */
1696   1,   /* field[1] = welcome_text */
1697 };
1698 static const ProtobufCIntRange mumble_proto__server_config__number_ranges[1 + 1] =
1699 {
1700   { 1, 0 },
1701   { 0, 5 }
1702 };
1703 const ProtobufCMessageDescriptor mumble_proto__server_config__descriptor =
1704 {
1705   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1706   "MumbleProto.ServerConfig",
1707   "ServerConfig",
1708   "MumbleProto__ServerConfig",
1709   "MumbleProto",
1710   sizeof(MumbleProto__ServerConfig),
1711   5,
1712   mumble_proto__server_config__field_descriptors,
1713   mumble_proto__server_config__field_indices_by_name,
1714   1,  mumble_proto__server_config__number_ranges,
1715   (ProtobufCMessageInit) mumble_proto__server_config__init,
1716   NULL,NULL,NULL    /* reserved[123] */
1717 };
1718 static const ProtobufCFieldDescriptor mumble_proto__server_sync__field_descriptors[4] =
1719 {
1720   {
1721     "session",
1722     1,
1723     PROTOBUF_C_LABEL_OPTIONAL,
1724     PROTOBUF_C_TYPE_UINT32,
1725     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, has_session),
1726     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, session),
1727     NULL,
1728     NULL,
1729     0,            /* packed */
1730     0,NULL,NULL    /* reserved1,reserved2, etc */
1731   },
1732   {
1733     "max_bandwidth",
1734     2,
1735     PROTOBUF_C_LABEL_OPTIONAL,
1736     PROTOBUF_C_TYPE_UINT32,
1737     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, has_max_bandwidth),
1738     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, max_bandwidth),
1739     NULL,
1740     NULL,
1741     0,            /* packed */
1742     0,NULL,NULL    /* reserved1,reserved2, etc */
1743   },
1744   {
1745     "welcome_text",
1746     3,
1747     PROTOBUF_C_LABEL_OPTIONAL,
1748     PROTOBUF_C_TYPE_STRING,
1749     0,   /* quantifier_offset */
1750     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, welcome_text),
1751     NULL,
1752     NULL,
1753     0,            /* packed */
1754     0,NULL,NULL    /* reserved1,reserved2, etc */
1755   },
1756   {
1757     "permissions",
1758     4,
1759     PROTOBUF_C_LABEL_OPTIONAL,
1760     PROTOBUF_C_TYPE_UINT64,
1761     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, has_permissions),
1762     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, permissions),
1763     NULL,
1764     NULL,
1765     0,            /* packed */
1766     0,NULL,NULL    /* reserved1,reserved2, etc */
1767   },
1768 };
1769 static const unsigned mumble_proto__server_sync__field_indices_by_name[] = {
1770   1,   /* field[1] = max_bandwidth */
1771   3,   /* field[3] = permissions */
1772   0,   /* field[0] = session */
1773   2,   /* field[2] = welcome_text */
1774 };
1775 static const ProtobufCIntRange mumble_proto__server_sync__number_ranges[1 + 1] =
1776 {
1777   { 1, 0 },
1778   { 0, 4 }
1779 };
1780 const ProtobufCMessageDescriptor mumble_proto__server_sync__descriptor =
1781 {
1782   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1783   "MumbleProto.ServerSync",
1784   "ServerSync",
1785   "MumbleProto__ServerSync",
1786   "MumbleProto",
1787   sizeof(MumbleProto__ServerSync),
1788   4,
1789   mumble_proto__server_sync__field_descriptors,
1790   mumble_proto__server_sync__field_indices_by_name,
1791   1,  mumble_proto__server_sync__number_ranges,
1792   (ProtobufCMessageInit) mumble_proto__server_sync__init,
1793   NULL,NULL,NULL    /* reserved[123] */
1794 };
1795 static const ProtobufCFieldDescriptor mumble_proto__channel_remove__field_descriptors[1] =
1796 {
1797   {
1798     "channel_id",
1799     1,
1800     PROTOBUF_C_LABEL_REQUIRED,
1801     PROTOBUF_C_TYPE_UINT32,
1802     0,   /* quantifier_offset */
1803     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelRemove, channel_id),
1804     NULL,
1805     NULL,
1806     0,            /* packed */
1807     0,NULL,NULL    /* reserved1,reserved2, etc */
1808   },
1809 };
1810 static const unsigned mumble_proto__channel_remove__field_indices_by_name[] = {
1811   0,   /* field[0] = channel_id */
1812 };
1813 static const ProtobufCIntRange mumble_proto__channel_remove__number_ranges[1 + 1] =
1814 {
1815   { 1, 0 },
1816   { 0, 1 }
1817 };
1818 const ProtobufCMessageDescriptor mumble_proto__channel_remove__descriptor =
1819 {
1820   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1821   "MumbleProto.ChannelRemove",
1822   "ChannelRemove",
1823   "MumbleProto__ChannelRemove",
1824   "MumbleProto",
1825   sizeof(MumbleProto__ChannelRemove),
1826   1,
1827   mumble_proto__channel_remove__field_descriptors,
1828   mumble_proto__channel_remove__field_indices_by_name,
1829   1,  mumble_proto__channel_remove__number_ranges,
1830   (ProtobufCMessageInit) mumble_proto__channel_remove__init,
1831   NULL,NULL,NULL    /* reserved[123] */
1832 };
1833 static const protobuf_c_boolean mumble_proto__channel_state__temporary__default_value = 0;
1834 static const int32_t mumble_proto__channel_state__position__default_value = 0;
1835 static const ProtobufCFieldDescriptor mumble_proto__channel_state__field_descriptors[10] =
1836 {
1837   {
1838     "channel_id",
1839     1,
1840     PROTOBUF_C_LABEL_OPTIONAL,
1841     PROTOBUF_C_TYPE_UINT32,
1842     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, has_channel_id),
1843     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, channel_id),
1844     NULL,
1845     NULL,
1846     0,            /* packed */
1847     0,NULL,NULL    /* reserved1,reserved2, etc */
1848   },
1849   {
1850     "parent",
1851     2,
1852     PROTOBUF_C_LABEL_OPTIONAL,
1853     PROTOBUF_C_TYPE_UINT32,
1854     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, has_parent),
1855     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, parent),
1856     NULL,
1857     NULL,
1858     0,            /* packed */
1859     0,NULL,NULL    /* reserved1,reserved2, etc */
1860   },
1861   {
1862     "name",
1863     3,
1864     PROTOBUF_C_LABEL_OPTIONAL,
1865     PROTOBUF_C_TYPE_STRING,
1866     0,   /* quantifier_offset */
1867     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, name),
1868     NULL,
1869     NULL,
1870     0,            /* packed */
1871     0,NULL,NULL    /* reserved1,reserved2, etc */
1872   },
1873   {
1874     "links",
1875     4,
1876     PROTOBUF_C_LABEL_REPEATED,
1877     PROTOBUF_C_TYPE_UINT32,
1878     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, n_links),
1879     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, links),
1880     NULL,
1881     NULL,
1882     0,            /* packed */
1883     0,NULL,NULL    /* reserved1,reserved2, etc */
1884   },
1885   {
1886     "description",
1887     5,
1888     PROTOBUF_C_LABEL_OPTIONAL,
1889     PROTOBUF_C_TYPE_STRING,
1890     0,   /* quantifier_offset */
1891     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, description),
1892     NULL,
1893     NULL,
1894     0,            /* packed */
1895     0,NULL,NULL    /* reserved1,reserved2, etc */
1896   },
1897   {
1898     "links_add",
1899     6,
1900     PROTOBUF_C_LABEL_REPEATED,
1901     PROTOBUF_C_TYPE_UINT32,
1902     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, n_links_add),
1903     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, links_add),
1904     NULL,
1905     NULL,
1906     0,            /* packed */
1907     0,NULL,NULL    /* reserved1,reserved2, etc */
1908   },
1909   {
1910     "links_remove",
1911     7,
1912     PROTOBUF_C_LABEL_REPEATED,
1913     PROTOBUF_C_TYPE_UINT32,
1914     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, n_links_remove),
1915     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, links_remove),
1916     NULL,
1917     NULL,
1918     0,            /* packed */
1919     0,NULL,NULL    /* reserved1,reserved2, etc */
1920   },
1921   {
1922     "temporary",
1923     8,
1924     PROTOBUF_C_LABEL_OPTIONAL,
1925     PROTOBUF_C_TYPE_BOOL,
1926     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, has_temporary),
1927     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, temporary),
1928     NULL,
1929     &mumble_proto__channel_state__temporary__default_value,
1930     0,            /* packed */
1931     0,NULL,NULL    /* reserved1,reserved2, etc */
1932   },
1933   {
1934     "position",
1935     9,
1936     PROTOBUF_C_LABEL_OPTIONAL,
1937     PROTOBUF_C_TYPE_INT32,
1938     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, has_position),
1939     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, position),
1940     NULL,
1941     &mumble_proto__channel_state__position__default_value,
1942     0,            /* packed */
1943     0,NULL,NULL    /* reserved1,reserved2, etc */
1944   },
1945   {
1946     "description_hash",
1947     10,
1948     PROTOBUF_C_LABEL_OPTIONAL,
1949     PROTOBUF_C_TYPE_BYTES,
1950     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, has_description_hash),
1951     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, description_hash),
1952     NULL,
1953     NULL,
1954     0,            /* packed */
1955     0,NULL,NULL    /* reserved1,reserved2, etc */
1956   },
1957 };
1958 static const unsigned mumble_proto__channel_state__field_indices_by_name[] = {
1959   0,   /* field[0] = channel_id */
1960   4,   /* field[4] = description */
1961   9,   /* field[9] = description_hash */
1962   3,   /* field[3] = links */
1963   5,   /* field[5] = links_add */
1964   6,   /* field[6] = links_remove */
1965   2,   /* field[2] = name */
1966   1,   /* field[1] = parent */
1967   8,   /* field[8] = position */
1968   7,   /* field[7] = temporary */
1969 };
1970 static const ProtobufCIntRange mumble_proto__channel_state__number_ranges[1 + 1] =
1971 {
1972   { 1, 0 },
1973   { 0, 10 }
1974 };
1975 const ProtobufCMessageDescriptor mumble_proto__channel_state__descriptor =
1976 {
1977   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1978   "MumbleProto.ChannelState",
1979   "ChannelState",
1980   "MumbleProto__ChannelState",
1981   "MumbleProto",
1982   sizeof(MumbleProto__ChannelState),
1983   10,
1984   mumble_proto__channel_state__field_descriptors,
1985   mumble_proto__channel_state__field_indices_by_name,
1986   1,  mumble_proto__channel_state__number_ranges,
1987   (ProtobufCMessageInit) mumble_proto__channel_state__init,
1988   NULL,NULL,NULL    /* reserved[123] */
1989 };
1990 static const ProtobufCFieldDescriptor mumble_proto__user_remove__field_descriptors[4] =
1991 {
1992   {
1993     "session",
1994     1,
1995     PROTOBUF_C_LABEL_REQUIRED,
1996     PROTOBUF_C_TYPE_UINT32,
1997     0,   /* quantifier_offset */
1998     PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, session),
1999     NULL,
2000     NULL,
2001     0,            /* packed */
2002     0,NULL,NULL    /* reserved1,reserved2, etc */
2003   },
2004   {
2005     "actor",
2006     2,
2007     PROTOBUF_C_LABEL_OPTIONAL,
2008     PROTOBUF_C_TYPE_UINT32,
2009     PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, has_actor),
2010     PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, actor),
2011     NULL,
2012     NULL,
2013     0,            /* packed */
2014     0,NULL,NULL    /* reserved1,reserved2, etc */
2015   },
2016   {
2017     "reason",
2018     3,
2019     PROTOBUF_C_LABEL_OPTIONAL,
2020     PROTOBUF_C_TYPE_STRING,
2021     0,   /* quantifier_offset */
2022     PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, reason),
2023     NULL,
2024     NULL,
2025     0,            /* packed */
2026     0,NULL,NULL    /* reserved1,reserved2, etc */
2027   },
2028   {
2029     "ban",
2030     4,
2031     PROTOBUF_C_LABEL_OPTIONAL,
2032     PROTOBUF_C_TYPE_BOOL,
2033     PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, has_ban),
2034     PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, ban),
2035     NULL,
2036     NULL,
2037     0,            /* packed */
2038     0,NULL,NULL    /* reserved1,reserved2, etc */
2039   },
2040 };
2041 static const unsigned mumble_proto__user_remove__field_indices_by_name[] = {
2042   1,   /* field[1] = actor */
2043   3,   /* field[3] = ban */
2044   2,   /* field[2] = reason */
2045   0,   /* field[0] = session */
2046 };
2047 static const ProtobufCIntRange mumble_proto__user_remove__number_ranges[1 + 1] =
2048 {
2049   { 1, 0 },
2050   { 0, 4 }
2051 };
2052 const ProtobufCMessageDescriptor mumble_proto__user_remove__descriptor =
2053 {
2054   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2055   "MumbleProto.UserRemove",
2056   "UserRemove",
2057   "MumbleProto__UserRemove",
2058   "MumbleProto",
2059   sizeof(MumbleProto__UserRemove),
2060   4,
2061   mumble_proto__user_remove__field_descriptors,
2062   mumble_proto__user_remove__field_indices_by_name,
2063   1,  mumble_proto__user_remove__number_ranges,
2064   (ProtobufCMessageInit) mumble_proto__user_remove__init,
2065   NULL,NULL,NULL    /* reserved[123] */
2066 };
2067 static const ProtobufCFieldDescriptor mumble_proto__user_state__field_descriptors[19] =
2068 {
2069   {
2070     "session",
2071     1,
2072     PROTOBUF_C_LABEL_OPTIONAL,
2073     PROTOBUF_C_TYPE_UINT32,
2074     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_session),
2075     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, session),
2076     NULL,
2077     NULL,
2078     0,            /* packed */
2079     0,NULL,NULL    /* reserved1,reserved2, etc */
2080   },
2081   {
2082     "actor",
2083     2,
2084     PROTOBUF_C_LABEL_OPTIONAL,
2085     PROTOBUF_C_TYPE_UINT32,
2086     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_actor),
2087     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, actor),
2088     NULL,
2089     NULL,
2090     0,            /* packed */
2091     0,NULL,NULL    /* reserved1,reserved2, etc */
2092   },
2093   {
2094     "name",
2095     3,
2096     PROTOBUF_C_LABEL_OPTIONAL,
2097     PROTOBUF_C_TYPE_STRING,
2098     0,   /* quantifier_offset */
2099     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, name),
2100     NULL,
2101     NULL,
2102     0,            /* packed */
2103     0,NULL,NULL    /* reserved1,reserved2, etc */
2104   },
2105   {
2106     "user_id",
2107     4,
2108     PROTOBUF_C_LABEL_OPTIONAL,
2109     PROTOBUF_C_TYPE_UINT32,
2110     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_user_id),
2111     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, user_id),
2112     NULL,
2113     NULL,
2114     0,            /* packed */
2115     0,NULL,NULL    /* reserved1,reserved2, etc */
2116   },
2117   {
2118     "channel_id",
2119     5,
2120     PROTOBUF_C_LABEL_OPTIONAL,
2121     PROTOBUF_C_TYPE_UINT32,
2122     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_channel_id),
2123     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, channel_id),
2124     NULL,
2125     NULL,
2126     0,            /* packed */
2127     0,NULL,NULL    /* reserved1,reserved2, etc */
2128   },
2129   {
2130     "mute",
2131     6,
2132     PROTOBUF_C_LABEL_OPTIONAL,
2133     PROTOBUF_C_TYPE_BOOL,
2134     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_mute),
2135     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, mute),
2136     NULL,
2137     NULL,
2138     0,            /* packed */
2139     0,NULL,NULL    /* reserved1,reserved2, etc */
2140   },
2141   {
2142     "deaf",
2143     7,
2144     PROTOBUF_C_LABEL_OPTIONAL,
2145     PROTOBUF_C_TYPE_BOOL,
2146     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_deaf),
2147     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, deaf),
2148     NULL,
2149     NULL,
2150     0,            /* packed */
2151     0,NULL,NULL    /* reserved1,reserved2, etc */
2152   },
2153   {
2154     "suppress",
2155     8,
2156     PROTOBUF_C_LABEL_OPTIONAL,
2157     PROTOBUF_C_TYPE_BOOL,
2158     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_suppress),
2159     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, suppress),
2160     NULL,
2161     NULL,
2162     0,            /* packed */
2163     0,NULL,NULL    /* reserved1,reserved2, etc */
2164   },
2165   {
2166     "self_mute",
2167     9,
2168     PROTOBUF_C_LABEL_OPTIONAL,
2169     PROTOBUF_C_TYPE_BOOL,
2170     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_self_mute),
2171     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, self_mute),
2172     NULL,
2173     NULL,
2174     0,            /* packed */
2175     0,NULL,NULL    /* reserved1,reserved2, etc */
2176   },
2177   {
2178     "self_deaf",
2179     10,
2180     PROTOBUF_C_LABEL_OPTIONAL,
2181     PROTOBUF_C_TYPE_BOOL,
2182     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_self_deaf),
2183     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, self_deaf),
2184     NULL,
2185     NULL,
2186     0,            /* packed */
2187     0,NULL,NULL    /* reserved1,reserved2, etc */
2188   },
2189   {
2190     "texture",
2191     11,
2192     PROTOBUF_C_LABEL_OPTIONAL,
2193     PROTOBUF_C_TYPE_BYTES,
2194     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_texture),
2195     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, texture),
2196     NULL,
2197     NULL,
2198     0,            /* packed */
2199     0,NULL,NULL    /* reserved1,reserved2, etc */
2200   },
2201   {
2202     "plugin_context",
2203     12,
2204     PROTOBUF_C_LABEL_OPTIONAL,
2205     PROTOBUF_C_TYPE_BYTES,
2206     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_plugin_context),
2207     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, plugin_context),
2208     NULL,
2209     NULL,
2210     0,            /* packed */
2211     0,NULL,NULL    /* reserved1,reserved2, etc */
2212   },
2213   {
2214     "plugin_identity",
2215     13,
2216     PROTOBUF_C_LABEL_OPTIONAL,
2217     PROTOBUF_C_TYPE_STRING,
2218     0,   /* quantifier_offset */
2219     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, plugin_identity),
2220     NULL,
2221     NULL,
2222     0,            /* packed */
2223     0,NULL,NULL    /* reserved1,reserved2, etc */
2224   },
2225   {
2226     "comment",
2227     14,
2228     PROTOBUF_C_LABEL_OPTIONAL,
2229     PROTOBUF_C_TYPE_STRING,
2230     0,   /* quantifier_offset */
2231     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, comment),
2232     NULL,
2233     NULL,
2234     0,            /* packed */
2235     0,NULL,NULL    /* reserved1,reserved2, etc */
2236   },
2237   {
2238     "hash",
2239     15,
2240     PROTOBUF_C_LABEL_OPTIONAL,
2241     PROTOBUF_C_TYPE_STRING,
2242     0,   /* quantifier_offset */
2243     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, hash),
2244     NULL,
2245     NULL,
2246     0,            /* packed */
2247     0,NULL,NULL    /* reserved1,reserved2, etc */
2248   },
2249   {
2250     "comment_hash",
2251     16,
2252     PROTOBUF_C_LABEL_OPTIONAL,
2253     PROTOBUF_C_TYPE_BYTES,
2254     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_comment_hash),
2255     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, comment_hash),
2256     NULL,
2257     NULL,
2258     0,            /* packed */
2259     0,NULL,NULL    /* reserved1,reserved2, etc */
2260   },
2261   {
2262     "texture_hash",
2263     17,
2264     PROTOBUF_C_LABEL_OPTIONAL,
2265     PROTOBUF_C_TYPE_BYTES,
2266     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_texture_hash),
2267     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, texture_hash),
2268     NULL,
2269     NULL,
2270     0,            /* packed */
2271     0,NULL,NULL    /* reserved1,reserved2, etc */
2272   },
2273   {
2274     "priority_speaker",
2275     18,
2276     PROTOBUF_C_LABEL_OPTIONAL,
2277     PROTOBUF_C_TYPE_BOOL,
2278     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_priority_speaker),
2279     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, priority_speaker),
2280     NULL,
2281     NULL,
2282     0,            /* packed */
2283     0,NULL,NULL    /* reserved1,reserved2, etc */
2284   },
2285   {
2286     "recording",
2287     19,
2288     PROTOBUF_C_LABEL_OPTIONAL,
2289     PROTOBUF_C_TYPE_BOOL,
2290     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_recording),
2291     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, recording),
2292     NULL,
2293     NULL,
2294     0,            /* packed */
2295     0,NULL,NULL    /* reserved1,reserved2, etc */
2296   },
2297 };
2298 static const unsigned mumble_proto__user_state__field_indices_by_name[] = {
2299   1,   /* field[1] = actor */
2300   4,   /* field[4] = channel_id */
2301   13,   /* field[13] = comment */
2302   15,   /* field[15] = comment_hash */
2303   6,   /* field[6] = deaf */
2304   14,   /* field[14] = hash */
2305   5,   /* field[5] = mute */
2306   2,   /* field[2] = name */
2307   11,   /* field[11] = plugin_context */
2308   12,   /* field[12] = plugin_identity */
2309   17,   /* field[17] = priority_speaker */
2310   18,   /* field[18] = recording */
2311   9,   /* field[9] = self_deaf */
2312   8,   /* field[8] = self_mute */
2313   0,   /* field[0] = session */
2314   7,   /* field[7] = suppress */
2315   10,   /* field[10] = texture */
2316   16,   /* field[16] = texture_hash */
2317   3,   /* field[3] = user_id */
2318 };
2319 static const ProtobufCIntRange mumble_proto__user_state__number_ranges[1 + 1] =
2320 {
2321   { 1, 0 },
2322   { 0, 19 }
2323 };
2324 const ProtobufCMessageDescriptor mumble_proto__user_state__descriptor =
2325 {
2326   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2327   "MumbleProto.UserState",
2328   "UserState",
2329   "MumbleProto__UserState",
2330   "MumbleProto",
2331   sizeof(MumbleProto__UserState),
2332   19,
2333   mumble_proto__user_state__field_descriptors,
2334   mumble_proto__user_state__field_indices_by_name,
2335   1,  mumble_proto__user_state__number_ranges,
2336   (ProtobufCMessageInit) mumble_proto__user_state__init,
2337   NULL,NULL,NULL    /* reserved[123] */
2338 };
2339 static const ProtobufCFieldDescriptor mumble_proto__ban_list__ban_entry__field_descriptors[7] =
2340 {
2341   {
2342     "address",
2343     1,
2344     PROTOBUF_C_LABEL_REQUIRED,
2345     PROTOBUF_C_TYPE_BYTES,
2346     0,   /* quantifier_offset */
2347     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, address),
2348     NULL,
2349     NULL,
2350     0,            /* packed */
2351     0,NULL,NULL    /* reserved1,reserved2, etc */
2352   },
2353   {
2354     "mask",
2355     2,
2356     PROTOBUF_C_LABEL_REQUIRED,
2357     PROTOBUF_C_TYPE_UINT32,
2358     0,   /* quantifier_offset */
2359     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, mask),
2360     NULL,
2361     NULL,
2362     0,            /* packed */
2363     0,NULL,NULL    /* reserved1,reserved2, etc */
2364   },
2365   {
2366     "name",
2367     3,
2368     PROTOBUF_C_LABEL_OPTIONAL,
2369     PROTOBUF_C_TYPE_STRING,
2370     0,   /* quantifier_offset */
2371     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, name),
2372     NULL,
2373     NULL,
2374     0,            /* packed */
2375     0,NULL,NULL    /* reserved1,reserved2, etc */
2376   },
2377   {
2378     "hash",
2379     4,
2380     PROTOBUF_C_LABEL_OPTIONAL,
2381     PROTOBUF_C_TYPE_STRING,
2382     0,   /* quantifier_offset */
2383     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, hash),
2384     NULL,
2385     NULL,
2386     0,            /* packed */
2387     0,NULL,NULL    /* reserved1,reserved2, etc */
2388   },
2389   {
2390     "reason",
2391     5,
2392     PROTOBUF_C_LABEL_OPTIONAL,
2393     PROTOBUF_C_TYPE_STRING,
2394     0,   /* quantifier_offset */
2395     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, reason),
2396     NULL,
2397     NULL,
2398     0,            /* packed */
2399     0,NULL,NULL    /* reserved1,reserved2, etc */
2400   },
2401   {
2402     "start",
2403     6,
2404     PROTOBUF_C_LABEL_OPTIONAL,
2405     PROTOBUF_C_TYPE_STRING,
2406     0,   /* quantifier_offset */
2407     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, start),
2408     NULL,
2409     NULL,
2410     0,            /* packed */
2411     0,NULL,NULL    /* reserved1,reserved2, etc */
2412   },
2413   {
2414     "duration",
2415     7,
2416     PROTOBUF_C_LABEL_OPTIONAL,
2417     PROTOBUF_C_TYPE_UINT32,
2418     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, has_duration),
2419     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, duration),
2420     NULL,
2421     NULL,
2422     0,            /* packed */
2423     0,NULL,NULL    /* reserved1,reserved2, etc */
2424   },
2425 };
2426 static const unsigned mumble_proto__ban_list__ban_entry__field_indices_by_name[] = {
2427   0,   /* field[0] = address */
2428   6,   /* field[6] = duration */
2429   3,   /* field[3] = hash */
2430   1,   /* field[1] = mask */
2431   2,   /* field[2] = name */
2432   4,   /* field[4] = reason */
2433   5,   /* field[5] = start */
2434 };
2435 static const ProtobufCIntRange mumble_proto__ban_list__ban_entry__number_ranges[1 + 1] =
2436 {
2437   { 1, 0 },
2438   { 0, 7 }
2439 };
2440 const ProtobufCMessageDescriptor mumble_proto__ban_list__ban_entry__descriptor =
2441 {
2442   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2443   "MumbleProto.BanList.BanEntry",
2444   "BanEntry",
2445   "MumbleProto__BanList__BanEntry",
2446   "MumbleProto",
2447   sizeof(MumbleProto__BanList__BanEntry),
2448   7,
2449   mumble_proto__ban_list__ban_entry__field_descriptors,
2450   mumble_proto__ban_list__ban_entry__field_indices_by_name,
2451   1,  mumble_proto__ban_list__ban_entry__number_ranges,
2452   (ProtobufCMessageInit) mumble_proto__ban_list__ban_entry__init,
2453   NULL,NULL,NULL    /* reserved[123] */
2454 };
2455 static const protobuf_c_boolean mumble_proto__ban_list__query__default_value = 0;
2456 static const ProtobufCFieldDescriptor mumble_proto__ban_list__field_descriptors[2] =
2457 {
2458   {
2459     "bans",
2460     1,
2461     PROTOBUF_C_LABEL_REPEATED,
2462     PROTOBUF_C_TYPE_MESSAGE,
2463     PROTOBUF_C_OFFSETOF(MumbleProto__BanList, n_bans),
2464     PROTOBUF_C_OFFSETOF(MumbleProto__BanList, bans),
2465     &mumble_proto__ban_list__ban_entry__descriptor,
2466     NULL,
2467     0,            /* packed */
2468     0,NULL,NULL    /* reserved1,reserved2, etc */
2469   },
2470   {
2471     "query",
2472     2,
2473     PROTOBUF_C_LABEL_OPTIONAL,
2474     PROTOBUF_C_TYPE_BOOL,
2475     PROTOBUF_C_OFFSETOF(MumbleProto__BanList, has_query),
2476     PROTOBUF_C_OFFSETOF(MumbleProto__BanList, query),
2477     NULL,
2478     &mumble_proto__ban_list__query__default_value,
2479     0,            /* packed */
2480     0,NULL,NULL    /* reserved1,reserved2, etc */
2481   },
2482 };
2483 static const unsigned mumble_proto__ban_list__field_indices_by_name[] = {
2484   0,   /* field[0] = bans */
2485   1,   /* field[1] = query */
2486 };
2487 static const ProtobufCIntRange mumble_proto__ban_list__number_ranges[1 + 1] =
2488 {
2489   { 1, 0 },
2490   { 0, 2 }
2491 };
2492 const ProtobufCMessageDescriptor mumble_proto__ban_list__descriptor =
2493 {
2494   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2495   "MumbleProto.BanList",
2496   "BanList",
2497   "MumbleProto__BanList",
2498   "MumbleProto",
2499   sizeof(MumbleProto__BanList),
2500   2,
2501   mumble_proto__ban_list__field_descriptors,
2502   mumble_proto__ban_list__field_indices_by_name,
2503   1,  mumble_proto__ban_list__number_ranges,
2504   (ProtobufCMessageInit) mumble_proto__ban_list__init,
2505   NULL,NULL,NULL    /* reserved[123] */
2506 };
2507 static const ProtobufCFieldDescriptor mumble_proto__text_message__field_descriptors[5] =
2508 {
2509   {
2510     "actor",
2511     1,
2512     PROTOBUF_C_LABEL_OPTIONAL,
2513     PROTOBUF_C_TYPE_UINT32,
2514     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, has_actor),
2515     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, actor),
2516     NULL,
2517     NULL,
2518     0,            /* packed */
2519     0,NULL,NULL    /* reserved1,reserved2, etc */
2520   },
2521   {
2522     "session",
2523     2,
2524     PROTOBUF_C_LABEL_REPEATED,
2525     PROTOBUF_C_TYPE_UINT32,
2526     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, n_session),
2527     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, session),
2528     NULL,
2529     NULL,
2530     0,            /* packed */
2531     0,NULL,NULL    /* reserved1,reserved2, etc */
2532   },
2533   {
2534     "channel_id",
2535     3,
2536     PROTOBUF_C_LABEL_REPEATED,
2537     PROTOBUF_C_TYPE_UINT32,
2538     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, n_channel_id),
2539     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, channel_id),
2540     NULL,
2541     NULL,
2542     0,            /* packed */
2543     0,NULL,NULL    /* reserved1,reserved2, etc */
2544   },
2545   {
2546     "tree_id",
2547     4,
2548     PROTOBUF_C_LABEL_REPEATED,
2549     PROTOBUF_C_TYPE_UINT32,
2550     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, n_tree_id),
2551     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, tree_id),
2552     NULL,
2553     NULL,
2554     0,            /* packed */
2555     0,NULL,NULL    /* reserved1,reserved2, etc */
2556   },
2557   {
2558     "message",
2559     5,
2560     PROTOBUF_C_LABEL_REQUIRED,
2561     PROTOBUF_C_TYPE_STRING,
2562     0,   /* quantifier_offset */
2563     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, message),
2564     NULL,
2565     NULL,
2566     0,            /* packed */
2567     0,NULL,NULL    /* reserved1,reserved2, etc */
2568   },
2569 };
2570 static const unsigned mumble_proto__text_message__field_indices_by_name[] = {
2571   0,   /* field[0] = actor */
2572   2,   /* field[2] = channel_id */
2573   4,   /* field[4] = message */
2574   1,   /* field[1] = session */
2575   3,   /* field[3] = tree_id */
2576 };
2577 static const ProtobufCIntRange mumble_proto__text_message__number_ranges[1 + 1] =
2578 {
2579   { 1, 0 },
2580   { 0, 5 }
2581 };
2582 const ProtobufCMessageDescriptor mumble_proto__text_message__descriptor =
2583 {
2584   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2585   "MumbleProto.TextMessage",
2586   "TextMessage",
2587   "MumbleProto__TextMessage",
2588   "MumbleProto",
2589   sizeof(MumbleProto__TextMessage),
2590   5,
2591   mumble_proto__text_message__field_descriptors,
2592   mumble_proto__text_message__field_indices_by_name,
2593   1,  mumble_proto__text_message__number_ranges,
2594   (ProtobufCMessageInit) mumble_proto__text_message__init,
2595   NULL,NULL,NULL    /* reserved[123] */
2596 };
2597 const ProtobufCEnumValue mumble_proto__permission_denied__deny_type__enum_values_by_number[11] =
2598 {
2599   { "Text", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TEXT", 0 },
2600   { "Permission", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__PERMISSION", 1 },
2601   { "SuperUser", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__SUPERUSER", 2 },
2602   { "ChannelName", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__CHANNELNAME", 3 },
2603   { "TextTooLong", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TEXTTOOLONG", 4 },
2604   { "H9K", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__H9K", 5 },
2605   { "TemporaryChannel", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TEMPORARYCHANNEL", 6 },
2606   { "MissingCertificate", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__MISSINGCERTIFICATE", 7 },
2607   { "UserName", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__USERNAME", 8 },
2608   { "ChannelFull", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__CHANNELFULL", 9 },
2609   { "NestingLimit", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__NESTINGLIMIT", 10 },
2610 };
2611 static const ProtobufCIntRange mumble_proto__permission_denied__deny_type__value_ranges[] = {
2612 {0, 0},{0, 11}
2613 };
2614 const ProtobufCEnumValueIndex mumble_proto__permission_denied__deny_type__enum_values_by_name[11] =
2615 {
2616   { "ChannelFull", 9 },
2617   { "ChannelName", 3 },
2618   { "H9K", 5 },
2619   { "MissingCertificate", 7 },
2620   { "NestingLimit", 10 },
2621   { "Permission", 1 },
2622   { "SuperUser", 2 },
2623   { "TemporaryChannel", 6 },
2624   { "Text", 0 },
2625   { "TextTooLong", 4 },
2626   { "UserName", 8 },
2627 };
2628 const ProtobufCEnumDescriptor mumble_proto__permission_denied__deny_type__descriptor =
2629 {
2630   PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC,
2631   "MumbleProto.PermissionDenied.DenyType",
2632   "DenyType",
2633   "MumbleProto__PermissionDenied__DenyType",
2634   "MumbleProto",
2635   11,
2636   mumble_proto__permission_denied__deny_type__enum_values_by_number,
2637   11,
2638   mumble_proto__permission_denied__deny_type__enum_values_by_name,
2639   1,
2640   mumble_proto__permission_denied__deny_type__value_ranges,
2641   NULL,NULL,NULL,NULL   /* reserved[1234] */
2642 };
2643 static const ProtobufCFieldDescriptor mumble_proto__permission_denied__field_descriptors[6] =
2644 {
2645   {
2646     "permission",
2647     1,
2648     PROTOBUF_C_LABEL_OPTIONAL,
2649     PROTOBUF_C_TYPE_UINT32,
2650     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, has_permission),
2651     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, permission),
2652     NULL,
2653     NULL,
2654     0,            /* packed */
2655     0,NULL,NULL    /* reserved1,reserved2, etc */
2656   },
2657   {
2658     "channel_id",
2659     2,
2660     PROTOBUF_C_LABEL_OPTIONAL,
2661     PROTOBUF_C_TYPE_UINT32,
2662     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, has_channel_id),
2663     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, channel_id),
2664     NULL,
2665     NULL,
2666     0,            /* packed */
2667     0,NULL,NULL    /* reserved1,reserved2, etc */
2668   },
2669   {
2670     "session",
2671     3,
2672     PROTOBUF_C_LABEL_OPTIONAL,
2673     PROTOBUF_C_TYPE_UINT32,
2674     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, has_session),
2675     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, session),
2676     NULL,
2677     NULL,
2678     0,            /* packed */
2679     0,NULL,NULL    /* reserved1,reserved2, etc */
2680   },
2681   {
2682     "reason",
2683     4,
2684     PROTOBUF_C_LABEL_OPTIONAL,
2685     PROTOBUF_C_TYPE_STRING,
2686     0,   /* quantifier_offset */
2687     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, reason),
2688     NULL,
2689     NULL,
2690     0,            /* packed */
2691     0,NULL,NULL    /* reserved1,reserved2, etc */
2692   },
2693   {
2694     "type",
2695     5,
2696     PROTOBUF_C_LABEL_OPTIONAL,
2697     PROTOBUF_C_TYPE_ENUM,
2698     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, has_type),
2699     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, type),
2700     &mumble_proto__permission_denied__deny_type__descriptor,
2701     NULL,
2702     0,            /* packed */
2703     0,NULL,NULL    /* reserved1,reserved2, etc */
2704   },
2705   {
2706     "name",
2707     6,
2708     PROTOBUF_C_LABEL_OPTIONAL,
2709     PROTOBUF_C_TYPE_STRING,
2710     0,   /* quantifier_offset */
2711     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, name),
2712     NULL,
2713     NULL,
2714     0,            /* packed */
2715     0,NULL,NULL    /* reserved1,reserved2, etc */
2716   },
2717 };
2718 static const unsigned mumble_proto__permission_denied__field_indices_by_name[] = {
2719   1,   /* field[1] = channel_id */
2720   5,   /* field[5] = name */
2721   0,   /* field[0] = permission */
2722   3,   /* field[3] = reason */
2723   2,   /* field[2] = session */
2724   4,   /* field[4] = type */
2725 };
2726 static const ProtobufCIntRange mumble_proto__permission_denied__number_ranges[1 + 1] =
2727 {
2728   { 1, 0 },
2729   { 0, 6 }
2730 };
2731 const ProtobufCMessageDescriptor mumble_proto__permission_denied__descriptor =
2732 {
2733   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2734   "MumbleProto.PermissionDenied",
2735   "PermissionDenied",
2736   "MumbleProto__PermissionDenied",
2737   "MumbleProto",
2738   sizeof(MumbleProto__PermissionDenied),
2739   6,
2740   mumble_proto__permission_denied__field_descriptors,
2741   mumble_proto__permission_denied__field_indices_by_name,
2742   1,  mumble_proto__permission_denied__number_ranges,
2743   (ProtobufCMessageInit) mumble_proto__permission_denied__init,
2744   NULL,NULL,NULL    /* reserved[123] */
2745 };
2746 static const protobuf_c_boolean mumble_proto__acl__chan_group__inherited__default_value = 1;
2747 static const protobuf_c_boolean mumble_proto__acl__chan_group__inherit__default_value = 1;
2748 static const protobuf_c_boolean mumble_proto__acl__chan_group__inheritable__default_value = 1;
2749 static const ProtobufCFieldDescriptor mumble_proto__acl__chan_group__field_descriptors[7] =
2750 {
2751   {
2752     "name",
2753     1,
2754     PROTOBUF_C_LABEL_REQUIRED,
2755     PROTOBUF_C_TYPE_STRING,
2756     0,   /* quantifier_offset */
2757     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, name),
2758     NULL,
2759     NULL,
2760     0,            /* packed */
2761     0,NULL,NULL    /* reserved1,reserved2, etc */
2762   },
2763   {
2764     "inherited",
2765     2,
2766     PROTOBUF_C_LABEL_OPTIONAL,
2767     PROTOBUF_C_TYPE_BOOL,
2768     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, has_inherited),
2769     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, inherited),
2770     NULL,
2771     &mumble_proto__acl__chan_group__inherited__default_value,
2772     0,            /* packed */
2773     0,NULL,NULL    /* reserved1,reserved2, etc */
2774   },
2775   {
2776     "inherit",
2777     3,
2778     PROTOBUF_C_LABEL_OPTIONAL,
2779     PROTOBUF_C_TYPE_BOOL,
2780     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, has_inherit),
2781     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, inherit),
2782     NULL,
2783     &mumble_proto__acl__chan_group__inherit__default_value,
2784     0,            /* packed */
2785     0,NULL,NULL    /* reserved1,reserved2, etc */
2786   },
2787   {
2788     "inheritable",
2789     4,
2790     PROTOBUF_C_LABEL_OPTIONAL,
2791     PROTOBUF_C_TYPE_BOOL,
2792     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, has_inheritable),
2793     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, inheritable),
2794     NULL,
2795     &mumble_proto__acl__chan_group__inheritable__default_value,
2796     0,            /* packed */
2797     0,NULL,NULL    /* reserved1,reserved2, etc */
2798   },
2799   {
2800     "add",
2801     5,
2802     PROTOBUF_C_LABEL_REPEATED,
2803     PROTOBUF_C_TYPE_UINT32,
2804     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, n_add),
2805     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, add),
2806     NULL,
2807     NULL,
2808     0,            /* packed */
2809     0,NULL,NULL    /* reserved1,reserved2, etc */
2810   },
2811   {
2812     "remove",
2813     6,
2814     PROTOBUF_C_LABEL_REPEATED,
2815     PROTOBUF_C_TYPE_UINT32,
2816     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, n_remove),
2817     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, remove),
2818     NULL,
2819     NULL,
2820     0,            /* packed */
2821     0,NULL,NULL    /* reserved1,reserved2, etc */
2822   },
2823   {
2824     "inherited_members",
2825     7,
2826     PROTOBUF_C_LABEL_REPEATED,
2827     PROTOBUF_C_TYPE_UINT32,
2828     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, n_inherited_members),
2829     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, inherited_members),
2830     NULL,
2831     NULL,
2832     0,            /* packed */
2833     0,NULL,NULL    /* reserved1,reserved2, etc */
2834   },
2835 };
2836 static const unsigned mumble_proto__acl__chan_group__field_indices_by_name[] = {
2837   4,   /* field[4] = add */
2838   2,   /* field[2] = inherit */
2839   3,   /* field[3] = inheritable */
2840   1,   /* field[1] = inherited */
2841   6,   /* field[6] = inherited_members */
2842   0,   /* field[0] = name */
2843   5,   /* field[5] = remove */
2844 };
2845 static const ProtobufCIntRange mumble_proto__acl__chan_group__number_ranges[1 + 1] =
2846 {
2847   { 1, 0 },
2848   { 0, 7 }
2849 };
2850 const ProtobufCMessageDescriptor mumble_proto__acl__chan_group__descriptor =
2851 {
2852   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2853   "MumbleProto.ACL.ChanGroup",
2854   "ChanGroup",
2855   "MumbleProto__ACL__ChanGroup",
2856   "MumbleProto",
2857   sizeof(MumbleProto__ACL__ChanGroup),
2858   7,
2859   mumble_proto__acl__chan_group__field_descriptors,
2860   mumble_proto__acl__chan_group__field_indices_by_name,
2861   1,  mumble_proto__acl__chan_group__number_ranges,
2862   (ProtobufCMessageInit) mumble_proto__acl__chan_group__init,
2863   NULL,NULL,NULL    /* reserved[123] */
2864 };
2865 static const protobuf_c_boolean mumble_proto__acl__chan_acl__apply_here__default_value = 1;
2866 static const protobuf_c_boolean mumble_proto__acl__chan_acl__apply_subs__default_value = 1;
2867 static const protobuf_c_boolean mumble_proto__acl__chan_acl__inherited__default_value = 1;
2868 static const ProtobufCFieldDescriptor mumble_proto__acl__chan_acl__field_descriptors[7] =
2869 {
2870   {
2871     "apply_here",
2872     1,
2873     PROTOBUF_C_LABEL_OPTIONAL,
2874     PROTOBUF_C_TYPE_BOOL,
2875     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_apply_here),
2876     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, apply_here),
2877     NULL,
2878     &mumble_proto__acl__chan_acl__apply_here__default_value,
2879     0,            /* packed */
2880     0,NULL,NULL    /* reserved1,reserved2, etc */
2881   },
2882   {
2883     "apply_subs",
2884     2,
2885     PROTOBUF_C_LABEL_OPTIONAL,
2886     PROTOBUF_C_TYPE_BOOL,
2887     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_apply_subs),
2888     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, apply_subs),
2889     NULL,
2890     &mumble_proto__acl__chan_acl__apply_subs__default_value,
2891     0,            /* packed */
2892     0,NULL,NULL    /* reserved1,reserved2, etc */
2893   },
2894   {
2895     "inherited",
2896     3,
2897     PROTOBUF_C_LABEL_OPTIONAL,
2898     PROTOBUF_C_TYPE_BOOL,
2899     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_inherited),
2900     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, inherited),
2901     NULL,
2902     &mumble_proto__acl__chan_acl__inherited__default_value,
2903     0,            /* packed */
2904     0,NULL,NULL    /* reserved1,reserved2, etc */
2905   },
2906   {
2907     "user_id",
2908     4,
2909     PROTOBUF_C_LABEL_OPTIONAL,
2910     PROTOBUF_C_TYPE_UINT32,
2911     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_user_id),
2912     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, user_id),
2913     NULL,
2914     NULL,
2915     0,            /* packed */
2916     0,NULL,NULL    /* reserved1,reserved2, etc */
2917   },
2918   {
2919     "group",
2920     5,
2921     PROTOBUF_C_LABEL_OPTIONAL,
2922     PROTOBUF_C_TYPE_STRING,
2923     0,   /* quantifier_offset */
2924     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, group),
2925     NULL,
2926     NULL,
2927     0,            /* packed */
2928     0,NULL,NULL    /* reserved1,reserved2, etc */
2929   },
2930   {
2931     "grant",
2932     6,
2933     PROTOBUF_C_LABEL_OPTIONAL,
2934     PROTOBUF_C_TYPE_UINT32,
2935     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_grant),
2936     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, grant),
2937     NULL,
2938     NULL,
2939     0,            /* packed */
2940     0,NULL,NULL    /* reserved1,reserved2, etc */
2941   },
2942   {
2943     "deny",
2944     7,
2945     PROTOBUF_C_LABEL_OPTIONAL,
2946     PROTOBUF_C_TYPE_UINT32,
2947     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_deny),
2948     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, deny),
2949     NULL,
2950     NULL,
2951     0,            /* packed */
2952     0,NULL,NULL    /* reserved1,reserved2, etc */
2953   },
2954 };
2955 static const unsigned mumble_proto__acl__chan_acl__field_indices_by_name[] = {
2956   0,   /* field[0] = apply_here */
2957   1,   /* field[1] = apply_subs */
2958   6,   /* field[6] = deny */
2959   5,   /* field[5] = grant */
2960   4,   /* field[4] = group */
2961   2,   /* field[2] = inherited */
2962   3,   /* field[3] = user_id */
2963 };
2964 static const ProtobufCIntRange mumble_proto__acl__chan_acl__number_ranges[1 + 1] =
2965 {
2966   { 1, 0 },
2967   { 0, 7 }
2968 };
2969 const ProtobufCMessageDescriptor mumble_proto__acl__chan_acl__descriptor =
2970 {
2971   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2972   "MumbleProto.ACL.ChanACL",
2973   "ChanACL",
2974   "MumbleProto__ACL__ChanACL",
2975   "MumbleProto",
2976   sizeof(MumbleProto__ACL__ChanACL),
2977   7,
2978   mumble_proto__acl__chan_acl__field_descriptors,
2979   mumble_proto__acl__chan_acl__field_indices_by_name,
2980   1,  mumble_proto__acl__chan_acl__number_ranges,
2981   (ProtobufCMessageInit) mumble_proto__acl__chan_acl__init,
2982   NULL,NULL,NULL    /* reserved[123] */
2983 };
2984 static const protobuf_c_boolean mumble_proto__acl__inherit_acls__default_value = 1;
2985 static const protobuf_c_boolean mumble_proto__acl__query__default_value = 0;
2986 static const ProtobufCFieldDescriptor mumble_proto__acl__field_descriptors[5] =
2987 {
2988   {
2989     "channel_id",
2990     1,
2991     PROTOBUF_C_LABEL_REQUIRED,
2992     PROTOBUF_C_TYPE_UINT32,
2993     0,   /* quantifier_offset */
2994     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, channel_id),
2995     NULL,
2996     NULL,
2997     0,            /* packed */
2998     0,NULL,NULL    /* reserved1,reserved2, etc */
2999   },
3000   {
3001     "inherit_acls",
3002     2,
3003     PROTOBUF_C_LABEL_OPTIONAL,
3004     PROTOBUF_C_TYPE_BOOL,
3005     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, has_inherit_acls),
3006     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, inherit_acls),
3007     NULL,
3008     &mumble_proto__acl__inherit_acls__default_value,
3009     0,            /* packed */
3010     0,NULL,NULL    /* reserved1,reserved2, etc */
3011   },
3012   {
3013     "groups",
3014     3,
3015     PROTOBUF_C_LABEL_REPEATED,
3016     PROTOBUF_C_TYPE_MESSAGE,
3017     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, n_groups),
3018     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, groups),
3019     &mumble_proto__acl__chan_group__descriptor,
3020     NULL,
3021     0,            /* packed */
3022     0,NULL,NULL    /* reserved1,reserved2, etc */
3023   },
3024   {
3025     "acls",
3026     4,
3027     PROTOBUF_C_LABEL_REPEATED,
3028     PROTOBUF_C_TYPE_MESSAGE,
3029     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, n_acls),
3030     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, acls),
3031     &mumble_proto__acl__chan_acl__descriptor,
3032     NULL,
3033     0,            /* packed */
3034     0,NULL,NULL    /* reserved1,reserved2, etc */
3035   },
3036   {
3037     "query",
3038     5,
3039     PROTOBUF_C_LABEL_OPTIONAL,
3040     PROTOBUF_C_TYPE_BOOL,
3041     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, has_query),
3042     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, query),
3043     NULL,
3044     &mumble_proto__acl__query__default_value,
3045     0,            /* packed */
3046     0,NULL,NULL    /* reserved1,reserved2, etc */
3047   },
3048 };
3049 static const unsigned mumble_proto__acl__field_indices_by_name[] = {
3050   3,   /* field[3] = acls */
3051   0,   /* field[0] = channel_id */
3052   2,   /* field[2] = groups */
3053   1,   /* field[1] = inherit_acls */
3054   4,   /* field[4] = query */
3055 };
3056 static const ProtobufCIntRange mumble_proto__acl__number_ranges[1 + 1] =
3057 {
3058   { 1, 0 },
3059   { 0, 5 }
3060 };
3061 const ProtobufCMessageDescriptor mumble_proto__acl__descriptor =
3062 {
3063   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
3064   "MumbleProto.ACL",
3065   "ACL",
3066   "MumbleProto__ACL",
3067   "MumbleProto",
3068   sizeof(MumbleProto__ACL),
3069   5,
3070   mumble_proto__acl__field_descriptors,
3071   mumble_proto__acl__field_indices_by_name,
3072   1,  mumble_proto__acl__number_ranges,
3073   (ProtobufCMessageInit) mumble_proto__acl__init,
3074   NULL,NULL,NULL    /* reserved[123] */
3075 };
3076 static const ProtobufCFieldDescriptor mumble_proto__query_users__field_descriptors[2] =
3077 {
3078   {
3079     "ids",
3080     1,
3081     PROTOBUF_C_LABEL_REPEATED,
3082     PROTOBUF_C_TYPE_UINT32,
3083     PROTOBUF_C_OFFSETOF(MumbleProto__QueryUsers, n_ids),
3084     PROTOBUF_C_OFFSETOF(MumbleProto__QueryUsers, ids),
3085     NULL,
3086     NULL,
3087     0,            /* packed */
3088     0,NULL,NULL    /* reserved1,reserved2, etc */
3089   },
3090   {
3091     "names",
3092     2,
3093     PROTOBUF_C_LABEL_REPEATED,
3094     PROTOBUF_C_TYPE_STRING,
3095     PROTOBUF_C_OFFSETOF(MumbleProto__QueryUsers, n_names),
3096     PROTOBUF_C_OFFSETOF(MumbleProto__QueryUsers, names),
3097     NULL,
3098     NULL,
3099     0,            /* packed */
3100     0,NULL,NULL    /* reserved1,reserved2, etc */
3101   },
3102 };
3103 static const unsigned mumble_proto__query_users__field_indices_by_name[] = {
3104   0,   /* field[0] = ids */
3105   1,   /* field[1] = names */
3106 };
3107 static const ProtobufCIntRange mumble_proto__query_users__number_ranges[1 + 1] =
3108 {
3109   { 1, 0 },
3110   { 0, 2 }
3111 };
3112 const ProtobufCMessageDescriptor mumble_proto__query_users__descriptor =
3113 {
3114   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
3115   "MumbleProto.QueryUsers",
3116   "QueryUsers",
3117   "MumbleProto__QueryUsers",
3118   "MumbleProto",
3119   sizeof(MumbleProto__QueryUsers),
3120   2,
3121   mumble_proto__query_users__field_descriptors,
3122   mumble_proto__query_users__field_indices_by_name,
3123   1,  mumble_proto__query_users__number_ranges,
3124   (ProtobufCMessageInit) mumble_proto__query_users__init,
3125   NULL,NULL,NULL    /* reserved[123] */
3126 };
3127 static const ProtobufCFieldDescriptor mumble_proto__crypt_setup__field_descriptors[3] =
3128 {
3129   {
3130     "key",
3131     1,
3132     PROTOBUF_C_LABEL_OPTIONAL,
3133     PROTOBUF_C_TYPE_BYTES,
3134     PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, has_key),
3135     PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, key),
3136     NULL,
3137     NULL,
3138     0,            /* packed */
3139     0,NULL,NULL    /* reserved1,reserved2, etc */
3140   },
3141   {
3142     "client_nonce",
3143     2,
3144     PROTOBUF_C_LABEL_OPTIONAL,
3145     PROTOBUF_C_TYPE_BYTES,
3146     PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, has_client_nonce),
3147     PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, client_nonce),
3148     NULL,
3149     NULL,
3150     0,            /* packed */
3151     0,NULL,NULL    /* reserved1,reserved2, etc */
3152   },
3153   {
3154     "server_nonce",
3155     3,
3156     PROTOBUF_C_LABEL_OPTIONAL,
3157     PROTOBUF_C_TYPE_BYTES,
3158     PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, has_server_nonce),
3159     PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, server_nonce),
3160     NULL,
3161     NULL,
3162     0,            /* packed */
3163     0,NULL,NULL    /* reserved1,reserved2, etc */
3164   },
3165 };
3166 static const unsigned mumble_proto__crypt_setup__field_indices_by_name[] = {
3167   1,   /* field[1] = client_nonce */
3168   0,   /* field[0] = key */
3169   2,   /* field[2] = server_nonce */
3170 };
3171 static const ProtobufCIntRange mumble_proto__crypt_setup__number_ranges[1 + 1] =
3172 {
3173   { 1, 0 },
3174   { 0, 3 }
3175 };
3176 const ProtobufCMessageDescriptor mumble_proto__crypt_setup__descriptor =
3177 {
3178   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
3179   "MumbleProto.CryptSetup",
3180   "CryptSetup",
3181   "MumbleProto__CryptSetup",
3182   "MumbleProto",
3183   sizeof(MumbleProto__CryptSetup),
3184   3,
3185   mumble_proto__crypt_setup__field_descriptors,
3186   mumble_proto__crypt_setup__field_indices_by_name,
3187   1,  mumble_proto__crypt_setup__number_ranges,
3188   (ProtobufCMessageInit) mumble_proto__crypt_setup__init,
3189   NULL,NULL,NULL    /* reserved[123] */
3190 };
3191 const ProtobufCEnumValue mumble_proto__context_action_modify__context__enum_values_by_number[3] =
3192 {
3193   { "Server", "MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__CONTEXT__SERVER", 1 },
3194   { "Channel", "MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__CONTEXT__CHANNEL", 2 },
3195   { "User", "MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__CONTEXT__USER", 4 },
3196 };
3197 static const ProtobufCIntRange mumble_proto__context_action_modify__context__value_ranges[] = {
3198 {1, 0},{4, 2},{0, 3}
3199 };
3200 const ProtobufCEnumValueIndex mumble_proto__context_action_modify__context__enum_values_by_name[3] =
3201 {
3202   { "Channel", 1 },
3203   { "Server", 0 },
3204   { "User", 2 },
3205 };
3206 const ProtobufCEnumDescriptor mumble_proto__context_action_modify__context__descriptor =
3207 {
3208   PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC,
3209   "MumbleProto.ContextActionModify.Context",
3210   "Context",
3211   "MumbleProto__ContextActionModify__Context",
3212   "MumbleProto",
3213   3,
3214   mumble_proto__context_action_modify__context__enum_values_by_number,
3215   3,
3216   mumble_proto__context_action_modify__context__enum_values_by_name,
3217   2,
3218   mumble_proto__context_action_modify__context__value_ranges,
3219   NULL,NULL,NULL,NULL   /* reserved[1234] */
3220 };
3221 const ProtobufCEnumValue mumble_proto__context_action_modify__operation__enum_values_by_number[2] =
3222 {
3223   { "Add", "MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__OPERATION__ADD", 0 },
3224   { "Remove", "MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__OPERATION__REMOVE", 1 },
3225 };
3226 static const ProtobufCIntRange mumble_proto__context_action_modify__operation__value_ranges[] = {
3227 {0, 0},{0, 2}
3228 };
3229 const ProtobufCEnumValueIndex mumble_proto__context_action_modify__operation__enum_values_by_name[2] =
3230 {
3231   { "Add", 0 },
3232   { "Remove", 1 },
3233 };
3234 const ProtobufCEnumDescriptor mumble_proto__context_action_modify__operation__descriptor =
3235 {
3236   PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC,
3237   "MumbleProto.ContextActionModify.Operation",
3238   "Operation",
3239   "MumbleProto__ContextActionModify__Operation",
3240   "MumbleProto",
3241   2,
3242   mumble_proto__context_action_modify__operation__enum_values_by_number,
3243   2,
3244   mumble_proto__context_action_modify__operation__enum_values_by_name,
3245   1,
3246   mumble_proto__context_action_modify__operation__value_ranges,
3247   NULL,NULL,NULL,NULL   /* reserved[1234] */
3248 };
3249 static const ProtobufCFieldDescriptor mumble_proto__context_action_modify__field_descriptors[4] =
3250 {
3251   {
3252     "action",
3253     1,
3254     PROTOBUF_C_LABEL_REQUIRED,
3255     PROTOBUF_C_TYPE_STRING,
3256     0,   /* quantifier_offset */
3257     PROTOBUF_C_OFFSETOF(MumbleProto__ContextActionModify, action),
3258     NULL,
3259     NULL,
3260     0,            /* packed */
3261     0,NULL,NULL    /* reserved1,reserved2, etc */
3262   },
3263   {
3264     "text",
3265     2,
3266     PROTOBUF_C_LABEL_OPTIONAL,
3267     PROTOBUF_C_TYPE_STRING,
3268     0,   /* quantifier_offset */
3269     PROTOBUF_C_OFFSETOF(MumbleProto__ContextActionModify, text),
3270     NULL,
3271     NULL,
3272     0,            /* packed */
3273     0,NULL,NULL    /* reserved1,reserved2, etc */
3274   },
3275   {
3276     "context",
3277     3,
3278     PROTOBUF_C_LABEL_OPTIONAL,
3279     PROTOBUF_C_TYPE_UINT32,
3280     PROTOBUF_C_OFFSETOF(MumbleProto__ContextActionModify, has_context),
3281     PROTOBUF_C_OFFSETOF(MumbleProto__ContextActionModify, context),
3282     NULL,
3283     NULL,
3284     0,            /* packed */
3285     0,NULL,NULL    /* reserved1,reserved2, etc */
3286   },
3287   {
3288     "operation",
3289     4,
3290     PROTOBUF_C_LABEL_OPTIONAL,
3291     PROTOBUF_C_TYPE_ENUM,
3292     PROTOBUF_C_OFFSETOF(MumbleProto__ContextActionModify, has_operation),
3293     PROTOBUF_C_OFFSETOF(MumbleProto__ContextActionModify, operation),
3294     &mumble_proto__context_action_modify__operation__descriptor,
3295     NULL,
3296     0,            /* packed */
3297     0,NULL,NULL    /* reserved1,reserved2, etc */
3298   },
3299 };
3300 static const unsigned mumble_proto__context_action_modify__field_indices_by_name[] = {
3301   0,   /* field[0] = action */
3302   2,   /* field[2] = context */
3303   3,   /* field[3] = operation */
3304   1,   /* field[1] = text */
3305 };
3306 static const ProtobufCIntRange mumble_proto__context_action_modify__number_ranges[1 + 1] =
3307 {
3308   { 1, 0 },
3309   { 0, 4 }
3310 };
3311 const ProtobufCMessageDescriptor mumble_proto__context_action_modify__descriptor =
3312 {
3313   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
3314   "MumbleProto.ContextActionModify",
3315   "ContextActionModify",
3316   "MumbleProto__ContextActionModify",
3317   "MumbleProto",
3318   sizeof(MumbleProto__ContextActionModify),
3319   4,
3320   mumble_proto__context_action_modify__field_descriptors,
3321   mumble_proto__context_action_modify__field_indices_by_name,
3322   1,  mumble_proto__context_action_modify__number_ranges,
3323   (ProtobufCMessageInit) mumble_proto__context_action_modify__init,
3324   NULL,NULL,NULL    /* reserved[123] */
3325 };
3326 static const ProtobufCFieldDescriptor mumble_proto__context_action__field_descriptors[3] =
3327 {
3328   {
3329     "session",
3330     1,
3331     PROTOBUF_C_LABEL_OPTIONAL,
3332     PROTOBUF_C_TYPE_UINT32,
3333     PROTOBUF_C_OFFSETOF(MumbleProto__ContextAction, has_session),
3334     PROTOBUF_C_OFFSETOF(MumbleProto__ContextAction, session),
3335     NULL,
3336     NULL,
3337     0,            /* packed */
3338     0,NULL,NULL    /* reserved1,reserved2, etc */
3339   },
3340   {
3341     "channel_id",
3342     2,
3343     PROTOBUF_C_LABEL_OPTIONAL,
3344     PROTOBUF_C_TYPE_UINT32,
3345     PROTOBUF_C_OFFSETOF(MumbleProto__ContextAction, has_channel_id),
3346     PROTOBUF_C_OFFSETOF(MumbleProto__ContextAction, channel_id),
3347     NULL,
3348     NULL,
3349     0,            /* packed */
3350     0,NULL,NULL    /* reserved1,reserved2, etc */
3351   },
3352   {
3353     "action",
3354     3,
3355     PROTOBUF_C_LABEL_REQUIRED,
3356     PROTOBUF_C_TYPE_STRING,
3357     0,   /* quantifier_offset */
3358     PROTOBUF_C_OFFSETOF(MumbleProto__ContextAction, action),
3359     NULL,
3360     NULL,
3361     0,            /* packed */
3362     0,NULL,NULL    /* reserved1,reserved2, etc */
3363   },
3364 };
3365 static const unsigned mumble_proto__context_action__field_indices_by_name[] = {
3366   2,   /* field[2] = action */
3367   1,   /* field[1] = channel_id */
3368   0,   /* field[0] = session */
3369 };
3370 static const ProtobufCIntRange mumble_proto__context_action__number_ranges[1 + 1] =
3371 {
3372   { 1, 0 },
3373   { 0, 3 }
3374 };
3375 const ProtobufCMessageDescriptor mumble_proto__context_action__descriptor =
3376 {
3377   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
3378   "MumbleProto.ContextAction",
3379   "ContextAction",
3380   "MumbleProto__ContextAction",
3381   "MumbleProto",
3382   sizeof(MumbleProto__ContextAction),
3383   3,
3384   mumble_proto__context_action__field_descriptors,
3385   mumble_proto__context_action__field_indices_by_name,
3386   1,  mumble_proto__context_action__number_ranges,
3387   (ProtobufCMessageInit) mumble_proto__context_action__init,
3388   NULL,NULL,NULL    /* reserved[123] */
3389 };
3390 static const ProtobufCFieldDescriptor mumble_proto__user_list__user__field_descriptors[2] =
3391 {
3392   {
3393     "user_id",
3394     1,
3395     PROTOBUF_C_LABEL_REQUIRED,
3396     PROTOBUF_C_TYPE_UINT32,
3397     0,   /* quantifier_offset */
3398     PROTOBUF_C_OFFSETOF(MumbleProto__UserList__User, user_id),
3399     NULL,
3400     NULL,
3401     0,            /* packed */
3402     0,NULL,NULL    /* reserved1,reserved2, etc */
3403   },
3404   {
3405     "name",
3406     2,
3407     PROTOBUF_C_LABEL_OPTIONAL,
3408     PROTOBUF_C_TYPE_STRING,
3409     0,   /* quantifier_offset */
3410     PROTOBUF_C_OFFSETOF(MumbleProto__UserList__User, name),
3411     NULL,
3412     NULL,
3413     0,            /* packed */
3414     0,NULL,NULL    /* reserved1,reserved2, etc */
3415   },
3416 };
3417 static const unsigned mumble_proto__user_list__user__field_indices_by_name[] = {
3418   1,   /* field[1] = name */
3419   0,   /* field[0] = user_id */
3420 };
3421 static const ProtobufCIntRange mumble_proto__user_list__user__number_ranges[1 + 1] =
3422 {
3423   { 1, 0 },
3424   { 0, 2 }
3425 };
3426 const ProtobufCMessageDescriptor mumble_proto__user_list__user__descriptor =
3427 {
3428   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
3429   "MumbleProto.UserList.User",
3430   "User",
3431   "MumbleProto__UserList__User",
3432   "MumbleProto",
3433   sizeof(MumbleProto__UserList__User),
3434   2,
3435   mumble_proto__user_list__user__field_descriptors,
3436   mumble_proto__user_list__user__field_indices_by_name,
3437   1,  mumble_proto__user_list__user__number_ranges,
3438   (ProtobufCMessageInit) mumble_proto__user_list__user__init,
3439   NULL,NULL,NULL    /* reserved[123] */
3440 };
3441 static const ProtobufCFieldDescriptor mumble_proto__user_list__field_descriptors[1] =
3442 {
3443   {
3444     "users",
3445     1,
3446     PROTOBUF_C_LABEL_REPEATED,
3447     PROTOBUF_C_TYPE_MESSAGE,
3448     PROTOBUF_C_OFFSETOF(MumbleProto__UserList, n_users),
3449     PROTOBUF_C_OFFSETOF(MumbleProto__UserList, users),
3450     &mumble_proto__user_list__user__descriptor,
3451     NULL,
3452     0,            /* packed */
3453     0,NULL,NULL    /* reserved1,reserved2, etc */
3454   },
3455 };
3456 static const unsigned mumble_proto__user_list__field_indices_by_name[] = {
3457   0,   /* field[0] = users */
3458 };
3459 static const ProtobufCIntRange mumble_proto__user_list__number_ranges[1 + 1] =
3460 {
3461   { 1, 0 },
3462   { 0, 1 }
3463 };
3464 const ProtobufCMessageDescriptor mumble_proto__user_list__descriptor =
3465 {
3466   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
3467   "MumbleProto.UserList",
3468   "UserList",
3469   "MumbleProto__UserList",
3470   "MumbleProto",
3471   sizeof(MumbleProto__UserList),
3472   1,
3473   mumble_proto__user_list__field_descriptors,
3474   mumble_proto__user_list__field_indices_by_name,
3475   1,  mumble_proto__user_list__number_ranges,
3476   (ProtobufCMessageInit) mumble_proto__user_list__init,
3477   NULL,NULL,NULL    /* reserved[123] */
3478 };
3479 static const protobuf_c_boolean mumble_proto__voice_target__target__links__default_value = 0;
3480 static const protobuf_c_boolean mumble_proto__voice_target__target__children__default_value = 0;
3481 static const ProtobufCFieldDescriptor mumble_proto__voice_target__target__field_descriptors[5] =
3482 {
3483   {
3484     "session",
3485     1,
3486     PROTOBUF_C_LABEL_REPEATED,
3487     PROTOBUF_C_TYPE_UINT32,
3488     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, n_session),
3489     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, session),
3490     NULL,
3491     NULL,
3492     0,            /* packed */
3493     0,NULL,NULL    /* reserved1,reserved2, etc */
3494   },
3495   {
3496     "channel_id",
3497     2,
3498     PROTOBUF_C_LABEL_OPTIONAL,
3499     PROTOBUF_C_TYPE_UINT32,
3500     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, has_channel_id),
3501     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, channel_id),
3502     NULL,
3503     NULL,
3504     0,            /* packed */
3505     0,NULL,NULL    /* reserved1,reserved2, etc */
3506   },
3507   {
3508     "group",
3509     3,
3510     PROTOBUF_C_LABEL_OPTIONAL,
3511     PROTOBUF_C_TYPE_STRING,
3512     0,   /* quantifier_offset */
3513     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, group),
3514     NULL,
3515     NULL,
3516     0,            /* packed */
3517     0,NULL,NULL    /* reserved1,reserved2, etc */
3518   },
3519   {
3520     "links",
3521     4,
3522     PROTOBUF_C_LABEL_OPTIONAL,
3523     PROTOBUF_C_TYPE_BOOL,
3524     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, has_links),
3525     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, links),
3526     NULL,
3527     &mumble_proto__voice_target__target__links__default_value,
3528     0,            /* packed */
3529     0,NULL,NULL    /* reserved1,reserved2, etc */
3530   },
3531   {
3532     "children",
3533     5,
3534     PROTOBUF_C_LABEL_OPTIONAL,
3535     PROTOBUF_C_TYPE_BOOL,
3536     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, has_children),
3537     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, children),
3538     NULL,
3539     &mumble_proto__voice_target__target__children__default_value,
3540     0,            /* packed */
3541     0,NULL,NULL    /* reserved1,reserved2, etc */
3542   },
3543 };
3544 static const unsigned mumble_proto__voice_target__target__field_indices_by_name[] = {
3545   1,   /* field[1] = channel_id */
3546   4,   /* field[4] = children */
3547   2,   /* field[2] = group */
3548   3,   /* field[3] = links */
3549   0,   /* field[0] = session */
3550 };
3551 static const ProtobufCIntRange mumble_proto__voice_target__target__number_ranges[1 + 1] =
3552 {
3553   { 1, 0 },
3554   { 0, 5 }
3555 };
3556 const ProtobufCMessageDescriptor mumble_proto__voice_target__target__descriptor =
3557 {
3558   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
3559   "MumbleProto.VoiceTarget.Target",
3560   "Target",
3561   "MumbleProto__VoiceTarget__Target",
3562   "MumbleProto",
3563   sizeof(MumbleProto__VoiceTarget__Target),
3564   5,
3565   mumble_proto__voice_target__target__field_descriptors,
3566   mumble_proto__voice_target__target__field_indices_by_name,
3567   1,  mumble_proto__voice_target__target__number_ranges,
3568   (ProtobufCMessageInit) mumble_proto__voice_target__target__init,
3569   NULL,NULL,NULL    /* reserved[123] */
3570 };
3571 static const ProtobufCFieldDescriptor mumble_proto__voice_target__field_descriptors[2] =
3572 {
3573   {
3574     "id",
3575     1,
3576     PROTOBUF_C_LABEL_OPTIONAL,
3577     PROTOBUF_C_TYPE_UINT32,
3578     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget, has_id),
3579     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget, id),
3580     NULL,
3581     NULL,
3582     0,            /* packed */
3583     0,NULL,NULL    /* reserved1,reserved2, etc */
3584   },
3585   {
3586     "targets",
3587     2,
3588     PROTOBUF_C_LABEL_REPEATED,
3589     PROTOBUF_C_TYPE_MESSAGE,
3590     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget, n_targets),
3591     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget, targets),
3592     &mumble_proto__voice_target__target__descriptor,
3593     NULL,
3594     0,            /* packed */
3595     0,NULL,NULL    /* reserved1,reserved2, etc */
3596   },
3597 };
3598 static const unsigned mumble_proto__voice_target__field_indices_by_name[] = {
3599   0,   /* field[0] = id */
3600   1,   /* field[1] = targets */
3601 };
3602 static const ProtobufCIntRange mumble_proto__voice_target__number_ranges[1 + 1] =
3603 {
3604   { 1, 0 },
3605   { 0, 2 }
3606 };
3607 const ProtobufCMessageDescriptor mumble_proto__voice_target__descriptor =
3608 {
3609   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
3610   "MumbleProto.VoiceTarget",
3611   "VoiceTarget",
3612   "MumbleProto__VoiceTarget",
3613   "MumbleProto",
3614   sizeof(MumbleProto__VoiceTarget),
3615   2,
3616   mumble_proto__voice_target__field_descriptors,
3617   mumble_proto__voice_target__field_indices_by_name,
3618   1,  mumble_proto__voice_target__number_ranges,
3619   (ProtobufCMessageInit) mumble_proto__voice_target__init,
3620   NULL,NULL,NULL    /* reserved[123] */
3621 };
3622 static const protobuf_c_boolean mumble_proto__permission_query__flush__default_value = 0;
3623 static const ProtobufCFieldDescriptor mumble_proto__permission_query__field_descriptors[3] =
3624 {
3625   {
3626     "channel_id",
3627     1,
3628     PROTOBUF_C_LABEL_OPTIONAL,
3629     PROTOBUF_C_TYPE_UINT32,
3630     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, has_channel_id),
3631     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, channel_id),
3632     NULL,
3633     NULL,
3634     0,            /* packed */
3635     0,NULL,NULL    /* reserved1,reserved2, etc */
3636   },
3637   {
3638     "permissions",
3639     2,
3640     PROTOBUF_C_LABEL_OPTIONAL,
3641     PROTOBUF_C_TYPE_UINT32,
3642     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, has_permissions),
3643     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, permissions),
3644     NULL,
3645     NULL,
3646     0,            /* packed */
3647     0,NULL,NULL    /* reserved1,reserved2, etc */
3648   },
3649   {
3650     "flush",
3651     3,
3652     PROTOBUF_C_LABEL_OPTIONAL,
3653     PROTOBUF_C_TYPE_BOOL,
3654     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, has_flush),
3655     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, flush),
3656     NULL,
3657     &mumble_proto__permission_query__flush__default_value,
3658     0,            /* packed */
3659     0,NULL,NULL    /* reserved1,reserved2, etc */
3660   },
3661 };
3662 static const unsigned mumble_proto__permission_query__field_indices_by_name[] = {
3663   0,   /* field[0] = channel_id */
3664   2,   /* field[2] = flush */
3665   1,   /* field[1] = permissions */
3666 };
3667 static const ProtobufCIntRange mumble_proto__permission_query__number_ranges[1 + 1] =
3668 {
3669   { 1, 0 },
3670   { 0, 3 }
3671 };
3672 const ProtobufCMessageDescriptor mumble_proto__permission_query__descriptor =
3673 {
3674   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
3675   "MumbleProto.PermissionQuery",
3676   "PermissionQuery",
3677   "MumbleProto__PermissionQuery",
3678   "MumbleProto",
3679   sizeof(MumbleProto__PermissionQuery),
3680   3,
3681   mumble_proto__permission_query__field_descriptors,
3682   mumble_proto__permission_query__field_indices_by_name,
3683   1,  mumble_proto__permission_query__number_ranges,
3684   (ProtobufCMessageInit) mumble_proto__permission_query__init,
3685   NULL,NULL,NULL    /* reserved[123] */
3686 };
3687 static const protobuf_c_boolean mumble_proto__codec_version__prefer_alpha__default_value = 1;
3688 static const protobuf_c_boolean mumble_proto__codec_version__opus__default_value = 0;
3689 static const ProtobufCFieldDescriptor mumble_proto__codec_version__field_descriptors[4] =
3690 {
3691   {
3692     "alpha",
3693     1,
3694     PROTOBUF_C_LABEL_REQUIRED,
3695     PROTOBUF_C_TYPE_INT32,
3696     0,   /* quantifier_offset */
3697     PROTOBUF_C_OFFSETOF(MumbleProto__CodecVersion, alpha),
3698     NULL,
3699     NULL,
3700     0,            /* packed */
3701     0,NULL,NULL    /* reserved1,reserved2, etc */
3702   },
3703   {
3704     "beta",
3705     2,
3706     PROTOBUF_C_LABEL_REQUIRED,
3707     PROTOBUF_C_TYPE_INT32,
3708     0,   /* quantifier_offset */
3709     PROTOBUF_C_OFFSETOF(MumbleProto__CodecVersion, beta),
3710     NULL,
3711     NULL,
3712     0,            /* packed */
3713     0,NULL,NULL    /* reserved1,reserved2, etc */
3714   },
3715   {
3716     "prefer_alpha",
3717     3,
3718     PROTOBUF_C_LABEL_REQUIRED,
3719     PROTOBUF_C_TYPE_BOOL,
3720     0,   /* quantifier_offset */
3721     PROTOBUF_C_OFFSETOF(MumbleProto__CodecVersion, prefer_alpha),
3722     NULL,
3723     &mumble_proto__codec_version__prefer_alpha__default_value,
3724     0,            /* packed */
3725     0,NULL,NULL    /* reserved1,reserved2, etc */
3726   },
3727   {
3728     "opus",
3729     4,
3730     PROTOBUF_C_LABEL_OPTIONAL,
3731     PROTOBUF_C_TYPE_BOOL,
3732     PROTOBUF_C_OFFSETOF(MumbleProto__CodecVersion, has_opus),
3733     PROTOBUF_C_OFFSETOF(MumbleProto__CodecVersion, opus),
3734     NULL,
3735     &mumble_proto__codec_version__opus__default_value,
3736     0,            /* packed */
3737     0,NULL,NULL    /* reserved1,reserved2, etc */
3738   },
3739 };
3740 static const unsigned mumble_proto__codec_version__field_indices_by_name[] = {
3741   0,   /* field[0] = alpha */
3742   1,   /* field[1] = beta */
3743   3,   /* field[3] = opus */
3744   2,   /* field[2] = prefer_alpha */
3745 };
3746 static const ProtobufCIntRange mumble_proto__codec_version__number_ranges[1 + 1] =
3747 {
3748   { 1, 0 },
3749   { 0, 4 }
3750 };
3751 const ProtobufCMessageDescriptor mumble_proto__codec_version__descriptor =
3752 {
3753   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
3754   "MumbleProto.CodecVersion",
3755   "CodecVersion",
3756   "MumbleProto__CodecVersion",
3757   "MumbleProto",
3758   sizeof(MumbleProto__CodecVersion),
3759   4,
3760   mumble_proto__codec_version__field_descriptors,
3761   mumble_proto__codec_version__field_indices_by_name,
3762   1,  mumble_proto__codec_version__number_ranges,
3763   (ProtobufCMessageInit) mumble_proto__codec_version__init,
3764   NULL,NULL,NULL    /* reserved[123] */
3765 };
3766 static const ProtobufCFieldDescriptor mumble_proto__user_stats__stats__field_descriptors[4] =
3767 {
3768   {
3769     "good",
3770     1,
3771     PROTOBUF_C_LABEL_OPTIONAL,
3772     PROTOBUF_C_TYPE_UINT32,
3773     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, has_good),
3774     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, good),
3775     NULL,
3776     NULL,
3777     0,            /* packed */
3778     0,NULL,NULL    /* reserved1,reserved2, etc */
3779   },
3780   {
3781     "late",
3782     2,
3783     PROTOBUF_C_LABEL_OPTIONAL,
3784     PROTOBUF_C_TYPE_UINT32,
3785     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, has_late),
3786     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, late),
3787     NULL,
3788     NULL,
3789     0,            /* packed */
3790     0,NULL,NULL    /* reserved1,reserved2, etc */
3791   },
3792   {
3793     "lost",
3794     3,
3795     PROTOBUF_C_LABEL_OPTIONAL,
3796     PROTOBUF_C_TYPE_UINT32,
3797     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, has_lost),
3798     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, lost),
3799     NULL,
3800     NULL,
3801     0,            /* packed */
3802     0,NULL,NULL    /* reserved1,reserved2, etc */
3803   },
3804   {
3805     "resync",
3806     4,
3807     PROTOBUF_C_LABEL_OPTIONAL,
3808     PROTOBUF_C_TYPE_UINT32,
3809     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, has_resync),
3810     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, resync),
3811     NULL,
3812     NULL,
3813     0,            /* packed */
3814     0,NULL,NULL    /* reserved1,reserved2, etc */
3815   },
3816 };
3817 static const unsigned mumble_proto__user_stats__stats__field_indices_by_name[] = {
3818   0,   /* field[0] = good */
3819   1,   /* field[1] = late */
3820   2,   /* field[2] = lost */
3821   3,   /* field[3] = resync */
3822 };
3823 static const ProtobufCIntRange mumble_proto__user_stats__stats__number_ranges[1 + 1] =
3824 {
3825   { 1, 0 },
3826   { 0, 4 }
3827 };
3828 const ProtobufCMessageDescriptor mumble_proto__user_stats__stats__descriptor =
3829 {
3830   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
3831   "MumbleProto.UserStats.Stats",
3832   "Stats",
3833   "MumbleProto__UserStats__Stats",
3834   "MumbleProto",
3835   sizeof(MumbleProto__UserStats__Stats),
3836   4,
3837   mumble_proto__user_stats__stats__field_descriptors,
3838   mumble_proto__user_stats__stats__field_indices_by_name,
3839   1,  mumble_proto__user_stats__stats__number_ranges,
3840   (ProtobufCMessageInit) mumble_proto__user_stats__stats__init,
3841   NULL,NULL,NULL    /* reserved[123] */
3842 };
3843 static const protobuf_c_boolean mumble_proto__user_stats__stats_only__default_value = 0;
3844 static const protobuf_c_boolean mumble_proto__user_stats__strong_certificate__default_value = 0;
3845 static const protobuf_c_boolean mumble_proto__user_stats__opus__default_value = 0;
3846 static const ProtobufCFieldDescriptor mumble_proto__user_stats__field_descriptors[19] =
3847 {
3848   {
3849     "session",
3850     1,
3851     PROTOBUF_C_LABEL_OPTIONAL,
3852     PROTOBUF_C_TYPE_UINT32,
3853     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_session),
3854     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, session),
3855     NULL,
3856     NULL,
3857     0,            /* packed */
3858     0,NULL,NULL    /* reserved1,reserved2, etc */
3859   },
3860   {
3861     "stats_only",
3862     2,
3863     PROTOBUF_C_LABEL_OPTIONAL,
3864     PROTOBUF_C_TYPE_BOOL,
3865     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_stats_only),
3866     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, stats_only),
3867     NULL,
3868     &mumble_proto__user_stats__stats_only__default_value,
3869     0,            /* packed */
3870     0,NULL,NULL    /* reserved1,reserved2, etc */
3871   },
3872   {
3873     "certificates",
3874     3,
3875     PROTOBUF_C_LABEL_REPEATED,
3876     PROTOBUF_C_TYPE_BYTES,
3877     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, n_certificates),
3878     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, certificates),
3879     NULL,
3880     NULL,
3881     0,            /* packed */
3882     0,NULL,NULL    /* reserved1,reserved2, etc */
3883   },
3884   {
3885     "from_client",
3886     4,
3887     PROTOBUF_C_LABEL_OPTIONAL,
3888     PROTOBUF_C_TYPE_MESSAGE,
3889     0,   /* quantifier_offset */
3890     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, from_client),
3891     &mumble_proto__user_stats__stats__descriptor,
3892     NULL,
3893     0,            /* packed */
3894     0,NULL,NULL    /* reserved1,reserved2, etc */
3895   },
3896   {
3897     "from_server",
3898     5,
3899     PROTOBUF_C_LABEL_OPTIONAL,
3900     PROTOBUF_C_TYPE_MESSAGE,
3901     0,   /* quantifier_offset */
3902     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, from_server),
3903     &mumble_proto__user_stats__stats__descriptor,
3904     NULL,
3905     0,            /* packed */
3906     0,NULL,NULL    /* reserved1,reserved2, etc */
3907   },
3908   {
3909     "udp_packets",
3910     6,
3911     PROTOBUF_C_LABEL_OPTIONAL,
3912     PROTOBUF_C_TYPE_UINT32,
3913     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_udp_packets),
3914     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, udp_packets),
3915     NULL,
3916     NULL,
3917     0,            /* packed */
3918     0,NULL,NULL    /* reserved1,reserved2, etc */
3919   },
3920   {
3921     "tcp_packets",
3922     7,
3923     PROTOBUF_C_LABEL_OPTIONAL,
3924     PROTOBUF_C_TYPE_UINT32,
3925     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_tcp_packets),
3926     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, tcp_packets),
3927     NULL,
3928     NULL,
3929     0,            /* packed */
3930     0,NULL,NULL    /* reserved1,reserved2, etc */
3931   },
3932   {
3933     "udp_ping_avg",
3934     8,
3935     PROTOBUF_C_LABEL_OPTIONAL,
3936     PROTOBUF_C_TYPE_FLOAT,
3937     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_udp_ping_avg),
3938     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, udp_ping_avg),
3939     NULL,
3940     NULL,
3941     0,            /* packed */
3942     0,NULL,NULL    /* reserved1,reserved2, etc */
3943   },
3944   {
3945     "udp_ping_var",
3946     9,
3947     PROTOBUF_C_LABEL_OPTIONAL,
3948     PROTOBUF_C_TYPE_FLOAT,
3949     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_udp_ping_var),
3950     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, udp_ping_var),
3951     NULL,
3952     NULL,
3953     0,            /* packed */
3954     0,NULL,NULL    /* reserved1,reserved2, etc */
3955   },
3956   {
3957     "tcp_ping_avg",
3958     10,
3959     PROTOBUF_C_LABEL_OPTIONAL,
3960     PROTOBUF_C_TYPE_FLOAT,
3961     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_tcp_ping_avg),
3962     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, tcp_ping_avg),
3963     NULL,
3964     NULL,
3965     0,            /* packed */
3966     0,NULL,NULL    /* reserved1,reserved2, etc */
3967   },
3968   {
3969     "tcp_ping_var",
3970     11,
3971     PROTOBUF_C_LABEL_OPTIONAL,
3972     PROTOBUF_C_TYPE_FLOAT,
3973     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_tcp_ping_var),
3974     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, tcp_ping_var),
3975     NULL,
3976     NULL,
3977     0,            /* packed */
3978     0,NULL,NULL    /* reserved1,reserved2, etc */
3979   },
3980   {
3981     "version",
3982     12,
3983     PROTOBUF_C_LABEL_OPTIONAL,
3984     PROTOBUF_C_TYPE_MESSAGE,
3985     0,   /* quantifier_offset */
3986     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, version),
3987     &mumble_proto__version__descriptor,
3988     NULL,
3989     0,            /* packed */
3990     0,NULL,NULL    /* reserved1,reserved2, etc */
3991   },
3992   {
3993     "celt_versions",
3994     13,
3995     PROTOBUF_C_LABEL_REPEATED,
3996     PROTOBUF_C_TYPE_INT32,
3997     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, n_celt_versions),
3998     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, celt_versions),
3999     NULL,
4000     NULL,
4001     0,            /* packed */
4002     0,NULL,NULL    /* reserved1,reserved2, etc */
4003   },
4004   {
4005     "address",
4006     14,
4007     PROTOBUF_C_LABEL_OPTIONAL,
4008     PROTOBUF_C_TYPE_BYTES,
4009     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_address),
4010     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, address),
4011     NULL,
4012     NULL,
4013     0,            /* packed */
4014     0,NULL,NULL    /* reserved1,reserved2, etc */
4015   },
4016   {
4017     "bandwidth",
4018     15,
4019     PROTOBUF_C_LABEL_OPTIONAL,
4020     PROTOBUF_C_TYPE_UINT32,
4021     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_bandwidth),
4022     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, bandwidth),
4023     NULL,
4024     NULL,
4025     0,            /* packed */
4026     0,NULL,NULL    /* reserved1,reserved2, etc */
4027   },
4028   {
4029     "onlinesecs",
4030     16,
4031     PROTOBUF_C_LABEL_OPTIONAL,
4032     PROTOBUF_C_TYPE_UINT32,
4033     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_onlinesecs),
4034     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, onlinesecs),
4035     NULL,
4036     NULL,
4037     0,            /* packed */
4038     0,NULL,NULL    /* reserved1,reserved2, etc */
4039   },
4040   {
4041     "idlesecs",
4042     17,
4043     PROTOBUF_C_LABEL_OPTIONAL,
4044     PROTOBUF_C_TYPE_UINT32,
4045     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_idlesecs),
4046     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, idlesecs),
4047     NULL,
4048     NULL,
4049     0,            /* packed */
4050     0,NULL,NULL    /* reserved1,reserved2, etc */
4051   },
4052   {
4053     "strong_certificate",
4054     18,
4055     PROTOBUF_C_LABEL_OPTIONAL,
4056     PROTOBUF_C_TYPE_BOOL,
4057     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_strong_certificate),
4058     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, strong_certificate),
4059     NULL,
4060     &mumble_proto__user_stats__strong_certificate__default_value,
4061     0,            /* packed */
4062     0,NULL,NULL    /* reserved1,reserved2, etc */
4063   },
4064   {
4065     "opus",
4066     19,
4067     PROTOBUF_C_LABEL_OPTIONAL,
4068     PROTOBUF_C_TYPE_BOOL,
4069     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_opus),
4070     PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, opus),
4071     NULL,
4072     &mumble_proto__user_stats__opus__default_value,
4073     0,            /* packed */
4074     0,NULL,NULL    /* reserved1,reserved2, etc */
4075   },
4076 };
4077 static const unsigned mumble_proto__user_stats__field_indices_by_name[] = {
4078   13,   /* field[13] = address */
4079   14,   /* field[14] = bandwidth */
4080   12,   /* field[12] = celt_versions */
4081   2,   /* field[2] = certificates */
4082   3,   /* field[3] = from_client */
4083   4,   /* field[4] = from_server */
4084   16,   /* field[16] = idlesecs */
4085   15,   /* field[15] = onlinesecs */
4086   18,   /* field[18] = opus */
4087   0,   /* field[0] = session */
4088   1,   /* field[1] = stats_only */
4089   17,   /* field[17] = strong_certificate */
4090   6,   /* field[6] = tcp_packets */
4091   9,   /* field[9] = tcp_ping_avg */
4092   10,   /* field[10] = tcp_ping_var */
4093   5,   /* field[5] = udp_packets */
4094   7,   /* field[7] = udp_ping_avg */
4095   8,   /* field[8] = udp_ping_var */
4096   11,   /* field[11] = version */
4097 };
4098 static const ProtobufCIntRange mumble_proto__user_stats__number_ranges[1 + 1] =
4099 {
4100   { 1, 0 },
4101   { 0, 19 }
4102 };
4103 const ProtobufCMessageDescriptor mumble_proto__user_stats__descriptor =
4104 {
4105   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
4106   "MumbleProto.UserStats",
4107   "UserStats",
4108   "MumbleProto__UserStats",
4109   "MumbleProto",
4110   sizeof(MumbleProto__UserStats),
4111   19,
4112   mumble_proto__user_stats__field_descriptors,
4113   mumble_proto__user_stats__field_indices_by_name,
4114   1,  mumble_proto__user_stats__number_ranges,
4115   (ProtobufCMessageInit) mumble_proto__user_stats__init,
4116   NULL,NULL,NULL    /* reserved[123] */
4117 };
4118 static const ProtobufCFieldDescriptor mumble_proto__suggest_config__field_descriptors[3] =
4119 {
4120   {
4121     "version",
4122     1,
4123     PROTOBUF_C_LABEL_OPTIONAL,
4124     PROTOBUF_C_TYPE_UINT32,
4125     PROTOBUF_C_OFFSETOF(MumbleProto__SuggestConfig, has_version),
4126     PROTOBUF_C_OFFSETOF(MumbleProto__SuggestConfig, version),
4127     NULL,
4128     NULL,
4129     0,            /* packed */
4130     0,NULL,NULL    /* reserved1,reserved2, etc */
4131   },
4132   {
4133     "positional",
4134     2,
4135     PROTOBUF_C_LABEL_OPTIONAL,
4136     PROTOBUF_C_TYPE_BOOL,
4137     PROTOBUF_C_OFFSETOF(MumbleProto__SuggestConfig, has_positional),
4138     PROTOBUF_C_OFFSETOF(MumbleProto__SuggestConfig, positional),
4139     NULL,
4140     NULL,
4141     0,            /* packed */
4142     0,NULL,NULL    /* reserved1,reserved2, etc */
4143   },
4144   {
4145     "push_to_talk",
4146     3,
4147     PROTOBUF_C_LABEL_OPTIONAL,
4148     PROTOBUF_C_TYPE_BOOL,
4149     PROTOBUF_C_OFFSETOF(MumbleProto__SuggestConfig, has_push_to_talk),
4150     PROTOBUF_C_OFFSETOF(MumbleProto__SuggestConfig, push_to_talk),
4151     NULL,
4152     NULL,
4153     0,            /* packed */
4154     0,NULL,NULL    /* reserved1,reserved2, etc */
4155   },
4156 };
4157 static const unsigned mumble_proto__suggest_config__field_indices_by_name[] = {
4158   1,   /* field[1] = positional */
4159   2,   /* field[2] = push_to_talk */
4160   0,   /* field[0] = version */
4161 };
4162 static const ProtobufCIntRange mumble_proto__suggest_config__number_ranges[1 + 1] =
4163 {
4164   { 1, 0 },
4165   { 0, 3 }
4166 };
4167 const ProtobufCMessageDescriptor mumble_proto__suggest_config__descriptor =
4168 {
4169   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
4170   "MumbleProto.SuggestConfig",
4171   "SuggestConfig",
4172   "MumbleProto__SuggestConfig",
4173   "MumbleProto",
4174   sizeof(MumbleProto__SuggestConfig),
4175   3,
4176   mumble_proto__suggest_config__field_descriptors,
4177   mumble_proto__suggest_config__field_indices_by_name,
4178   1,  mumble_proto__suggest_config__number_ranges,
4179   (ProtobufCMessageInit) mumble_proto__suggest_config__init,
4180   NULL,NULL,NULL    /* reserved[123] */
4181 };
4182 static const ProtobufCFieldDescriptor mumble_proto__request_blob__field_descriptors[3] =
4183 {
4184   {
4185     "session_texture",
4186     1,
4187     PROTOBUF_C_LABEL_REPEATED,
4188     PROTOBUF_C_TYPE_UINT32,
4189     PROTOBUF_C_OFFSETOF(MumbleProto__RequestBlob, n_session_texture),
4190     PROTOBUF_C_OFFSETOF(MumbleProto__RequestBlob, session_texture),
4191     NULL,
4192     NULL,
4193     0,            /* packed */
4194     0,NULL,NULL    /* reserved1,reserved2, etc */
4195   },
4196   {
4197     "session_comment",
4198     2,
4199     PROTOBUF_C_LABEL_REPEATED,
4200     PROTOBUF_C_TYPE_UINT32,
4201     PROTOBUF_C_OFFSETOF(MumbleProto__RequestBlob, n_session_comment),
4202     PROTOBUF_C_OFFSETOF(MumbleProto__RequestBlob, session_comment),
4203     NULL,
4204     NULL,
4205     0,            /* packed */
4206     0,NULL,NULL    /* reserved1,reserved2, etc */
4207   },
4208   {
4209     "channel_description",
4210     3,
4211     PROTOBUF_C_LABEL_REPEATED,
4212     PROTOBUF_C_TYPE_UINT32,
4213     PROTOBUF_C_OFFSETOF(MumbleProto__RequestBlob, n_channel_description),
4214     PROTOBUF_C_OFFSETOF(MumbleProto__RequestBlob, channel_description),
4215     NULL,
4216     NULL,
4217     0,            /* packed */
4218     0,NULL,NULL    /* reserved1,reserved2, etc */
4219   },
4220 };
4221 static const unsigned mumble_proto__request_blob__field_indices_by_name[] = {
4222   2,   /* field[2] = channel_description */
4223   1,   /* field[1] = session_comment */
4224   0,   /* field[0] = session_texture */
4225 };
4226 static const ProtobufCIntRange mumble_proto__request_blob__number_ranges[1 + 1] =
4227 {
4228   { 1, 0 },
4229   { 0, 3 }
4230 };
4231 const ProtobufCMessageDescriptor mumble_proto__request_blob__descriptor =
4232 {
4233   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
4234   "MumbleProto.RequestBlob",
4235   "RequestBlob",
4236   "MumbleProto__RequestBlob",
4237   "MumbleProto",
4238   sizeof(MumbleProto__RequestBlob),
4239   3,
4240   mumble_proto__request_blob__field_descriptors,
4241   mumble_proto__request_blob__field_indices_by_name,
4242   1,  mumble_proto__request_blob__number_ranges,
4243   (ProtobufCMessageInit) mumble_proto__request_blob__init,
4244   NULL,NULL,NULL    /* reserved[123] */
4245 };