src/Mumble.pb-c.c

   1 /* Generated by the protocol buffer compiler.  DO NOT EDIT! */
   2
   3 #include "Mumble.pb-c.h"
   4 void   mumble_proto__version__init
   5                      (MumbleProto__Version         *message)
   6 {
   7   static MumbleProto__Version init_value = MUMBLE_PROTO__VERSION__INIT;
   8   *message = init_value;
   9 }
  10 size_t mumble_proto__version__get_packed_size
  11                      (const MumbleProto__Version *message)
  12 {
  13   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__version__descriptor);
  14   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  15 }
  16 size_t mumble_proto__version__pack
  17                      (const MumbleProto__Version *message,
  18                       uint8_t       *out)
  19 {
  20   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__version__descriptor);
  21   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  22 }
  23 size_t mumble_proto__version__pack_to_buffer
  24                      (const MumbleProto__Version *message,
  25                       ProtobufCBuffer *buffer)
  26 {
  27   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__version__descriptor);
  28   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  29 }
  30 MumbleProto__Version *
  31        mumble_proto__version__unpack
  32                      (ProtobufCAllocator  *allocator,
  33                       size_t               len,
  34                       const uint8_t       *data)
  35 {
  36   return (MumbleProto__Version *)
  37      protobuf_c_message_unpack (&mumble_proto__version__descriptor,
  38                                 allocator, len, data);
  39 }
  40 void   mumble_proto__version__free_unpacked
  41                      (MumbleProto__Version *message,
  42                       ProtobufCAllocator *allocator)
  43 {
  44   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__version__descriptor);
  45   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  46 }
  47 void   mumble_proto__udptunnel__init
  48                      (MumbleProto__UDPTunnel         *message)
  49 {
  50   static MumbleProto__UDPTunnel init_value = MUMBLE_PROTO__UDPTUNNEL__INIT;
  51   *message = init_value;
  52 }
  53 size_t mumble_proto__udptunnel__get_packed_size
  54                      (const MumbleProto__UDPTunnel *message)
  55 {
  56   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  57   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  58 }
  59 size_t mumble_proto__udptunnel__pack
  60                      (const MumbleProto__UDPTunnel *message,
  61                       uint8_t       *out)
  62 {
  63   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  64   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  65 }
  66 size_t mumble_proto__udptunnel__pack_to_buffer
  67                      (const MumbleProto__UDPTunnel *message,
  68                       ProtobufCBuffer *buffer)
  69 {
  70   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  71   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  72 }
  73 MumbleProto__UDPTunnel *
  74        mumble_proto__udptunnel__unpack
  75                      (ProtobufCAllocator  *allocator,
  76                       size_t               len,
  77                       const uint8_t       *data)
  78 {
  79   return (MumbleProto__UDPTunnel *)
  80      protobuf_c_message_unpack (&mumble_proto__udptunnel__descriptor,
  81                                 allocator, len, data);
  82 }
  83 void   mumble_proto__udptunnel__free_unpacked
  84                      (MumbleProto__UDPTunnel *message,
  85                       ProtobufCAllocator *allocator)
  86 {
  87   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__udptunnel__descriptor);
  88   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  89 }
  90 void   mumble_proto__authenticate__init
  91                      (MumbleProto__Authenticate         *message)
  92 {
  93   static MumbleProto__Authenticate init_value = MUMBLE_PROTO__AUTHENTICATE__INIT;
  94   *message = init_value;
  95 }
  96 size_t mumble_proto__authenticate__get_packed_size
  97                      (const MumbleProto__Authenticate *message)
  98 {
  99   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__authenticate__descriptor);
 100   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 101 }
 102 size_t mumble_proto__authenticate__pack
 103                      (const MumbleProto__Authenticate *message,
 104                       uint8_t       *out)
 105 {
 106   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__authenticate__descriptor);
 107   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 108 }
 109 size_t mumble_proto__authenticate__pack_to_buffer
 110                      (const MumbleProto__Authenticate *message,
 111                       ProtobufCBuffer *buffer)
 112 {
 113   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__authenticate__descriptor);
 114   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 115 }
 116 MumbleProto__Authenticate *
 117        mumble_proto__authenticate__unpack
 118                      (ProtobufCAllocator  *allocator,
 119                       size_t               len,
 120                       const uint8_t       *data)
 121 {
 122   return (MumbleProto__Authenticate *)
 123      protobuf_c_message_unpack (&mumble_proto__authenticate__descriptor,
 124                                 allocator, len, data);
 125 }
 126 void   mumble_proto__authenticate__free_unpacked
 127                      (MumbleProto__Authenticate *message,
 128                       ProtobufCAllocator *allocator)
 129 {
 130   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__authenticate__descriptor);
 131   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 132 }
 133 void   mumble_proto__ping__init
 134                      (MumbleProto__Ping         *message)
 135 {
 136   static MumbleProto__Ping init_value = MUMBLE_PROTO__PING__INIT;
 137   *message = init_value;
 138 }
 139 size_t mumble_proto__ping__get_packed_size
 140                      (const MumbleProto__Ping *message)
 141 {
 142   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ping__descriptor);
 143   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 144 }
 145 size_t mumble_proto__ping__pack
 146                      (const MumbleProto__Ping *message,
 147                       uint8_t       *out)
 148 {
 149   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ping__descriptor);
 150   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 151 }
 152 size_t mumble_proto__ping__pack_to_buffer
 153                      (const MumbleProto__Ping *message,
 154                       ProtobufCBuffer *buffer)
 155 {
 156   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ping__descriptor);
 157   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 158 }
 159 MumbleProto__Ping *
 160        mumble_proto__ping__unpack
 161                      (ProtobufCAllocator  *allocator,
 162                       size_t               len,
 163                       const uint8_t       *data)
 164 {
 165   return (MumbleProto__Ping *)
 166      protobuf_c_message_unpack (&mumble_proto__ping__descriptor,
 167                                 allocator, len, data);
 168 }
 169 void   mumble_proto__ping__free_unpacked
 170                      (MumbleProto__Ping *message,
 171                       ProtobufCAllocator *allocator)
 172 {
 173   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ping__descriptor);
 174   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 175 }
 176 void   mumble_proto__reject__init
 177                      (MumbleProto__Reject         *message)
 178 {
 179   static MumbleProto__Reject init_value = MUMBLE_PROTO__REJECT__INIT;
 180   *message = init_value;
 181 }
 182 size_t mumble_proto__reject__get_packed_size
 183                      (const MumbleProto__Reject *message)
 184 {
 185   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__reject__descriptor);
 186   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 187 }
 188 size_t mumble_proto__reject__pack
 189                      (const MumbleProto__Reject *message,
 190                       uint8_t       *out)
 191 {
 192   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__reject__descriptor);
 193   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 194 }
 195 size_t mumble_proto__reject__pack_to_buffer
 196                      (const MumbleProto__Reject *message,
 197                       ProtobufCBuffer *buffer)
 198 {
 199   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__reject__descriptor);
 200   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 201 }
 202 MumbleProto__Reject *
 203        mumble_proto__reject__unpack
 204                      (ProtobufCAllocator  *allocator,
 205                       size_t               len,
 206                       const uint8_t       *data)
 207 {
 208   return (MumbleProto__Reject *)
 209      protobuf_c_message_unpack (&mumble_proto__reject__descriptor,
 210                                 allocator, len, data);
 211 }
 212 void   mumble_proto__reject__free_unpacked
 213                      (MumbleProto__Reject *message,
 214                       ProtobufCAllocator *allocator)
 215 {
 216   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__reject__descriptor);
 217   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 218 }
 219 void   mumble_proto__server_sync__init
 220                      (MumbleProto__ServerSync         *message)
 221 {
 222   static MumbleProto__ServerSync init_value = MUMBLE_PROTO__SERVER_SYNC__INIT;
 223   *message = init_value;
 224 }
 225 size_t mumble_proto__server_sync__get_packed_size
 226                      (const MumbleProto__ServerSync *message)
 227 {
 228   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_sync__descriptor);
 229   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 230 }
 231 size_t mumble_proto__server_sync__pack
 232                      (const MumbleProto__ServerSync *message,
 233                       uint8_t       *out)
 234 {
 235   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_sync__descriptor);
 236   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 237 }
 238 size_t mumble_proto__server_sync__pack_to_buffer
 239                      (const MumbleProto__ServerSync *message,
 240                       ProtobufCBuffer *buffer)
 241 {
 242   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_sync__descriptor);
 243   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 244 }
 245 MumbleProto__ServerSync *
 246        mumble_proto__server_sync__unpack
 247                      (ProtobufCAllocator  *allocator,
 248                       size_t               len,
 249                       const uint8_t       *data)
 250 {
 251   return (MumbleProto__ServerSync *)
 252      protobuf_c_message_unpack (&mumble_proto__server_sync__descriptor,
 253                                 allocator, len, data);
 254 }
 255 void   mumble_proto__server_sync__free_unpacked
 256                      (MumbleProto__ServerSync *message,
 257                       ProtobufCAllocator *allocator)
 258 {
 259   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_sync__descriptor);
 260   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 261 }
 262 void   mumble_proto__channel_remove__init
 263                      (MumbleProto__ChannelRemove         *message)
 264 {
 265   static MumbleProto__ChannelRemove init_value = MUMBLE_PROTO__CHANNEL_REMOVE__INIT;
 266   *message = init_value;
 267 }
 268 size_t mumble_proto__channel_remove__get_packed_size
 269                      (const MumbleProto__ChannelRemove *message)
 270 {
 271   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_remove__descriptor);
 272   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 273 }
 274 size_t mumble_proto__channel_remove__pack
 275                      (const MumbleProto__ChannelRemove *message,
 276                       uint8_t       *out)
 277 {
 278   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_remove__descriptor);
 279   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 280 }
 281 size_t mumble_proto__channel_remove__pack_to_buffer
 282                      (const MumbleProto__ChannelRemove *message,
 283                       ProtobufCBuffer *buffer)
 284 {
 285   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_remove__descriptor);
 286   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 287 }
 288 MumbleProto__ChannelRemove *
 289        mumble_proto__channel_remove__unpack
 290                      (ProtobufCAllocator  *allocator,
 291                       size_t               len,
 292                       const uint8_t       *data)
 293 {
 294   return (MumbleProto__ChannelRemove *)
 295      protobuf_c_message_unpack (&mumble_proto__channel_remove__descriptor,
 296                                 allocator, len, data);
 297 }
 298 void   mumble_proto__channel_remove__free_unpacked
 299                      (MumbleProto__ChannelRemove *message,
 300                       ProtobufCAllocator *allocator)
 301 {
 302   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_remove__descriptor);
 303   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 304 }
 305 void   mumble_proto__channel_state__init
 306                      (MumbleProto__ChannelState         *message)
 307 {
 308   static MumbleProto__ChannelState init_value = MUMBLE_PROTO__CHANNEL_STATE__INIT;
 309   *message = init_value;
 310 }
 311 size_t mumble_proto__channel_state__get_packed_size
 312                      (const MumbleProto__ChannelState *message)
 313 {
 314   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_state__descriptor);
 315   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 316 }
 317 size_t mumble_proto__channel_state__pack
 318                      (const MumbleProto__ChannelState *message,
 319                       uint8_t       *out)
 320 {
 321   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_state__descriptor);
 322   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 323 }
 324 size_t mumble_proto__channel_state__pack_to_buffer
 325                      (const MumbleProto__ChannelState *message,
 326                       ProtobufCBuffer *buffer)
 327 {
 328   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_state__descriptor);
 329   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 330 }
 331 MumbleProto__ChannelState *
 332        mumble_proto__channel_state__unpack
 333                      (ProtobufCAllocator  *allocator,
 334                       size_t               len,
 335                       const uint8_t       *data)
 336 {
 337   return (MumbleProto__ChannelState *)
 338      protobuf_c_message_unpack (&mumble_proto__channel_state__descriptor,
 339                                 allocator, len, data);
 340 }
 341 void   mumble_proto__channel_state__free_unpacked
 342                      (MumbleProto__ChannelState *message,
 343                       ProtobufCAllocator *allocator)
 344 {
 345   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__channel_state__descriptor);
 346   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 347 }
 348 void   mumble_proto__user_remove__init
 349                      (MumbleProto__UserRemove         *message)
 350 {
 351   static MumbleProto__UserRemove init_value = MUMBLE_PROTO__USER_REMOVE__INIT;
 352   *message = init_value;
 353 }
 354 size_t mumble_proto__user_remove__get_packed_size
 355                      (const MumbleProto__UserRemove *message)
 356 {
 357   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_remove__descriptor);
 358   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 359 }
 360 size_t mumble_proto__user_remove__pack
 361                      (const MumbleProto__UserRemove *message,
 362                       uint8_t       *out)
 363 {
 364   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_remove__descriptor);
 365   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 366 }
 367 size_t mumble_proto__user_remove__pack_to_buffer
 368                      (const MumbleProto__UserRemove *message,
 369                       ProtobufCBuffer *buffer)
 370 {
 371   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_remove__descriptor);
 372   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 373 }
 374 MumbleProto__UserRemove *
 375        mumble_proto__user_remove__unpack
 376                      (ProtobufCAllocator  *allocator,
 377                       size_t               len,
 378                       const uint8_t       *data)
 379 {
 380   return (MumbleProto__UserRemove *)
 381      protobuf_c_message_unpack (&mumble_proto__user_remove__descriptor,
 382                                 allocator, len, data);
 383 }
 384 void   mumble_proto__user_remove__free_unpacked
 385                      (MumbleProto__UserRemove *message,
 386                       ProtobufCAllocator *allocator)
 387 {
 388   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_remove__descriptor);
 389   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 390 }
 391 void   mumble_proto__user_state__init
 392                      (MumbleProto__UserState         *message)
 393 {
 394   static MumbleProto__UserState init_value = MUMBLE_PROTO__USER_STATE__INIT;
 395   *message = init_value;
 396 }
 397 size_t mumble_proto__user_state__get_packed_size
 398                      (const MumbleProto__UserState *message)
 399 {
 400   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_state__descriptor);
 401   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 402 }
 403 size_t mumble_proto__user_state__pack
 404                      (const MumbleProto__UserState *message,
 405                       uint8_t       *out)
 406 {
 407   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_state__descriptor);
 408   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 409 }
 410 size_t mumble_proto__user_state__pack_to_buffer
 411                      (const MumbleProto__UserState *message,
 412                       ProtobufCBuffer *buffer)
 413 {
 414   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_state__descriptor);
 415   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 416 }
 417 MumbleProto__UserState *
 418        mumble_proto__user_state__unpack
 419                      (ProtobufCAllocator  *allocator,
 420                       size_t               len,
 421                       const uint8_t       *data)
 422 {
 423   return (MumbleProto__UserState *)
 424      protobuf_c_message_unpack (&mumble_proto__user_state__descriptor,
 425                                 allocator, len, data);
 426 }
 427 void   mumble_proto__user_state__free_unpacked
 428                      (MumbleProto__UserState *message,
 429                       ProtobufCAllocator *allocator)
 430 {
 431   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_state__descriptor);
 432   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 433 }
 434 void   mumble_proto__ban_list__init
 435                      (MumbleProto__BanList         *message)
 436 {
 437   static MumbleProto__BanList init_value = MUMBLE_PROTO__BAN_LIST__INIT;
 438   *message = init_value;
 439 }
 440 size_t mumble_proto__ban_list__get_packed_size
 441                      (const MumbleProto__BanList *message)
 442 {
 443   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ban_list__descriptor);
 444   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 445 }
 446 size_t mumble_proto__ban_list__pack
 447                      (const MumbleProto__BanList *message,
 448                       uint8_t       *out)
 449 {
 450   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ban_list__descriptor);
 451   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 452 }
 453 size_t mumble_proto__ban_list__pack_to_buffer
 454                      (const MumbleProto__BanList *message,
 455                       ProtobufCBuffer *buffer)
 456 {
 457   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ban_list__descriptor);
 458   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 459 }
 460 MumbleProto__BanList *
 461        mumble_proto__ban_list__unpack
 462                      (ProtobufCAllocator  *allocator,
 463                       size_t               len,
 464                       const uint8_t       *data)
 465 {
 466   return (MumbleProto__BanList *)
 467      protobuf_c_message_unpack (&mumble_proto__ban_list__descriptor,
 468                                 allocator, len, data);
 469 }
 470 void   mumble_proto__ban_list__free_unpacked
 471                      (MumbleProto__BanList *message,
 472                       ProtobufCAllocator *allocator)
 473 {
 474   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__ban_list__descriptor);
 475   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 476 }
 477 void   mumble_proto__text_message__init
 478                      (MumbleProto__TextMessage         *message)
 479 {
 480   static MumbleProto__TextMessage init_value = MUMBLE_PROTO__TEXT_MESSAGE__INIT;
 481   *message = init_value;
 482 }
 483 size_t mumble_proto__text_message__get_packed_size
 484                      (const MumbleProto__TextMessage *message)
 485 {
 486   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__text_message__descriptor);
 487   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 488 }
 489 size_t mumble_proto__text_message__pack
 490                      (const MumbleProto__TextMessage *message,
 491                       uint8_t       *out)
 492 {
 493   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__text_message__descriptor);
 494   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 495 }
 496 size_t mumble_proto__text_message__pack_to_buffer
 497                      (const MumbleProto__TextMessage *message,
 498                       ProtobufCBuffer *buffer)
 499 {
 500   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__text_message__descriptor);
 501   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 502 }
 503 MumbleProto__TextMessage *
 504        mumble_proto__text_message__unpack
 505                      (ProtobufCAllocator  *allocator,
 506                       size_t               len,
 507                       const uint8_t       *data)
 508 {
 509   return (MumbleProto__TextMessage *)
 510      protobuf_c_message_unpack (&mumble_proto__text_message__descriptor,
 511                                 allocator, len, data);
 512 }
 513 void   mumble_proto__text_message__free_unpacked
 514                      (MumbleProto__TextMessage *message,
 515                       ProtobufCAllocator *allocator)
 516 {
 517   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__text_message__descriptor);
 518   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 519 }
 520 void   mumble_proto__permission_denied__init
 521                      (MumbleProto__PermissionDenied         *message)
 522 {
 523   static MumbleProto__PermissionDenied init_value = MUMBLE_PROTO__PERMISSION_DENIED__INIT;
 524   *message = init_value;
 525 }
 526 size_t mumble_proto__permission_denied__get_packed_size
 527                      (const MumbleProto__PermissionDenied *message)
 528 {
 529   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_denied__descriptor);
 530   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 531 }
 532 size_t mumble_proto__permission_denied__pack
 533                      (const MumbleProto__PermissionDenied *message,
 534                       uint8_t       *out)
 535 {
 536   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_denied__descriptor);
 537   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 538 }
 539 size_t mumble_proto__permission_denied__pack_to_buffer
 540                      (const MumbleProto__PermissionDenied *message,
 541                       ProtobufCBuffer *buffer)
 542 {
 543   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_denied__descriptor);
 544   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 545 }
 546 MumbleProto__PermissionDenied *
 547        mumble_proto__permission_denied__unpack
 548                      (ProtobufCAllocator  *allocator,
 549                       size_t               len,
 550                       const uint8_t       *data)
 551 {
 552   return (MumbleProto__PermissionDenied *)
 553      protobuf_c_message_unpack (&mumble_proto__permission_denied__descriptor,
 554                                 allocator, len, data);
 555 }
 556 void   mumble_proto__permission_denied__free_unpacked
 557                      (MumbleProto__PermissionDenied *message,
 558                       ProtobufCAllocator *allocator)
 559 {
 560   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_denied__descriptor);
 561   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 562 }
 563 void   mumble_proto__acl__init
 564                      (MumbleProto__ACL         *message)
 565 {
 566   static MumbleProto__ACL init_value = MUMBLE_PROTO__ACL__INIT;
 567   *message = init_value;
 568 }
 569 size_t mumble_proto__acl__get_packed_size
 570                      (const MumbleProto__ACL *message)
 571 {
 572   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__acl__descriptor);
 573   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 574 }
 575 size_t mumble_proto__acl__pack
 576                      (const MumbleProto__ACL *message,
 577                       uint8_t       *out)
 578 {
 579   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__acl__descriptor);
 580   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 581 }
 582 size_t mumble_proto__acl__pack_to_buffer
 583                      (const MumbleProto__ACL *message,
 584                       ProtobufCBuffer *buffer)
 585 {
 586   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__acl__descriptor);
 587   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 588 }
 589 MumbleProto__ACL *
 590        mumble_proto__acl__unpack
 591                      (ProtobufCAllocator  *allocator,
 592                       size_t               len,
 593                       const uint8_t       *data)
 594 {
 595   return (MumbleProto__ACL *)
 596      protobuf_c_message_unpack (&mumble_proto__acl__descriptor,
 597                                 allocator, len, data);
 598 }
 599 void   mumble_proto__acl__free_unpacked
 600                      (MumbleProto__ACL *message,
 601                       ProtobufCAllocator *allocator)
 602 {
 603   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__acl__descriptor);
 604   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 605 }
 606 void   mumble_proto__query_users__init
 607                      (MumbleProto__QueryUsers         *message)
 608 {
 609   static MumbleProto__QueryUsers init_value = MUMBLE_PROTO__QUERY_USERS__INIT;
 610   *message = init_value;
 611 }
 612 size_t mumble_proto__query_users__get_packed_size
 613                      (const MumbleProto__QueryUsers *message)
 614 {
 615   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__query_users__descriptor);
 616   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 617 }
 618 size_t mumble_proto__query_users__pack
 619                      (const MumbleProto__QueryUsers *message,
 620                       uint8_t       *out)
 621 {
 622   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__query_users__descriptor);
 623   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 624 }
 625 size_t mumble_proto__query_users__pack_to_buffer
 626                      (const MumbleProto__QueryUsers *message,
 627                       ProtobufCBuffer *buffer)
 628 {
 629   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__query_users__descriptor);
 630   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 631 }
 632 MumbleProto__QueryUsers *
 633        mumble_proto__query_users__unpack
 634                      (ProtobufCAllocator  *allocator,
 635                       size_t               len,
 636                       const uint8_t       *data)
 637 {
 638   return (MumbleProto__QueryUsers *)
 639      protobuf_c_message_unpack (&mumble_proto__query_users__descriptor,
 640                                 allocator, len, data);
 641 }
 642 void   mumble_proto__query_users__free_unpacked
 643                      (MumbleProto__QueryUsers *message,
 644                       ProtobufCAllocator *allocator)
 645 {
 646   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__query_users__descriptor);
 647   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 648 }
 649 void   mumble_proto__crypt_setup__init
 650                      (MumbleProto__CryptSetup         *message)
 651 {
 652   static MumbleProto__CryptSetup init_value = MUMBLE_PROTO__CRYPT_SETUP__INIT;
 653   *message = init_value;
 654 }
 655 size_t mumble_proto__crypt_setup__get_packed_size
 656                      (const MumbleProto__CryptSetup *message)
 657 {
 658   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
 659   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 660 }
 661 size_t mumble_proto__crypt_setup__pack
 662                      (const MumbleProto__CryptSetup *message,
 663                       uint8_t       *out)
 664 {
 665   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
 666   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 667 }
 668 size_t mumble_proto__crypt_setup__pack_to_buffer
 669                      (const MumbleProto__CryptSetup *message,
 670                       ProtobufCBuffer *buffer)
 671 {
 672   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
 673   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 674 }
 675 MumbleProto__CryptSetup *
 676        mumble_proto__crypt_setup__unpack
 677                      (ProtobufCAllocator  *allocator,
 678                       size_t               len,
 679                       const uint8_t       *data)
 680 {
 681   return (MumbleProto__CryptSetup *)
 682      protobuf_c_message_unpack (&mumble_proto__crypt_setup__descriptor,
 683                                 allocator, len, data);
 684 }
 685 void   mumble_proto__crypt_setup__free_unpacked
 686                      (MumbleProto__CryptSetup *message,
 687                       ProtobufCAllocator *allocator)
 688 {
 689   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
 690   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 691 }
 692 void   mumble_proto__context_action_add__init
 693                      (MumbleProto__ContextActionAdd         *message)
 694 {
 695   static MumbleProto__ContextActionAdd init_value = MUMBLE_PROTO__CONTEXT_ACTION_ADD__INIT;
 696   *message = init_value;
 697 }
 698 size_t mumble_proto__context_action_add__get_packed_size
 699                      (const MumbleProto__ContextActionAdd *message)
 700 {
 701   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action_add__descriptor);
 702   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 703 }
 704 size_t mumble_proto__context_action_add__pack
 705                      (const MumbleProto__ContextActionAdd *message,
 706                       uint8_t       *out)
 707 {
 708   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action_add__descriptor);
 709   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 710 }
 711 size_t mumble_proto__context_action_add__pack_to_buffer
 712                      (const MumbleProto__ContextActionAdd *message,
 713                       ProtobufCBuffer *buffer)
 714 {
 715   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action_add__descriptor);
 716   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 717 }
 718 MumbleProto__ContextActionAdd *
 719        mumble_proto__context_action_add__unpack
 720                      (ProtobufCAllocator  *allocator,
 721                       size_t               len,
 722                       const uint8_t       *data)
 723 {
 724   return (MumbleProto__ContextActionAdd *)
 725      protobuf_c_message_unpack (&mumble_proto__context_action_add__descriptor,
 726                                 allocator, len, data);
 727 }
 728 void   mumble_proto__context_action_add__free_unpacked
 729                      (MumbleProto__ContextActionAdd *message,
 730                       ProtobufCAllocator *allocator)
 731 {
 732   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action_add__descriptor);
 733   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 734 }
 735 void   mumble_proto__context_action__init
 736                      (MumbleProto__ContextAction         *message)
 737 {
 738   static MumbleProto__ContextAction init_value = MUMBLE_PROTO__CONTEXT_ACTION__INIT;
 739   *message = init_value;
 740 }
 741 size_t mumble_proto__context_action__get_packed_size
 742                      (const MumbleProto__ContextAction *message)
 743 {
 744   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action__descriptor);
 745   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 746 }
 747 size_t mumble_proto__context_action__pack
 748                      (const MumbleProto__ContextAction *message,
 749                       uint8_t       *out)
 750 {
 751   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action__descriptor);
 752   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 753 }
 754 size_t mumble_proto__context_action__pack_to_buffer
 755                      (const MumbleProto__ContextAction *message,
 756                       ProtobufCBuffer *buffer)
 757 {
 758   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action__descriptor);
 759   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 760 }
 761 MumbleProto__ContextAction *
 762        mumble_proto__context_action__unpack
 763                      (ProtobufCAllocator  *allocator,
 764                       size_t               len,
 765                       const uint8_t       *data)
 766 {
 767   return (MumbleProto__ContextAction *)
 768      protobuf_c_message_unpack (&mumble_proto__context_action__descriptor,
 769                                 allocator, len, data);
 770 }
 771 void   mumble_proto__context_action__free_unpacked
 772                      (MumbleProto__ContextAction *message,
 773                       ProtobufCAllocator *allocator)
 774 {
 775   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__context_action__descriptor);
 776   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 777 }
 778 void   mumble_proto__user_list__init
 779                      (MumbleProto__UserList         *message)
 780 {
 781   static MumbleProto__UserList init_value = MUMBLE_PROTO__USER_LIST__INIT;
 782   *message = init_value;
 783 }
 784 size_t mumble_proto__user_list__get_packed_size
 785                      (const MumbleProto__UserList *message)
 786 {
 787   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_list__descriptor);
 788   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 789 }
 790 size_t mumble_proto__user_list__pack
 791                      (const MumbleProto__UserList *message,
 792                       uint8_t       *out)
 793 {
 794   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_list__descriptor);
 795   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 796 }
 797 size_t mumble_proto__user_list__pack_to_buffer
 798                      (const MumbleProto__UserList *message,
 799                       ProtobufCBuffer *buffer)
 800 {
 801   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_list__descriptor);
 802   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 803 }
 804 MumbleProto__UserList *
 805        mumble_proto__user_list__unpack
 806                      (ProtobufCAllocator  *allocator,
 807                       size_t               len,
 808                       const uint8_t       *data)
 809 {
 810   return (MumbleProto__UserList *)
 811      protobuf_c_message_unpack (&mumble_proto__user_list__descriptor,
 812                                 allocator, len, data);
 813 }
 814 void   mumble_proto__user_list__free_unpacked
 815                      (MumbleProto__UserList *message,
 816                       ProtobufCAllocator *allocator)
 817 {
 818   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_list__descriptor);
 819   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 820 }
 821 void   mumble_proto__voice_target__init
 822                      (MumbleProto__VoiceTarget         *message)
 823 {
 824   static MumbleProto__VoiceTarget init_value = MUMBLE_PROTO__VOICE_TARGET__INIT;
 825   *message = init_value;
 826 }
 827 size_t mumble_proto__voice_target__get_packed_size
 828                      (const MumbleProto__VoiceTarget *message)
 829 {
 830   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__voice_target__descriptor);
 831   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 832 }
 833 size_t mumble_proto__voice_target__pack
 834                      (const MumbleProto__VoiceTarget *message,
 835                       uint8_t       *out)
 836 {
 837   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__voice_target__descriptor);
 838   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 839 }
 840 size_t mumble_proto__voice_target__pack_to_buffer
 841                      (const MumbleProto__VoiceTarget *message,
 842                       ProtobufCBuffer *buffer)
 843 {
 844   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__voice_target__descriptor);
 845   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 846 }
 847 MumbleProto__VoiceTarget *
 848        mumble_proto__voice_target__unpack
 849                      (ProtobufCAllocator  *allocator,
 850                       size_t               len,
 851                       const uint8_t       *data)
 852 {
 853   return (MumbleProto__VoiceTarget *)
 854      protobuf_c_message_unpack (&mumble_proto__voice_target__descriptor,
 855                                 allocator, len, data);
 856 }
 857 void   mumble_proto__voice_target__free_unpacked
 858                      (MumbleProto__VoiceTarget *message,
 859                       ProtobufCAllocator *allocator)
 860 {
 861   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__voice_target__descriptor);
 862   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 863 }
 864 void   mumble_proto__permission_query__init
 865                      (MumbleProto__PermissionQuery         *message)
 866 {
 867   static MumbleProto__PermissionQuery init_value = MUMBLE_PROTO__PERMISSION_QUERY__INIT;
 868   *message = init_value;
 869 }
 870 size_t mumble_proto__permission_query__get_packed_size
 871                      (const MumbleProto__PermissionQuery *message)
 872 {
 873   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_query__descriptor);
 874   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 875 }
 876 size_t mumble_proto__permission_query__pack
 877                      (const MumbleProto__PermissionQuery *message,
 878                       uint8_t       *out)
 879 {
 880   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_query__descriptor);
 881   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 882 }
 883 size_t mumble_proto__permission_query__pack_to_buffer
 884                      (const MumbleProto__PermissionQuery *message,
 885                       ProtobufCBuffer *buffer)
 886 {
 887   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_query__descriptor);
 888   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 889 }
 890 MumbleProto__PermissionQuery *
 891        mumble_proto__permission_query__unpack
 892                      (ProtobufCAllocator  *allocator,
 893                       size_t               len,
 894                       const uint8_t       *data)
 895 {
 896   return (MumbleProto__PermissionQuery *)
 897      protobuf_c_message_unpack (&mumble_proto__permission_query__descriptor,
 898                                 allocator, len, data);
 899 }
 900 void   mumble_proto__permission_query__free_unpacked
 901                      (MumbleProto__PermissionQuery *message,
 902                       ProtobufCAllocator *allocator)
 903 {
 904   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__permission_query__descriptor);
 905   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 906 }
 907 void   mumble_proto__codec_version__init
 908                      (MumbleProto__CodecVersion         *message)
 909 {
 910   static MumbleProto__CodecVersion init_value = MUMBLE_PROTO__CODEC_VERSION__INIT;
 911   *message = init_value;
 912 }
 913 size_t mumble_proto__codec_version__get_packed_size
 914                      (const MumbleProto__CodecVersion *message)
 915 {
 916   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__codec_version__descriptor);
 917   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 918 }
 919 size_t mumble_proto__codec_version__pack
 920                      (const MumbleProto__CodecVersion *message,
 921                       uint8_t       *out)
 922 {
 923   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__codec_version__descriptor);
 924   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 925 }
 926 size_t mumble_proto__codec_version__pack_to_buffer
 927                      (const MumbleProto__CodecVersion *message,
 928                       ProtobufCBuffer *buffer)
 929 {
 930   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__codec_version__descriptor);
 931   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 932 }
 933 MumbleProto__CodecVersion *
 934        mumble_proto__codec_version__unpack
 935                      (ProtobufCAllocator  *allocator,
 936                       size_t               len,
 937                       const uint8_t       *data)
 938 {
 939   return (MumbleProto__CodecVersion *)
 940      protobuf_c_message_unpack (&mumble_proto__codec_version__descriptor,
 941                                 allocator, len, data);
 942 }
 943 void   mumble_proto__codec_version__free_unpacked
 944                      (MumbleProto__CodecVersion *message,
 945                       ProtobufCAllocator *allocator)
 946 {
 947   PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__codec_version__descriptor);
 948   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 949 }
 950 static const ProtobufCFieldDescriptor mumble_proto__version__field_descriptors[4] =
 951 {
 952   {
 953     "version",
 954     1,
 955     PROTOBUF_C_LABEL_OPTIONAL,
 956     PROTOBUF_C_TYPE_UINT32,
 957     PROTOBUF_C_OFFSETOF(MumbleProto__Version, has_version),
 958     PROTOBUF_C_OFFSETOF(MumbleProto__Version, version),
 959     NULL,
 960     NULL,
 961     NULL,NULL    /* reserved1, reserved2 */
 962   },
 963   {
 964     "release",
 965     2,
 966     PROTOBUF_C_LABEL_OPTIONAL,
 967     PROTOBUF_C_TYPE_STRING,
 968     0,   /* quantifier_offset */
 969     PROTOBUF_C_OFFSETOF(MumbleProto__Version, release),
 970     NULL,
 971     NULL,
 972     NULL,NULL    /* reserved1, reserved2 */
 973   },
 974   {
 975     "os",
 976     3,
 977     PROTOBUF_C_LABEL_OPTIONAL,
 978     PROTOBUF_C_TYPE_STRING,
 979     0,   /* quantifier_offset */
 980     PROTOBUF_C_OFFSETOF(MumbleProto__Version, os),
 981     NULL,
 982     NULL,
 983     NULL,NULL    /* reserved1, reserved2 */
 984   },
 985   {
 986     "os_version",
 987     4,
 988     PROTOBUF_C_LABEL_OPTIONAL,
 989     PROTOBUF_C_TYPE_STRING,
 990     0,   /* quantifier_offset */
 991     PROTOBUF_C_OFFSETOF(MumbleProto__Version, os_version),
 992     NULL,
 993     NULL,
 994     NULL,NULL    /* reserved1, reserved2 */
 995   },
 996 };
 997 static const unsigned mumble_proto__version__field_indices_by_name[] = {
 998   2,   /* field[2] = os */
 999   3,   /* field[3] = os_version */
1000   1,   /* field[1] = release */
1001   0,   /* field[0] = version */
1002 };
1003 static const ProtobufCIntRange mumble_proto__version__number_ranges[1 + 1] =
1004 {
1005   { 1, 0 },
1006   { 0, 4 }
1007 };
1008 const ProtobufCMessageDescriptor mumble_proto__version__descriptor =
1009 {
1010   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1011   "MumbleProto.Version",
1012   "Version",
1013   "MumbleProto__Version",
1014   "MumbleProto",
1015   sizeof(MumbleProto__Version),
1016   4,
1017   mumble_proto__version__field_descriptors,
1018   mumble_proto__version__field_indices_by_name,
1019   1,  mumble_proto__version__number_ranges,
1020   NULL,NULL,NULL,NULL    /* reserved[1234] */
1021 };
1022 static const ProtobufCFieldDescriptor mumble_proto__udptunnel__field_descriptors[1] =
1023 {
1024   {
1025     "packet",
1026     1,
1027     PROTOBUF_C_LABEL_REQUIRED,
1028     PROTOBUF_C_TYPE_BYTES,
1029     0,   /* quantifier_offset */
1030     PROTOBUF_C_OFFSETOF(MumbleProto__UDPTunnel, packet),
1031     NULL,
1032     NULL,
1033     NULL,NULL    /* reserved1, reserved2 */
1034   },
1035 };
1036 static const unsigned mumble_proto__udptunnel__field_indices_by_name[] = {
1037   0,   /* field[0] = packet */
1038 };
1039 static const ProtobufCIntRange mumble_proto__udptunnel__number_ranges[1 + 1] =
1040 {
1041   { 1, 0 },
1042   { 0, 1 }
1043 };
1044 const ProtobufCMessageDescriptor mumble_proto__udptunnel__descriptor =
1045 {
1046   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1047   "MumbleProto.UDPTunnel",
1048   "UDPTunnel",
1049   "MumbleProto__UDPTunnel",
1050   "MumbleProto",
1051   sizeof(MumbleProto__UDPTunnel),
1052   1,
1053   mumble_proto__udptunnel__field_descriptors,
1054   mumble_proto__udptunnel__field_indices_by_name,
1055   1,  mumble_proto__udptunnel__number_ranges,
1056   NULL,NULL,NULL,NULL    /* reserved[1234] */
1057 };
1058 static const ProtobufCFieldDescriptor mumble_proto__authenticate__field_descriptors[4] =
1059 {
1060   {
1061     "username",
1062     1,
1063     PROTOBUF_C_LABEL_OPTIONAL,
1064     PROTOBUF_C_TYPE_STRING,
1065     0,   /* quantifier_offset */
1066     PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, username),
1067     NULL,
1068     NULL,
1069     NULL,NULL    /* reserved1, reserved2 */
1070   },
1071   {
1072     "password",
1073     2,
1074     PROTOBUF_C_LABEL_OPTIONAL,
1075     PROTOBUF_C_TYPE_STRING,
1076     0,   /* quantifier_offset */
1077     PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, password),
1078     NULL,
1079     NULL,
1080     NULL,NULL    /* reserved1, reserved2 */
1081   },
1082   {
1083     "tokens",
1084     3,
1085     PROTOBUF_C_LABEL_REPEATED,
1086     PROTOBUF_C_TYPE_STRING,
1087     PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, n_tokens),
1088     PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, tokens),
1089     NULL,
1090     NULL,
1091     NULL,NULL    /* reserved1, reserved2 */
1092   },
1093   {
1094     "celt_versions",
1095     4,
1096     PROTOBUF_C_LABEL_REPEATED,
1097     PROTOBUF_C_TYPE_INT32,
1098     PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, n_celt_versions),
1099     PROTOBUF_C_OFFSETOF(MumbleProto__Authenticate, celt_versions),
1100     NULL,
1101     NULL,
1102     NULL,NULL    /* reserved1, reserved2 */
1103   },
1104 };
1105 static const unsigned mumble_proto__authenticate__field_indices_by_name[] = {
1106   3,   /* field[3] = celt_versions */
1107   1,   /* field[1] = password */
1108   2,   /* field[2] = tokens */
1109   0,   /* field[0] = username */
1110 };
1111 static const ProtobufCIntRange mumble_proto__authenticate__number_ranges[1 + 1] =
1112 {
1113   { 1, 0 },
1114   { 0, 4 }
1115 };
1116 const ProtobufCMessageDescriptor mumble_proto__authenticate__descriptor =
1117 {
1118   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1119   "MumbleProto.Authenticate",
1120   "Authenticate",
1121   "MumbleProto__Authenticate",
1122   "MumbleProto",
1123   sizeof(MumbleProto__Authenticate),
1124   4,
1125   mumble_proto__authenticate__field_descriptors,
1126   mumble_proto__authenticate__field_indices_by_name,
1127   1,  mumble_proto__authenticate__number_ranges,
1128   NULL,NULL,NULL,NULL    /* reserved[1234] */
1129 };
1130 static const ProtobufCFieldDescriptor mumble_proto__ping__field_descriptors[11] =
1131 {
1132   {
1133     "timestamp",
1134     1,
1135     PROTOBUF_C_LABEL_OPTIONAL,
1136     PROTOBUF_C_TYPE_UINT64,
1137     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_timestamp),
1138     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, timestamp),
1139     NULL,
1140     NULL,
1141     NULL,NULL    /* reserved1, reserved2 */
1142   },
1143   {
1144     "good",
1145     2,
1146     PROTOBUF_C_LABEL_OPTIONAL,
1147     PROTOBUF_C_TYPE_UINT32,
1148     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_good),
1149     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, good),
1150     NULL,
1151     NULL,
1152     NULL,NULL    /* reserved1, reserved2 */
1153   },
1154   {
1155     "late",
1156     3,
1157     PROTOBUF_C_LABEL_OPTIONAL,
1158     PROTOBUF_C_TYPE_UINT32,
1159     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_late),
1160     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, late),
1161     NULL,
1162     NULL,
1163     NULL,NULL    /* reserved1, reserved2 */
1164   },
1165   {
1166     "lost",
1167     4,
1168     PROTOBUF_C_LABEL_OPTIONAL,
1169     PROTOBUF_C_TYPE_UINT32,
1170     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_lost),
1171     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, lost),
1172     NULL,
1173     NULL,
1174     NULL,NULL    /* reserved1, reserved2 */
1175   },
1176   {
1177     "resync",
1178     5,
1179     PROTOBUF_C_LABEL_OPTIONAL,
1180     PROTOBUF_C_TYPE_UINT32,
1181     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_resync),
1182     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, resync),
1183     NULL,
1184     NULL,
1185     NULL,NULL    /* reserved1, reserved2 */
1186   },
1187   {
1188     "udp_packets",
1189     6,
1190     PROTOBUF_C_LABEL_OPTIONAL,
1191     PROTOBUF_C_TYPE_UINT32,
1192     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_udp_packets),
1193     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, udp_packets),
1194     NULL,
1195     NULL,
1196     NULL,NULL    /* reserved1, reserved2 */
1197   },
1198   {
1199     "tcp_packets",
1200     7,
1201     PROTOBUF_C_LABEL_OPTIONAL,
1202     PROTOBUF_C_TYPE_UINT32,
1203     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_tcp_packets),
1204     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, tcp_packets),
1205     NULL,
1206     NULL,
1207     NULL,NULL    /* reserved1, reserved2 */
1208   },
1209   {
1210     "udp_ping_avg",
1211     8,
1212     PROTOBUF_C_LABEL_OPTIONAL,
1213     PROTOBUF_C_TYPE_FLOAT,
1214     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_udp_ping_avg),
1215     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, udp_ping_avg),
1216     NULL,
1217     NULL,
1218     NULL,NULL    /* reserved1, reserved2 */
1219   },
1220   {
1221     "udp_ping_var",
1222     9,
1223     PROTOBUF_C_LABEL_OPTIONAL,
1224     PROTOBUF_C_TYPE_FLOAT,
1225     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_udp_ping_var),
1226     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, udp_ping_var),
1227     NULL,
1228     NULL,
1229     NULL,NULL    /* reserved1, reserved2 */
1230   },
1231   {
1232     "tcp_ping_avg",
1233     10,
1234     PROTOBUF_C_LABEL_OPTIONAL,
1235     PROTOBUF_C_TYPE_FLOAT,
1236     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_tcp_ping_avg),
1237     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, tcp_ping_avg),
1238     NULL,
1239     NULL,
1240     NULL,NULL    /* reserved1, reserved2 */
1241   },
1242   {
1243     "tcp_ping_var",
1244     11,
1245     PROTOBUF_C_LABEL_OPTIONAL,
1246     PROTOBUF_C_TYPE_FLOAT,
1247     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, has_tcp_ping_var),
1248     PROTOBUF_C_OFFSETOF(MumbleProto__Ping, tcp_ping_var),
1249     NULL,
1250     NULL,
1251     NULL,NULL    /* reserved1, reserved2 */
1252   },
1253 };
1254 static const unsigned mumble_proto__ping__field_indices_by_name[] = {
1255   1,   /* field[1] = good */
1256   2,   /* field[2] = late */
1257   3,   /* field[3] = lost */
1258   4,   /* field[4] = resync */
1259   6,   /* field[6] = tcp_packets */
1260   9,   /* field[9] = tcp_ping_avg */
1261   10,   /* field[10] = tcp_ping_var */
1262   0,   /* field[0] = timestamp */
1263   5,   /* field[5] = udp_packets */
1264   7,   /* field[7] = udp_ping_avg */
1265   8,   /* field[8] = udp_ping_var */
1266 };
1267 static const ProtobufCIntRange mumble_proto__ping__number_ranges[1 + 1] =
1268 {
1269   { 1, 0 },
1270   { 0, 11 }
1271 };
1272 const ProtobufCMessageDescriptor mumble_proto__ping__descriptor =
1273 {
1274   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1275   "MumbleProto.Ping",
1276   "Ping",
1277   "MumbleProto__Ping",
1278   "MumbleProto",
1279   sizeof(MumbleProto__Ping),
1280   11,
1281   mumble_proto__ping__field_descriptors,
1282   mumble_proto__ping__field_indices_by_name,
1283   1,  mumble_proto__ping__number_ranges,
1284   NULL,NULL,NULL,NULL    /* reserved[1234] */
1285 };
1286 const ProtobufCEnumValue mumble_proto__reject__reject_type__enum_values_by_number[8] =
1287 {
1288   { "None", "MUMBLE_PROTO__REJECT__REJECT_TYPE__NONE", 0 },
1289   { "WrongVersion", "MUMBLE_PROTO__REJECT__REJECT_TYPE__WRONGVERSION", 1 },
1290   { "InvalidUsername", "MUMBLE_PROTO__REJECT__REJECT_TYPE__INVALIDUSERNAME", 2 },
1291   { "WrongUserPW", "MUMBLE_PROTO__REJECT__REJECT_TYPE__WRONGUSERPW", 3 },
1292   { "WrongServerPW", "MUMBLE_PROTO__REJECT__REJECT_TYPE__WRONGSERVERPW", 4 },
1293   { "UsernameInUse", "MUMBLE_PROTO__REJECT__REJECT_TYPE__USERNAMEINUSE", 5 },
1294   { "ServerFull", "MUMBLE_PROTO__REJECT__REJECT_TYPE__SERVERFULL", 6 },
1295   { "NoCertificate", "MUMBLE_PROTO__REJECT__REJECT_TYPE__NOCERTIFICATE", 7 },
1296 };
1297 static const ProtobufCIntRange mumble_proto__reject__reject_type__value_ranges[] = {
1298 {0, 0},{0, 8}
1299 };
1300 const ProtobufCEnumValueIndex mumble_proto__reject__reject_type__enum_values_by_name[8] =
1301 {
1302   { "InvalidUsername", 2 },
1303   { "NoCertificate", 7 },
1304   { "None", 0 },
1305   { "ServerFull", 6 },
1306   { "UsernameInUse", 5 },
1307   { "WrongServerPW", 4 },
1308   { "WrongUserPW", 3 },
1309   { "WrongVersion", 1 },
1310 };
1311 const ProtobufCEnumDescriptor mumble_proto__reject__reject_type__descriptor =
1312 {
1313   PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC,
1314   "MumbleProto.Reject.RejectType",
1315   "RejectType",
1316   "MumbleProto__Reject__RejectType",
1317   "MumbleProto",
1318   8,
1319   mumble_proto__reject__reject_type__enum_values_by_number,
1320   8,
1321   mumble_proto__reject__reject_type__enum_values_by_name,
1322   1,
1323   mumble_proto__reject__reject_type__value_ranges,
1324   NULL,NULL,NULL,NULL   /* reserved[1234] */
1325 };
1326 static const ProtobufCFieldDescriptor mumble_proto__reject__field_descriptors[2] =
1327 {
1328   {
1329     "type",
1330     1,
1331     PROTOBUF_C_LABEL_OPTIONAL,
1332     PROTOBUF_C_TYPE_ENUM,
1333     PROTOBUF_C_OFFSETOF(MumbleProto__Reject, has_type),
1334     PROTOBUF_C_OFFSETOF(MumbleProto__Reject, type),
1335     &mumble_proto__reject__reject_type__descriptor,
1336     NULL,
1337     NULL,NULL    /* reserved1, reserved2 */
1338   },
1339   {
1340     "reason",
1341     2,
1342     PROTOBUF_C_LABEL_OPTIONAL,
1343     PROTOBUF_C_TYPE_STRING,
1344     0,   /* quantifier_offset */
1345     PROTOBUF_C_OFFSETOF(MumbleProto__Reject, reason),
1346     NULL,
1347     NULL,
1348     NULL,NULL    /* reserved1, reserved2 */
1349   },
1350 };
1351 static const unsigned mumble_proto__reject__field_indices_by_name[] = {
1352   1,   /* field[1] = reason */
1353   0,   /* field[0] = type */
1354 };
1355 static const ProtobufCIntRange mumble_proto__reject__number_ranges[1 + 1] =
1356 {
1357   { 1, 0 },
1358   { 0, 2 }
1359 };
1360 const ProtobufCMessageDescriptor mumble_proto__reject__descriptor =
1361 {
1362   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1363   "MumbleProto.Reject",
1364   "Reject",
1365   "MumbleProto__Reject",
1366   "MumbleProto",
1367   sizeof(MumbleProto__Reject),
1368   2,
1369   mumble_proto__reject__field_descriptors,
1370   mumble_proto__reject__field_indices_by_name,
1371   1,  mumble_proto__reject__number_ranges,
1372   NULL,NULL,NULL,NULL    /* reserved[1234] */
1373 };
1374 static const protobuf_c_boolean mumble_proto__server_sync__allow_html__default_value = 1;
1375 static const ProtobufCFieldDescriptor mumble_proto__server_sync__field_descriptors[5] =
1376 {
1377   {
1378     "session",
1379     1,
1380     PROTOBUF_C_LABEL_OPTIONAL,
1381     PROTOBUF_C_TYPE_UINT32,
1382     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, has_session),
1383     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, session),
1384     NULL,
1385     NULL,
1386     NULL,NULL    /* reserved1, reserved2 */
1387   },
1388   {
1389     "max_bandwidth",
1390     2,
1391     PROTOBUF_C_LABEL_OPTIONAL,
1392     PROTOBUF_C_TYPE_UINT32,
1393     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, has_max_bandwidth),
1394     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, max_bandwidth),
1395     NULL,
1396     NULL,
1397     NULL,NULL    /* reserved1, reserved2 */
1398   },
1399   {
1400     "welcome_text",
1401     3,
1402     PROTOBUF_C_LABEL_OPTIONAL,
1403     PROTOBUF_C_TYPE_STRING,
1404     0,   /* quantifier_offset */
1405     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, welcome_text),
1406     NULL,
1407     NULL,
1408     NULL,NULL    /* reserved1, reserved2 */
1409   },
1410   {
1411     "permissions",
1412     4,
1413     PROTOBUF_C_LABEL_OPTIONAL,
1414     PROTOBUF_C_TYPE_UINT64,
1415     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, has_permissions),
1416     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, permissions),
1417     NULL,
1418     NULL,
1419     NULL,NULL    /* reserved1, reserved2 */
1420   },
1421   {
1422     "allow_html",
1423     5,
1424     PROTOBUF_C_LABEL_OPTIONAL,
1425     PROTOBUF_C_TYPE_BOOL,
1426     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, has_allow_html),
1427     PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, allow_html),
1428     NULL,
1429     &mumble_proto__server_sync__allow_html__default_value,
1430     NULL,NULL    /* reserved1, reserved2 */
1431   },
1432 };
1433 static const unsigned mumble_proto__server_sync__field_indices_by_name[] = {
1434   4,   /* field[4] = allow_html */
1435   1,   /* field[1] = max_bandwidth */
1436   3,   /* field[3] = permissions */
1437   0,   /* field[0] = session */
1438   2,   /* field[2] = welcome_text */
1439 };
1440 static const ProtobufCIntRange mumble_proto__server_sync__number_ranges[1 + 1] =
1441 {
1442   { 1, 0 },
1443   { 0, 5 }
1444 };
1445 const ProtobufCMessageDescriptor mumble_proto__server_sync__descriptor =
1446 {
1447   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1448   "MumbleProto.ServerSync",
1449   "ServerSync",
1450   "MumbleProto__ServerSync",
1451   "MumbleProto",
1452   sizeof(MumbleProto__ServerSync),
1453   5,
1454   mumble_proto__server_sync__field_descriptors,
1455   mumble_proto__server_sync__field_indices_by_name,
1456   1,  mumble_proto__server_sync__number_ranges,
1457   NULL,NULL,NULL,NULL    /* reserved[1234] */
1458 };
1459 static const ProtobufCFieldDescriptor mumble_proto__channel_remove__field_descriptors[1] =
1460 {
1461   {
1462     "channel_id",
1463     1,
1464     PROTOBUF_C_LABEL_REQUIRED,
1465     PROTOBUF_C_TYPE_UINT32,
1466     0,   /* quantifier_offset */
1467     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelRemove, channel_id),
1468     NULL,
1469     NULL,
1470     NULL,NULL    /* reserved1, reserved2 */
1471   },
1472 };
1473 static const unsigned mumble_proto__channel_remove__field_indices_by_name[] = {
1474   0,   /* field[0] = channel_id */
1475 };
1476 static const ProtobufCIntRange mumble_proto__channel_remove__number_ranges[1 + 1] =
1477 {
1478   { 1, 0 },
1479   { 0, 1 }
1480 };
1481 const ProtobufCMessageDescriptor mumble_proto__channel_remove__descriptor =
1482 {
1483   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1484   "MumbleProto.ChannelRemove",
1485   "ChannelRemove",
1486   "MumbleProto__ChannelRemove",
1487   "MumbleProto",
1488   sizeof(MumbleProto__ChannelRemove),
1489   1,
1490   mumble_proto__channel_remove__field_descriptors,
1491   mumble_proto__channel_remove__field_indices_by_name,
1492   1,  mumble_proto__channel_remove__number_ranges,
1493   NULL,NULL,NULL,NULL    /* reserved[1234] */
1494 };
1495 static const protobuf_c_boolean mumble_proto__channel_state__temporary__default_value = 0;
1496 static const int32_t mumble_proto__channel_state__position__default_value = 0;
1497 static const ProtobufCFieldDescriptor mumble_proto__channel_state__field_descriptors[9] =
1498 {
1499   {
1500     "channel_id",
1501     1,
1502     PROTOBUF_C_LABEL_OPTIONAL,
1503     PROTOBUF_C_TYPE_UINT32,
1504     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, has_channel_id),
1505     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, channel_id),
1506     NULL,
1507     NULL,
1508     NULL,NULL    /* reserved1, reserved2 */
1509   },
1510   {
1511     "parent",
1512     2,
1513     PROTOBUF_C_LABEL_OPTIONAL,
1514     PROTOBUF_C_TYPE_UINT32,
1515     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, has_parent),
1516     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, parent),
1517     NULL,
1518     NULL,
1519     NULL,NULL    /* reserved1, reserved2 */
1520   },
1521   {
1522     "name",
1523     3,
1524     PROTOBUF_C_LABEL_OPTIONAL,
1525     PROTOBUF_C_TYPE_STRING,
1526     0,   /* quantifier_offset */
1527     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, name),
1528     NULL,
1529     NULL,
1530     NULL,NULL    /* reserved1, reserved2 */
1531   },
1532   {
1533     "links",
1534     4,
1535     PROTOBUF_C_LABEL_REPEATED,
1536     PROTOBUF_C_TYPE_UINT32,
1537     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, n_links),
1538     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, links),
1539     NULL,
1540     NULL,
1541     NULL,NULL    /* reserved1, reserved2 */
1542   },
1543   {
1544     "description",
1545     5,
1546     PROTOBUF_C_LABEL_OPTIONAL,
1547     PROTOBUF_C_TYPE_STRING,
1548     0,   /* quantifier_offset */
1549     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, description),
1550     NULL,
1551     NULL,
1552     NULL,NULL    /* reserved1, reserved2 */
1553   },
1554   {
1555     "links_add",
1556     6,
1557     PROTOBUF_C_LABEL_REPEATED,
1558     PROTOBUF_C_TYPE_UINT32,
1559     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, n_links_add),
1560     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, links_add),
1561     NULL,
1562     NULL,
1563     NULL,NULL    /* reserved1, reserved2 */
1564   },
1565   {
1566     "links_remove",
1567     7,
1568     PROTOBUF_C_LABEL_REPEATED,
1569     PROTOBUF_C_TYPE_UINT32,
1570     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, n_links_remove),
1571     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, links_remove),
1572     NULL,
1573     NULL,
1574     NULL,NULL    /* reserved1, reserved2 */
1575   },
1576   {
1577     "temporary",
1578     8,
1579     PROTOBUF_C_LABEL_OPTIONAL,
1580     PROTOBUF_C_TYPE_BOOL,
1581     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, has_temporary),
1582     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, temporary),
1583     NULL,
1584     &mumble_proto__channel_state__temporary__default_value,
1585     NULL,NULL    /* reserved1, reserved2 */
1586   },
1587   {
1588     "position",
1589     9,
1590     PROTOBUF_C_LABEL_OPTIONAL,
1591     PROTOBUF_C_TYPE_INT32,
1592     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, has_position),
1593     PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, position),
1594     NULL,
1595     &mumble_proto__channel_state__position__default_value,
1596     NULL,NULL    /* reserved1, reserved2 */
1597   },
1598 };
1599 static const unsigned mumble_proto__channel_state__field_indices_by_name[] = {
1600   0,   /* field[0] = channel_id */
1601   4,   /* field[4] = description */
1602   3,   /* field[3] = links */
1603   5,   /* field[5] = links_add */
1604   6,   /* field[6] = links_remove */
1605   2,   /* field[2] = name */
1606   1,   /* field[1] = parent */
1607   8,   /* field[8] = position */
1608   7,   /* field[7] = temporary */
1609 };
1610 static const ProtobufCIntRange mumble_proto__channel_state__number_ranges[1 + 1] =
1611 {
1612   { 1, 0 },
1613   { 0, 9 }
1614 };
1615 const ProtobufCMessageDescriptor mumble_proto__channel_state__descriptor =
1616 {
1617   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1618   "MumbleProto.ChannelState",
1619   "ChannelState",
1620   "MumbleProto__ChannelState",
1621   "MumbleProto",
1622   sizeof(MumbleProto__ChannelState),
1623   9,
1624   mumble_proto__channel_state__field_descriptors,
1625   mumble_proto__channel_state__field_indices_by_name,
1626   1,  mumble_proto__channel_state__number_ranges,
1627   NULL,NULL,NULL,NULL    /* reserved[1234] */
1628 };
1629 static const ProtobufCFieldDescriptor mumble_proto__user_remove__field_descriptors[4] =
1630 {
1631   {
1632     "session",
1633     1,
1634     PROTOBUF_C_LABEL_REQUIRED,
1635     PROTOBUF_C_TYPE_UINT32,
1636     0,   /* quantifier_offset */
1637     PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, session),
1638     NULL,
1639     NULL,
1640     NULL,NULL    /* reserved1, reserved2 */
1641   },
1642   {
1643     "actor",
1644     2,
1645     PROTOBUF_C_LABEL_OPTIONAL,
1646     PROTOBUF_C_TYPE_UINT32,
1647     PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, has_actor),
1648     PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, actor),
1649     NULL,
1650     NULL,
1651     NULL,NULL    /* reserved1, reserved2 */
1652   },
1653   {
1654     "reason",
1655     3,
1656     PROTOBUF_C_LABEL_OPTIONAL,
1657     PROTOBUF_C_TYPE_STRING,
1658     0,   /* quantifier_offset */
1659     PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, reason),
1660     NULL,
1661     NULL,
1662     NULL,NULL    /* reserved1, reserved2 */
1663   },
1664   {
1665     "ban",
1666     4,
1667     PROTOBUF_C_LABEL_OPTIONAL,
1668     PROTOBUF_C_TYPE_BOOL,
1669     PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, has_ban),
1670     PROTOBUF_C_OFFSETOF(MumbleProto__UserRemove, ban),
1671     NULL,
1672     NULL,
1673     NULL,NULL    /* reserved1, reserved2 */
1674   },
1675 };
1676 static const unsigned mumble_proto__user_remove__field_indices_by_name[] = {
1677   1,   /* field[1] = actor */
1678   3,   /* field[3] = ban */
1679   2,   /* field[2] = reason */
1680   0,   /* field[0] = session */
1681 };
1682 static const ProtobufCIntRange mumble_proto__user_remove__number_ranges[1 + 1] =
1683 {
1684   { 1, 0 },
1685   { 0, 4 }
1686 };
1687 const ProtobufCMessageDescriptor mumble_proto__user_remove__descriptor =
1688 {
1689   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1690   "MumbleProto.UserRemove",
1691   "UserRemove",
1692   "MumbleProto__UserRemove",
1693   "MumbleProto",
1694   sizeof(MumbleProto__UserRemove),
1695   4,
1696   mumble_proto__user_remove__field_descriptors,
1697   mumble_proto__user_remove__field_indices_by_name,
1698   1,  mumble_proto__user_remove__number_ranges,
1699   NULL,NULL,NULL,NULL    /* reserved[1234] */
1700 };
1701 static const ProtobufCFieldDescriptor mumble_proto__user_state__field_descriptors[15] =
1702 {
1703   {
1704     "session",
1705     1,
1706     PROTOBUF_C_LABEL_OPTIONAL,
1707     PROTOBUF_C_TYPE_UINT32,
1708     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_session),
1709     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, session),
1710     NULL,
1711     NULL,
1712     NULL,NULL    /* reserved1, reserved2 */
1713   },
1714   {
1715     "actor",
1716     2,
1717     PROTOBUF_C_LABEL_OPTIONAL,
1718     PROTOBUF_C_TYPE_UINT32,
1719     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_actor),
1720     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, actor),
1721     NULL,
1722     NULL,
1723     NULL,NULL    /* reserved1, reserved2 */
1724   },
1725   {
1726     "name",
1727     3,
1728     PROTOBUF_C_LABEL_OPTIONAL,
1729     PROTOBUF_C_TYPE_STRING,
1730     0,   /* quantifier_offset */
1731     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, name),
1732     NULL,
1733     NULL,
1734     NULL,NULL    /* reserved1, reserved2 */
1735   },
1736   {
1737     "user_id",
1738     4,
1739     PROTOBUF_C_LABEL_OPTIONAL,
1740     PROTOBUF_C_TYPE_UINT32,
1741     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_user_id),
1742     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, user_id),
1743     NULL,
1744     NULL,
1745     NULL,NULL    /* reserved1, reserved2 */
1746   },
1747   {
1748     "channel_id",
1749     5,
1750     PROTOBUF_C_LABEL_OPTIONAL,
1751     PROTOBUF_C_TYPE_UINT32,
1752     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_channel_id),
1753     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, channel_id),
1754     NULL,
1755     NULL,
1756     NULL,NULL    /* reserved1, reserved2 */
1757   },
1758   {
1759     "mute",
1760     6,
1761     PROTOBUF_C_LABEL_OPTIONAL,
1762     PROTOBUF_C_TYPE_BOOL,
1763     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_mute),
1764     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, mute),
1765     NULL,
1766     NULL,
1767     NULL,NULL    /* reserved1, reserved2 */
1768   },
1769   {
1770     "deaf",
1771     7,
1772     PROTOBUF_C_LABEL_OPTIONAL,
1773     PROTOBUF_C_TYPE_BOOL,
1774     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_deaf),
1775     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, deaf),
1776     NULL,
1777     NULL,
1778     NULL,NULL    /* reserved1, reserved2 */
1779   },
1780   {
1781     "suppress",
1782     8,
1783     PROTOBUF_C_LABEL_OPTIONAL,
1784     PROTOBUF_C_TYPE_BOOL,
1785     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_suppress),
1786     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, suppress),
1787     NULL,
1788     NULL,
1789     NULL,NULL    /* reserved1, reserved2 */
1790   },
1791   {
1792     "self_mute",
1793     9,
1794     PROTOBUF_C_LABEL_OPTIONAL,
1795     PROTOBUF_C_TYPE_BOOL,
1796     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_self_mute),
1797     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, self_mute),
1798     NULL,
1799     NULL,
1800     NULL,NULL    /* reserved1, reserved2 */
1801   },
1802   {
1803     "self_deaf",
1804     10,
1805     PROTOBUF_C_LABEL_OPTIONAL,
1806     PROTOBUF_C_TYPE_BOOL,
1807     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_self_deaf),
1808     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, self_deaf),
1809     NULL,
1810     NULL,
1811     NULL,NULL    /* reserved1, reserved2 */
1812   },
1813   {
1814     "texture",
1815     11,
1816     PROTOBUF_C_LABEL_OPTIONAL,
1817     PROTOBUF_C_TYPE_BYTES,
1818     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_texture),
1819     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, texture),
1820     NULL,
1821     NULL,
1822     NULL,NULL    /* reserved1, reserved2 */
1823   },
1824   {
1825     "plugin_context",
1826     12,
1827     PROTOBUF_C_LABEL_OPTIONAL,
1828     PROTOBUF_C_TYPE_STRING,
1829     0,   /* quantifier_offset */
1830     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, plugin_context),
1831     NULL,
1832     NULL,
1833     NULL,NULL    /* reserved1, reserved2 */
1834   },
1835   {
1836     "plugin_identity",
1837     13,
1838     PROTOBUF_C_LABEL_OPTIONAL,
1839     PROTOBUF_C_TYPE_STRING,
1840     0,   /* quantifier_offset */
1841     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, plugin_identity),
1842     NULL,
1843     NULL,
1844     NULL,NULL    /* reserved1, reserved2 */
1845   },
1846   {
1847     "comment",
1848     14,
1849     PROTOBUF_C_LABEL_OPTIONAL,
1850     PROTOBUF_C_TYPE_STRING,
1851     0,   /* quantifier_offset */
1852     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, comment),
1853     NULL,
1854     NULL,
1855     NULL,NULL    /* reserved1, reserved2 */
1856   },
1857   {
1858     "hash",
1859     15,
1860     PROTOBUF_C_LABEL_OPTIONAL,
1861     PROTOBUF_C_TYPE_STRING,
1862     0,   /* quantifier_offset */
1863     PROTOBUF_C_OFFSETOF(MumbleProto__UserState, hash),
1864     NULL,
1865     NULL,
1866     NULL,NULL    /* reserved1, reserved2 */
1867   },
1868 };
1869 static const unsigned mumble_proto__user_state__field_indices_by_name[] = {
1870   1,   /* field[1] = actor */
1871   4,   /* field[4] = channel_id */
1872   13,   /* field[13] = comment */
1873   6,   /* field[6] = deaf */
1874   14,   /* field[14] = hash */
1875   5,   /* field[5] = mute */
1876   2,   /* field[2] = name */
1877   11,   /* field[11] = plugin_context */
1878   12,   /* field[12] = plugin_identity */
1879   9,   /* field[9] = self_deaf */
1880   8,   /* field[8] = self_mute */
1881   0,   /* field[0] = session */
1882   7,   /* field[7] = suppress */
1883   10,   /* field[10] = texture */
1884   3,   /* field[3] = user_id */
1885 };
1886 static const ProtobufCIntRange mumble_proto__user_state__number_ranges[1 + 1] =
1887 {
1888   { 1, 0 },
1889   { 0, 15 }
1890 };
1891 const ProtobufCMessageDescriptor mumble_proto__user_state__descriptor =
1892 {
1893   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
1894   "MumbleProto.UserState",
1895   "UserState",
1896   "MumbleProto__UserState",
1897   "MumbleProto",
1898   sizeof(MumbleProto__UserState),
1899   15,
1900   mumble_proto__user_state__field_descriptors,
1901   mumble_proto__user_state__field_indices_by_name,
1902   1,  mumble_proto__user_state__number_ranges,
1903   NULL,NULL,NULL,NULL    /* reserved[1234] */
1904 };
1905 static const ProtobufCFieldDescriptor mumble_proto__ban_list__ban_entry__field_descriptors[7] =
1906 {
1907   {
1908     "address",
1909     1,
1910     PROTOBUF_C_LABEL_REQUIRED,
1911     PROTOBUF_C_TYPE_BYTES,
1912     0,   /* quantifier_offset */
1913     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, address),
1914     NULL,
1915     NULL,
1916     NULL,NULL    /* reserved1, reserved2 */
1917   },
1918   {
1919     "mask",
1920     2,
1921     PROTOBUF_C_LABEL_REQUIRED,
1922     PROTOBUF_C_TYPE_UINT32,
1923     0,   /* quantifier_offset */
1924     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, mask),
1925     NULL,
1926     NULL,
1927     NULL,NULL    /* reserved1, reserved2 */
1928   },
1929   {
1930     "name",
1931     3,
1932     PROTOBUF_C_LABEL_OPTIONAL,
1933     PROTOBUF_C_TYPE_STRING,
1934     0,   /* quantifier_offset */
1935     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, name),
1936     NULL,
1937     NULL,
1938     NULL,NULL    /* reserved1, reserved2 */
1939   },
1940   {
1941     "hash",
1942     4,
1943     PROTOBUF_C_LABEL_OPTIONAL,
1944     PROTOBUF_C_TYPE_STRING,
1945     0,   /* quantifier_offset */
1946     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, hash),
1947     NULL,
1948     NULL,
1949     NULL,NULL    /* reserved1, reserved2 */
1950   },
1951   {
1952     "reason",
1953     5,
1954     PROTOBUF_C_LABEL_OPTIONAL,
1955     PROTOBUF_C_TYPE_STRING,
1956     0,   /* quantifier_offset */
1957     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, reason),
1958     NULL,
1959     NULL,
1960     NULL,NULL    /* reserved1, reserved2 */
1961   },
1962   {
1963     "start",
1964     6,
1965     PROTOBUF_C_LABEL_OPTIONAL,
1966     PROTOBUF_C_TYPE_STRING,
1967     0,   /* quantifier_offset */
1968     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, start),
1969     NULL,
1970     NULL,
1971     NULL,NULL    /* reserved1, reserved2 */
1972   },
1973   {
1974     "duration",
1975     7,
1976     PROTOBUF_C_LABEL_OPTIONAL,
1977     PROTOBUF_C_TYPE_UINT32,
1978     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, has_duration),
1979     PROTOBUF_C_OFFSETOF(MumbleProto__BanList__BanEntry, duration),
1980     NULL,
1981     NULL,
1982     NULL,NULL    /* reserved1, reserved2 */
1983   },
1984 };
1985 static const unsigned mumble_proto__ban_list__ban_entry__field_indices_by_name[] = {
1986   0,   /* field[0] = address */
1987   6,   /* field[6] = duration */
1988   3,   /* field[3] = hash */
1989   1,   /* field[1] = mask */
1990   2,   /* field[2] = name */
1991   4,   /* field[4] = reason */
1992   5,   /* field[5] = start */
1993 };
1994 static const ProtobufCIntRange mumble_proto__ban_list__ban_entry__number_ranges[1 + 1] =
1995 {
1996   { 1, 0 },
1997   { 0, 7 }
1998 };
1999 const ProtobufCMessageDescriptor mumble_proto__ban_list__ban_entry__descriptor =
2000 {
2001   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2002   "MumbleProto.BanList.BanEntry",
2003   "BanEntry",
2004   "MumbleProto__BanList__BanEntry",
2005   "MumbleProto",
2006   sizeof(MumbleProto__BanList__BanEntry),
2007   7,
2008   mumble_proto__ban_list__ban_entry__field_descriptors,
2009   mumble_proto__ban_list__ban_entry__field_indices_by_name,
2010   1,  mumble_proto__ban_list__ban_entry__number_ranges,
2011   NULL,NULL,NULL,NULL    /* reserved[1234] */
2012 };
2013 static const protobuf_c_boolean mumble_proto__ban_list__query__default_value = 0;
2014 static const ProtobufCFieldDescriptor mumble_proto__ban_list__field_descriptors[2] =
2015 {
2016   {
2017     "bans",
2018     1,
2019     PROTOBUF_C_LABEL_REPEATED,
2020     PROTOBUF_C_TYPE_MESSAGE,
2021     PROTOBUF_C_OFFSETOF(MumbleProto__BanList, n_bans),
2022     PROTOBUF_C_OFFSETOF(MumbleProto__BanList, bans),
2023     &mumble_proto__ban_list__ban_entry__descriptor,
2024     NULL,
2025     NULL,NULL    /* reserved1, reserved2 */
2026   },
2027   {
2028     "query",
2029     2,
2030     PROTOBUF_C_LABEL_OPTIONAL,
2031     PROTOBUF_C_TYPE_BOOL,
2032     PROTOBUF_C_OFFSETOF(MumbleProto__BanList, has_query),
2033     PROTOBUF_C_OFFSETOF(MumbleProto__BanList, query),
2034     NULL,
2035     &mumble_proto__ban_list__query__default_value,
2036     NULL,NULL    /* reserved1, reserved2 */
2037   },
2038 };
2039 static const unsigned mumble_proto__ban_list__field_indices_by_name[] = {
2040   0,   /* field[0] = bans */
2041   1,   /* field[1] = query */
2042 };
2043 static const ProtobufCIntRange mumble_proto__ban_list__number_ranges[1 + 1] =
2044 {
2045   { 1, 0 },
2046   { 0, 2 }
2047 };
2048 const ProtobufCMessageDescriptor mumble_proto__ban_list__descriptor =
2049 {
2050   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2051   "MumbleProto.BanList",
2052   "BanList",
2053   "MumbleProto__BanList",
2054   "MumbleProto",
2055   sizeof(MumbleProto__BanList),
2056   2,
2057   mumble_proto__ban_list__field_descriptors,
2058   mumble_proto__ban_list__field_indices_by_name,
2059   1,  mumble_proto__ban_list__number_ranges,
2060   NULL,NULL,NULL,NULL    /* reserved[1234] */
2061 };
2062 static const ProtobufCFieldDescriptor mumble_proto__text_message__field_descriptors[5] =
2063 {
2064   {
2065     "actor",
2066     1,
2067     PROTOBUF_C_LABEL_OPTIONAL,
2068     PROTOBUF_C_TYPE_UINT32,
2069     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, has_actor),
2070     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, actor),
2071     NULL,
2072     NULL,
2073     NULL,NULL    /* reserved1, reserved2 */
2074   },
2075   {
2076     "session",
2077     2,
2078     PROTOBUF_C_LABEL_REPEATED,
2079     PROTOBUF_C_TYPE_UINT32,
2080     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, n_session),
2081     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, session),
2082     NULL,
2083     NULL,
2084     NULL,NULL    /* reserved1, reserved2 */
2085   },
2086   {
2087     "channel_id",
2088     3,
2089     PROTOBUF_C_LABEL_REPEATED,
2090     PROTOBUF_C_TYPE_UINT32,
2091     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, n_channel_id),
2092     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, channel_id),
2093     NULL,
2094     NULL,
2095     NULL,NULL    /* reserved1, reserved2 */
2096   },
2097   {
2098     "tree_id",
2099     4,
2100     PROTOBUF_C_LABEL_REPEATED,
2101     PROTOBUF_C_TYPE_UINT32,
2102     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, n_tree_id),
2103     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, tree_id),
2104     NULL,
2105     NULL,
2106     NULL,NULL    /* reserved1, reserved2 */
2107   },
2108   {
2109     "message",
2110     5,
2111     PROTOBUF_C_LABEL_REQUIRED,
2112     PROTOBUF_C_TYPE_STRING,
2113     0,   /* quantifier_offset */
2114     PROTOBUF_C_OFFSETOF(MumbleProto__TextMessage, message),
2115     NULL,
2116     NULL,
2117     NULL,NULL    /* reserved1, reserved2 */
2118   },
2119 };
2120 static const unsigned mumble_proto__text_message__field_indices_by_name[] = {
2121   0,   /* field[0] = actor */
2122   2,   /* field[2] = channel_id */
2123   4,   /* field[4] = message */
2124   1,   /* field[1] = session */
2125   3,   /* field[3] = tree_id */
2126 };
2127 static const ProtobufCIntRange mumble_proto__text_message__number_ranges[1 + 1] =
2128 {
2129   { 1, 0 },
2130   { 0, 5 }
2131 };
2132 const ProtobufCMessageDescriptor mumble_proto__text_message__descriptor =
2133 {
2134   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2135   "MumbleProto.TextMessage",
2136   "TextMessage",
2137   "MumbleProto__TextMessage",
2138   "MumbleProto",
2139   sizeof(MumbleProto__TextMessage),
2140   5,
2141   mumble_proto__text_message__field_descriptors,
2142   mumble_proto__text_message__field_indices_by_name,
2143   1,  mumble_proto__text_message__number_ranges,
2144   NULL,NULL,NULL,NULL    /* reserved[1234] */
2145 };
2146 const ProtobufCEnumValue mumble_proto__permission_denied__deny_type__enum_values_by_number[8] =
2147 {
2148   { "Text", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TEXT", 0 },
2149   { "Permission", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__PERMISSION", 1 },
2150   { "SuperUser", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__SUPERUSER", 2 },
2151   { "ChannelName", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__CHANNELNAME", 3 },
2152   { "TextTooLong", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TEXTTOOLONG", 4 },
2153   { "H9K", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__H9K", 5 },
2154   { "TemporaryChannel", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TEMPORARYCHANNEL", 6 },
2155   { "MissingCertificate", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__MISSINGCERTIFICATE", 7 },
2156 };
2157 static const ProtobufCIntRange mumble_proto__permission_denied__deny_type__value_ranges[] = {
2158 {0, 0},{0, 8}
2159 };
2160 const ProtobufCEnumValueIndex mumble_proto__permission_denied__deny_type__enum_values_by_name[8] =
2161 {
2162   { "ChannelName", 3 },
2163   { "H9K", 5 },
2164   { "MissingCertificate", 7 },
2165   { "Permission", 1 },
2166   { "SuperUser", 2 },
2167   { "TemporaryChannel", 6 },
2168   { "Text", 0 },
2169   { "TextTooLong", 4 },
2170 };
2171 const ProtobufCEnumDescriptor mumble_proto__permission_denied__deny_type__descriptor =
2172 {
2173   PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC,
2174   "MumbleProto.PermissionDenied.DenyType",
2175   "DenyType",
2176   "MumbleProto__PermissionDenied__DenyType",
2177   "MumbleProto",
2178   8,
2179   mumble_proto__permission_denied__deny_type__enum_values_by_number,
2180   8,
2181   mumble_proto__permission_denied__deny_type__enum_values_by_name,
2182   1,
2183   mumble_proto__permission_denied__deny_type__value_ranges,
2184   NULL,NULL,NULL,NULL   /* reserved[1234] */
2185 };
2186 static const ProtobufCFieldDescriptor mumble_proto__permission_denied__field_descriptors[5] =
2187 {
2188   {
2189     "permission",
2190     1,
2191     PROTOBUF_C_LABEL_OPTIONAL,
2192     PROTOBUF_C_TYPE_UINT32,
2193     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, has_permission),
2194     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, permission),
2195     NULL,
2196     NULL,
2197     NULL,NULL    /* reserved1, reserved2 */
2198   },
2199   {
2200     "channel_id",
2201     2,
2202     PROTOBUF_C_LABEL_OPTIONAL,
2203     PROTOBUF_C_TYPE_UINT32,
2204     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, has_channel_id),
2205     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, channel_id),
2206     NULL,
2207     NULL,
2208     NULL,NULL    /* reserved1, reserved2 */
2209   },
2210   {
2211     "session",
2212     3,
2213     PROTOBUF_C_LABEL_OPTIONAL,
2214     PROTOBUF_C_TYPE_UINT32,
2215     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, has_session),
2216     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, session),
2217     NULL,
2218     NULL,
2219     NULL,NULL    /* reserved1, reserved2 */
2220   },
2221   {
2222     "reason",
2223     4,
2224     PROTOBUF_C_LABEL_OPTIONAL,
2225     PROTOBUF_C_TYPE_STRING,
2226     0,   /* quantifier_offset */
2227     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, reason),
2228     NULL,
2229     NULL,
2230     NULL,NULL    /* reserved1, reserved2 */
2231   },
2232   {
2233     "type",
2234     5,
2235     PROTOBUF_C_LABEL_OPTIONAL,
2236     PROTOBUF_C_TYPE_ENUM,
2237     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, has_type),
2238     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, type),
2239     &mumble_proto__permission_denied__deny_type__descriptor,
2240     NULL,
2241     NULL,NULL    /* reserved1, reserved2 */
2242   },
2243 };
2244 static const unsigned mumble_proto__permission_denied__field_indices_by_name[] = {
2245   1,   /* field[1] = channel_id */
2246   0,   /* field[0] = permission */
2247   3,   /* field[3] = reason */
2248   2,   /* field[2] = session */
2249   4,   /* field[4] = type */
2250 };
2251 static const ProtobufCIntRange mumble_proto__permission_denied__number_ranges[1 + 1] =
2252 {
2253   { 1, 0 },
2254   { 0, 5 }
2255 };
2256 const ProtobufCMessageDescriptor mumble_proto__permission_denied__descriptor =
2257 {
2258   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2259   "MumbleProto.PermissionDenied",
2260   "PermissionDenied",
2261   "MumbleProto__PermissionDenied",
2262   "MumbleProto",
2263   sizeof(MumbleProto__PermissionDenied),
2264   5,
2265   mumble_proto__permission_denied__field_descriptors,
2266   mumble_proto__permission_denied__field_indices_by_name,
2267   1,  mumble_proto__permission_denied__number_ranges,
2268   NULL,NULL,NULL,NULL    /* reserved[1234] */
2269 };
2270 static const protobuf_c_boolean mumble_proto__acl__chan_group__inherited__default_value = 1;
2271 static const protobuf_c_boolean mumble_proto__acl__chan_group__inherit__default_value = 1;
2272 static const protobuf_c_boolean mumble_proto__acl__chan_group__inheritable__default_value = 1;
2273 static const ProtobufCFieldDescriptor mumble_proto__acl__chan_group__field_descriptors[7] =
2274 {
2275   {
2276     "name",
2277     1,
2278     PROTOBUF_C_LABEL_REQUIRED,
2279     PROTOBUF_C_TYPE_STRING,
2280     0,   /* quantifier_offset */
2281     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, name),
2282     NULL,
2283     NULL,
2284     NULL,NULL    /* reserved1, reserved2 */
2285   },
2286   {
2287     "inherited",
2288     2,
2289     PROTOBUF_C_LABEL_OPTIONAL,
2290     PROTOBUF_C_TYPE_BOOL,
2291     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, has_inherited),
2292     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, inherited),
2293     NULL,
2294     &mumble_proto__acl__chan_group__inherited__default_value,
2295     NULL,NULL    /* reserved1, reserved2 */
2296   },
2297   {
2298     "inherit",
2299     3,
2300     PROTOBUF_C_LABEL_OPTIONAL,
2301     PROTOBUF_C_TYPE_BOOL,
2302     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, has_inherit),
2303     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, inherit),
2304     NULL,
2305     &mumble_proto__acl__chan_group__inherit__default_value,
2306     NULL,NULL    /* reserved1, reserved2 */
2307   },
2308   {
2309     "inheritable",
2310     4,
2311     PROTOBUF_C_LABEL_OPTIONAL,
2312     PROTOBUF_C_TYPE_BOOL,
2313     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, has_inheritable),
2314     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, inheritable),
2315     NULL,
2316     &mumble_proto__acl__chan_group__inheritable__default_value,
2317     NULL,NULL    /* reserved1, reserved2 */
2318   },
2319   {
2320     "add",
2321     5,
2322     PROTOBUF_C_LABEL_REPEATED,
2323     PROTOBUF_C_TYPE_UINT32,
2324     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, n_add),
2325     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, add),
2326     NULL,
2327     NULL,
2328     NULL,NULL    /* reserved1, reserved2 */
2329   },
2330   {
2331     "remove",
2332     6,
2333     PROTOBUF_C_LABEL_REPEATED,
2334     PROTOBUF_C_TYPE_UINT32,
2335     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, n_remove),
2336     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, remove),
2337     NULL,
2338     NULL,
2339     NULL,NULL    /* reserved1, reserved2 */
2340   },
2341   {
2342     "inherited_members",
2343     7,
2344     PROTOBUF_C_LABEL_REPEATED,
2345     PROTOBUF_C_TYPE_UINT32,
2346     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, n_inherited_members),
2347     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanGroup, inherited_members),
2348     NULL,
2349     NULL,
2350     NULL,NULL    /* reserved1, reserved2 */
2351   },
2352 };
2353 static const unsigned mumble_proto__acl__chan_group__field_indices_by_name[] = {
2354   4,   /* field[4] = add */
2355   2,   /* field[2] = inherit */
2356   3,   /* field[3] = inheritable */
2357   1,   /* field[1] = inherited */
2358   6,   /* field[6] = inherited_members */
2359   0,   /* field[0] = name */
2360   5,   /* field[5] = remove */
2361 };
2362 static const ProtobufCIntRange mumble_proto__acl__chan_group__number_ranges[1 + 1] =
2363 {
2364   { 1, 0 },
2365   { 0, 7 }
2366 };
2367 const ProtobufCMessageDescriptor mumble_proto__acl__chan_group__descriptor =
2368 {
2369   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2370   "MumbleProto.ACL.ChanGroup",
2371   "ChanGroup",
2372   "MumbleProto__ACL__ChanGroup",
2373   "MumbleProto",
2374   sizeof(MumbleProto__ACL__ChanGroup),
2375   7,
2376   mumble_proto__acl__chan_group__field_descriptors,
2377   mumble_proto__acl__chan_group__field_indices_by_name,
2378   1,  mumble_proto__acl__chan_group__number_ranges,
2379   NULL,NULL,NULL,NULL    /* reserved[1234] */
2380 };
2381 static const protobuf_c_boolean mumble_proto__acl__chan_acl__apply_here__default_value = 1;
2382 static const protobuf_c_boolean mumble_proto__acl__chan_acl__apply_subs__default_value = 1;
2383 static const protobuf_c_boolean mumble_proto__acl__chan_acl__inherited__default_value = 1;
2384 static const ProtobufCFieldDescriptor mumble_proto__acl__chan_acl__field_descriptors[7] =
2385 {
2386   {
2387     "apply_here",
2388     1,
2389     PROTOBUF_C_LABEL_OPTIONAL,
2390     PROTOBUF_C_TYPE_BOOL,
2391     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_apply_here),
2392     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, apply_here),
2393     NULL,
2394     &mumble_proto__acl__chan_acl__apply_here__default_value,
2395     NULL,NULL    /* reserved1, reserved2 */
2396   },
2397   {
2398     "apply_subs",
2399     2,
2400     PROTOBUF_C_LABEL_OPTIONAL,
2401     PROTOBUF_C_TYPE_BOOL,
2402     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_apply_subs),
2403     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, apply_subs),
2404     NULL,
2405     &mumble_proto__acl__chan_acl__apply_subs__default_value,
2406     NULL,NULL    /* reserved1, reserved2 */
2407   },
2408   {
2409     "inherited",
2410     3,
2411     PROTOBUF_C_LABEL_OPTIONAL,
2412     PROTOBUF_C_TYPE_BOOL,
2413     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_inherited),
2414     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, inherited),
2415     NULL,
2416     &mumble_proto__acl__chan_acl__inherited__default_value,
2417     NULL,NULL    /* reserved1, reserved2 */
2418   },
2419   {
2420     "user_id",
2421     4,
2422     PROTOBUF_C_LABEL_OPTIONAL,
2423     PROTOBUF_C_TYPE_UINT32,
2424     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_user_id),
2425     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, user_id),
2426     NULL,
2427     NULL,
2428     NULL,NULL    /* reserved1, reserved2 */
2429   },
2430   {
2431     "group",
2432     5,
2433     PROTOBUF_C_LABEL_OPTIONAL,
2434     PROTOBUF_C_TYPE_STRING,
2435     0,   /* quantifier_offset */
2436     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, group),
2437     NULL,
2438     NULL,
2439     NULL,NULL    /* reserved1, reserved2 */
2440   },
2441   {
2442     "grant",
2443     6,
2444     PROTOBUF_C_LABEL_OPTIONAL,
2445     PROTOBUF_C_TYPE_UINT32,
2446     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_grant),
2447     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, grant),
2448     NULL,
2449     NULL,
2450     NULL,NULL    /* reserved1, reserved2 */
2451   },
2452   {
2453     "deny",
2454     7,
2455     PROTOBUF_C_LABEL_OPTIONAL,
2456     PROTOBUF_C_TYPE_UINT32,
2457     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, has_deny),
2458     PROTOBUF_C_OFFSETOF(MumbleProto__ACL__ChanACL, deny),
2459     NULL,
2460     NULL,
2461     NULL,NULL    /* reserved1, reserved2 */
2462   },
2463 };
2464 static const unsigned mumble_proto__acl__chan_acl__field_indices_by_name[] = {
2465   0,   /* field[0] = apply_here */
2466   1,   /* field[1] = apply_subs */
2467   6,   /* field[6] = deny */
2468   5,   /* field[5] = grant */
2469   4,   /* field[4] = group */
2470   2,   /* field[2] = inherited */
2471   3,   /* field[3] = user_id */
2472 };
2473 static const ProtobufCIntRange mumble_proto__acl__chan_acl__number_ranges[1 + 1] =
2474 {
2475   { 1, 0 },
2476   { 0, 7 }
2477 };
2478 const ProtobufCMessageDescriptor mumble_proto__acl__chan_acl__descriptor =
2479 {
2480   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2481   "MumbleProto.ACL.ChanACL",
2482   "ChanACL",
2483   "MumbleProto__ACL__ChanACL",
2484   "MumbleProto",
2485   sizeof(MumbleProto__ACL__ChanACL),
2486   7,
2487   mumble_proto__acl__chan_acl__field_descriptors,
2488   mumble_proto__acl__chan_acl__field_indices_by_name,
2489   1,  mumble_proto__acl__chan_acl__number_ranges,
2490   NULL,NULL,NULL,NULL    /* reserved[1234] */
2491 };
2492 static const protobuf_c_boolean mumble_proto__acl__inherit_acls__default_value = 1;
2493 static const protobuf_c_boolean mumble_proto__acl__query__default_value = 0;
2494 static const ProtobufCFieldDescriptor mumble_proto__acl__field_descriptors[5] =
2495 {
2496   {
2497     "channel_id",
2498     1,
2499     PROTOBUF_C_LABEL_REQUIRED,
2500     PROTOBUF_C_TYPE_UINT32,
2501     0,   /* quantifier_offset */
2502     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, channel_id),
2503     NULL,
2504     NULL,
2505     NULL,NULL    /* reserved1, reserved2 */
2506   },
2507   {
2508     "inherit_acls",
2509     2,
2510     PROTOBUF_C_LABEL_OPTIONAL,
2511     PROTOBUF_C_TYPE_BOOL,
2512     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, has_inherit_acls),
2513     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, inherit_acls),
2514     NULL,
2515     &mumble_proto__acl__inherit_acls__default_value,
2516     NULL,NULL    /* reserved1, reserved2 */
2517   },
2518   {
2519     "groups",
2520     3,
2521     PROTOBUF_C_LABEL_REPEATED,
2522     PROTOBUF_C_TYPE_MESSAGE,
2523     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, n_groups),
2524     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, groups),
2525     &mumble_proto__acl__chan_group__descriptor,
2526     NULL,
2527     NULL,NULL    /* reserved1, reserved2 */
2528   },
2529   {
2530     "acls",
2531     4,
2532     PROTOBUF_C_LABEL_REPEATED,
2533     PROTOBUF_C_TYPE_MESSAGE,
2534     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, n_acls),
2535     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, acls),
2536     &mumble_proto__acl__chan_acl__descriptor,
2537     NULL,
2538     NULL,NULL    /* reserved1, reserved2 */
2539   },
2540   {
2541     "query",
2542     5,
2543     PROTOBUF_C_LABEL_OPTIONAL,
2544     PROTOBUF_C_TYPE_BOOL,
2545     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, has_query),
2546     PROTOBUF_C_OFFSETOF(MumbleProto__ACL, query),
2547     NULL,
2548     &mumble_proto__acl__query__default_value,
2549     NULL,NULL    /* reserved1, reserved2 */
2550   },
2551 };
2552 static const unsigned mumble_proto__acl__field_indices_by_name[] = {
2553   3,   /* field[3] = acls */
2554   0,   /* field[0] = channel_id */
2555   2,   /* field[2] = groups */
2556   1,   /* field[1] = inherit_acls */
2557   4,   /* field[4] = query */
2558 };
2559 static const ProtobufCIntRange mumble_proto__acl__number_ranges[1 + 1] =
2560 {
2561   { 1, 0 },
2562   { 0, 5 }
2563 };
2564 const ProtobufCMessageDescriptor mumble_proto__acl__descriptor =
2565 {
2566   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2567   "MumbleProto.ACL",
2568   "ACL",
2569   "MumbleProto__ACL",
2570   "MumbleProto",
2571   sizeof(MumbleProto__ACL),
2572   5,
2573   mumble_proto__acl__field_descriptors,
2574   mumble_proto__acl__field_indices_by_name,
2575   1,  mumble_proto__acl__number_ranges,
2576   NULL,NULL,NULL,NULL    /* reserved[1234] */
2577 };
2578 static const ProtobufCFieldDescriptor mumble_proto__query_users__field_descriptors[2] =
2579 {
2580   {
2581     "ids",
2582     1,
2583     PROTOBUF_C_LABEL_REPEATED,
2584     PROTOBUF_C_TYPE_UINT32,
2585     PROTOBUF_C_OFFSETOF(MumbleProto__QueryUsers, n_ids),
2586     PROTOBUF_C_OFFSETOF(MumbleProto__QueryUsers, ids),
2587     NULL,
2588     NULL,
2589     NULL,NULL    /* reserved1, reserved2 */
2590   },
2591   {
2592     "names",
2593     2,
2594     PROTOBUF_C_LABEL_REPEATED,
2595     PROTOBUF_C_TYPE_STRING,
2596     PROTOBUF_C_OFFSETOF(MumbleProto__QueryUsers, n_names),
2597     PROTOBUF_C_OFFSETOF(MumbleProto__QueryUsers, names),
2598     NULL,
2599     NULL,
2600     NULL,NULL    /* reserved1, reserved2 */
2601   },
2602 };
2603 static const unsigned mumble_proto__query_users__field_indices_by_name[] = {
2604   0,   /* field[0] = ids */
2605   1,   /* field[1] = names */
2606 };
2607 static const ProtobufCIntRange mumble_proto__query_users__number_ranges[1 + 1] =
2608 {
2609   { 1, 0 },
2610   { 0, 2 }
2611 };
2612 const ProtobufCMessageDescriptor mumble_proto__query_users__descriptor =
2613 {
2614   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2615   "MumbleProto.QueryUsers",
2616   "QueryUsers",
2617   "MumbleProto__QueryUsers",
2618   "MumbleProto",
2619   sizeof(MumbleProto__QueryUsers),
2620   2,
2621   mumble_proto__query_users__field_descriptors,
2622   mumble_proto__query_users__field_indices_by_name,
2623   1,  mumble_proto__query_users__number_ranges,
2624   NULL,NULL,NULL,NULL    /* reserved[1234] */
2625 };
2626 static const ProtobufCFieldDescriptor mumble_proto__crypt_setup__field_descriptors[3] =
2627 {
2628   {
2629     "key",
2630     1,
2631     PROTOBUF_C_LABEL_OPTIONAL,
2632     PROTOBUF_C_TYPE_BYTES,
2633     PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, has_key),
2634     PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, key),
2635     NULL,
2636     NULL,
2637     NULL,NULL    /* reserved1, reserved2 */
2638   },
2639   {
2640     "client_nonce",
2641     2,
2642     PROTOBUF_C_LABEL_OPTIONAL,
2643     PROTOBUF_C_TYPE_BYTES,
2644     PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, has_client_nonce),
2645     PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, client_nonce),
2646     NULL,
2647     NULL,
2648     NULL,NULL    /* reserved1, reserved2 */
2649   },
2650   {
2651     "server_nonce",
2652     3,
2653     PROTOBUF_C_LABEL_OPTIONAL,
2654     PROTOBUF_C_TYPE_BYTES,
2655     PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, has_server_nonce),
2656     PROTOBUF_C_OFFSETOF(MumbleProto__CryptSetup, server_nonce),
2657     NULL,
2658     NULL,
2659     NULL,NULL    /* reserved1, reserved2 */
2660   },
2661 };
2662 static const unsigned mumble_proto__crypt_setup__field_indices_by_name[] = {
2663   1,   /* field[1] = client_nonce */
2664   0,   /* field[0] = key */
2665   2,   /* field[2] = server_nonce */
2666 };
2667 static const ProtobufCIntRange mumble_proto__crypt_setup__number_ranges[1 + 1] =
2668 {
2669   { 1, 0 },
2670   { 0, 3 }
2671 };
2672 const ProtobufCMessageDescriptor mumble_proto__crypt_setup__descriptor =
2673 {
2674   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2675   "MumbleProto.CryptSetup",
2676   "CryptSetup",
2677   "MumbleProto__CryptSetup",
2678   "MumbleProto",
2679   sizeof(MumbleProto__CryptSetup),
2680   3,
2681   mumble_proto__crypt_setup__field_descriptors,
2682   mumble_proto__crypt_setup__field_indices_by_name,
2683   1,  mumble_proto__crypt_setup__number_ranges,
2684   NULL,NULL,NULL,NULL    /* reserved[1234] */
2685 };
2686 const ProtobufCEnumValue mumble_proto__context_action_add__context__enum_values_by_number[3] =
2687 {
2688   { "Server", "MUMBLE_PROTO__CONTEXT_ACTION_ADD__CONTEXT__SERVER", 1 },
2689   { "Channel", "MUMBLE_PROTO__CONTEXT_ACTION_ADD__CONTEXT__CHANNEL", 2 },
2690   { "User", "MUMBLE_PROTO__CONTEXT_ACTION_ADD__CONTEXT__USER", 4 },
2691 };
2692 static const ProtobufCIntRange mumble_proto__context_action_add__context__value_ranges[] = {
2693 {1, 0},{4, 2},{0, 3}
2694 };
2695 const ProtobufCEnumValueIndex mumble_proto__context_action_add__context__enum_values_by_name[3] =
2696 {
2697   { "Channel", 1 },
2698   { "Server", 0 },
2699   { "User", 2 },
2700 };
2701 const ProtobufCEnumDescriptor mumble_proto__context_action_add__context__descriptor =
2702 {
2703   PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC,
2704   "MumbleProto.ContextActionAdd.Context",
2705   "Context",
2706   "MumbleProto__ContextActionAdd__Context",
2707   "MumbleProto",
2708   3,
2709   mumble_proto__context_action_add__context__enum_values_by_number,
2710   3,
2711   mumble_proto__context_action_add__context__enum_values_by_name,
2712   2,
2713   mumble_proto__context_action_add__context__value_ranges,
2714   NULL,NULL,NULL,NULL   /* reserved[1234] */
2715 };
2716 static const ProtobufCFieldDescriptor mumble_proto__context_action_add__field_descriptors[3] =
2717 {
2718   {
2719     "action",
2720     1,
2721     PROTOBUF_C_LABEL_REQUIRED,
2722     PROTOBUF_C_TYPE_STRING,
2723     0,   /* quantifier_offset */
2724     PROTOBUF_C_OFFSETOF(MumbleProto__ContextActionAdd, action),
2725     NULL,
2726     NULL,
2727     NULL,NULL    /* reserved1, reserved2 */
2728   },
2729   {
2730     "text",
2731     2,
2732     PROTOBUF_C_LABEL_REQUIRED,
2733     PROTOBUF_C_TYPE_STRING,
2734     0,   /* quantifier_offset */
2735     PROTOBUF_C_OFFSETOF(MumbleProto__ContextActionAdd, text),
2736     NULL,
2737     NULL,
2738     NULL,NULL    /* reserved1, reserved2 */
2739   },
2740   {
2741     "context",
2742     3,
2743     PROTOBUF_C_LABEL_OPTIONAL,
2744     PROTOBUF_C_TYPE_UINT32,
2745     PROTOBUF_C_OFFSETOF(MumbleProto__ContextActionAdd, has_context),
2746     PROTOBUF_C_OFFSETOF(MumbleProto__ContextActionAdd, context),
2747     NULL,
2748     NULL,
2749     NULL,NULL    /* reserved1, reserved2 */
2750   },
2751 };
2752 static const unsigned mumble_proto__context_action_add__field_indices_by_name[] = {
2753   0,   /* field[0] = action */
2754   2,   /* field[2] = context */
2755   1,   /* field[1] = text */
2756 };
2757 static const ProtobufCIntRange mumble_proto__context_action_add__number_ranges[1 + 1] =
2758 {
2759   { 1, 0 },
2760   { 0, 3 }
2761 };
2762 const ProtobufCMessageDescriptor mumble_proto__context_action_add__descriptor =
2763 {
2764   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2765   "MumbleProto.ContextActionAdd",
2766   "ContextActionAdd",
2767   "MumbleProto__ContextActionAdd",
2768   "MumbleProto",
2769   sizeof(MumbleProto__ContextActionAdd),
2770   3,
2771   mumble_proto__context_action_add__field_descriptors,
2772   mumble_proto__context_action_add__field_indices_by_name,
2773   1,  mumble_proto__context_action_add__number_ranges,
2774   NULL,NULL,NULL,NULL    /* reserved[1234] */
2775 };
2776 static const ProtobufCFieldDescriptor mumble_proto__context_action__field_descriptors[3] =
2777 {
2778   {
2779     "session",
2780     1,
2781     PROTOBUF_C_LABEL_OPTIONAL,
2782     PROTOBUF_C_TYPE_UINT32,
2783     PROTOBUF_C_OFFSETOF(MumbleProto__ContextAction, has_session),
2784     PROTOBUF_C_OFFSETOF(MumbleProto__ContextAction, session),
2785     NULL,
2786     NULL,
2787     NULL,NULL    /* reserved1, reserved2 */
2788   },
2789   {
2790     "channel_id",
2791     2,
2792     PROTOBUF_C_LABEL_OPTIONAL,
2793     PROTOBUF_C_TYPE_UINT32,
2794     PROTOBUF_C_OFFSETOF(MumbleProto__ContextAction, has_channel_id),
2795     PROTOBUF_C_OFFSETOF(MumbleProto__ContextAction, channel_id),
2796     NULL,
2797     NULL,
2798     NULL,NULL    /* reserved1, reserved2 */
2799   },
2800   {
2801     "action",
2802     3,
2803     PROTOBUF_C_LABEL_REQUIRED,
2804     PROTOBUF_C_TYPE_STRING,
2805     0,   /* quantifier_offset */
2806     PROTOBUF_C_OFFSETOF(MumbleProto__ContextAction, action),
2807     NULL,
2808     NULL,
2809     NULL,NULL    /* reserved1, reserved2 */
2810   },
2811 };
2812 static const unsigned mumble_proto__context_action__field_indices_by_name[] = {
2813   2,   /* field[2] = action */
2814   1,   /* field[1] = channel_id */
2815   0,   /* field[0] = session */
2816 };
2817 static const ProtobufCIntRange mumble_proto__context_action__number_ranges[1 + 1] =
2818 {
2819   { 1, 0 },
2820   { 0, 3 }
2821 };
2822 const ProtobufCMessageDescriptor mumble_proto__context_action__descriptor =
2823 {
2824   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2825   "MumbleProto.ContextAction",
2826   "ContextAction",
2827   "MumbleProto__ContextAction",
2828   "MumbleProto",
2829   sizeof(MumbleProto__ContextAction),
2830   3,
2831   mumble_proto__context_action__field_descriptors,
2832   mumble_proto__context_action__field_indices_by_name,
2833   1,  mumble_proto__context_action__number_ranges,
2834   NULL,NULL,NULL,NULL    /* reserved[1234] */
2835 };
2836 static const ProtobufCFieldDescriptor mumble_proto__user_list__user__field_descriptors[2] =
2837 {
2838   {
2839     "user_id",
2840     1,
2841     PROTOBUF_C_LABEL_REQUIRED,
2842     PROTOBUF_C_TYPE_UINT32,
2843     0,   /* quantifier_offset */
2844     PROTOBUF_C_OFFSETOF(MumbleProto__UserList__User, user_id),
2845     NULL,
2846     NULL,
2847     NULL,NULL    /* reserved1, reserved2 */
2848   },
2849   {
2850     "name",
2851     2,
2852     PROTOBUF_C_LABEL_OPTIONAL,
2853     PROTOBUF_C_TYPE_STRING,
2854     0,   /* quantifier_offset */
2855     PROTOBUF_C_OFFSETOF(MumbleProto__UserList__User, name),
2856     NULL,
2857     NULL,
2858     NULL,NULL    /* reserved1, reserved2 */
2859   },
2860 };
2861 static const unsigned mumble_proto__user_list__user__field_indices_by_name[] = {
2862   1,   /* field[1] = name */
2863   0,   /* field[0] = user_id */
2864 };
2865 static const ProtobufCIntRange mumble_proto__user_list__user__number_ranges[1 + 1] =
2866 {
2867   { 1, 0 },
2868   { 0, 2 }
2869 };
2870 const ProtobufCMessageDescriptor mumble_proto__user_list__user__descriptor =
2871 {
2872   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2873   "MumbleProto.UserList.User",
2874   "User",
2875   "MumbleProto__UserList__User",
2876   "MumbleProto",
2877   sizeof(MumbleProto__UserList__User),
2878   2,
2879   mumble_proto__user_list__user__field_descriptors,
2880   mumble_proto__user_list__user__field_indices_by_name,
2881   1,  mumble_proto__user_list__user__number_ranges,
2882   NULL,NULL,NULL,NULL    /* reserved[1234] */
2883 };
2884 static const ProtobufCFieldDescriptor mumble_proto__user_list__field_descriptors[1] =
2885 {
2886   {
2887     "users",
2888     1,
2889     PROTOBUF_C_LABEL_REPEATED,
2890     PROTOBUF_C_TYPE_MESSAGE,
2891     PROTOBUF_C_OFFSETOF(MumbleProto__UserList, n_users),
2892     PROTOBUF_C_OFFSETOF(MumbleProto__UserList, users),
2893     &mumble_proto__user_list__user__descriptor,
2894     NULL,
2895     NULL,NULL    /* reserved1, reserved2 */
2896   },
2897 };
2898 static const unsigned mumble_proto__user_list__field_indices_by_name[] = {
2899   0,   /* field[0] = users */
2900 };
2901 static const ProtobufCIntRange mumble_proto__user_list__number_ranges[1 + 1] =
2902 {
2903   { 1, 0 },
2904   { 0, 1 }
2905 };
2906 const ProtobufCMessageDescriptor mumble_proto__user_list__descriptor =
2907 {
2908   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2909   "MumbleProto.UserList",
2910   "UserList",
2911   "MumbleProto__UserList",
2912   "MumbleProto",
2913   sizeof(MumbleProto__UserList),
2914   1,
2915   mumble_proto__user_list__field_descriptors,
2916   mumble_proto__user_list__field_indices_by_name,
2917   1,  mumble_proto__user_list__number_ranges,
2918   NULL,NULL,NULL,NULL    /* reserved[1234] */
2919 };
2920 static const protobuf_c_boolean mumble_proto__voice_target__target__links__default_value = 0;
2921 static const protobuf_c_boolean mumble_proto__voice_target__target__children__default_value = 0;
2922 static const ProtobufCFieldDescriptor mumble_proto__voice_target__target__field_descriptors[5] =
2923 {
2924   {
2925     "session",
2926     1,
2927     PROTOBUF_C_LABEL_REPEATED,
2928     PROTOBUF_C_TYPE_UINT32,
2929     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, n_session),
2930     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, session),
2931     NULL,
2932     NULL,
2933     NULL,NULL    /* reserved1, reserved2 */
2934   },
2935   {
2936     "channel_id",
2937     2,
2938     PROTOBUF_C_LABEL_OPTIONAL,
2939     PROTOBUF_C_TYPE_UINT32,
2940     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, has_channel_id),
2941     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, channel_id),
2942     NULL,
2943     NULL,
2944     NULL,NULL    /* reserved1, reserved2 */
2945   },
2946   {
2947     "group",
2948     3,
2949     PROTOBUF_C_LABEL_OPTIONAL,
2950     PROTOBUF_C_TYPE_STRING,
2951     0,   /* quantifier_offset */
2952     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, group),
2953     NULL,
2954     NULL,
2955     NULL,NULL    /* reserved1, reserved2 */
2956   },
2957   {
2958     "links",
2959     4,
2960     PROTOBUF_C_LABEL_OPTIONAL,
2961     PROTOBUF_C_TYPE_BOOL,
2962     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, has_links),
2963     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, links),
2964     NULL,
2965     &mumble_proto__voice_target__target__links__default_value,
2966     NULL,NULL    /* reserved1, reserved2 */
2967   },
2968   {
2969     "children",
2970     5,
2971     PROTOBUF_C_LABEL_OPTIONAL,
2972     PROTOBUF_C_TYPE_BOOL,
2973     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, has_children),
2974     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget__Target, children),
2975     NULL,
2976     &mumble_proto__voice_target__target__children__default_value,
2977     NULL,NULL    /* reserved1, reserved2 */
2978   },
2979 };
2980 static const unsigned mumble_proto__voice_target__target__field_indices_by_name[] = {
2981   1,   /* field[1] = channel_id */
2982   4,   /* field[4] = children */
2983   2,   /* field[2] = group */
2984   3,   /* field[3] = links */
2985   0,   /* field[0] = session */
2986 };
2987 static const ProtobufCIntRange mumble_proto__voice_target__target__number_ranges[1 + 1] =
2988 {
2989   { 1, 0 },
2990   { 0, 5 }
2991 };
2992 const ProtobufCMessageDescriptor mumble_proto__voice_target__target__descriptor =
2993 {
2994   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
2995   "MumbleProto.VoiceTarget.Target",
2996   "Target",
2997   "MumbleProto__VoiceTarget__Target",
2998   "MumbleProto",
2999   sizeof(MumbleProto__VoiceTarget__Target),
3000   5,
3001   mumble_proto__voice_target__target__field_descriptors,
3002   mumble_proto__voice_target__target__field_indices_by_name,
3003   1,  mumble_proto__voice_target__target__number_ranges,
3004   NULL,NULL,NULL,NULL    /* reserved[1234] */
3005 };
3006 static const ProtobufCFieldDescriptor mumble_proto__voice_target__field_descriptors[2] =
3007 {
3008   {
3009     "id",
3010     1,
3011     PROTOBUF_C_LABEL_OPTIONAL,
3012     PROTOBUF_C_TYPE_UINT32,
3013     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget, has_id),
3014     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget, id),
3015     NULL,
3016     NULL,
3017     NULL,NULL    /* reserved1, reserved2 */
3018   },
3019   {
3020     "targets",
3021     2,
3022     PROTOBUF_C_LABEL_REPEATED,
3023     PROTOBUF_C_TYPE_MESSAGE,
3024     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget, n_targets),
3025     PROTOBUF_C_OFFSETOF(MumbleProto__VoiceTarget, targets),
3026     &mumble_proto__voice_target__target__descriptor,
3027     NULL,
3028     NULL,NULL    /* reserved1, reserved2 */
3029   },
3030 };
3031 static const unsigned mumble_proto__voice_target__field_indices_by_name[] = {
3032   0,   /* field[0] = id */
3033   1,   /* field[1] = targets */
3034 };
3035 static const ProtobufCIntRange mumble_proto__voice_target__number_ranges[1 + 1] =
3036 {
3037   { 1, 0 },
3038   { 0, 2 }
3039 };
3040 const ProtobufCMessageDescriptor mumble_proto__voice_target__descriptor =
3041 {
3042   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
3043   "MumbleProto.VoiceTarget",
3044   "VoiceTarget",
3045   "MumbleProto__VoiceTarget",
3046   "MumbleProto",
3047   sizeof(MumbleProto__VoiceTarget),
3048   2,
3049   mumble_proto__voice_target__field_descriptors,
3050   mumble_proto__voice_target__field_indices_by_name,
3051   1,  mumble_proto__voice_target__number_ranges,
3052   NULL,NULL,NULL,NULL    /* reserved[1234] */
3053 };
3054 static const protobuf_c_boolean mumble_proto__permission_query__flush__default_value = 0;
3055 static const ProtobufCFieldDescriptor mumble_proto__permission_query__field_descriptors[3] =
3056 {
3057   {
3058     "channel_id",
3059     1,
3060     PROTOBUF_C_LABEL_OPTIONAL,
3061     PROTOBUF_C_TYPE_UINT32,
3062     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, has_channel_id),
3063     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, channel_id),
3064     NULL,
3065     NULL,
3066     NULL,NULL    /* reserved1, reserved2 */
3067   },
3068   {
3069     "permissions",
3070     2,
3071     PROTOBUF_C_LABEL_OPTIONAL,
3072     PROTOBUF_C_TYPE_UINT32,
3073     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, has_permissions),
3074     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, permissions),
3075     NULL,
3076     NULL,
3077     NULL,NULL    /* reserved1, reserved2 */
3078   },
3079   {
3080     "flush",
3081     3,
3082     PROTOBUF_C_LABEL_OPTIONAL,
3083     PROTOBUF_C_TYPE_BOOL,
3084     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, has_flush),
3085     PROTOBUF_C_OFFSETOF(MumbleProto__PermissionQuery, flush),
3086     NULL,
3087     &mumble_proto__permission_query__flush__default_value,
3088     NULL,NULL    /* reserved1, reserved2 */
3089   },
3090 };
3091 static const unsigned mumble_proto__permission_query__field_indices_by_name[] = {
3092   0,   /* field[0] = channel_id */
3093   2,   /* field[2] = flush */
3094   1,   /* field[1] = permissions */
3095 };
3096 static const ProtobufCIntRange mumble_proto__permission_query__number_ranges[1 + 1] =
3097 {
3098   { 1, 0 },
3099   { 0, 3 }
3100 };
3101 const ProtobufCMessageDescriptor mumble_proto__permission_query__descriptor =
3102 {
3103   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
3104   "MumbleProto.PermissionQuery",
3105   "PermissionQuery",
3106   "MumbleProto__PermissionQuery",
3107   "MumbleProto",
3108   sizeof(MumbleProto__PermissionQuery),
3109   3,
3110   mumble_proto__permission_query__field_descriptors,
3111   mumble_proto__permission_query__field_indices_by_name,
3112   1,  mumble_proto__permission_query__number_ranges,
3113   NULL,NULL,NULL,NULL    /* reserved[1234] */
3114 };
3115 static const protobuf_c_boolean mumble_proto__codec_version__prefer_alpha__default_value = 1;
3116 static const ProtobufCFieldDescriptor mumble_proto__codec_version__field_descriptors[3] =
3117 {
3118   {
3119     "alpha",
3120     1,
3121     PROTOBUF_C_LABEL_REQUIRED,
3122     PROTOBUF_C_TYPE_INT32,
3123     0,   /* quantifier_offset */
3124     PROTOBUF_C_OFFSETOF(MumbleProto__CodecVersion, alpha),
3125     NULL,
3126     NULL,
3127     NULL,NULL    /* reserved1, reserved2 */
3128   },
3129   {
3130     "beta",
3131     2,
3132     PROTOBUF_C_LABEL_REQUIRED,
3133     PROTOBUF_C_TYPE_INT32,
3134     0,   /* quantifier_offset */
3135     PROTOBUF_C_OFFSETOF(MumbleProto__CodecVersion, beta),
3136     NULL,
3137     NULL,
3138     NULL,NULL    /* reserved1, reserved2 */
3139   },
3140   {
3141     "prefer_alpha",
3142     3,
3143     PROTOBUF_C_LABEL_REQUIRED,
3144     PROTOBUF_C_TYPE_BOOL,
3145     0,   /* quantifier_offset */
3146     PROTOBUF_C_OFFSETOF(MumbleProto__CodecVersion, prefer_alpha),
3147     NULL,
3148     &mumble_proto__codec_version__prefer_alpha__default_value,
3149     NULL,NULL    /* reserved1, reserved2 */
3150   },
3151 };
3152 static const unsigned mumble_proto__codec_version__field_indices_by_name[] = {
3153   0,   /* field[0] = alpha */
3154   1,   /* field[1] = beta */
3155   2,   /* field[2] = prefer_alpha */
3156 };
3157 static const ProtobufCIntRange mumble_proto__codec_version__number_ranges[1 + 1] =
3158 {
3159   { 1, 0 },
3160   { 0, 3 }
3161 };
3162 const ProtobufCMessageDescriptor mumble_proto__codec_version__descriptor =
3163 {
3164   PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC,
3165   "MumbleProto.CodecVersion",
3166   "CodecVersion",
3167   "MumbleProto__CodecVersion",
3168   "MumbleProto",
3169   sizeof(MumbleProto__CodecVersion),
3170   3,
3171   mumble_proto__codec_version__field_descriptors,
3172   mumble_proto__codec_version__field_indices_by_name,
3173   1,  mumble_proto__codec_version__number_ranges,
3174   NULL,NULL,NULL,NULL    /* reserved[1234] */
3175 };