/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
/* Generated from: rpc.proto */

/* Do not generate deprecated warnings for self */
#ifndef PROTOBUF_C__NO_DEPRECATED
#define PROTOBUF_C__NO_DEPRECATED
#endif

#include "rpc.pb-c.h"
void   etcdserverpb__response_header__init
                     (Etcdserverpb__ResponseHeader         *message)
{
  static const Etcdserverpb__ResponseHeader init_value = ETCDSERVERPB__RESPONSE_HEADER__INIT;
  *message = init_value;
}
size_t etcdserverpb__response_header__get_packed_size
                     (const Etcdserverpb__ResponseHeader *message)
{
  assert(message->base.descriptor == &etcdserverpb__response_header__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__response_header__pack
                     (const Etcdserverpb__ResponseHeader *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__response_header__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__response_header__pack_to_buffer
                     (const Etcdserverpb__ResponseHeader *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__response_header__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__ResponseHeader *
       etcdserverpb__response_header__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__ResponseHeader *)
     protobuf_c_message_unpack (&etcdserverpb__response_header__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__response_header__free_unpacked
                     (Etcdserverpb__ResponseHeader *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__response_header__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__range_request__init
                     (Etcdserverpb__RangeRequest         *message)
{
  static const Etcdserverpb__RangeRequest init_value = ETCDSERVERPB__RANGE_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__range_request__get_packed_size
                     (const Etcdserverpb__RangeRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__range_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__range_request__pack
                     (const Etcdserverpb__RangeRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__range_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__range_request__pack_to_buffer
                     (const Etcdserverpb__RangeRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__range_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__RangeRequest *
       etcdserverpb__range_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__RangeRequest *)
     protobuf_c_message_unpack (&etcdserverpb__range_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__range_request__free_unpacked
                     (Etcdserverpb__RangeRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__range_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__range_response__init
                     (Etcdserverpb__RangeResponse         *message)
{
  static const Etcdserverpb__RangeResponse init_value = ETCDSERVERPB__RANGE_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__range_response__get_packed_size
                     (const Etcdserverpb__RangeResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__range_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__range_response__pack
                     (const Etcdserverpb__RangeResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__range_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__range_response__pack_to_buffer
                     (const Etcdserverpb__RangeResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__range_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__RangeResponse *
       etcdserverpb__range_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__RangeResponse *)
     protobuf_c_message_unpack (&etcdserverpb__range_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__range_response__free_unpacked
                     (Etcdserverpb__RangeResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__range_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__put_request__init
                     (Etcdserverpb__PutRequest         *message)
{
  static const Etcdserverpb__PutRequest init_value = ETCDSERVERPB__PUT_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__put_request__get_packed_size
                     (const Etcdserverpb__PutRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__put_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__put_request__pack
                     (const Etcdserverpb__PutRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__put_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__put_request__pack_to_buffer
                     (const Etcdserverpb__PutRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__put_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__PutRequest *
       etcdserverpb__put_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__PutRequest *)
     protobuf_c_message_unpack (&etcdserverpb__put_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__put_request__free_unpacked
                     (Etcdserverpb__PutRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__put_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__put_response__init
                     (Etcdserverpb__PutResponse         *message)
{
  static const Etcdserverpb__PutResponse init_value = ETCDSERVERPB__PUT_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__put_response__get_packed_size
                     (const Etcdserverpb__PutResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__put_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__put_response__pack
                     (const Etcdserverpb__PutResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__put_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__put_response__pack_to_buffer
                     (const Etcdserverpb__PutResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__put_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__PutResponse *
       etcdserverpb__put_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__PutResponse *)
     protobuf_c_message_unpack (&etcdserverpb__put_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__put_response__free_unpacked
                     (Etcdserverpb__PutResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__put_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__delete_range_request__init
                     (Etcdserverpb__DeleteRangeRequest         *message)
{
  static const Etcdserverpb__DeleteRangeRequest init_value = ETCDSERVERPB__DELETE_RANGE_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__delete_range_request__get_packed_size
                     (const Etcdserverpb__DeleteRangeRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__delete_range_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__delete_range_request__pack
                     (const Etcdserverpb__DeleteRangeRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__delete_range_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__delete_range_request__pack_to_buffer
                     (const Etcdserverpb__DeleteRangeRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__delete_range_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__DeleteRangeRequest *
       etcdserverpb__delete_range_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__DeleteRangeRequest *)
     protobuf_c_message_unpack (&etcdserverpb__delete_range_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__delete_range_request__free_unpacked
                     (Etcdserverpb__DeleteRangeRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__delete_range_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__delete_range_response__init
                     (Etcdserverpb__DeleteRangeResponse         *message)
{
  static const Etcdserverpb__DeleteRangeResponse init_value = ETCDSERVERPB__DELETE_RANGE_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__delete_range_response__get_packed_size
                     (const Etcdserverpb__DeleteRangeResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__delete_range_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__delete_range_response__pack
                     (const Etcdserverpb__DeleteRangeResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__delete_range_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__delete_range_response__pack_to_buffer
                     (const Etcdserverpb__DeleteRangeResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__delete_range_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__DeleteRangeResponse *
       etcdserverpb__delete_range_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__DeleteRangeResponse *)
     protobuf_c_message_unpack (&etcdserverpb__delete_range_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__delete_range_response__free_unpacked
                     (Etcdserverpb__DeleteRangeResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__delete_range_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__watch_request__init
                     (Etcdserverpb__WatchRequest         *message)
{
  static const Etcdserverpb__WatchRequest init_value = ETCDSERVERPB__WATCH_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__watch_request__get_packed_size
                     (const Etcdserverpb__WatchRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__watch_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__watch_request__pack
                     (const Etcdserverpb__WatchRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__watch_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__watch_request__pack_to_buffer
                     (const Etcdserverpb__WatchRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__watch_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__WatchRequest *
       etcdserverpb__watch_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__WatchRequest *)
     protobuf_c_message_unpack (&etcdserverpb__watch_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__watch_request__free_unpacked
                     (Etcdserverpb__WatchRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__watch_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__watch_create_request__init
                     (Etcdserverpb__WatchCreateRequest         *message)
{
  static const Etcdserverpb__WatchCreateRequest init_value = ETCDSERVERPB__WATCH_CREATE_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__watch_create_request__get_packed_size
                     (const Etcdserverpb__WatchCreateRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__watch_create_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__watch_create_request__pack
                     (const Etcdserverpb__WatchCreateRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__watch_create_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__watch_create_request__pack_to_buffer
                     (const Etcdserverpb__WatchCreateRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__watch_create_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__WatchCreateRequest *
       etcdserverpb__watch_create_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__WatchCreateRequest *)
     protobuf_c_message_unpack (&etcdserverpb__watch_create_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__watch_create_request__free_unpacked
                     (Etcdserverpb__WatchCreateRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__watch_create_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__watch_cancel_request__init
                     (Etcdserverpb__WatchCancelRequest         *message)
{
  static const Etcdserverpb__WatchCancelRequest init_value = ETCDSERVERPB__WATCH_CANCEL_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__watch_cancel_request__get_packed_size
                     (const Etcdserverpb__WatchCancelRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__watch_cancel_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__watch_cancel_request__pack
                     (const Etcdserverpb__WatchCancelRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__watch_cancel_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__watch_cancel_request__pack_to_buffer
                     (const Etcdserverpb__WatchCancelRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__watch_cancel_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__WatchCancelRequest *
       etcdserverpb__watch_cancel_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__WatchCancelRequest *)
     protobuf_c_message_unpack (&etcdserverpb__watch_cancel_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__watch_cancel_request__free_unpacked
                     (Etcdserverpb__WatchCancelRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__watch_cancel_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__watch_progress_request__init
                     (Etcdserverpb__WatchProgressRequest         *message)
{
  static const Etcdserverpb__WatchProgressRequest init_value = ETCDSERVERPB__WATCH_PROGRESS_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__watch_progress_request__get_packed_size
                     (const Etcdserverpb__WatchProgressRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__watch_progress_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__watch_progress_request__pack
                     (const Etcdserverpb__WatchProgressRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__watch_progress_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__watch_progress_request__pack_to_buffer
                     (const Etcdserverpb__WatchProgressRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__watch_progress_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__WatchProgressRequest *
       etcdserverpb__watch_progress_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__WatchProgressRequest *)
     protobuf_c_message_unpack (&etcdserverpb__watch_progress_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__watch_progress_request__free_unpacked
                     (Etcdserverpb__WatchProgressRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__watch_progress_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__watch_response__init
                     (Etcdserverpb__WatchResponse         *message)
{
  static const Etcdserverpb__WatchResponse init_value = ETCDSERVERPB__WATCH_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__watch_response__get_packed_size
                     (const Etcdserverpb__WatchResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__watch_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__watch_response__pack
                     (const Etcdserverpb__WatchResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__watch_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__watch_response__pack_to_buffer
                     (const Etcdserverpb__WatchResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__watch_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__WatchResponse *
       etcdserverpb__watch_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__WatchResponse *)
     protobuf_c_message_unpack (&etcdserverpb__watch_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__watch_response__free_unpacked
                     (Etcdserverpb__WatchResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__watch_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__lease_grant_request__init
                     (Etcdserverpb__LeaseGrantRequest         *message)
{
  static const Etcdserverpb__LeaseGrantRequest init_value = ETCDSERVERPB__LEASE_GRANT_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__lease_grant_request__get_packed_size
                     (const Etcdserverpb__LeaseGrantRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__lease_grant_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__lease_grant_request__pack
                     (const Etcdserverpb__LeaseGrantRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__lease_grant_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__lease_grant_request__pack_to_buffer
                     (const Etcdserverpb__LeaseGrantRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__lease_grant_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__LeaseGrantRequest *
       etcdserverpb__lease_grant_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__LeaseGrantRequest *)
     protobuf_c_message_unpack (&etcdserverpb__lease_grant_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__lease_grant_request__free_unpacked
                     (Etcdserverpb__LeaseGrantRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__lease_grant_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__lease_grant_response__init
                     (Etcdserverpb__LeaseGrantResponse         *message)
{
  static const Etcdserverpb__LeaseGrantResponse init_value = ETCDSERVERPB__LEASE_GRANT_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__lease_grant_response__get_packed_size
                     (const Etcdserverpb__LeaseGrantResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__lease_grant_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__lease_grant_response__pack
                     (const Etcdserverpb__LeaseGrantResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__lease_grant_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__lease_grant_response__pack_to_buffer
                     (const Etcdserverpb__LeaseGrantResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__lease_grant_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__LeaseGrantResponse *
       etcdserverpb__lease_grant_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__LeaseGrantResponse *)
     protobuf_c_message_unpack (&etcdserverpb__lease_grant_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__lease_grant_response__free_unpacked
                     (Etcdserverpb__LeaseGrantResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__lease_grant_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__lease_revoke_request__init
                     (Etcdserverpb__LeaseRevokeRequest         *message)
{
  static const Etcdserverpb__LeaseRevokeRequest init_value = ETCDSERVERPB__LEASE_REVOKE_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__lease_revoke_request__get_packed_size
                     (const Etcdserverpb__LeaseRevokeRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__lease_revoke_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__lease_revoke_request__pack
                     (const Etcdserverpb__LeaseRevokeRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__lease_revoke_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__lease_revoke_request__pack_to_buffer
                     (const Etcdserverpb__LeaseRevokeRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__lease_revoke_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__LeaseRevokeRequest *
       etcdserverpb__lease_revoke_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__LeaseRevokeRequest *)
     protobuf_c_message_unpack (&etcdserverpb__lease_revoke_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__lease_revoke_request__free_unpacked
                     (Etcdserverpb__LeaseRevokeRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__lease_revoke_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__lease_revoke_response__init
                     (Etcdserverpb__LeaseRevokeResponse         *message)
{
  static const Etcdserverpb__LeaseRevokeResponse init_value = ETCDSERVERPB__LEASE_REVOKE_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__lease_revoke_response__get_packed_size
                     (const Etcdserverpb__LeaseRevokeResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__lease_revoke_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__lease_revoke_response__pack
                     (const Etcdserverpb__LeaseRevokeResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__lease_revoke_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__lease_revoke_response__pack_to_buffer
                     (const Etcdserverpb__LeaseRevokeResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__lease_revoke_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__LeaseRevokeResponse *
       etcdserverpb__lease_revoke_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__LeaseRevokeResponse *)
     protobuf_c_message_unpack (&etcdserverpb__lease_revoke_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__lease_revoke_response__free_unpacked
                     (Etcdserverpb__LeaseRevokeResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__lease_revoke_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__lease_keep_alive_request__init
                     (Etcdserverpb__LeaseKeepAliveRequest         *message)
{
  static const Etcdserverpb__LeaseKeepAliveRequest init_value = ETCDSERVERPB__LEASE_KEEP_ALIVE_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__lease_keep_alive_request__get_packed_size
                     (const Etcdserverpb__LeaseKeepAliveRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__lease_keep_alive_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__lease_keep_alive_request__pack
                     (const Etcdserverpb__LeaseKeepAliveRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__lease_keep_alive_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__lease_keep_alive_request__pack_to_buffer
                     (const Etcdserverpb__LeaseKeepAliveRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__lease_keep_alive_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__LeaseKeepAliveRequest *
       etcdserverpb__lease_keep_alive_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__LeaseKeepAliveRequest *)
     protobuf_c_message_unpack (&etcdserverpb__lease_keep_alive_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__lease_keep_alive_request__free_unpacked
                     (Etcdserverpb__LeaseKeepAliveRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__lease_keep_alive_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__lease_keep_alive_response__init
                     (Etcdserverpb__LeaseKeepAliveResponse         *message)
{
  static const Etcdserverpb__LeaseKeepAliveResponse init_value = ETCDSERVERPB__LEASE_KEEP_ALIVE_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__lease_keep_alive_response__get_packed_size
                     (const Etcdserverpb__LeaseKeepAliveResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__lease_keep_alive_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__lease_keep_alive_response__pack
                     (const Etcdserverpb__LeaseKeepAliveResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__lease_keep_alive_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__lease_keep_alive_response__pack_to_buffer
                     (const Etcdserverpb__LeaseKeepAliveResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__lease_keep_alive_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__LeaseKeepAliveResponse *
       etcdserverpb__lease_keep_alive_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__LeaseKeepAliveResponse *)
     protobuf_c_message_unpack (&etcdserverpb__lease_keep_alive_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__lease_keep_alive_response__free_unpacked
                     (Etcdserverpb__LeaseKeepAliveResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__lease_keep_alive_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__lease_time_to_live_request__init
                     (Etcdserverpb__LeaseTimeToLiveRequest         *message)
{
  static const Etcdserverpb__LeaseTimeToLiveRequest init_value = ETCDSERVERPB__LEASE_TIME_TO_LIVE_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__lease_time_to_live_request__get_packed_size
                     (const Etcdserverpb__LeaseTimeToLiveRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__lease_time_to_live_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__lease_time_to_live_request__pack
                     (const Etcdserverpb__LeaseTimeToLiveRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__lease_time_to_live_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__lease_time_to_live_request__pack_to_buffer
                     (const Etcdserverpb__LeaseTimeToLiveRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__lease_time_to_live_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__LeaseTimeToLiveRequest *
       etcdserverpb__lease_time_to_live_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__LeaseTimeToLiveRequest *)
     protobuf_c_message_unpack (&etcdserverpb__lease_time_to_live_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__lease_time_to_live_request__free_unpacked
                     (Etcdserverpb__LeaseTimeToLiveRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__lease_time_to_live_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__lease_time_to_live_response__init
                     (Etcdserverpb__LeaseTimeToLiveResponse         *message)
{
  static const Etcdserverpb__LeaseTimeToLiveResponse init_value = ETCDSERVERPB__LEASE_TIME_TO_LIVE_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__lease_time_to_live_response__get_packed_size
                     (const Etcdserverpb__LeaseTimeToLiveResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__lease_time_to_live_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__lease_time_to_live_response__pack
                     (const Etcdserverpb__LeaseTimeToLiveResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__lease_time_to_live_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__lease_time_to_live_response__pack_to_buffer
                     (const Etcdserverpb__LeaseTimeToLiveResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__lease_time_to_live_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__LeaseTimeToLiveResponse *
       etcdserverpb__lease_time_to_live_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__LeaseTimeToLiveResponse *)
     protobuf_c_message_unpack (&etcdserverpb__lease_time_to_live_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__lease_time_to_live_response__free_unpacked
                     (Etcdserverpb__LeaseTimeToLiveResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__lease_time_to_live_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__lease_leases_request__init
                     (Etcdserverpb__LeaseLeasesRequest         *message)
{
  static const Etcdserverpb__LeaseLeasesRequest init_value = ETCDSERVERPB__LEASE_LEASES_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__lease_leases_request__get_packed_size
                     (const Etcdserverpb__LeaseLeasesRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__lease_leases_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__lease_leases_request__pack
                     (const Etcdserverpb__LeaseLeasesRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__lease_leases_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__lease_leases_request__pack_to_buffer
                     (const Etcdserverpb__LeaseLeasesRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__lease_leases_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__LeaseLeasesRequest *
       etcdserverpb__lease_leases_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__LeaseLeasesRequest *)
     protobuf_c_message_unpack (&etcdserverpb__lease_leases_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__lease_leases_request__free_unpacked
                     (Etcdserverpb__LeaseLeasesRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__lease_leases_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__lease_status__init
                     (Etcdserverpb__LeaseStatus         *message)
{
  static const Etcdserverpb__LeaseStatus init_value = ETCDSERVERPB__LEASE_STATUS__INIT;
  *message = init_value;
}
size_t etcdserverpb__lease_status__get_packed_size
                     (const Etcdserverpb__LeaseStatus *message)
{
  assert(message->base.descriptor == &etcdserverpb__lease_status__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__lease_status__pack
                     (const Etcdserverpb__LeaseStatus *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__lease_status__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__lease_status__pack_to_buffer
                     (const Etcdserverpb__LeaseStatus *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__lease_status__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__LeaseStatus *
       etcdserverpb__lease_status__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__LeaseStatus *)
     protobuf_c_message_unpack (&etcdserverpb__lease_status__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__lease_status__free_unpacked
                     (Etcdserverpb__LeaseStatus *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__lease_status__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__lease_leases_response__init
                     (Etcdserverpb__LeaseLeasesResponse         *message)
{
  static const Etcdserverpb__LeaseLeasesResponse init_value = ETCDSERVERPB__LEASE_LEASES_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__lease_leases_response__get_packed_size
                     (const Etcdserverpb__LeaseLeasesResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__lease_leases_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__lease_leases_response__pack
                     (const Etcdserverpb__LeaseLeasesResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__lease_leases_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__lease_leases_response__pack_to_buffer
                     (const Etcdserverpb__LeaseLeasesResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__lease_leases_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__LeaseLeasesResponse *
       etcdserverpb__lease_leases_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__LeaseLeasesResponse *)
     protobuf_c_message_unpack (&etcdserverpb__lease_leases_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__lease_leases_response__free_unpacked
                     (Etcdserverpb__LeaseLeasesResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__lease_leases_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__compaction_request__init
                     (Etcdserverpb__CompactionRequest         *message)
{
  static const Etcdserverpb__CompactionRequest init_value = ETCDSERVERPB__COMPACTION_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__compaction_request__get_packed_size
                     (const Etcdserverpb__CompactionRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__compaction_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__compaction_request__pack
                     (const Etcdserverpb__CompactionRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__compaction_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__compaction_request__pack_to_buffer
                     (const Etcdserverpb__CompactionRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__compaction_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__CompactionRequest *
       etcdserverpb__compaction_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__CompactionRequest *)
     protobuf_c_message_unpack (&etcdserverpb__compaction_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__compaction_request__free_unpacked
                     (Etcdserverpb__CompactionRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__compaction_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__compaction_response__init
                     (Etcdserverpb__CompactionResponse         *message)
{
  static const Etcdserverpb__CompactionResponse init_value = ETCDSERVERPB__COMPACTION_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__compaction_response__get_packed_size
                     (const Etcdserverpb__CompactionResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__compaction_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__compaction_response__pack
                     (const Etcdserverpb__CompactionResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__compaction_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__compaction_response__pack_to_buffer
                     (const Etcdserverpb__CompactionResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__compaction_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__CompactionResponse *
       etcdserverpb__compaction_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__CompactionResponse *)
     protobuf_c_message_unpack (&etcdserverpb__compaction_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__compaction_response__free_unpacked
                     (Etcdserverpb__CompactionResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__compaction_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__status_request__init
                     (Etcdserverpb__StatusRequest         *message)
{
  static const Etcdserverpb__StatusRequest init_value = ETCDSERVERPB__STATUS_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__status_request__get_packed_size
                     (const Etcdserverpb__StatusRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__status_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__status_request__pack
                     (const Etcdserverpb__StatusRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__status_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__status_request__pack_to_buffer
                     (const Etcdserverpb__StatusRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__status_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__StatusRequest *
       etcdserverpb__status_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__StatusRequest *)
     protobuf_c_message_unpack (&etcdserverpb__status_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__status_request__free_unpacked
                     (Etcdserverpb__StatusRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__status_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__status_response__init
                     (Etcdserverpb__StatusResponse         *message)
{
  static const Etcdserverpb__StatusResponse init_value = ETCDSERVERPB__STATUS_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__status_response__get_packed_size
                     (const Etcdserverpb__StatusResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__status_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__status_response__pack
                     (const Etcdserverpb__StatusResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__status_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__status_response__pack_to_buffer
                     (const Etcdserverpb__StatusResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__status_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__StatusResponse *
       etcdserverpb__status_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__StatusResponse *)
     protobuf_c_message_unpack (&etcdserverpb__status_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__status_response__free_unpacked
                     (Etcdserverpb__StatusResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__status_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__alarm_member__init
                     (Etcdserverpb__AlarmMember         *message)
{
  static const Etcdserverpb__AlarmMember init_value = ETCDSERVERPB__ALARM_MEMBER__INIT;
  *message = init_value;
}
size_t etcdserverpb__alarm_member__get_packed_size
                     (const Etcdserverpb__AlarmMember *message)
{
  assert(message->base.descriptor == &etcdserverpb__alarm_member__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__alarm_member__pack
                     (const Etcdserverpb__AlarmMember *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__alarm_member__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__alarm_member__pack_to_buffer
                     (const Etcdserverpb__AlarmMember *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__alarm_member__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AlarmMember *
       etcdserverpb__alarm_member__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AlarmMember *)
     protobuf_c_message_unpack (&etcdserverpb__alarm_member__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__alarm_member__free_unpacked
                     (Etcdserverpb__AlarmMember *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__alarm_member__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__alarm_request__init
                     (Etcdserverpb__AlarmRequest         *message)
{
  static const Etcdserverpb__AlarmRequest init_value = ETCDSERVERPB__ALARM_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__alarm_request__get_packed_size
                     (const Etcdserverpb__AlarmRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__alarm_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__alarm_request__pack
                     (const Etcdserverpb__AlarmRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__alarm_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__alarm_request__pack_to_buffer
                     (const Etcdserverpb__AlarmRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__alarm_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AlarmRequest *
       etcdserverpb__alarm_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AlarmRequest *)
     protobuf_c_message_unpack (&etcdserverpb__alarm_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__alarm_request__free_unpacked
                     (Etcdserverpb__AlarmRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__alarm_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__alarm_response__init
                     (Etcdserverpb__AlarmResponse         *message)
{
  static const Etcdserverpb__AlarmResponse init_value = ETCDSERVERPB__ALARM_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__alarm_response__get_packed_size
                     (const Etcdserverpb__AlarmResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__alarm_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__alarm_response__pack
                     (const Etcdserverpb__AlarmResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__alarm_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__alarm_response__pack_to_buffer
                     (const Etcdserverpb__AlarmResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__alarm_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AlarmResponse *
       etcdserverpb__alarm_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AlarmResponse *)
     protobuf_c_message_unpack (&etcdserverpb__alarm_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__alarm_response__free_unpacked
                     (Etcdserverpb__AlarmResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__alarm_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__defragment_request__init
                     (Etcdserverpb__DefragmentRequest         *message)
{
  static const Etcdserverpb__DefragmentRequest init_value = ETCDSERVERPB__DEFRAGMENT_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__defragment_request__get_packed_size
                     (const Etcdserverpb__DefragmentRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__defragment_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__defragment_request__pack
                     (const Etcdserverpb__DefragmentRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__defragment_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__defragment_request__pack_to_buffer
                     (const Etcdserverpb__DefragmentRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__defragment_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__DefragmentRequest *
       etcdserverpb__defragment_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__DefragmentRequest *)
     protobuf_c_message_unpack (&etcdserverpb__defragment_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__defragment_request__free_unpacked
                     (Etcdserverpb__DefragmentRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__defragment_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__defragment_response__init
                     (Etcdserverpb__DefragmentResponse         *message)
{
  static const Etcdserverpb__DefragmentResponse init_value = ETCDSERVERPB__DEFRAGMENT_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__defragment_response__get_packed_size
                     (const Etcdserverpb__DefragmentResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__defragment_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__defragment_response__pack
                     (const Etcdserverpb__DefragmentResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__defragment_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__defragment_response__pack_to_buffer
                     (const Etcdserverpb__DefragmentResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__defragment_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__DefragmentResponse *
       etcdserverpb__defragment_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__DefragmentResponse *)
     protobuf_c_message_unpack (&etcdserverpb__defragment_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__defragment_response__free_unpacked
                     (Etcdserverpb__DefragmentResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__defragment_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__hash_kv_request__init
                     (Etcdserverpb__HashKVRequest         *message)
{
  static const Etcdserverpb__HashKVRequest init_value = ETCDSERVERPB__HASH_KV_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__hash_kv_request__get_packed_size
                     (const Etcdserverpb__HashKVRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__hash_kv_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__hash_kv_request__pack
                     (const Etcdserverpb__HashKVRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__hash_kv_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__hash_kv_request__pack_to_buffer
                     (const Etcdserverpb__HashKVRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__hash_kv_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__HashKVRequest *
       etcdserverpb__hash_kv_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__HashKVRequest *)
     protobuf_c_message_unpack (&etcdserverpb__hash_kv_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__hash_kv_request__free_unpacked
                     (Etcdserverpb__HashKVRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__hash_kv_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__hash_kv_response__init
                     (Etcdserverpb__HashKVResponse         *message)
{
  static const Etcdserverpb__HashKVResponse init_value = ETCDSERVERPB__HASH_KV_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__hash_kv_response__get_packed_size
                     (const Etcdserverpb__HashKVResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__hash_kv_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__hash_kv_response__pack
                     (const Etcdserverpb__HashKVResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__hash_kv_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__hash_kv_response__pack_to_buffer
                     (const Etcdserverpb__HashKVResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__hash_kv_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__HashKVResponse *
       etcdserverpb__hash_kv_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__HashKVResponse *)
     protobuf_c_message_unpack (&etcdserverpb__hash_kv_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__hash_kv_response__free_unpacked
                     (Etcdserverpb__HashKVResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__hash_kv_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__move_leader_request__init
                     (Etcdserverpb__MoveLeaderRequest         *message)
{
  static const Etcdserverpb__MoveLeaderRequest init_value = ETCDSERVERPB__MOVE_LEADER_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__move_leader_request__get_packed_size
                     (const Etcdserverpb__MoveLeaderRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__move_leader_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__move_leader_request__pack
                     (const Etcdserverpb__MoveLeaderRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__move_leader_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__move_leader_request__pack_to_buffer
                     (const Etcdserverpb__MoveLeaderRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__move_leader_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__MoveLeaderRequest *
       etcdserverpb__move_leader_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__MoveLeaderRequest *)
     protobuf_c_message_unpack (&etcdserverpb__move_leader_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__move_leader_request__free_unpacked
                     (Etcdserverpb__MoveLeaderRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__move_leader_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__move_leader_response__init
                     (Etcdserverpb__MoveLeaderResponse         *message)
{
  static const Etcdserverpb__MoveLeaderResponse init_value = ETCDSERVERPB__MOVE_LEADER_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__move_leader_response__get_packed_size
                     (const Etcdserverpb__MoveLeaderResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__move_leader_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__move_leader_response__pack
                     (const Etcdserverpb__MoveLeaderResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__move_leader_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__move_leader_response__pack_to_buffer
                     (const Etcdserverpb__MoveLeaderResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__move_leader_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__MoveLeaderResponse *
       etcdserverpb__move_leader_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__MoveLeaderResponse *)
     protobuf_c_message_unpack (&etcdserverpb__move_leader_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__move_leader_response__free_unpacked
                     (Etcdserverpb__MoveLeaderResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__move_leader_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_status_request__init
                     (Etcdserverpb__AuthStatusRequest         *message)
{
  static const Etcdserverpb__AuthStatusRequest init_value = ETCDSERVERPB__AUTH_STATUS_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_status_request__get_packed_size
                     (const Etcdserverpb__AuthStatusRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_status_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_status_request__pack
                     (const Etcdserverpb__AuthStatusRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_status_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_status_request__pack_to_buffer
                     (const Etcdserverpb__AuthStatusRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_status_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthStatusRequest *
       etcdserverpb__auth_status_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthStatusRequest *)
     protobuf_c_message_unpack (&etcdserverpb__auth_status_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_status_request__free_unpacked
                     (Etcdserverpb__AuthStatusRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_status_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_status_response__init
                     (Etcdserverpb__AuthStatusResponse         *message)
{
  static const Etcdserverpb__AuthStatusResponse init_value = ETCDSERVERPB__AUTH_STATUS_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_status_response__get_packed_size
                     (const Etcdserverpb__AuthStatusResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_status_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_status_response__pack
                     (const Etcdserverpb__AuthStatusResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_status_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_status_response__pack_to_buffer
                     (const Etcdserverpb__AuthStatusResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_status_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthStatusResponse *
       etcdserverpb__auth_status_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthStatusResponse *)
     protobuf_c_message_unpack (&etcdserverpb__auth_status_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_status_response__free_unpacked
                     (Etcdserverpb__AuthStatusResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_status_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__compare__init
                     (Etcdserverpb__Compare         *message)
{
  static const Etcdserverpb__Compare init_value = ETCDSERVERPB__COMPARE__INIT;
  *message = init_value;
}
size_t etcdserverpb__compare__get_packed_size
                     (const Etcdserverpb__Compare *message)
{
  assert(message->base.descriptor == &etcdserverpb__compare__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__compare__pack
                     (const Etcdserverpb__Compare *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__compare__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__compare__pack_to_buffer
                     (const Etcdserverpb__Compare *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__compare__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__Compare *
       etcdserverpb__compare__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__Compare *)
     protobuf_c_message_unpack (&etcdserverpb__compare__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__compare__free_unpacked
                     (Etcdserverpb__Compare *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__compare__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__request_op__init
                     (Etcdserverpb__RequestOp         *message)
{
  static const Etcdserverpb__RequestOp init_value = ETCDSERVERPB__REQUEST_OP__INIT;
  *message = init_value;
}
size_t etcdserverpb__request_op__get_packed_size
                     (const Etcdserverpb__RequestOp *message)
{
  assert(message->base.descriptor == &etcdserverpb__request_op__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__request_op__pack
                     (const Etcdserverpb__RequestOp *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__request_op__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__request_op__pack_to_buffer
                     (const Etcdserverpb__RequestOp *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__request_op__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__RequestOp *
       etcdserverpb__request_op__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__RequestOp *)
     protobuf_c_message_unpack (&etcdserverpb__request_op__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__request_op__free_unpacked
                     (Etcdserverpb__RequestOp *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__request_op__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__response_op__init
                     (Etcdserverpb__ResponseOp         *message)
{
  static const Etcdserverpb__ResponseOp init_value = ETCDSERVERPB__RESPONSE_OP__INIT;
  *message = init_value;
}
size_t etcdserverpb__response_op__get_packed_size
                     (const Etcdserverpb__ResponseOp *message)
{
  assert(message->base.descriptor == &etcdserverpb__response_op__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__response_op__pack
                     (const Etcdserverpb__ResponseOp *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__response_op__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__response_op__pack_to_buffer
                     (const Etcdserverpb__ResponseOp *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__response_op__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__ResponseOp *
       etcdserverpb__response_op__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__ResponseOp *)
     protobuf_c_message_unpack (&etcdserverpb__response_op__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__response_op__free_unpacked
                     (Etcdserverpb__ResponseOp *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__response_op__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__txn_request__init
                     (Etcdserverpb__TxnRequest         *message)
{
  static const Etcdserverpb__TxnRequest init_value = ETCDSERVERPB__TXN_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__txn_request__get_packed_size
                     (const Etcdserverpb__TxnRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__txn_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__txn_request__pack
                     (const Etcdserverpb__TxnRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__txn_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__txn_request__pack_to_buffer
                     (const Etcdserverpb__TxnRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__txn_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__TxnRequest *
       etcdserverpb__txn_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__TxnRequest *)
     protobuf_c_message_unpack (&etcdserverpb__txn_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__txn_request__free_unpacked
                     (Etcdserverpb__TxnRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__txn_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__txn_response__init
                     (Etcdserverpb__TxnResponse         *message)
{
  static const Etcdserverpb__TxnResponse init_value = ETCDSERVERPB__TXN_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__txn_response__get_packed_size
                     (const Etcdserverpb__TxnResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__txn_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__txn_response__pack
                     (const Etcdserverpb__TxnResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__txn_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__txn_response__pack_to_buffer
                     (const Etcdserverpb__TxnResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__txn_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__TxnResponse *
       etcdserverpb__txn_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__TxnResponse *)
     protobuf_c_message_unpack (&etcdserverpb__txn_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__txn_response__free_unpacked
                     (Etcdserverpb__TxnResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__txn_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__authenticate_request__init
                     (Etcdserverpb__AuthenticateRequest         *message)
{
  static const Etcdserverpb__AuthenticateRequest init_value = ETCDSERVERPB__AUTHENTICATE_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__authenticate_request__get_packed_size
                     (const Etcdserverpb__AuthenticateRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__authenticate_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__authenticate_request__pack
                     (const Etcdserverpb__AuthenticateRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__authenticate_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__authenticate_request__pack_to_buffer
                     (const Etcdserverpb__AuthenticateRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__authenticate_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthenticateRequest *
       etcdserverpb__authenticate_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthenticateRequest *)
     protobuf_c_message_unpack (&etcdserverpb__authenticate_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__authenticate_request__free_unpacked
                     (Etcdserverpb__AuthenticateRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__authenticate_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__authenticate_response__init
                     (Etcdserverpb__AuthenticateResponse         *message)
{
  static const Etcdserverpb__AuthenticateResponse init_value = ETCDSERVERPB__AUTHENTICATE_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__authenticate_response__get_packed_size
                     (const Etcdserverpb__AuthenticateResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__authenticate_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__authenticate_response__pack
                     (const Etcdserverpb__AuthenticateResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__authenticate_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__authenticate_response__pack_to_buffer
                     (const Etcdserverpb__AuthenticateResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__authenticate_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthenticateResponse *
       etcdserverpb__authenticate_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthenticateResponse *)
     protobuf_c_message_unpack (&etcdserverpb__authenticate_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__authenticate_response__free_unpacked
                     (Etcdserverpb__AuthenticateResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__authenticate_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_user_add_request__init
                     (Etcdserverpb__AuthUserAddRequest         *message)
{
  static const Etcdserverpb__AuthUserAddRequest init_value = ETCDSERVERPB__AUTH_USER_ADD_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_user_add_request__get_packed_size
                     (const Etcdserverpb__AuthUserAddRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_add_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_user_add_request__pack
                     (const Etcdserverpb__AuthUserAddRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_add_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_user_add_request__pack_to_buffer
                     (const Etcdserverpb__AuthUserAddRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_add_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthUserAddRequest *
       etcdserverpb__auth_user_add_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthUserAddRequest *)
     protobuf_c_message_unpack (&etcdserverpb__auth_user_add_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_user_add_request__free_unpacked
                     (Etcdserverpb__AuthUserAddRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_user_add_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_user_add_response__init
                     (Etcdserverpb__AuthUserAddResponse         *message)
{
  static const Etcdserverpb__AuthUserAddResponse init_value = ETCDSERVERPB__AUTH_USER_ADD_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_user_add_response__get_packed_size
                     (const Etcdserverpb__AuthUserAddResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_add_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_user_add_response__pack
                     (const Etcdserverpb__AuthUserAddResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_add_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_user_add_response__pack_to_buffer
                     (const Etcdserverpb__AuthUserAddResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_add_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthUserAddResponse *
       etcdserverpb__auth_user_add_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthUserAddResponse *)
     protobuf_c_message_unpack (&etcdserverpb__auth_user_add_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_user_add_response__free_unpacked
                     (Etcdserverpb__AuthUserAddResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_user_add_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_user_delete_request__init
                     (Etcdserverpb__AuthUserDeleteRequest         *message)
{
  static const Etcdserverpb__AuthUserDeleteRequest init_value = ETCDSERVERPB__AUTH_USER_DELETE_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_user_delete_request__get_packed_size
                     (const Etcdserverpb__AuthUserDeleteRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_delete_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_user_delete_request__pack
                     (const Etcdserverpb__AuthUserDeleteRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_delete_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_user_delete_request__pack_to_buffer
                     (const Etcdserverpb__AuthUserDeleteRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_delete_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthUserDeleteRequest *
       etcdserverpb__auth_user_delete_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthUserDeleteRequest *)
     protobuf_c_message_unpack (&etcdserverpb__auth_user_delete_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_user_delete_request__free_unpacked
                     (Etcdserverpb__AuthUserDeleteRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_user_delete_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_user_delete_response__init
                     (Etcdserverpb__AuthUserDeleteResponse         *message)
{
  static const Etcdserverpb__AuthUserDeleteResponse init_value = ETCDSERVERPB__AUTH_USER_DELETE_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_user_delete_response__get_packed_size
                     (const Etcdserverpb__AuthUserDeleteResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_delete_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_user_delete_response__pack
                     (const Etcdserverpb__AuthUserDeleteResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_delete_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_user_delete_response__pack_to_buffer
                     (const Etcdserverpb__AuthUserDeleteResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_delete_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthUserDeleteResponse *
       etcdserverpb__auth_user_delete_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthUserDeleteResponse *)
     protobuf_c_message_unpack (&etcdserverpb__auth_user_delete_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_user_delete_response__free_unpacked
                     (Etcdserverpb__AuthUserDeleteResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_user_delete_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_user_change_password_request__init
                     (Etcdserverpb__AuthUserChangePasswordRequest         *message)
{
  static const Etcdserverpb__AuthUserChangePasswordRequest init_value = ETCDSERVERPB__AUTH_USER_CHANGE_PASSWORD_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_user_change_password_request__get_packed_size
                     (const Etcdserverpb__AuthUserChangePasswordRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_change_password_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_user_change_password_request__pack
                     (const Etcdserverpb__AuthUserChangePasswordRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_change_password_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_user_change_password_request__pack_to_buffer
                     (const Etcdserverpb__AuthUserChangePasswordRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_change_password_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthUserChangePasswordRequest *
       etcdserverpb__auth_user_change_password_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthUserChangePasswordRequest *)
     protobuf_c_message_unpack (&etcdserverpb__auth_user_change_password_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_user_change_password_request__free_unpacked
                     (Etcdserverpb__AuthUserChangePasswordRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_user_change_password_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_user_change_password_response__init
                     (Etcdserverpb__AuthUserChangePasswordResponse         *message)
{
  static const Etcdserverpb__AuthUserChangePasswordResponse init_value = ETCDSERVERPB__AUTH_USER_CHANGE_PASSWORD_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_user_change_password_response__get_packed_size
                     (const Etcdserverpb__AuthUserChangePasswordResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_change_password_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_user_change_password_response__pack
                     (const Etcdserverpb__AuthUserChangePasswordResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_change_password_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_user_change_password_response__pack_to_buffer
                     (const Etcdserverpb__AuthUserChangePasswordResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_change_password_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthUserChangePasswordResponse *
       etcdserverpb__auth_user_change_password_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthUserChangePasswordResponse *)
     protobuf_c_message_unpack (&etcdserverpb__auth_user_change_password_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_user_change_password_response__free_unpacked
                     (Etcdserverpb__AuthUserChangePasswordResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_user_change_password_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_enable_request__init
                     (Etcdserverpb__AuthEnableRequest         *message)
{
  static const Etcdserverpb__AuthEnableRequest init_value = ETCDSERVERPB__AUTH_ENABLE_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_enable_request__get_packed_size
                     (const Etcdserverpb__AuthEnableRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_enable_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_enable_request__pack
                     (const Etcdserverpb__AuthEnableRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_enable_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_enable_request__pack_to_buffer
                     (const Etcdserverpb__AuthEnableRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_enable_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthEnableRequest *
       etcdserverpb__auth_enable_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthEnableRequest *)
     protobuf_c_message_unpack (&etcdserverpb__auth_enable_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_enable_request__free_unpacked
                     (Etcdserverpb__AuthEnableRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_enable_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_enable_response__init
                     (Etcdserverpb__AuthEnableResponse         *message)
{
  static const Etcdserverpb__AuthEnableResponse init_value = ETCDSERVERPB__AUTH_ENABLE_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_enable_response__get_packed_size
                     (const Etcdserverpb__AuthEnableResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_enable_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_enable_response__pack
                     (const Etcdserverpb__AuthEnableResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_enable_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_enable_response__pack_to_buffer
                     (const Etcdserverpb__AuthEnableResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_enable_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthEnableResponse *
       etcdserverpb__auth_enable_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthEnableResponse *)
     protobuf_c_message_unpack (&etcdserverpb__auth_enable_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_enable_response__free_unpacked
                     (Etcdserverpb__AuthEnableResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_enable_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_disable_request__init
                     (Etcdserverpb__AuthDisableRequest         *message)
{
  static const Etcdserverpb__AuthDisableRequest init_value = ETCDSERVERPB__AUTH_DISABLE_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_disable_request__get_packed_size
                     (const Etcdserverpb__AuthDisableRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_disable_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_disable_request__pack
                     (const Etcdserverpb__AuthDisableRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_disable_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_disable_request__pack_to_buffer
                     (const Etcdserverpb__AuthDisableRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_disable_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthDisableRequest *
       etcdserverpb__auth_disable_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthDisableRequest *)
     protobuf_c_message_unpack (&etcdserverpb__auth_disable_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_disable_request__free_unpacked
                     (Etcdserverpb__AuthDisableRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_disable_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_disable_response__init
                     (Etcdserverpb__AuthDisableResponse         *message)
{
  static const Etcdserverpb__AuthDisableResponse init_value = ETCDSERVERPB__AUTH_DISABLE_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_disable_response__get_packed_size
                     (const Etcdserverpb__AuthDisableResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_disable_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_disable_response__pack
                     (const Etcdserverpb__AuthDisableResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_disable_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_disable_response__pack_to_buffer
                     (const Etcdserverpb__AuthDisableResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_disable_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthDisableResponse *
       etcdserverpb__auth_disable_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthDisableResponse *)
     protobuf_c_message_unpack (&etcdserverpb__auth_disable_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_disable_response__free_unpacked
                     (Etcdserverpb__AuthDisableResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_disable_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__permission__init
                     (Etcdserverpb__Permission         *message)
{
  static const Etcdserverpb__Permission init_value = ETCDSERVERPB__PERMISSION__INIT;
  *message = init_value;
}
size_t etcdserverpb__permission__get_packed_size
                     (const Etcdserverpb__Permission *message)
{
  assert(message->base.descriptor == &etcdserverpb__permission__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__permission__pack
                     (const Etcdserverpb__Permission *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__permission__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__permission__pack_to_buffer
                     (const Etcdserverpb__Permission *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__permission__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__Permission *
       etcdserverpb__permission__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__Permission *)
     protobuf_c_message_unpack (&etcdserverpb__permission__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__permission__free_unpacked
                     (Etcdserverpb__Permission *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__permission__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__role__init
                     (Etcdserverpb__Role         *message)
{
  static const Etcdserverpb__Role init_value = ETCDSERVERPB__ROLE__INIT;
  *message = init_value;
}
size_t etcdserverpb__role__get_packed_size
                     (const Etcdserverpb__Role *message)
{
  assert(message->base.descriptor == &etcdserverpb__role__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__role__pack
                     (const Etcdserverpb__Role *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__role__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__role__pack_to_buffer
                     (const Etcdserverpb__Role *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__role__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__Role *
       etcdserverpb__role__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__Role *)
     protobuf_c_message_unpack (&etcdserverpb__role__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__role__free_unpacked
                     (Etcdserverpb__Role *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__role__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_role_add_request__init
                     (Etcdserverpb__AuthRoleAddRequest         *message)
{
  static const Etcdserverpb__AuthRoleAddRequest init_value = ETCDSERVERPB__AUTH_ROLE_ADD_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_role_add_request__get_packed_size
                     (const Etcdserverpb__AuthRoleAddRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_add_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_role_add_request__pack
                     (const Etcdserverpb__AuthRoleAddRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_add_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_role_add_request__pack_to_buffer
                     (const Etcdserverpb__AuthRoleAddRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_add_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthRoleAddRequest *
       etcdserverpb__auth_role_add_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthRoleAddRequest *)
     protobuf_c_message_unpack (&etcdserverpb__auth_role_add_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_role_add_request__free_unpacked
                     (Etcdserverpb__AuthRoleAddRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_role_add_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_role_add_response__init
                     (Etcdserverpb__AuthRoleAddResponse         *message)
{
  static const Etcdserverpb__AuthRoleAddResponse init_value = ETCDSERVERPB__AUTH_ROLE_ADD_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_role_add_response__get_packed_size
                     (const Etcdserverpb__AuthRoleAddResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_add_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_role_add_response__pack
                     (const Etcdserverpb__AuthRoleAddResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_add_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_role_add_response__pack_to_buffer
                     (const Etcdserverpb__AuthRoleAddResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_add_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthRoleAddResponse *
       etcdserverpb__auth_role_add_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthRoleAddResponse *)
     protobuf_c_message_unpack (&etcdserverpb__auth_role_add_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_role_add_response__free_unpacked
                     (Etcdserverpb__AuthRoleAddResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_role_add_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_role_delete_request__init
                     (Etcdserverpb__AuthRoleDeleteRequest         *message)
{
  static const Etcdserverpb__AuthRoleDeleteRequest init_value = ETCDSERVERPB__AUTH_ROLE_DELETE_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_role_delete_request__get_packed_size
                     (const Etcdserverpb__AuthRoleDeleteRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_delete_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_role_delete_request__pack
                     (const Etcdserverpb__AuthRoleDeleteRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_delete_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_role_delete_request__pack_to_buffer
                     (const Etcdserverpb__AuthRoleDeleteRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_delete_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthRoleDeleteRequest *
       etcdserverpb__auth_role_delete_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthRoleDeleteRequest *)
     protobuf_c_message_unpack (&etcdserverpb__auth_role_delete_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_role_delete_request__free_unpacked
                     (Etcdserverpb__AuthRoleDeleteRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_role_delete_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_role_delete_response__init
                     (Etcdserverpb__AuthRoleDeleteResponse         *message)
{
  static const Etcdserverpb__AuthRoleDeleteResponse init_value = ETCDSERVERPB__AUTH_ROLE_DELETE_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_role_delete_response__get_packed_size
                     (const Etcdserverpb__AuthRoleDeleteResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_delete_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_role_delete_response__pack
                     (const Etcdserverpb__AuthRoleDeleteResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_delete_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_role_delete_response__pack_to_buffer
                     (const Etcdserverpb__AuthRoleDeleteResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_delete_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthRoleDeleteResponse *
       etcdserverpb__auth_role_delete_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthRoleDeleteResponse *)
     protobuf_c_message_unpack (&etcdserverpb__auth_role_delete_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_role_delete_response__free_unpacked
                     (Etcdserverpb__AuthRoleDeleteResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_role_delete_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_role_get_request__init
                     (Etcdserverpb__AuthRoleGetRequest         *message)
{
  static const Etcdserverpb__AuthRoleGetRequest init_value = ETCDSERVERPB__AUTH_ROLE_GET_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_role_get_request__get_packed_size
                     (const Etcdserverpb__AuthRoleGetRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_get_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_role_get_request__pack
                     (const Etcdserverpb__AuthRoleGetRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_get_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_role_get_request__pack_to_buffer
                     (const Etcdserverpb__AuthRoleGetRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_get_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthRoleGetRequest *
       etcdserverpb__auth_role_get_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthRoleGetRequest *)
     protobuf_c_message_unpack (&etcdserverpb__auth_role_get_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_role_get_request__free_unpacked
                     (Etcdserverpb__AuthRoleGetRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_role_get_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_role_get_response__init
                     (Etcdserverpb__AuthRoleGetResponse         *message)
{
  static const Etcdserverpb__AuthRoleGetResponse init_value = ETCDSERVERPB__AUTH_ROLE_GET_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_role_get_response__get_packed_size
                     (const Etcdserverpb__AuthRoleGetResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_get_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_role_get_response__pack
                     (const Etcdserverpb__AuthRoleGetResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_get_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_role_get_response__pack_to_buffer
                     (const Etcdserverpb__AuthRoleGetResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_get_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthRoleGetResponse *
       etcdserverpb__auth_role_get_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthRoleGetResponse *)
     protobuf_c_message_unpack (&etcdserverpb__auth_role_get_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_role_get_response__free_unpacked
                     (Etcdserverpb__AuthRoleGetResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_role_get_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_role_list_request__init
                     (Etcdserverpb__AuthRoleListRequest         *message)
{
  static const Etcdserverpb__AuthRoleListRequest init_value = ETCDSERVERPB__AUTH_ROLE_LIST_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_role_list_request__get_packed_size
                     (const Etcdserverpb__AuthRoleListRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_list_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_role_list_request__pack
                     (const Etcdserverpb__AuthRoleListRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_list_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_role_list_request__pack_to_buffer
                     (const Etcdserverpb__AuthRoleListRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_list_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthRoleListRequest *
       etcdserverpb__auth_role_list_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthRoleListRequest *)
     protobuf_c_message_unpack (&etcdserverpb__auth_role_list_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_role_list_request__free_unpacked
                     (Etcdserverpb__AuthRoleListRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_role_list_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_role_list_response__init
                     (Etcdserverpb__AuthRoleListResponse         *message)
{
  static const Etcdserverpb__AuthRoleListResponse init_value = ETCDSERVERPB__AUTH_ROLE_LIST_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_role_list_response__get_packed_size
                     (const Etcdserverpb__AuthRoleListResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_list_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_role_list_response__pack
                     (const Etcdserverpb__AuthRoleListResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_list_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_role_list_response__pack_to_buffer
                     (const Etcdserverpb__AuthRoleListResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_list_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthRoleListResponse *
       etcdserverpb__auth_role_list_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthRoleListResponse *)
     protobuf_c_message_unpack (&etcdserverpb__auth_role_list_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_role_list_response__free_unpacked
                     (Etcdserverpb__AuthRoleListResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_role_list_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_role_grant_permission_request__init
                     (Etcdserverpb__AuthRoleGrantPermissionRequest         *message)
{
  static const Etcdserverpb__AuthRoleGrantPermissionRequest init_value = ETCDSERVERPB__AUTH_ROLE_GRANT_PERMISSION_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_role_grant_permission_request__get_packed_size
                     (const Etcdserverpb__AuthRoleGrantPermissionRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_grant_permission_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_role_grant_permission_request__pack
                     (const Etcdserverpb__AuthRoleGrantPermissionRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_grant_permission_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_role_grant_permission_request__pack_to_buffer
                     (const Etcdserverpb__AuthRoleGrantPermissionRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_grant_permission_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthRoleGrantPermissionRequest *
       etcdserverpb__auth_role_grant_permission_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthRoleGrantPermissionRequest *)
     protobuf_c_message_unpack (&etcdserverpb__auth_role_grant_permission_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_role_grant_permission_request__free_unpacked
                     (Etcdserverpb__AuthRoleGrantPermissionRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_role_grant_permission_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_role_grant_permission_response__init
                     (Etcdserverpb__AuthRoleGrantPermissionResponse         *message)
{
  static const Etcdserverpb__AuthRoleGrantPermissionResponse init_value = ETCDSERVERPB__AUTH_ROLE_GRANT_PERMISSION_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_role_grant_permission_response__get_packed_size
                     (const Etcdserverpb__AuthRoleGrantPermissionResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_grant_permission_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_role_grant_permission_response__pack
                     (const Etcdserverpb__AuthRoleGrantPermissionResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_grant_permission_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_role_grant_permission_response__pack_to_buffer
                     (const Etcdserverpb__AuthRoleGrantPermissionResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_grant_permission_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthRoleGrantPermissionResponse *
       etcdserverpb__auth_role_grant_permission_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthRoleGrantPermissionResponse *)
     protobuf_c_message_unpack (&etcdserverpb__auth_role_grant_permission_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_role_grant_permission_response__free_unpacked
                     (Etcdserverpb__AuthRoleGrantPermissionResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_role_grant_permission_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_role_revoke_permission_request__init
                     (Etcdserverpb__AuthRoleRevokePermissionRequest         *message)
{
  static const Etcdserverpb__AuthRoleRevokePermissionRequest init_value = ETCDSERVERPB__AUTH_ROLE_REVOKE_PERMISSION_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_role_revoke_permission_request__get_packed_size
                     (const Etcdserverpb__AuthRoleRevokePermissionRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_revoke_permission_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_role_revoke_permission_request__pack
                     (const Etcdserverpb__AuthRoleRevokePermissionRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_revoke_permission_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_role_revoke_permission_request__pack_to_buffer
                     (const Etcdserverpb__AuthRoleRevokePermissionRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_revoke_permission_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthRoleRevokePermissionRequest *
       etcdserverpb__auth_role_revoke_permission_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthRoleRevokePermissionRequest *)
     protobuf_c_message_unpack (&etcdserverpb__auth_role_revoke_permission_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_role_revoke_permission_request__free_unpacked
                     (Etcdserverpb__AuthRoleRevokePermissionRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_role_revoke_permission_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_role_revoke_permission_response__init
                     (Etcdserverpb__AuthRoleRevokePermissionResponse         *message)
{
  static const Etcdserverpb__AuthRoleRevokePermissionResponse init_value = ETCDSERVERPB__AUTH_ROLE_REVOKE_PERMISSION_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_role_revoke_permission_response__get_packed_size
                     (const Etcdserverpb__AuthRoleRevokePermissionResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_revoke_permission_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_role_revoke_permission_response__pack
                     (const Etcdserverpb__AuthRoleRevokePermissionResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_revoke_permission_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_role_revoke_permission_response__pack_to_buffer
                     (const Etcdserverpb__AuthRoleRevokePermissionResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_role_revoke_permission_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthRoleRevokePermissionResponse *
       etcdserverpb__auth_role_revoke_permission_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthRoleRevokePermissionResponse *)
     protobuf_c_message_unpack (&etcdserverpb__auth_role_revoke_permission_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_role_revoke_permission_response__free_unpacked
                     (Etcdserverpb__AuthRoleRevokePermissionResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_role_revoke_permission_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_user_grant_role_request__init
                     (Etcdserverpb__AuthUserGrantRoleRequest         *message)
{
  static const Etcdserverpb__AuthUserGrantRoleRequest init_value = ETCDSERVERPB__AUTH_USER_GRANT_ROLE_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_user_grant_role_request__get_packed_size
                     (const Etcdserverpb__AuthUserGrantRoleRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_grant_role_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_user_grant_role_request__pack
                     (const Etcdserverpb__AuthUserGrantRoleRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_grant_role_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_user_grant_role_request__pack_to_buffer
                     (const Etcdserverpb__AuthUserGrantRoleRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_grant_role_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthUserGrantRoleRequest *
       etcdserverpb__auth_user_grant_role_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthUserGrantRoleRequest *)
     protobuf_c_message_unpack (&etcdserverpb__auth_user_grant_role_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_user_grant_role_request__free_unpacked
                     (Etcdserverpb__AuthUserGrantRoleRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_user_grant_role_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_user_grant_role_response__init
                     (Etcdserverpb__AuthUserGrantRoleResponse         *message)
{
  static const Etcdserverpb__AuthUserGrantRoleResponse init_value = ETCDSERVERPB__AUTH_USER_GRANT_ROLE_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_user_grant_role_response__get_packed_size
                     (const Etcdserverpb__AuthUserGrantRoleResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_grant_role_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_user_grant_role_response__pack
                     (const Etcdserverpb__AuthUserGrantRoleResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_grant_role_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_user_grant_role_response__pack_to_buffer
                     (const Etcdserverpb__AuthUserGrantRoleResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_grant_role_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthUserGrantRoleResponse *
       etcdserverpb__auth_user_grant_role_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthUserGrantRoleResponse *)
     protobuf_c_message_unpack (&etcdserverpb__auth_user_grant_role_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_user_grant_role_response__free_unpacked
                     (Etcdserverpb__AuthUserGrantRoleResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_user_grant_role_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_user_revoke_role_request__init
                     (Etcdserverpb__AuthUserRevokeRoleRequest         *message)
{
  static const Etcdserverpb__AuthUserRevokeRoleRequest init_value = ETCDSERVERPB__AUTH_USER_REVOKE_ROLE_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_user_revoke_role_request__get_packed_size
                     (const Etcdserverpb__AuthUserRevokeRoleRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_revoke_role_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_user_revoke_role_request__pack
                     (const Etcdserverpb__AuthUserRevokeRoleRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_revoke_role_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_user_revoke_role_request__pack_to_buffer
                     (const Etcdserverpb__AuthUserRevokeRoleRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_revoke_role_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthUserRevokeRoleRequest *
       etcdserverpb__auth_user_revoke_role_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthUserRevokeRoleRequest *)
     protobuf_c_message_unpack (&etcdserverpb__auth_user_revoke_role_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_user_revoke_role_request__free_unpacked
                     (Etcdserverpb__AuthUserRevokeRoleRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_user_revoke_role_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_user_revoke_role_response__init
                     (Etcdserverpb__AuthUserRevokeRoleResponse         *message)
{
  static const Etcdserverpb__AuthUserRevokeRoleResponse init_value = ETCDSERVERPB__AUTH_USER_REVOKE_ROLE_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_user_revoke_role_response__get_packed_size
                     (const Etcdserverpb__AuthUserRevokeRoleResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_revoke_role_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_user_revoke_role_response__pack
                     (const Etcdserverpb__AuthUserRevokeRoleResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_revoke_role_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_user_revoke_role_response__pack_to_buffer
                     (const Etcdserverpb__AuthUserRevokeRoleResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_revoke_role_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthUserRevokeRoleResponse *
       etcdserverpb__auth_user_revoke_role_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthUserRevokeRoleResponse *)
     protobuf_c_message_unpack (&etcdserverpb__auth_user_revoke_role_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_user_revoke_role_response__free_unpacked
                     (Etcdserverpb__AuthUserRevokeRoleResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_user_revoke_role_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_user_get_request__init
                     (Etcdserverpb__AuthUserGetRequest         *message)
{
  static const Etcdserverpb__AuthUserGetRequest init_value = ETCDSERVERPB__AUTH_USER_GET_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_user_get_request__get_packed_size
                     (const Etcdserverpb__AuthUserGetRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_get_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_user_get_request__pack
                     (const Etcdserverpb__AuthUserGetRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_get_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_user_get_request__pack_to_buffer
                     (const Etcdserverpb__AuthUserGetRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_get_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthUserGetRequest *
       etcdserverpb__auth_user_get_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthUserGetRequest *)
     protobuf_c_message_unpack (&etcdserverpb__auth_user_get_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_user_get_request__free_unpacked
                     (Etcdserverpb__AuthUserGetRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_user_get_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_user_get_response__init
                     (Etcdserverpb__AuthUserGetResponse         *message)
{
  static const Etcdserverpb__AuthUserGetResponse init_value = ETCDSERVERPB__AUTH_USER_GET_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_user_get_response__get_packed_size
                     (const Etcdserverpb__AuthUserGetResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_get_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_user_get_response__pack
                     (const Etcdserverpb__AuthUserGetResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_get_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_user_get_response__pack_to_buffer
                     (const Etcdserverpb__AuthUserGetResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_get_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthUserGetResponse *
       etcdserverpb__auth_user_get_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthUserGetResponse *)
     protobuf_c_message_unpack (&etcdserverpb__auth_user_get_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_user_get_response__free_unpacked
                     (Etcdserverpb__AuthUserGetResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_user_get_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_user_list_request__init
                     (Etcdserverpb__AuthUserListRequest         *message)
{
  static const Etcdserverpb__AuthUserListRequest init_value = ETCDSERVERPB__AUTH_USER_LIST_REQUEST__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_user_list_request__get_packed_size
                     (const Etcdserverpb__AuthUserListRequest *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_list_request__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_user_list_request__pack
                     (const Etcdserverpb__AuthUserListRequest *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_list_request__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_user_list_request__pack_to_buffer
                     (const Etcdserverpb__AuthUserListRequest *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_list_request__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthUserListRequest *
       etcdserverpb__auth_user_list_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthUserListRequest *)
     protobuf_c_message_unpack (&etcdserverpb__auth_user_list_request__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_user_list_request__free_unpacked
                     (Etcdserverpb__AuthUserListRequest *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_user_list_request__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   etcdserverpb__auth_user_list_response__init
                     (Etcdserverpb__AuthUserListResponse         *message)
{
  static const Etcdserverpb__AuthUserListResponse init_value = ETCDSERVERPB__AUTH_USER_LIST_RESPONSE__INIT;
  *message = init_value;
}
size_t etcdserverpb__auth_user_list_response__get_packed_size
                     (const Etcdserverpb__AuthUserListResponse *message)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_list_response__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t etcdserverpb__auth_user_list_response__pack
                     (const Etcdserverpb__AuthUserListResponse *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_list_response__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t etcdserverpb__auth_user_list_response__pack_to_buffer
                     (const Etcdserverpb__AuthUserListResponse *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &etcdserverpb__auth_user_list_response__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Etcdserverpb__AuthUserListResponse *
       etcdserverpb__auth_user_list_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Etcdserverpb__AuthUserListResponse *)
     protobuf_c_message_unpack (&etcdserverpb__auth_user_list_response__descriptor,
                                allocator, len, data);
}
void   etcdserverpb__auth_user_list_response__free_unpacked
                     (Etcdserverpb__AuthUserListResponse *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &etcdserverpb__auth_user_list_response__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
static const ProtobufCFieldDescriptor etcdserverpb__response_header__field_descriptors[4] =
{
  {
    "cluster_id",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__ResponseHeader, cluster_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "member_id",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__ResponseHeader, member_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "revision",
    3,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__ResponseHeader, revision),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "raft_term",
    4,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__ResponseHeader, raft_term),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__response_header__field_indices_by_name[] = {
  0,   /* field[0] = cluster_id */
  1,   /* field[1] = member_id */
  3,   /* field[3] = raft_term */
  2,   /* field[2] = revision */
};
static const ProtobufCIntRange etcdserverpb__response_header__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 4 }
};
const ProtobufCMessageDescriptor etcdserverpb__response_header__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.ResponseHeader",
  "ResponseHeader",
  "Etcdserverpb__ResponseHeader",
  "etcdserverpb",
  sizeof(Etcdserverpb__ResponseHeader),
  4,
  etcdserverpb__response_header__field_descriptors,
  etcdserverpb__response_header__field_indices_by_name,
  1,  etcdserverpb__response_header__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__response_header__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCEnumValue etcdserverpb__range_request__sort_order__enum_values_by_number[3] =
{
  { "NONE", "ETCDSERVERPB__RANGE_REQUEST__SORT_ORDER__NONE", 0 },
  { "ASCEND", "ETCDSERVERPB__RANGE_REQUEST__SORT_ORDER__ASCEND", 1 },
  { "DESCEND", "ETCDSERVERPB__RANGE_REQUEST__SORT_ORDER__DESCEND", 2 },
};
static const ProtobufCIntRange etcdserverpb__range_request__sort_order__value_ranges[] = {
{0, 0},{0, 3}
};
static const ProtobufCEnumValueIndex etcdserverpb__range_request__sort_order__enum_values_by_name[3] =
{
  { "ASCEND", 1 },
  { "DESCEND", 2 },
  { "NONE", 0 },
};
const ProtobufCEnumDescriptor etcdserverpb__range_request__sort_order__descriptor =
{
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
  "etcdserverpb.RangeRequest.SortOrder",
  "SortOrder",
  "Etcdserverpb__RangeRequest__SortOrder",
  "etcdserverpb",
  3,
  etcdserverpb__range_request__sort_order__enum_values_by_number,
  3,
  etcdserverpb__range_request__sort_order__enum_values_by_name,
  1,
  etcdserverpb__range_request__sort_order__value_ranges,
  NULL,NULL,NULL,NULL   /* reserved[1234] */
};
static const ProtobufCEnumValue etcdserverpb__range_request__sort_target__enum_values_by_number[5] =
{
  { "KEY", "ETCDSERVERPB__RANGE_REQUEST__SORT_TARGET__KEY", 0 },
  { "VERSION", "ETCDSERVERPB__RANGE_REQUEST__SORT_TARGET__VERSION", 1 },
  { "CREATE", "ETCDSERVERPB__RANGE_REQUEST__SORT_TARGET__CREATE", 2 },
  { "MOD", "ETCDSERVERPB__RANGE_REQUEST__SORT_TARGET__MOD", 3 },
  { "VALUE", "ETCDSERVERPB__RANGE_REQUEST__SORT_TARGET__VALUE", 4 },
};
static const ProtobufCIntRange etcdserverpb__range_request__sort_target__value_ranges[] = {
{0, 0},{0, 5}
};
static const ProtobufCEnumValueIndex etcdserverpb__range_request__sort_target__enum_values_by_name[5] =
{
  { "CREATE", 2 },
  { "KEY", 0 },
  { "MOD", 3 },
  { "VALUE", 4 },
  { "VERSION", 1 },
};
const ProtobufCEnumDescriptor etcdserverpb__range_request__sort_target__descriptor =
{
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
  "etcdserverpb.RangeRequest.SortTarget",
  "SortTarget",
  "Etcdserverpb__RangeRequest__SortTarget",
  "etcdserverpb",
  5,
  etcdserverpb__range_request__sort_target__enum_values_by_number,
  5,
  etcdserverpb__range_request__sort_target__enum_values_by_name,
  1,
  etcdserverpb__range_request__sort_target__value_ranges,
  NULL,NULL,NULL,NULL   /* reserved[1234] */
};
static const ProtobufCFieldDescriptor etcdserverpb__range_request__field_descriptors[13] =
{
  {
    "key",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__RangeRequest, key),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "range_end",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__RangeRequest, range_end),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "limit",
    3,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__RangeRequest, limit),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "revision",
    4,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__RangeRequest, revision),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "sort_order",
    5,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_ENUM,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__RangeRequest, sort_order),
    &etcdserverpb__range_request__sort_order__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "sort_target",
    6,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_ENUM,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__RangeRequest, sort_target),
    &etcdserverpb__range_request__sort_target__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "serializable",
    7,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__RangeRequest, serializable),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "keys_only",
    8,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__RangeRequest, keys_only),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "count_only",
    9,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__RangeRequest, count_only),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "min_mod_revision",
    10,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__RangeRequest, min_mod_revision),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "max_mod_revision",
    11,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__RangeRequest, max_mod_revision),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "min_create_revision",
    12,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__RangeRequest, min_create_revision),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "max_create_revision",
    13,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__RangeRequest, max_create_revision),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__range_request__field_indices_by_name[] = {
  8,   /* field[8] = count_only */
  0,   /* field[0] = key */
  7,   /* field[7] = keys_only */
  2,   /* field[2] = limit */
  12,   /* field[12] = max_create_revision */
  10,   /* field[10] = max_mod_revision */
  11,   /* field[11] = min_create_revision */
  9,   /* field[9] = min_mod_revision */
  1,   /* field[1] = range_end */
  3,   /* field[3] = revision */
  6,   /* field[6] = serializable */
  4,   /* field[4] = sort_order */
  5,   /* field[5] = sort_target */
};
static const ProtobufCIntRange etcdserverpb__range_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 13 }
};
const ProtobufCMessageDescriptor etcdserverpb__range_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.RangeRequest",
  "RangeRequest",
  "Etcdserverpb__RangeRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__RangeRequest),
  13,
  etcdserverpb__range_request__field_descriptors,
  etcdserverpb__range_request__field_indices_by_name,
  1,  etcdserverpb__range_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__range_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__range_response__field_descriptors[4] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__RangeResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "kvs",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Etcdserverpb__RangeResponse, n_kvs),
    offsetof(Etcdserverpb__RangeResponse, kvs),
    &mvccpb__key_value__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "more",
    3,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__RangeResponse, more),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "count",
    4,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__RangeResponse, count),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__range_response__field_indices_by_name[] = {
  3,   /* field[3] = count */
  0,   /* field[0] = header */
  1,   /* field[1] = kvs */
  2,   /* field[2] = more */
};
static const ProtobufCIntRange etcdserverpb__range_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 4 }
};
const ProtobufCMessageDescriptor etcdserverpb__range_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.RangeResponse",
  "RangeResponse",
  "Etcdserverpb__RangeResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__RangeResponse),
  4,
  etcdserverpb__range_response__field_descriptors,
  etcdserverpb__range_response__field_indices_by_name,
  1,  etcdserverpb__range_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__range_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__put_request__field_descriptors[6] =
{
  {
    "key",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__PutRequest, key),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "value",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__PutRequest, value),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "lease",
    3,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__PutRequest, lease),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "prev_kv",
    4,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__PutRequest, prev_kv),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ignore_value",
    5,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__PutRequest, ignore_value),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ignore_lease",
    6,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__PutRequest, ignore_lease),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__put_request__field_indices_by_name[] = {
  5,   /* field[5] = ignore_lease */
  4,   /* field[4] = ignore_value */
  0,   /* field[0] = key */
  2,   /* field[2] = lease */
  3,   /* field[3] = prev_kv */
  1,   /* field[1] = value */
};
static const ProtobufCIntRange etcdserverpb__put_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 6 }
};
const ProtobufCMessageDescriptor etcdserverpb__put_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.PutRequest",
  "PutRequest",
  "Etcdserverpb__PutRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__PutRequest),
  6,
  etcdserverpb__put_request__field_descriptors,
  etcdserverpb__put_request__field_indices_by_name,
  1,  etcdserverpb__put_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__put_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__put_response__field_descriptors[2] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__PutResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "prev_kv",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__PutResponse, prev_kv),
    &mvccpb__key_value__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__put_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
  1,   /* field[1] = prev_kv */
};
static const ProtobufCIntRange etcdserverpb__put_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor etcdserverpb__put_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.PutResponse",
  "PutResponse",
  "Etcdserverpb__PutResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__PutResponse),
  2,
  etcdserverpb__put_response__field_descriptors,
  etcdserverpb__put_response__field_indices_by_name,
  1,  etcdserverpb__put_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__put_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__delete_range_request__field_descriptors[3] =
{
  {
    "key",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__DeleteRangeRequest, key),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "range_end",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__DeleteRangeRequest, range_end),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "prev_kv",
    3,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__DeleteRangeRequest, prev_kv),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__delete_range_request__field_indices_by_name[] = {
  0,   /* field[0] = key */
  2,   /* field[2] = prev_kv */
  1,   /* field[1] = range_end */
};
static const ProtobufCIntRange etcdserverpb__delete_range_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor etcdserverpb__delete_range_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.DeleteRangeRequest",
  "DeleteRangeRequest",
  "Etcdserverpb__DeleteRangeRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__DeleteRangeRequest),
  3,
  etcdserverpb__delete_range_request__field_descriptors,
  etcdserverpb__delete_range_request__field_indices_by_name,
  1,  etcdserverpb__delete_range_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__delete_range_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__delete_range_response__field_descriptors[3] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__DeleteRangeResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "deleted",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__DeleteRangeResponse, deleted),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "prev_kvs",
    3,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Etcdserverpb__DeleteRangeResponse, n_prev_kvs),
    offsetof(Etcdserverpb__DeleteRangeResponse, prev_kvs),
    &mvccpb__key_value__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__delete_range_response__field_indices_by_name[] = {
  1,   /* field[1] = deleted */
  0,   /* field[0] = header */
  2,   /* field[2] = prev_kvs */
};
static const ProtobufCIntRange etcdserverpb__delete_range_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor etcdserverpb__delete_range_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.DeleteRangeResponse",
  "DeleteRangeResponse",
  "Etcdserverpb__DeleteRangeResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__DeleteRangeResponse),
  3,
  etcdserverpb__delete_range_response__field_descriptors,
  etcdserverpb__delete_range_response__field_indices_by_name,
  1,  etcdserverpb__delete_range_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__delete_range_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__watch_request__field_descriptors[3] =
{
  {
    "create_request",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Etcdserverpb__WatchRequest, request_union_case),
    offsetof(Etcdserverpb__WatchRequest, create_request),
    &etcdserverpb__watch_create_request__descriptor,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "cancel_request",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Etcdserverpb__WatchRequest, request_union_case),
    offsetof(Etcdserverpb__WatchRequest, cancel_request),
    &etcdserverpb__watch_cancel_request__descriptor,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "progress_request",
    3,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Etcdserverpb__WatchRequest, request_union_case),
    offsetof(Etcdserverpb__WatchRequest, progress_request),
    &etcdserverpb__watch_progress_request__descriptor,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__watch_request__field_indices_by_name[] = {
  1,   /* field[1] = cancel_request */
  0,   /* field[0] = create_request */
  2,   /* field[2] = progress_request */
};
static const ProtobufCIntRange etcdserverpb__watch_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor etcdserverpb__watch_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.WatchRequest",
  "WatchRequest",
  "Etcdserverpb__WatchRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__WatchRequest),
  3,
  etcdserverpb__watch_request__field_descriptors,
  etcdserverpb__watch_request__field_indices_by_name,
  1,  etcdserverpb__watch_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__watch_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__watch_create_request__field_descriptors[6] =
{
  {
    "key",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__WatchCreateRequest, key),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "range_end",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__WatchCreateRequest, range_end),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "start_revision",
    3,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__WatchCreateRequest, start_revision),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "progress_notify",
    4,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__WatchCreateRequest, progress_notify),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "prev_kv",
    6,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__WatchCreateRequest, prev_kv),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "watch_id",
    7,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__WatchCreateRequest, watch_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__watch_create_request__field_indices_by_name[] = {
  0,   /* field[0] = key */
  4,   /* field[4] = prev_kv */
  3,   /* field[3] = progress_notify */
  1,   /* field[1] = range_end */
  2,   /* field[2] = start_revision */
  5,   /* field[5] = watch_id */
};
static const ProtobufCIntRange etcdserverpb__watch_create_request__number_ranges[2 + 1] =
{
  { 1, 0 },
  { 6, 4 },
  { 0, 6 }
};
const ProtobufCMessageDescriptor etcdserverpb__watch_create_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.WatchCreateRequest",
  "WatchCreateRequest",
  "Etcdserverpb__WatchCreateRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__WatchCreateRequest),
  6,
  etcdserverpb__watch_create_request__field_descriptors,
  etcdserverpb__watch_create_request__field_indices_by_name,
  2,  etcdserverpb__watch_create_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__watch_create_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__watch_cancel_request__field_descriptors[1] =
{
  {
    "watch_id",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__WatchCancelRequest, watch_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__watch_cancel_request__field_indices_by_name[] = {
  0,   /* field[0] = watch_id */
};
static const ProtobufCIntRange etcdserverpb__watch_cancel_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__watch_cancel_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.WatchCancelRequest",
  "WatchCancelRequest",
  "Etcdserverpb__WatchCancelRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__WatchCancelRequest),
  1,
  etcdserverpb__watch_cancel_request__field_descriptors,
  etcdserverpb__watch_cancel_request__field_indices_by_name,
  1,  etcdserverpb__watch_cancel_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__watch_cancel_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
#define etcdserverpb__watch_progress_request__field_descriptors NULL
#define etcdserverpb__watch_progress_request__field_indices_by_name NULL
#define etcdserverpb__watch_progress_request__number_ranges NULL
const ProtobufCMessageDescriptor etcdserverpb__watch_progress_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.WatchProgressRequest",
  "WatchProgressRequest",
  "Etcdserverpb__WatchProgressRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__WatchProgressRequest),
  0,
  etcdserverpb__watch_progress_request__field_descriptors,
  etcdserverpb__watch_progress_request__field_indices_by_name,
  0,  etcdserverpb__watch_progress_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__watch_progress_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__watch_response__field_descriptors[7] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__WatchResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "watch_id",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__WatchResponse, watch_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "created",
    3,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__WatchResponse, created),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "canceled",
    4,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__WatchResponse, canceled),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "compact_revision",
    5,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__WatchResponse, compact_revision),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "cancel_reason",
    6,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__WatchResponse, cancel_reason),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "events",
    11,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Etcdserverpb__WatchResponse, n_events),
    offsetof(Etcdserverpb__WatchResponse, events),
    &mvccpb__event__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__watch_response__field_indices_by_name[] = {
  5,   /* field[5] = cancel_reason */
  3,   /* field[3] = canceled */
  4,   /* field[4] = compact_revision */
  2,   /* field[2] = created */
  6,   /* field[6] = events */
  0,   /* field[0] = header */
  1,   /* field[1] = watch_id */
};
static const ProtobufCIntRange etcdserverpb__watch_response__number_ranges[2 + 1] =
{
  { 1, 0 },
  { 11, 6 },
  { 0, 7 }
};
const ProtobufCMessageDescriptor etcdserverpb__watch_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.WatchResponse",
  "WatchResponse",
  "Etcdserverpb__WatchResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__WatchResponse),
  7,
  etcdserverpb__watch_response__field_descriptors,
  etcdserverpb__watch_response__field_indices_by_name,
  2,  etcdserverpb__watch_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__watch_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__lease_grant_request__field_descriptors[2] =
{
  {
    "TTL",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__LeaseGrantRequest, ttl),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ID",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__LeaseGrantRequest, id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__lease_grant_request__field_indices_by_name[] = {
  1,   /* field[1] = ID */
  0,   /* field[0] = TTL */
};
static const ProtobufCIntRange etcdserverpb__lease_grant_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor etcdserverpb__lease_grant_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.LeaseGrantRequest",
  "LeaseGrantRequest",
  "Etcdserverpb__LeaseGrantRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__LeaseGrantRequest),
  2,
  etcdserverpb__lease_grant_request__field_descriptors,
  etcdserverpb__lease_grant_request__field_indices_by_name,
  1,  etcdserverpb__lease_grant_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__lease_grant_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__lease_grant_response__field_descriptors[4] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__LeaseGrantResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ID",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__LeaseGrantResponse, id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "TTL",
    3,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__LeaseGrantResponse, ttl),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "error",
    4,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__LeaseGrantResponse, error),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__lease_grant_response__field_indices_by_name[] = {
  1,   /* field[1] = ID */
  2,   /* field[2] = TTL */
  3,   /* field[3] = error */
  0,   /* field[0] = header */
};
static const ProtobufCIntRange etcdserverpb__lease_grant_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 4 }
};
const ProtobufCMessageDescriptor etcdserverpb__lease_grant_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.LeaseGrantResponse",
  "LeaseGrantResponse",
  "Etcdserverpb__LeaseGrantResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__LeaseGrantResponse),
  4,
  etcdserverpb__lease_grant_response__field_descriptors,
  etcdserverpb__lease_grant_response__field_indices_by_name,
  1,  etcdserverpb__lease_grant_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__lease_grant_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__lease_revoke_request__field_descriptors[1] =
{
  {
    "ID",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__LeaseRevokeRequest, id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__lease_revoke_request__field_indices_by_name[] = {
  0,   /* field[0] = ID */
};
static const ProtobufCIntRange etcdserverpb__lease_revoke_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__lease_revoke_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.LeaseRevokeRequest",
  "LeaseRevokeRequest",
  "Etcdserverpb__LeaseRevokeRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__LeaseRevokeRequest),
  1,
  etcdserverpb__lease_revoke_request__field_descriptors,
  etcdserverpb__lease_revoke_request__field_indices_by_name,
  1,  etcdserverpb__lease_revoke_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__lease_revoke_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__lease_revoke_response__field_descriptors[1] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__LeaseRevokeResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__lease_revoke_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
};
static const ProtobufCIntRange etcdserverpb__lease_revoke_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__lease_revoke_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.LeaseRevokeResponse",
  "LeaseRevokeResponse",
  "Etcdserverpb__LeaseRevokeResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__LeaseRevokeResponse),
  1,
  etcdserverpb__lease_revoke_response__field_descriptors,
  etcdserverpb__lease_revoke_response__field_indices_by_name,
  1,  etcdserverpb__lease_revoke_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__lease_revoke_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__lease_keep_alive_request__field_descriptors[1] =
{
  {
    "ID",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__LeaseKeepAliveRequest, id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__lease_keep_alive_request__field_indices_by_name[] = {
  0,   /* field[0] = ID */
};
static const ProtobufCIntRange etcdserverpb__lease_keep_alive_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__lease_keep_alive_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.LeaseKeepAliveRequest",
  "LeaseKeepAliveRequest",
  "Etcdserverpb__LeaseKeepAliveRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__LeaseKeepAliveRequest),
  1,
  etcdserverpb__lease_keep_alive_request__field_descriptors,
  etcdserverpb__lease_keep_alive_request__field_indices_by_name,
  1,  etcdserverpb__lease_keep_alive_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__lease_keep_alive_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__lease_keep_alive_response__field_descriptors[3] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__LeaseKeepAliveResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ID",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__LeaseKeepAliveResponse, id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "TTL",
    3,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__LeaseKeepAliveResponse, ttl),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__lease_keep_alive_response__field_indices_by_name[] = {
  1,   /* field[1] = ID */
  2,   /* field[2] = TTL */
  0,   /* field[0] = header */
};
static const ProtobufCIntRange etcdserverpb__lease_keep_alive_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor etcdserverpb__lease_keep_alive_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.LeaseKeepAliveResponse",
  "LeaseKeepAliveResponse",
  "Etcdserverpb__LeaseKeepAliveResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__LeaseKeepAliveResponse),
  3,
  etcdserverpb__lease_keep_alive_response__field_descriptors,
  etcdserverpb__lease_keep_alive_response__field_indices_by_name,
  1,  etcdserverpb__lease_keep_alive_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__lease_keep_alive_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__lease_time_to_live_request__field_descriptors[2] =
{
  {
    "ID",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__LeaseTimeToLiveRequest, id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "keys",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__LeaseTimeToLiveRequest, keys),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__lease_time_to_live_request__field_indices_by_name[] = {
  0,   /* field[0] = ID */
  1,   /* field[1] = keys */
};
static const ProtobufCIntRange etcdserverpb__lease_time_to_live_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor etcdserverpb__lease_time_to_live_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.LeaseTimeToLiveRequest",
  "LeaseTimeToLiveRequest",
  "Etcdserverpb__LeaseTimeToLiveRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__LeaseTimeToLiveRequest),
  2,
  etcdserverpb__lease_time_to_live_request__field_descriptors,
  etcdserverpb__lease_time_to_live_request__field_indices_by_name,
  1,  etcdserverpb__lease_time_to_live_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__lease_time_to_live_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__lease_time_to_live_response__field_descriptors[5] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__LeaseTimeToLiveResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ID",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__LeaseTimeToLiveResponse, id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "TTL",
    3,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__LeaseTimeToLiveResponse, ttl),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "grantedTTL",
    4,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__LeaseTimeToLiveResponse, grantedttl),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "keys",
    5,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Etcdserverpb__LeaseTimeToLiveResponse, n_keys),
    offsetof(Etcdserverpb__LeaseTimeToLiveResponse, keys),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__lease_time_to_live_response__field_indices_by_name[] = {
  1,   /* field[1] = ID */
  2,   /* field[2] = TTL */
  3,   /* field[3] = grantedTTL */
  0,   /* field[0] = header */
  4,   /* field[4] = keys */
};
static const ProtobufCIntRange etcdserverpb__lease_time_to_live_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 5 }
};
const ProtobufCMessageDescriptor etcdserverpb__lease_time_to_live_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.LeaseTimeToLiveResponse",
  "LeaseTimeToLiveResponse",
  "Etcdserverpb__LeaseTimeToLiveResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__LeaseTimeToLiveResponse),
  5,
  etcdserverpb__lease_time_to_live_response__field_descriptors,
  etcdserverpb__lease_time_to_live_response__field_indices_by_name,
  1,  etcdserverpb__lease_time_to_live_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__lease_time_to_live_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
#define etcdserverpb__lease_leases_request__field_descriptors NULL
#define etcdserverpb__lease_leases_request__field_indices_by_name NULL
#define etcdserverpb__lease_leases_request__number_ranges NULL
const ProtobufCMessageDescriptor etcdserverpb__lease_leases_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.LeaseLeasesRequest",
  "LeaseLeasesRequest",
  "Etcdserverpb__LeaseLeasesRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__LeaseLeasesRequest),
  0,
  etcdserverpb__lease_leases_request__field_descriptors,
  etcdserverpb__lease_leases_request__field_indices_by_name,
  0,  etcdserverpb__lease_leases_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__lease_leases_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__lease_status__field_descriptors[1] =
{
  {
    "ID",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__LeaseStatus, id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__lease_status__field_indices_by_name[] = {
  0,   /* field[0] = ID */
};
static const ProtobufCIntRange etcdserverpb__lease_status__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__lease_status__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.LeaseStatus",
  "LeaseStatus",
  "Etcdserverpb__LeaseStatus",
  "etcdserverpb",
  sizeof(Etcdserverpb__LeaseStatus),
  1,
  etcdserverpb__lease_status__field_descriptors,
  etcdserverpb__lease_status__field_indices_by_name,
  1,  etcdserverpb__lease_status__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__lease_status__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__lease_leases_response__field_descriptors[2] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__LeaseLeasesResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "leases",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Etcdserverpb__LeaseLeasesResponse, n_leases),
    offsetof(Etcdserverpb__LeaseLeasesResponse, leases),
    &etcdserverpb__lease_status__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__lease_leases_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
  1,   /* field[1] = leases */
};
static const ProtobufCIntRange etcdserverpb__lease_leases_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor etcdserverpb__lease_leases_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.LeaseLeasesResponse",
  "LeaseLeasesResponse",
  "Etcdserverpb__LeaseLeasesResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__LeaseLeasesResponse),
  2,
  etcdserverpb__lease_leases_response__field_descriptors,
  etcdserverpb__lease_leases_response__field_indices_by_name,
  1,  etcdserverpb__lease_leases_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__lease_leases_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__compaction_request__field_descriptors[2] =
{
  {
    "revision",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__CompactionRequest, revision),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "physical",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__CompactionRequest, physical),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__compaction_request__field_indices_by_name[] = {
  1,   /* field[1] = physical */
  0,   /* field[0] = revision */
};
static const ProtobufCIntRange etcdserverpb__compaction_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor etcdserverpb__compaction_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.CompactionRequest",
  "CompactionRequest",
  "Etcdserverpb__CompactionRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__CompactionRequest),
  2,
  etcdserverpb__compaction_request__field_descriptors,
  etcdserverpb__compaction_request__field_indices_by_name,
  1,  etcdserverpb__compaction_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__compaction_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__compaction_response__field_descriptors[1] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__CompactionResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__compaction_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
};
static const ProtobufCIntRange etcdserverpb__compaction_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__compaction_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.CompactionResponse",
  "CompactionResponse",
  "Etcdserverpb__CompactionResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__CompactionResponse),
  1,
  etcdserverpb__compaction_response__field_descriptors,
  etcdserverpb__compaction_response__field_indices_by_name,
  1,  etcdserverpb__compaction_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__compaction_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
#define etcdserverpb__status_request__field_descriptors NULL
#define etcdserverpb__status_request__field_indices_by_name NULL
#define etcdserverpb__status_request__number_ranges NULL
const ProtobufCMessageDescriptor etcdserverpb__status_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.StatusRequest",
  "StatusRequest",
  "Etcdserverpb__StatusRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__StatusRequest),
  0,
  etcdserverpb__status_request__field_descriptors,
  etcdserverpb__status_request__field_indices_by_name,
  0,  etcdserverpb__status_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__status_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__status_response__field_descriptors[10] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__StatusResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "version",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__StatusResponse, version),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "dbSize",
    3,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__StatusResponse, dbsize),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "leader",
    4,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__StatusResponse, leader),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "raftIndex",
    5,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__StatusResponse, raftindex),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "raftTerm",
    6,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__StatusResponse, raftterm),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "raftAppliedIndex",
    7,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__StatusResponse, raftappliedindex),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "errors",
    8,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_STRING,
    offsetof(Etcdserverpb__StatusResponse, n_errors),
    offsetof(Etcdserverpb__StatusResponse, errors),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "dbSizeInUse",
    9,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__StatusResponse, dbsizeinuse),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "isLearner",
    10,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__StatusResponse, islearner),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__status_response__field_indices_by_name[] = {
  2,   /* field[2] = dbSize */
  8,   /* field[8] = dbSizeInUse */
  7,   /* field[7] = errors */
  0,   /* field[0] = header */
  9,   /* field[9] = isLearner */
  3,   /* field[3] = leader */
  6,   /* field[6] = raftAppliedIndex */
  4,   /* field[4] = raftIndex */
  5,   /* field[5] = raftTerm */
  1,   /* field[1] = version */
};
static const ProtobufCIntRange etcdserverpb__status_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 10 }
};
const ProtobufCMessageDescriptor etcdserverpb__status_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.StatusResponse",
  "StatusResponse",
  "Etcdserverpb__StatusResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__StatusResponse),
  10,
  etcdserverpb__status_response__field_descriptors,
  etcdserverpb__status_response__field_indices_by_name,
  1,  etcdserverpb__status_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__status_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
/* AlarmType enum */
static const ProtobufCEnumValue etcdserverpb__alarm_type__enum_values_by_number[3] =
{
  { "NONE", "ETCDSERVERPB__ALARM_TYPE__NONE", 0 },
  { "NOSPACE", "ETCDSERVERPB__ALARM_TYPE__NOSPACE", 1 },
  { "CORRUPT", "ETCDSERVERPB__ALARM_TYPE__CORRUPT", 2 },
};
static const ProtobufCIntRange etcdserverpb__alarm_type__value_ranges[] = {
{0, 0},{0, 3}
};
static const ProtobufCEnumValueIndex etcdserverpb__alarm_type__enum_values_by_name[3] =
{
  { "CORRUPT", 2 },
  { "NONE", 0 },
  { "NOSPACE", 1 },
};
const ProtobufCEnumDescriptor etcdserverpb__alarm_type__descriptor =
{
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
  "etcdserverpb.AlarmType",
  "AlarmType",
  "Etcdserverpb__AlarmType",
  "etcdserverpb",
  3,
  etcdserverpb__alarm_type__enum_values_by_number,
  3,
  etcdserverpb__alarm_type__enum_values_by_name,
  1,
  etcdserverpb__alarm_type__value_ranges,
  NULL,NULL,NULL,NULL   /* reserved[1234] */
};
/* AlarmRequest AlarmAction enum */
static const ProtobufCEnumValue etcdserverpb__alarm_request__alarm_action__enum_values_by_number[3] =
{
  { "GET", "ETCDSERVERPB__ALARM_REQUEST__ALARM_ACTION__GET", 0 },
  { "ACTIVATE", "ETCDSERVERPB__ALARM_REQUEST__ALARM_ACTION__ACTIVATE", 1 },
  { "DEACTIVATE", "ETCDSERVERPB__ALARM_REQUEST__ALARM_ACTION__DEACTIVATE", 2 },
};
static const ProtobufCIntRange etcdserverpb__alarm_request__alarm_action__value_ranges[] = {
{0, 0},{0, 3}
};
static const ProtobufCEnumValueIndex etcdserverpb__alarm_request__alarm_action__enum_values_by_name[3] =
{
  { "ACTIVATE", 1 },
  { "DEACTIVATE", 2 },
  { "GET", 0 },
};
const ProtobufCEnumDescriptor etcdserverpb__alarm_request__alarm_action__descriptor =
{
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
  "etcdserverpb.AlarmRequest.AlarmAction",
  "AlarmAction",
  "Etcdserverpb__AlarmRequest__AlarmAction",
  "etcdserverpb",
  3,
  etcdserverpb__alarm_request__alarm_action__enum_values_by_number,
  3,
  etcdserverpb__alarm_request__alarm_action__enum_values_by_name,
  1,
  etcdserverpb__alarm_request__alarm_action__value_ranges,
  NULL,NULL,NULL,NULL   /* reserved[1234] */
};
/* AlarmMember */
static const ProtobufCFieldDescriptor etcdserverpb__alarm_member__field_descriptors[2] =
{
  {
    "memberID",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AlarmMember, memberid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "alarm",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_ENUM,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AlarmMember, alarm),
    &etcdserverpb__alarm_type__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__alarm_member__field_indices_by_name[] = {
  1,   /* field[1] = alarm */
  0,   /* field[0] = memberID */
};
static const ProtobufCIntRange etcdserverpb__alarm_member__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor etcdserverpb__alarm_member__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AlarmMember",
  "AlarmMember",
  "Etcdserverpb__AlarmMember",
  "etcdserverpb",
  sizeof(Etcdserverpb__AlarmMember),
  2,
  etcdserverpb__alarm_member__field_descriptors,
  etcdserverpb__alarm_member__field_indices_by_name,
  1,  etcdserverpb__alarm_member__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__alarm_member__init,
  NULL,NULL,NULL    /* reserved[123] */
};
/* AlarmRequest */
static const ProtobufCFieldDescriptor etcdserverpb__alarm_request__field_descriptors[3] =
{
  {
    "action",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_ENUM,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AlarmRequest, action),
    &etcdserverpb__alarm_request__alarm_action__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "memberID",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AlarmRequest, memberid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "alarm",
    3,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_ENUM,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AlarmRequest, alarm),
    &etcdserverpb__alarm_type__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__alarm_request__field_indices_by_name[] = {
  0,   /* field[0] = action */
  2,   /* field[2] = alarm */
  1,   /* field[1] = memberID */
};
static const ProtobufCIntRange etcdserverpb__alarm_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor etcdserverpb__alarm_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AlarmRequest",
  "AlarmRequest",
  "Etcdserverpb__AlarmRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__AlarmRequest),
  3,
  etcdserverpb__alarm_request__field_descriptors,
  etcdserverpb__alarm_request__field_indices_by_name,
  1,  etcdserverpb__alarm_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__alarm_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
/* AlarmResponse */
static const ProtobufCFieldDescriptor etcdserverpb__alarm_response__field_descriptors[2] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AlarmResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "alarms",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Etcdserverpb__AlarmResponse, n_alarms),
    offsetof(Etcdserverpb__AlarmResponse, alarms),
    &etcdserverpb__alarm_member__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__alarm_response__field_indices_by_name[] = {
  1,   /* field[1] = alarms */
  0,   /* field[0] = header */
};
static const ProtobufCIntRange etcdserverpb__alarm_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor etcdserverpb__alarm_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AlarmResponse",
  "AlarmResponse",
  "Etcdserverpb__AlarmResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__AlarmResponse),
  2,
  etcdserverpb__alarm_response__field_descriptors,
  etcdserverpb__alarm_response__field_indices_by_name,
  1,  etcdserverpb__alarm_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__alarm_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
/* DefragmentRequest - empty message */
#define etcdserverpb__defragment_request__field_descriptors NULL
#define etcdserverpb__defragment_request__field_indices_by_name NULL
#define etcdserverpb__defragment_request__number_ranges NULL
const ProtobufCMessageDescriptor etcdserverpb__defragment_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.DefragmentRequest",
  "DefragmentRequest",
  "Etcdserverpb__DefragmentRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__DefragmentRequest),
  0,
  etcdserverpb__defragment_request__field_descriptors,
  etcdserverpb__defragment_request__field_indices_by_name,
  0,  etcdserverpb__defragment_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__defragment_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
/* DefragmentResponse */
static const ProtobufCFieldDescriptor etcdserverpb__defragment_response__field_descriptors[1] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__DefragmentResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__defragment_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
};
static const ProtobufCIntRange etcdserverpb__defragment_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__defragment_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.DefragmentResponse",
  "DefragmentResponse",
  "Etcdserverpb__DefragmentResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__DefragmentResponse),
  1,
  etcdserverpb__defragment_response__field_descriptors,
  etcdserverpb__defragment_response__field_indices_by_name,
  1,  etcdserverpb__defragment_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__defragment_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
/* HashKVRequest */
static const ProtobufCFieldDescriptor etcdserverpb__hash_kv_request__field_descriptors[1] =
{
  {
    "revision",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__HashKVRequest, revision),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__hash_kv_request__field_indices_by_name[] = {
  0,   /* field[0] = revision */
};
static const ProtobufCIntRange etcdserverpb__hash_kv_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__hash_kv_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.HashKVRequest",
  "HashKVRequest",
  "Etcdserverpb__HashKVRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__HashKVRequest),
  1,
  etcdserverpb__hash_kv_request__field_descriptors,
  etcdserverpb__hash_kv_request__field_indices_by_name,
  1,  etcdserverpb__hash_kv_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__hash_kv_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
/* HashKVResponse */
static const ProtobufCFieldDescriptor etcdserverpb__hash_kv_response__field_descriptors[3] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__HashKVResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "hash",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__HashKVResponse, hash),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "compact_revision",
    3,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__HashKVResponse, compact_revision),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__hash_kv_response__field_indices_by_name[] = {
  2,   /* field[2] = compact_revision */
  1,   /* field[1] = hash */
  0,   /* field[0] = header */
};
static const ProtobufCIntRange etcdserverpb__hash_kv_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor etcdserverpb__hash_kv_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.HashKVResponse",
  "HashKVResponse",
  "Etcdserverpb__HashKVResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__HashKVResponse),
  3,
  etcdserverpb__hash_kv_response__field_descriptors,
  etcdserverpb__hash_kv_response__field_indices_by_name,
  1,  etcdserverpb__hash_kv_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__hash_kv_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
/* MoveLeaderRequest */
static const ProtobufCFieldDescriptor etcdserverpb__move_leader_request__field_descriptors[1] =
{
  {
    "targetID",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__MoveLeaderRequest, targetid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__move_leader_request__field_indices_by_name[] = {
  0,   /* field[0] = targetID */
};
static const ProtobufCIntRange etcdserverpb__move_leader_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__move_leader_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.MoveLeaderRequest",
  "MoveLeaderRequest",
  "Etcdserverpb__MoveLeaderRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__MoveLeaderRequest),
  1,
  etcdserverpb__move_leader_request__field_descriptors,
  etcdserverpb__move_leader_request__field_indices_by_name,
  1,  etcdserverpb__move_leader_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__move_leader_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
/* MoveLeaderResponse */
static const ProtobufCFieldDescriptor etcdserverpb__move_leader_response__field_descriptors[1] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__MoveLeaderResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__move_leader_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
};
static const ProtobufCIntRange etcdserverpb__move_leader_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__move_leader_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.MoveLeaderResponse",
  "MoveLeaderResponse",
  "Etcdserverpb__MoveLeaderResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__MoveLeaderResponse),
  1,
  etcdserverpb__move_leader_response__field_descriptors,
  etcdserverpb__move_leader_response__field_indices_by_name,
  1,  etcdserverpb__move_leader_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__move_leader_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
/* AuthStatusRequest - empty message */
#define etcdserverpb__auth_status_request__field_descriptors NULL
#define etcdserverpb__auth_status_request__field_indices_by_name NULL
#define etcdserverpb__auth_status_request__number_ranges NULL
const ProtobufCMessageDescriptor etcdserverpb__auth_status_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthStatusRequest",
  "AuthStatusRequest",
  "Etcdserverpb__AuthStatusRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthStatusRequest),
  0,
  etcdserverpb__auth_status_request__field_descriptors,
  etcdserverpb__auth_status_request__field_indices_by_name,
  0,  etcdserverpb__auth_status_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_status_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
/* AuthStatusResponse */
static const ProtobufCFieldDescriptor etcdserverpb__auth_status_response__field_descriptors[3] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthStatusResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "enabled",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthStatusResponse, enabled),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "authRevision",
    3,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthStatusResponse, authrevision),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_status_response__field_indices_by_name[] = {
  2,   /* field[2] = authRevision */
  1,   /* field[1] = enabled */
  0,   /* field[0] = header */
};
static const ProtobufCIntRange etcdserverpb__auth_status_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_status_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthStatusResponse",
  "AuthStatusResponse",
  "Etcdserverpb__AuthStatusResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthStatusResponse),
  3,
  etcdserverpb__auth_status_response__field_descriptors,
  etcdserverpb__auth_status_response__field_indices_by_name,
  1,  etcdserverpb__auth_status_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_status_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCEnumValue etcdserverpb__compare__compare_result__enum_values_by_number[4] =
{
  { "EQUAL", "ETCDSERVERPB__COMPARE__COMPARE_RESULT__EQUAL", 0 },
  { "GREATER", "ETCDSERVERPB__COMPARE__COMPARE_RESULT__GREATER", 1 },
  { "LESS", "ETCDSERVERPB__COMPARE__COMPARE_RESULT__LESS", 2 },
  { "NOT_EQUAL", "ETCDSERVERPB__COMPARE__COMPARE_RESULT__NOT_EQUAL", 3 },
};
static const ProtobufCIntRange etcdserverpb__compare__compare_result__value_ranges[] = {
{0, 0},{0, 4}
};
static const ProtobufCEnumValueIndex etcdserverpb__compare__compare_result__enum_values_by_name[4] =
{
  { "EQUAL", 0 },
  { "GREATER", 1 },
  { "LESS", 2 },
  { "NOT_EQUAL", 3 },
};
const ProtobufCEnumDescriptor etcdserverpb__compare__compare_result__descriptor =
{
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
  "etcdserverpb.Compare.CompareResult",
  "CompareResult",
  "Etcdserverpb__Compare__CompareResult",
  "etcdserverpb",
  4,
  etcdserverpb__compare__compare_result__enum_values_by_number,
  4,
  etcdserverpb__compare__compare_result__enum_values_by_name,
  1,
  etcdserverpb__compare__compare_result__value_ranges,
  NULL,NULL,NULL,NULL   /* reserved[1234] */
};
static const ProtobufCEnumValue etcdserverpb__compare__compare_target__enum_values_by_number[5] =
{
  { "VERSION", "ETCDSERVERPB__COMPARE__COMPARE_TARGET__VERSION", 0 },
  { "CREATE", "ETCDSERVERPB__COMPARE__COMPARE_TARGET__CREATE", 1 },
  { "MOD", "ETCDSERVERPB__COMPARE__COMPARE_TARGET__MOD", 2 },
  { "VALUE", "ETCDSERVERPB__COMPARE__COMPARE_TARGET__VALUE", 3 },
  { "LEASE", "ETCDSERVERPB__COMPARE__COMPARE_TARGET__LEASE", 4 },
};
static const ProtobufCIntRange etcdserverpb__compare__compare_target__value_ranges[] = {
{0, 0},{0, 5}
};
static const ProtobufCEnumValueIndex etcdserverpb__compare__compare_target__enum_values_by_name[5] =
{
  { "CREATE", 1 },
  { "LEASE", 4 },
  { "MOD", 2 },
  { "VALUE", 3 },
  { "VERSION", 0 },
};
const ProtobufCEnumDescriptor etcdserverpb__compare__compare_target__descriptor =
{
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
  "etcdserverpb.Compare.CompareTarget",
  "CompareTarget",
  "Etcdserverpb__Compare__CompareTarget",
  "etcdserverpb",
  5,
  etcdserverpb__compare__compare_target__enum_values_by_number,
  5,
  etcdserverpb__compare__compare_target__enum_values_by_name,
  1,
  etcdserverpb__compare__compare_target__value_ranges,
  NULL,NULL,NULL,NULL   /* reserved[1234] */
};
static const ProtobufCFieldDescriptor etcdserverpb__compare__field_descriptors[9] =
{
  {
    "result",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_ENUM,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__Compare, result),
    &etcdserverpb__compare__compare_result__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "target",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_ENUM,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__Compare, target),
    &etcdserverpb__compare__compare_target__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "key",
    3,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__Compare, key),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "version",
    4,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    offsetof(Etcdserverpb__Compare, target_union_case),
    offsetof(Etcdserverpb__Compare, version),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "create_revision",
    5,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    offsetof(Etcdserverpb__Compare, target_union_case),
    offsetof(Etcdserverpb__Compare, create_revision),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "mod_revision",
    6,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    offsetof(Etcdserverpb__Compare, target_union_case),
    offsetof(Etcdserverpb__Compare, mod_revision),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "value",
    7,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Etcdserverpb__Compare, target_union_case),
    offsetof(Etcdserverpb__Compare, value),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "lease",
    8,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_INT64,
    offsetof(Etcdserverpb__Compare, target_union_case),
    offsetof(Etcdserverpb__Compare, lease),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "range_end",
    64,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__Compare, range_end),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__compare__field_indices_by_name[] = {
  4,   /* field[4] = create_revision */
  2,   /* field[2] = key */
  7,   /* field[7] = lease */
  5,   /* field[5] = mod_revision */
  8,   /* field[8] = range_end */
  0,   /* field[0] = result */
  1,   /* field[1] = target */
  6,   /* field[6] = value */
  3,   /* field[3] = version */
};
static const ProtobufCIntRange etcdserverpb__compare__number_ranges[2 + 1] =
{
  { 1, 0 },
  { 64, 8 },
  { 0, 9 }
};
const ProtobufCMessageDescriptor etcdserverpb__compare__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.Compare",
  "Compare",
  "Etcdserverpb__Compare",
  "etcdserverpb",
  sizeof(Etcdserverpb__Compare),
  9,
  etcdserverpb__compare__field_descriptors,
  etcdserverpb__compare__field_indices_by_name,
  2,  etcdserverpb__compare__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__compare__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__request_op__field_descriptors[3] =
{
  {
    "request_range",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Etcdserverpb__RequestOp, request_case),
    offsetof(Etcdserverpb__RequestOp, request_range),
    &etcdserverpb__range_request__descriptor,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "request_put",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Etcdserverpb__RequestOp, request_case),
    offsetof(Etcdserverpb__RequestOp, request_put),
    &etcdserverpb__put_request__descriptor,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "request_delete_range",
    3,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Etcdserverpb__RequestOp, request_case),
    offsetof(Etcdserverpb__RequestOp, request_delete_range),
    &etcdserverpb__delete_range_request__descriptor,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__request_op__field_indices_by_name[] = {
  2,   /* field[2] = request_delete_range */
  1,   /* field[1] = request_put */
  0,   /* field[0] = request_range */
};
static const ProtobufCIntRange etcdserverpb__request_op__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor etcdserverpb__request_op__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.RequestOp",
  "RequestOp",
  "Etcdserverpb__RequestOp",
  "etcdserverpb",
  sizeof(Etcdserverpb__RequestOp),
  3,
  etcdserverpb__request_op__field_descriptors,
  etcdserverpb__request_op__field_indices_by_name,
  1,  etcdserverpb__request_op__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__request_op__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__response_op__field_descriptors[3] =
{
  {
    "response_range",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Etcdserverpb__ResponseOp, response_case),
    offsetof(Etcdserverpb__ResponseOp, response_range),
    &etcdserverpb__range_response__descriptor,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "response_put",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Etcdserverpb__ResponseOp, response_case),
    offsetof(Etcdserverpb__ResponseOp, response_put),
    &etcdserverpb__put_response__descriptor,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "response_delete_range",
    3,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Etcdserverpb__ResponseOp, response_case),
    offsetof(Etcdserverpb__ResponseOp, response_delete_range),
    &etcdserverpb__delete_range_response__descriptor,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__response_op__field_indices_by_name[] = {
  2,   /* field[2] = response_delete_range */
  1,   /* field[1] = response_put */
  0,   /* field[0] = response_range */
};
static const ProtobufCIntRange etcdserverpb__response_op__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor etcdserverpb__response_op__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.ResponseOp",
  "ResponseOp",
  "Etcdserverpb__ResponseOp",
  "etcdserverpb",
  sizeof(Etcdserverpb__ResponseOp),
  3,
  etcdserverpb__response_op__field_descriptors,
  etcdserverpb__response_op__field_indices_by_name,
  1,  etcdserverpb__response_op__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__response_op__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__txn_request__field_descriptors[3] =
{
  {
    "compare",
    1,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Etcdserverpb__TxnRequest, n_compare),
    offsetof(Etcdserverpb__TxnRequest, compare),
    &etcdserverpb__compare__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "success",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Etcdserverpb__TxnRequest, n_success),
    offsetof(Etcdserverpb__TxnRequest, success),
    &etcdserverpb__request_op__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "failure",
    3,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Etcdserverpb__TxnRequest, n_failure),
    offsetof(Etcdserverpb__TxnRequest, failure),
    &etcdserverpb__request_op__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__txn_request__field_indices_by_name[] = {
  0,   /* field[0] = compare */
  2,   /* field[2] = failure */
  1,   /* field[1] = success */
};
static const ProtobufCIntRange etcdserverpb__txn_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor etcdserverpb__txn_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.TxnRequest",
  "TxnRequest",
  "Etcdserverpb__TxnRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__TxnRequest),
  3,
  etcdserverpb__txn_request__field_descriptors,
  etcdserverpb__txn_request__field_indices_by_name,
  1,  etcdserverpb__txn_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__txn_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__txn_response__field_descriptors[3] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__TxnResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "succeeded",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__TxnResponse, succeeded),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "responses",
    3,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Etcdserverpb__TxnResponse, n_responses),
    offsetof(Etcdserverpb__TxnResponse, responses),
    &etcdserverpb__response_op__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__txn_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
  2,   /* field[2] = responses */
  1,   /* field[1] = succeeded */
};
static const ProtobufCIntRange etcdserverpb__txn_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor etcdserverpb__txn_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.TxnResponse",
  "TxnResponse",
  "Etcdserverpb__TxnResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__TxnResponse),
  3,
  etcdserverpb__txn_response__field_descriptors,
  etcdserverpb__txn_response__field_indices_by_name,
  1,  etcdserverpb__txn_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__txn_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__authenticate_request__field_descriptors[2] =
{
  {
    "name",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthenticateRequest, name),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "password",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthenticateRequest, password),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__authenticate_request__field_indices_by_name[] = {
  0,   /* field[0] = name */
  1,   /* field[1] = password */
};
static const ProtobufCIntRange etcdserverpb__authenticate_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor etcdserverpb__authenticate_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthenticateRequest",
  "AuthenticateRequest",
  "Etcdserverpb__AuthenticateRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthenticateRequest),
  2,
  etcdserverpb__authenticate_request__field_descriptors,
  etcdserverpb__authenticate_request__field_indices_by_name,
  1,  etcdserverpb__authenticate_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__authenticate_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__authenticate_response__field_descriptors[2] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthenticateResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "token",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthenticateResponse, token),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__authenticate_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
  1,   /* field[1] = token */
};
static const ProtobufCIntRange etcdserverpb__authenticate_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor etcdserverpb__authenticate_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthenticateResponse",
  "AuthenticateResponse",
  "Etcdserverpb__AuthenticateResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthenticateResponse),
  2,
  etcdserverpb__authenticate_response__field_descriptors,
  etcdserverpb__authenticate_response__field_indices_by_name,
  1,  etcdserverpb__authenticate_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__authenticate_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_user_add_request__field_descriptors[2] =
{
  {
    "name",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthUserAddRequest, name),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "password",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthUserAddRequest, password),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_user_add_request__field_indices_by_name[] = {
  0,   /* field[0] = name */
  1,   /* field[1] = password */
};
static const ProtobufCIntRange etcdserverpb__auth_user_add_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_user_add_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthUserAddRequest",
  "AuthUserAddRequest",
  "Etcdserverpb__AuthUserAddRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthUserAddRequest),
  2,
  etcdserverpb__auth_user_add_request__field_descriptors,
  etcdserverpb__auth_user_add_request__field_indices_by_name,
  1,  etcdserverpb__auth_user_add_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_user_add_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_user_add_response__field_descriptors[1] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthUserAddResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_user_add_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
};
static const ProtobufCIntRange etcdserverpb__auth_user_add_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_user_add_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthUserAddResponse",
  "AuthUserAddResponse",
  "Etcdserverpb__AuthUserAddResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthUserAddResponse),
  1,
  etcdserverpb__auth_user_add_response__field_descriptors,
  etcdserverpb__auth_user_add_response__field_indices_by_name,
  1,  etcdserverpb__auth_user_add_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_user_add_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_user_delete_request__field_descriptors[1] =
{
  {
    "name",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthUserDeleteRequest, name),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_user_delete_request__field_indices_by_name[] = {
  0,   /* field[0] = name */
};
static const ProtobufCIntRange etcdserverpb__auth_user_delete_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_user_delete_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthUserDeleteRequest",
  "AuthUserDeleteRequest",
  "Etcdserverpb__AuthUserDeleteRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthUserDeleteRequest),
  1,
  etcdserverpb__auth_user_delete_request__field_descriptors,
  etcdserverpb__auth_user_delete_request__field_indices_by_name,
  1,  etcdserverpb__auth_user_delete_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_user_delete_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_user_delete_response__field_descriptors[1] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthUserDeleteResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_user_delete_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
};
static const ProtobufCIntRange etcdserverpb__auth_user_delete_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_user_delete_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthUserDeleteResponse",
  "AuthUserDeleteResponse",
  "Etcdserverpb__AuthUserDeleteResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthUserDeleteResponse),
  1,
  etcdserverpb__auth_user_delete_response__field_descriptors,
  etcdserverpb__auth_user_delete_response__field_indices_by_name,
  1,  etcdserverpb__auth_user_delete_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_user_delete_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_user_change_password_request__field_descriptors[2] =
{
  {
    "name",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthUserChangePasswordRequest, name),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "password",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthUserChangePasswordRequest, password),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_user_change_password_request__field_indices_by_name[] = {
  0,   /* field[0] = name */
  1,   /* field[1] = password */
};
static const ProtobufCIntRange etcdserverpb__auth_user_change_password_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_user_change_password_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthUserChangePasswordRequest",
  "AuthUserChangePasswordRequest",
  "Etcdserverpb__AuthUserChangePasswordRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthUserChangePasswordRequest),
  2,
  etcdserverpb__auth_user_change_password_request__field_descriptors,
  etcdserverpb__auth_user_change_password_request__field_indices_by_name,
  1,  etcdserverpb__auth_user_change_password_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_user_change_password_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_user_change_password_response__field_descriptors[1] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthUserChangePasswordResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_user_change_password_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
};
static const ProtobufCIntRange etcdserverpb__auth_user_change_password_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_user_change_password_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthUserChangePasswordResponse",
  "AuthUserChangePasswordResponse",
  "Etcdserverpb__AuthUserChangePasswordResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthUserChangePasswordResponse),
  1,
  etcdserverpb__auth_user_change_password_response__field_descriptors,
  etcdserverpb__auth_user_change_password_response__field_indices_by_name,
  1,  etcdserverpb__auth_user_change_password_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_user_change_password_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
#define etcdserverpb__auth_enable_request__field_descriptors NULL
#define etcdserverpb__auth_enable_request__field_indices_by_name NULL
#define etcdserverpb__auth_enable_request__number_ranges NULL
const ProtobufCMessageDescriptor etcdserverpb__auth_enable_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthEnableRequest",
  "AuthEnableRequest",
  "Etcdserverpb__AuthEnableRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthEnableRequest),
  0,
  etcdserverpb__auth_enable_request__field_descriptors,
  etcdserverpb__auth_enable_request__field_indices_by_name,
  0,  etcdserverpb__auth_enable_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_enable_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_enable_response__field_descriptors[1] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthEnableResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_enable_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
};
static const ProtobufCIntRange etcdserverpb__auth_enable_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_enable_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthEnableResponse",
  "AuthEnableResponse",
  "Etcdserverpb__AuthEnableResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthEnableResponse),
  1,
  etcdserverpb__auth_enable_response__field_descriptors,
  etcdserverpb__auth_enable_response__field_indices_by_name,
  1,  etcdserverpb__auth_enable_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_enable_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
#define etcdserverpb__auth_disable_request__field_descriptors NULL
#define etcdserverpb__auth_disable_request__field_indices_by_name NULL
#define etcdserverpb__auth_disable_request__number_ranges NULL
const ProtobufCMessageDescriptor etcdserverpb__auth_disable_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthDisableRequest",
  "AuthDisableRequest",
  "Etcdserverpb__AuthDisableRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthDisableRequest),
  0,
  etcdserverpb__auth_disable_request__field_descriptors,
  etcdserverpb__auth_disable_request__field_indices_by_name,
  0,  etcdserverpb__auth_disable_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_disable_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_disable_response__field_descriptors[1] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthDisableResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_disable_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
};
static const ProtobufCIntRange etcdserverpb__auth_disable_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_disable_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthDisableResponse",
  "AuthDisableResponse",
  "Etcdserverpb__AuthDisableResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthDisableResponse),
  1,
  etcdserverpb__auth_disable_response__field_descriptors,
  etcdserverpb__auth_disable_response__field_indices_by_name,
  1,  etcdserverpb__auth_disable_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_disable_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCEnumValue etcdserverpb__permission__type__enum_values_by_number[3] =
{
  { "READ", "ETCDSERVERPB__PERMISSION__TYPE__READ", 0 },
  { "WRITE", "ETCDSERVERPB__PERMISSION__TYPE__WRITE", 1 },
  { "READWRITE", "ETCDSERVERPB__PERMISSION__TYPE__READWRITE", 2 },
};
static const ProtobufCIntRange etcdserverpb__permission__type__value_ranges[] = {
{0, 0},{0, 3}
};
static const ProtobufCEnumValueIndex etcdserverpb__permission__type__enum_values_by_name[3] =
{
  { "READ", 0 },
  { "READWRITE", 2 },
  { "WRITE", 1 },
};
const ProtobufCEnumDescriptor etcdserverpb__permission__type__descriptor =
{
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
  "etcdserverpb.Permission.Type",
  "Type",
  "Etcdserverpb__Permission__Type",
  "etcdserverpb",
  3,
  etcdserverpb__permission__type__enum_values_by_number,
  3,
  etcdserverpb__permission__type__enum_values_by_name,
  1,
  etcdserverpb__permission__type__value_ranges,
  NULL,NULL,NULL,NULL   /* reserved[1234] */
};
static const ProtobufCFieldDescriptor etcdserverpb__permission__field_descriptors[3] =
{
  {
    "permType",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_ENUM,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__Permission, permtype),
    &etcdserverpb__permission__type__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "key",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__Permission, key),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "range_end",
    3,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__Permission, range_end),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__permission__field_indices_by_name[] = {
  1,   /* field[1] = key */
  0,   /* field[0] = permType */
  2,   /* field[2] = range_end */
};
static const ProtobufCIntRange etcdserverpb__permission__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor etcdserverpb__permission__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.Permission",
  "Permission",
  "Etcdserverpb__Permission",
  "etcdserverpb",
  sizeof(Etcdserverpb__Permission),
  3,
  etcdserverpb__permission__field_descriptors,
  etcdserverpb__permission__field_indices_by_name,
  1,  etcdserverpb__permission__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__permission__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__role__field_descriptors[2] =
{
  {
    "name",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__Role, name),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "keyPermission",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Etcdserverpb__Role, n_keypermission),
    offsetof(Etcdserverpb__Role, keypermission),
    &etcdserverpb__permission__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__role__field_indices_by_name[] = {
  1,   /* field[1] = keyPermission */
  0,   /* field[0] = name */
};
static const ProtobufCIntRange etcdserverpb__role__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor etcdserverpb__role__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.Role",
  "Role",
  "Etcdserverpb__Role",
  "etcdserverpb",
  sizeof(Etcdserverpb__Role),
  2,
  etcdserverpb__role__field_descriptors,
  etcdserverpb__role__field_indices_by_name,
  1,  etcdserverpb__role__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__role__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_role_add_request__field_descriptors[1] =
{
  {
    "name",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthRoleAddRequest, name),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_role_add_request__field_indices_by_name[] = {
  0,   /* field[0] = name */
};
static const ProtobufCIntRange etcdserverpb__auth_role_add_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_role_add_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthRoleAddRequest",
  "AuthRoleAddRequest",
  "Etcdserverpb__AuthRoleAddRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthRoleAddRequest),
  1,
  etcdserverpb__auth_role_add_request__field_descriptors,
  etcdserverpb__auth_role_add_request__field_indices_by_name,
  1,  etcdserverpb__auth_role_add_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_role_add_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_role_add_response__field_descriptors[1] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthRoleAddResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_role_add_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
};
static const ProtobufCIntRange etcdserverpb__auth_role_add_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_role_add_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthRoleAddResponse",
  "AuthRoleAddResponse",
  "Etcdserverpb__AuthRoleAddResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthRoleAddResponse),
  1,
  etcdserverpb__auth_role_add_response__field_descriptors,
  etcdserverpb__auth_role_add_response__field_indices_by_name,
  1,  etcdserverpb__auth_role_add_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_role_add_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_role_delete_request__field_descriptors[1] =
{
  {
    "role",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthRoleDeleteRequest, role),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_role_delete_request__field_indices_by_name[] = {
  0,   /* field[0] = role */
};
static const ProtobufCIntRange etcdserverpb__auth_role_delete_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_role_delete_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthRoleDeleteRequest",
  "AuthRoleDeleteRequest",
  "Etcdserverpb__AuthRoleDeleteRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthRoleDeleteRequest),
  1,
  etcdserverpb__auth_role_delete_request__field_descriptors,
  etcdserverpb__auth_role_delete_request__field_indices_by_name,
  1,  etcdserverpb__auth_role_delete_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_role_delete_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_role_delete_response__field_descriptors[1] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthRoleDeleteResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_role_delete_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
};
static const ProtobufCIntRange etcdserverpb__auth_role_delete_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_role_delete_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthRoleDeleteResponse",
  "AuthRoleDeleteResponse",
  "Etcdserverpb__AuthRoleDeleteResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthRoleDeleteResponse),
  1,
  etcdserverpb__auth_role_delete_response__field_descriptors,
  etcdserverpb__auth_role_delete_response__field_indices_by_name,
  1,  etcdserverpb__auth_role_delete_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_role_delete_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_role_get_request__field_descriptors[1] =
{
  {
    "role",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthRoleGetRequest, role),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_role_get_request__field_indices_by_name[] = {
  0,   /* field[0] = role */
};
static const ProtobufCIntRange etcdserverpb__auth_role_get_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_role_get_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthRoleGetRequest",
  "AuthRoleGetRequest",
  "Etcdserverpb__AuthRoleGetRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthRoleGetRequest),
  1,
  etcdserverpb__auth_role_get_request__field_descriptors,
  etcdserverpb__auth_role_get_request__field_indices_by_name,
  1,  etcdserverpb__auth_role_get_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_role_get_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_role_get_response__field_descriptors[2] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthRoleGetResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "perm",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Etcdserverpb__AuthRoleGetResponse, n_perm),
    offsetof(Etcdserverpb__AuthRoleGetResponse, perm),
    &etcdserverpb__permission__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_role_get_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
  1,   /* field[1] = perm */
};
static const ProtobufCIntRange etcdserverpb__auth_role_get_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_role_get_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthRoleGetResponse",
  "AuthRoleGetResponse",
  "Etcdserverpb__AuthRoleGetResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthRoleGetResponse),
  2,
  etcdserverpb__auth_role_get_response__field_descriptors,
  etcdserverpb__auth_role_get_response__field_indices_by_name,
  1,  etcdserverpb__auth_role_get_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_role_get_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
#define etcdserverpb__auth_role_list_request__field_descriptors NULL
#define etcdserverpb__auth_role_list_request__field_indices_by_name NULL
#define etcdserverpb__auth_role_list_request__number_ranges NULL
const ProtobufCMessageDescriptor etcdserverpb__auth_role_list_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthRoleListRequest",
  "AuthRoleListRequest",
  "Etcdserverpb__AuthRoleListRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthRoleListRequest),
  0,
  etcdserverpb__auth_role_list_request__field_descriptors,
  etcdserverpb__auth_role_list_request__field_indices_by_name,
  0,  etcdserverpb__auth_role_list_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_role_list_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_role_list_response__field_descriptors[2] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthRoleListResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "roles",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_STRING,
    offsetof(Etcdserverpb__AuthRoleListResponse, n_roles),
    offsetof(Etcdserverpb__AuthRoleListResponse, roles),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_role_list_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
  1,   /* field[1] = roles */
};
static const ProtobufCIntRange etcdserverpb__auth_role_list_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_role_list_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthRoleListResponse",
  "AuthRoleListResponse",
  "Etcdserverpb__AuthRoleListResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthRoleListResponse),
  2,
  etcdserverpb__auth_role_list_response__field_descriptors,
  etcdserverpb__auth_role_list_response__field_indices_by_name,
  1,  etcdserverpb__auth_role_list_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_role_list_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_role_grant_permission_request__field_descriptors[2] =
{
  {
    "name",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthRoleGrantPermissionRequest, name),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "perm",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthRoleGrantPermissionRequest, perm),
    &etcdserverpb__permission__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_role_grant_permission_request__field_indices_by_name[] = {
  0,   /* field[0] = name */
  1,   /* field[1] = perm */
};
static const ProtobufCIntRange etcdserverpb__auth_role_grant_permission_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_role_grant_permission_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthRoleGrantPermissionRequest",
  "AuthRoleGrantPermissionRequest",
  "Etcdserverpb__AuthRoleGrantPermissionRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthRoleGrantPermissionRequest),
  2,
  etcdserverpb__auth_role_grant_permission_request__field_descriptors,
  etcdserverpb__auth_role_grant_permission_request__field_indices_by_name,
  1,  etcdserverpb__auth_role_grant_permission_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_role_grant_permission_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_role_grant_permission_response__field_descriptors[1] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthRoleGrantPermissionResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_role_grant_permission_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
};
static const ProtobufCIntRange etcdserverpb__auth_role_grant_permission_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_role_grant_permission_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthRoleGrantPermissionResponse",
  "AuthRoleGrantPermissionResponse",
  "Etcdserverpb__AuthRoleGrantPermissionResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthRoleGrantPermissionResponse),
  1,
  etcdserverpb__auth_role_grant_permission_response__field_descriptors,
  etcdserverpb__auth_role_grant_permission_response__field_indices_by_name,
  1,  etcdserverpb__auth_role_grant_permission_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_role_grant_permission_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_role_revoke_permission_request__field_descriptors[3] =
{
  {
    "role",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthRoleRevokePermissionRequest, role),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "key",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthRoleRevokePermissionRequest, key),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "range_end",
    3,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthRoleRevokePermissionRequest, range_end),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_role_revoke_permission_request__field_indices_by_name[] = {
  1,   /* field[1] = key */
  2,   /* field[2] = range_end */
  0,   /* field[0] = role */
};
static const ProtobufCIntRange etcdserverpb__auth_role_revoke_permission_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_role_revoke_permission_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthRoleRevokePermissionRequest",
  "AuthRoleRevokePermissionRequest",
  "Etcdserverpb__AuthRoleRevokePermissionRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthRoleRevokePermissionRequest),
  3,
  etcdserverpb__auth_role_revoke_permission_request__field_descriptors,
  etcdserverpb__auth_role_revoke_permission_request__field_indices_by_name,
  1,  etcdserverpb__auth_role_revoke_permission_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_role_revoke_permission_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_role_revoke_permission_response__field_descriptors[1] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthRoleRevokePermissionResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_role_revoke_permission_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
};
static const ProtobufCIntRange etcdserverpb__auth_role_revoke_permission_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_role_revoke_permission_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthRoleRevokePermissionResponse",
  "AuthRoleRevokePermissionResponse",
  "Etcdserverpb__AuthRoleRevokePermissionResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthRoleRevokePermissionResponse),
  1,
  etcdserverpb__auth_role_revoke_permission_response__field_descriptors,
  etcdserverpb__auth_role_revoke_permission_response__field_indices_by_name,
  1,  etcdserverpb__auth_role_revoke_permission_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_role_revoke_permission_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_user_grant_role_request__field_descriptors[2] =
{
  {
    "user",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthUserGrantRoleRequest, user),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "role",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthUserGrantRoleRequest, role),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_user_grant_role_request__field_indices_by_name[] = {
  1,   /* field[1] = role */
  0,   /* field[0] = user */
};
static const ProtobufCIntRange etcdserverpb__auth_user_grant_role_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_user_grant_role_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthUserGrantRoleRequest",
  "AuthUserGrantRoleRequest",
  "Etcdserverpb__AuthUserGrantRoleRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthUserGrantRoleRequest),
  2,
  etcdserverpb__auth_user_grant_role_request__field_descriptors,
  etcdserverpb__auth_user_grant_role_request__field_indices_by_name,
  1,  etcdserverpb__auth_user_grant_role_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_user_grant_role_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_user_grant_role_response__field_descriptors[1] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthUserGrantRoleResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_user_grant_role_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
};
static const ProtobufCIntRange etcdserverpb__auth_user_grant_role_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_user_grant_role_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthUserGrantRoleResponse",
  "AuthUserGrantRoleResponse",
  "Etcdserverpb__AuthUserGrantRoleResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthUserGrantRoleResponse),
  1,
  etcdserverpb__auth_user_grant_role_response__field_descriptors,
  etcdserverpb__auth_user_grant_role_response__field_indices_by_name,
  1,  etcdserverpb__auth_user_grant_role_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_user_grant_role_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_user_revoke_role_request__field_descriptors[2] =
{
  {
    "name",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthUserRevokeRoleRequest, name),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "role",
    2,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthUserRevokeRoleRequest, role),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_user_revoke_role_request__field_indices_by_name[] = {
  0,   /* field[0] = name */
  1,   /* field[1] = role */
};
static const ProtobufCIntRange etcdserverpb__auth_user_revoke_role_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_user_revoke_role_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthUserRevokeRoleRequest",
  "AuthUserRevokeRoleRequest",
  "Etcdserverpb__AuthUserRevokeRoleRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthUserRevokeRoleRequest),
  2,
  etcdserverpb__auth_user_revoke_role_request__field_descriptors,
  etcdserverpb__auth_user_revoke_role_request__field_indices_by_name,
  1,  etcdserverpb__auth_user_revoke_role_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_user_revoke_role_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_user_revoke_role_response__field_descriptors[1] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthUserRevokeRoleResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_user_revoke_role_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
};
static const ProtobufCIntRange etcdserverpb__auth_user_revoke_role_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_user_revoke_role_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthUserRevokeRoleResponse",
  "AuthUserRevokeRoleResponse",
  "Etcdserverpb__AuthUserRevokeRoleResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthUserRevokeRoleResponse),
  1,
  etcdserverpb__auth_user_revoke_role_response__field_descriptors,
  etcdserverpb__auth_user_revoke_role_response__field_indices_by_name,
  1,  etcdserverpb__auth_user_revoke_role_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_user_revoke_role_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_user_get_request__field_descriptors[1] =
{
  {
    "name",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthUserGetRequest, name),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_user_get_request__field_indices_by_name[] = {
  0,   /* field[0] = name */
};
static const ProtobufCIntRange etcdserverpb__auth_user_get_request__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_user_get_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthUserGetRequest",
  "AuthUserGetRequest",
  "Etcdserverpb__AuthUserGetRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthUserGetRequest),
  1,
  etcdserverpb__auth_user_get_request__field_descriptors,
  etcdserverpb__auth_user_get_request__field_indices_by_name,
  1,  etcdserverpb__auth_user_get_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_user_get_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_user_get_response__field_descriptors[2] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthUserGetResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "roles",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_STRING,
    offsetof(Etcdserverpb__AuthUserGetResponse, n_roles),
    offsetof(Etcdserverpb__AuthUserGetResponse, roles),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_user_get_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
  1,   /* field[1] = roles */
};
static const ProtobufCIntRange etcdserverpb__auth_user_get_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_user_get_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthUserGetResponse",
  "AuthUserGetResponse",
  "Etcdserverpb__AuthUserGetResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthUserGetResponse),
  2,
  etcdserverpb__auth_user_get_response__field_descriptors,
  etcdserverpb__auth_user_get_response__field_indices_by_name,
  1,  etcdserverpb__auth_user_get_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_user_get_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
#define etcdserverpb__auth_user_list_request__field_descriptors NULL
#define etcdserverpb__auth_user_list_request__field_indices_by_name NULL
#define etcdserverpb__auth_user_list_request__number_ranges NULL
const ProtobufCMessageDescriptor etcdserverpb__auth_user_list_request__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthUserListRequest",
  "AuthUserListRequest",
  "Etcdserverpb__AuthUserListRequest",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthUserListRequest),
  0,
  etcdserverpb__auth_user_list_request__field_descriptors,
  etcdserverpb__auth_user_list_request__field_indices_by_name,
  0,  etcdserverpb__auth_user_list_request__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_user_list_request__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor etcdserverpb__auth_user_list_response__field_descriptors[2] =
{
  {
    "header",
    1,
    PROTOBUF_C_LABEL_NONE,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Etcdserverpb__AuthUserListResponse, header),
    &etcdserverpb__response_header__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "users",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_STRING,
    offsetof(Etcdserverpb__AuthUserListResponse, n_users),
    offsetof(Etcdserverpb__AuthUserListResponse, users),
    NULL,
    &protobuf_c_empty_string,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned etcdserverpb__auth_user_list_response__field_indices_by_name[] = {
  0,   /* field[0] = header */
  1,   /* field[1] = users */
};
static const ProtobufCIntRange etcdserverpb__auth_user_list_response__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor etcdserverpb__auth_user_list_response__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "etcdserverpb.AuthUserListResponse",
  "AuthUserListResponse",
  "Etcdserverpb__AuthUserListResponse",
  "etcdserverpb",
  sizeof(Etcdserverpb__AuthUserListResponse),
  2,
  etcdserverpb__auth_user_list_response__field_descriptors,
  etcdserverpb__auth_user_list_response__field_indices_by_name,
  1,  etcdserverpb__auth_user_list_response__number_ranges,
  (ProtobufCMessageInit) etcdserverpb__auth_user_list_response__init,
  NULL,NULL,NULL    /* reserved[123] */
};
