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

#ifndef PROTOBUF_C_rpc_2eproto__INCLUDED
#define PROTOBUF_C_rpc_2eproto__INCLUDED

#include <protobuf-c/protobuf-c.h>

PROTOBUF_C__BEGIN_DECLS

#if PROTOBUF_C_VERSION_NUMBER < 1003000
# error This file was generated by a newer version of protobuf-c which is incompatible with your libprotobuf-c headers. Please update your headers.
#elif 1005001 < PROTOBUF_C_MIN_COMPILER_VERSION
# error This file was generated by an older version of protobuf-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protobuf-c.
#endif

#include "kv.pb-c.h"

typedef struct Etcdserverpb__ResponseHeader Etcdserverpb__ResponseHeader;
typedef struct Etcdserverpb__RangeRequest Etcdserverpb__RangeRequest;
typedef struct Etcdserverpb__RangeResponse Etcdserverpb__RangeResponse;
typedef struct Etcdserverpb__PutRequest Etcdserverpb__PutRequest;
typedef struct Etcdserverpb__PutResponse Etcdserverpb__PutResponse;
typedef struct Etcdserverpb__DeleteRangeRequest Etcdserverpb__DeleteRangeRequest;
typedef struct Etcdserverpb__DeleteRangeResponse Etcdserverpb__DeleteRangeResponse;
typedef struct Etcdserverpb__WatchRequest Etcdserverpb__WatchRequest;
typedef struct Etcdserverpb__WatchCreateRequest Etcdserverpb__WatchCreateRequest;
typedef struct Etcdserverpb__WatchCancelRequest Etcdserverpb__WatchCancelRequest;
typedef struct Etcdserverpb__WatchProgressRequest Etcdserverpb__WatchProgressRequest;
typedef struct Etcdserverpb__WatchResponse Etcdserverpb__WatchResponse;
typedef struct Etcdserverpb__LeaseGrantRequest Etcdserverpb__LeaseGrantRequest;
typedef struct Etcdserverpb__LeaseGrantResponse Etcdserverpb__LeaseGrantResponse;
typedef struct Etcdserverpb__LeaseRevokeRequest Etcdserverpb__LeaseRevokeRequest;
typedef struct Etcdserverpb__LeaseRevokeResponse Etcdserverpb__LeaseRevokeResponse;
typedef struct Etcdserverpb__LeaseKeepAliveRequest Etcdserverpb__LeaseKeepAliveRequest;
typedef struct Etcdserverpb__LeaseKeepAliveResponse Etcdserverpb__LeaseKeepAliveResponse;
typedef struct Etcdserverpb__LeaseTimeToLiveRequest Etcdserverpb__LeaseTimeToLiveRequest;
typedef struct Etcdserverpb__LeaseTimeToLiveResponse Etcdserverpb__LeaseTimeToLiveResponse;
typedef struct Etcdserverpb__LeaseLeasesRequest Etcdserverpb__LeaseLeasesRequest;
typedef struct Etcdserverpb__LeaseStatus Etcdserverpb__LeaseStatus;
typedef struct Etcdserverpb__LeaseLeasesResponse Etcdserverpb__LeaseLeasesResponse;
typedef struct Etcdserverpb__CompactionRequest Etcdserverpb__CompactionRequest;
typedef struct Etcdserverpb__CompactionResponse Etcdserverpb__CompactionResponse;
typedef struct Etcdserverpb__StatusRequest Etcdserverpb__StatusRequest;
typedef struct Etcdserverpb__StatusResponse Etcdserverpb__StatusResponse;
typedef struct Etcdserverpb__AlarmMember Etcdserverpb__AlarmMember;
typedef struct Etcdserverpb__AlarmRequest Etcdserverpb__AlarmRequest;
typedef struct Etcdserverpb__AlarmResponse Etcdserverpb__AlarmResponse;
typedef struct Etcdserverpb__DefragmentRequest Etcdserverpb__DefragmentRequest;
typedef struct Etcdserverpb__DefragmentResponse Etcdserverpb__DefragmentResponse;
typedef struct Etcdserverpb__HashKVRequest Etcdserverpb__HashKVRequest;
typedef struct Etcdserverpb__HashKVResponse Etcdserverpb__HashKVResponse;
typedef struct Etcdserverpb__MoveLeaderRequest Etcdserverpb__MoveLeaderRequest;
typedef struct Etcdserverpb__MoveLeaderResponse Etcdserverpb__MoveLeaderResponse;
typedef struct Etcdserverpb__AuthStatusRequest Etcdserverpb__AuthStatusRequest;
typedef struct Etcdserverpb__AuthStatusResponse Etcdserverpb__AuthStatusResponse;
typedef struct Etcdserverpb__Compare Etcdserverpb__Compare;
typedef struct Etcdserverpb__RequestOp Etcdserverpb__RequestOp;
typedef struct Etcdserverpb__ResponseOp Etcdserverpb__ResponseOp;
typedef struct Etcdserverpb__TxnRequest Etcdserverpb__TxnRequest;
typedef struct Etcdserverpb__TxnResponse Etcdserverpb__TxnResponse;
typedef struct Etcdserverpb__AuthenticateRequest Etcdserverpb__AuthenticateRequest;
typedef struct Etcdserverpb__AuthenticateResponse Etcdserverpb__AuthenticateResponse;
typedef struct Etcdserverpb__AuthUserAddRequest Etcdserverpb__AuthUserAddRequest;
typedef struct Etcdserverpb__AuthUserAddResponse Etcdserverpb__AuthUserAddResponse;
typedef struct Etcdserverpb__AuthUserDeleteRequest Etcdserverpb__AuthUserDeleteRequest;
typedef struct Etcdserverpb__AuthUserDeleteResponse Etcdserverpb__AuthUserDeleteResponse;
typedef struct Etcdserverpb__AuthUserChangePasswordRequest Etcdserverpb__AuthUserChangePasswordRequest;
typedef struct Etcdserverpb__AuthUserChangePasswordResponse Etcdserverpb__AuthUserChangePasswordResponse;
typedef struct Etcdserverpb__AuthEnableRequest Etcdserverpb__AuthEnableRequest;
typedef struct Etcdserverpb__AuthEnableResponse Etcdserverpb__AuthEnableResponse;
typedef struct Etcdserverpb__AuthDisableRequest Etcdserverpb__AuthDisableRequest;
typedef struct Etcdserverpb__AuthDisableResponse Etcdserverpb__AuthDisableResponse;
typedef struct Etcdserverpb__Permission Etcdserverpb__Permission;
typedef struct Etcdserverpb__Role Etcdserverpb__Role;
typedef struct Etcdserverpb__AuthRoleAddRequest Etcdserverpb__AuthRoleAddRequest;
typedef struct Etcdserverpb__AuthRoleAddResponse Etcdserverpb__AuthRoleAddResponse;
typedef struct Etcdserverpb__AuthRoleDeleteRequest Etcdserverpb__AuthRoleDeleteRequest;
typedef struct Etcdserverpb__AuthRoleDeleteResponse Etcdserverpb__AuthRoleDeleteResponse;
typedef struct Etcdserverpb__AuthRoleGetRequest Etcdserverpb__AuthRoleGetRequest;
typedef struct Etcdserverpb__AuthRoleGetResponse Etcdserverpb__AuthRoleGetResponse;
typedef struct Etcdserverpb__AuthRoleListRequest Etcdserverpb__AuthRoleListRequest;
typedef struct Etcdserverpb__AuthRoleListResponse Etcdserverpb__AuthRoleListResponse;
typedef struct Etcdserverpb__AuthRoleGrantPermissionRequest Etcdserverpb__AuthRoleGrantPermissionRequest;
typedef struct Etcdserverpb__AuthRoleGrantPermissionResponse Etcdserverpb__AuthRoleGrantPermissionResponse;
typedef struct Etcdserverpb__AuthRoleRevokePermissionRequest Etcdserverpb__AuthRoleRevokePermissionRequest;
typedef struct Etcdserverpb__AuthRoleRevokePermissionResponse Etcdserverpb__AuthRoleRevokePermissionResponse;
typedef struct Etcdserverpb__AuthUserGrantRoleRequest Etcdserverpb__AuthUserGrantRoleRequest;
typedef struct Etcdserverpb__AuthUserGrantRoleResponse Etcdserverpb__AuthUserGrantRoleResponse;
typedef struct Etcdserverpb__AuthUserRevokeRoleRequest Etcdserverpb__AuthUserRevokeRoleRequest;
typedef struct Etcdserverpb__AuthUserRevokeRoleResponse Etcdserverpb__AuthUserRevokeRoleResponse;
typedef struct Etcdserverpb__AuthUserGetRequest Etcdserverpb__AuthUserGetRequest;
typedef struct Etcdserverpb__AuthUserGetResponse Etcdserverpb__AuthUserGetResponse;
typedef struct Etcdserverpb__AuthUserListRequest Etcdserverpb__AuthUserListRequest;
typedef struct Etcdserverpb__AuthUserListResponse Etcdserverpb__AuthUserListResponse;


/* --- enums --- */

typedef enum _Etcdserverpb__RangeRequest__SortOrder {
  ETCDSERVERPB__RANGE_REQUEST__SORT_ORDER__NONE = 0,
  ETCDSERVERPB__RANGE_REQUEST__SORT_ORDER__ASCEND = 1,
  ETCDSERVERPB__RANGE_REQUEST__SORT_ORDER__DESCEND = 2
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ETCDSERVERPB__RANGE_REQUEST__SORT_ORDER)
} Etcdserverpb__RangeRequest__SortOrder;
typedef enum _Etcdserverpb__RangeRequest__SortTarget {
  ETCDSERVERPB__RANGE_REQUEST__SORT_TARGET__KEY = 0,
  ETCDSERVERPB__RANGE_REQUEST__SORT_TARGET__VERSION = 1,
  ETCDSERVERPB__RANGE_REQUEST__SORT_TARGET__CREATE = 2,
  ETCDSERVERPB__RANGE_REQUEST__SORT_TARGET__MOD = 3,
  ETCDSERVERPB__RANGE_REQUEST__SORT_TARGET__VALUE = 4
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ETCDSERVERPB__RANGE_REQUEST__SORT_TARGET)
} Etcdserverpb__RangeRequest__SortTarget;
typedef enum _Etcdserverpb__Compare__CompareResult {
  ETCDSERVERPB__COMPARE__COMPARE_RESULT__EQUAL = 0,
  ETCDSERVERPB__COMPARE__COMPARE_RESULT__GREATER = 1,
  ETCDSERVERPB__COMPARE__COMPARE_RESULT__LESS = 2,
  ETCDSERVERPB__COMPARE__COMPARE_RESULT__NOT_EQUAL = 3
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ETCDSERVERPB__COMPARE__COMPARE_RESULT)
} Etcdserverpb__Compare__CompareResult;
typedef enum _Etcdserverpb__Compare__CompareTarget {
  ETCDSERVERPB__COMPARE__COMPARE_TARGET__VERSION = 0,
  ETCDSERVERPB__COMPARE__COMPARE_TARGET__CREATE = 1,
  ETCDSERVERPB__COMPARE__COMPARE_TARGET__MOD = 2,
  ETCDSERVERPB__COMPARE__COMPARE_TARGET__VALUE = 3,
  ETCDSERVERPB__COMPARE__COMPARE_TARGET__LEASE = 4
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ETCDSERVERPB__COMPARE__COMPARE_TARGET)
} Etcdserverpb__Compare__CompareTarget;
typedef enum _Etcdserverpb__Permission__Type {
  ETCDSERVERPB__PERMISSION__TYPE__READ = 0,
  ETCDSERVERPB__PERMISSION__TYPE__WRITE = 1,
  ETCDSERVERPB__PERMISSION__TYPE__READWRITE = 2
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ETCDSERVERPB__PERMISSION__TYPE)
} Etcdserverpb__Permission__Type;
typedef enum _Etcdserverpb__AlarmType {
  ETCDSERVERPB__ALARM_TYPE__NONE = 0,
  ETCDSERVERPB__ALARM_TYPE__NOSPACE = 1,
  ETCDSERVERPB__ALARM_TYPE__CORRUPT = 2
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ETCDSERVERPB__ALARM_TYPE)
} Etcdserverpb__AlarmType;
typedef enum _Etcdserverpb__AlarmRequest__AlarmAction {
  ETCDSERVERPB__ALARM_REQUEST__ALARM_ACTION__GET = 0,
  ETCDSERVERPB__ALARM_REQUEST__ALARM_ACTION__ACTIVATE = 1,
  ETCDSERVERPB__ALARM_REQUEST__ALARM_ACTION__DEACTIVATE = 2
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ETCDSERVERPB__ALARM_REQUEST__ALARM_ACTION)
} Etcdserverpb__AlarmRequest__AlarmAction;

/* --- messages --- */

struct  Etcdserverpb__ResponseHeader
{
  ProtobufCMessage base;
  uint64_t cluster_id;
  uint64_t member_id;
  int64_t revision;
  uint64_t raft_term;
};
#define ETCDSERVERPB__RESPONSE_HEADER__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__response_header__descriptor) \
    , 0, 0, 0, 0 }


struct  Etcdserverpb__RangeRequest
{
  ProtobufCMessage base;
  ProtobufCBinaryData key;
  ProtobufCBinaryData range_end;
  int64_t limit;
  int64_t revision;
  Etcdserverpb__RangeRequest__SortOrder sort_order;
  Etcdserverpb__RangeRequest__SortTarget sort_target;
  protobuf_c_boolean serializable;
  protobuf_c_boolean keys_only;
  protobuf_c_boolean count_only;
  int64_t min_mod_revision;
  int64_t max_mod_revision;
  int64_t min_create_revision;
  int64_t max_create_revision;
};
#define ETCDSERVERPB__RANGE_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__range_request__descriptor) \
    , {0,NULL}, {0,NULL}, 0, 0, ETCDSERVERPB__RANGE_REQUEST__SORT_ORDER__NONE, ETCDSERVERPB__RANGE_REQUEST__SORT_TARGET__KEY, 0, 0, 0, 0, 0, 0, 0 }


struct  Etcdserverpb__RangeResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
  size_t n_kvs;
  Mvccpb__KeyValue **kvs;
  protobuf_c_boolean more;
  int64_t count;
};
#define ETCDSERVERPB__RANGE_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__range_response__descriptor) \
    , NULL, 0,NULL, 0, 0 }


struct  Etcdserverpb__PutRequest
{
  ProtobufCMessage base;
  ProtobufCBinaryData key;
  ProtobufCBinaryData value;
  int64_t lease;
  protobuf_c_boolean prev_kv;
  protobuf_c_boolean ignore_value;
  protobuf_c_boolean ignore_lease;
};
#define ETCDSERVERPB__PUT_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__put_request__descriptor) \
    , {0,NULL}, {0,NULL}, 0, 0, 0, 0 }


struct  Etcdserverpb__PutResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
  Mvccpb__KeyValue *prev_kv;
};
#define ETCDSERVERPB__PUT_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__put_response__descriptor) \
    , NULL, NULL }


struct  Etcdserverpb__DeleteRangeRequest
{
  ProtobufCMessage base;
  ProtobufCBinaryData key;
  ProtobufCBinaryData range_end;
  protobuf_c_boolean prev_kv;
};
#define ETCDSERVERPB__DELETE_RANGE_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__delete_range_request__descriptor) \
    , {0,NULL}, {0,NULL}, 0 }


struct  Etcdserverpb__DeleteRangeResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
  int64_t deleted;
  size_t n_prev_kvs;
  Mvccpb__KeyValue **prev_kvs;
};
#define ETCDSERVERPB__DELETE_RANGE_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__delete_range_response__descriptor) \
    , NULL, 0, 0,NULL }


typedef enum {
  ETCDSERVERPB__WATCH_REQUEST__REQUEST_UNION__NOT_SET = 0,
  ETCDSERVERPB__WATCH_REQUEST__REQUEST_UNION_CREATE_REQUEST = 1,
  ETCDSERVERPB__WATCH_REQUEST__REQUEST_UNION_CANCEL_REQUEST = 2,
  ETCDSERVERPB__WATCH_REQUEST__REQUEST_UNION_PROGRESS_REQUEST = 3
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ETCDSERVERPB__WATCH_REQUEST__REQUEST_UNION__CASE)
} Etcdserverpb__WatchRequest__RequestUnionCase;

struct  Etcdserverpb__WatchRequest
{
  ProtobufCMessage base;
  Etcdserverpb__WatchRequest__RequestUnionCase request_union_case;
  union {
    Etcdserverpb__WatchCancelRequest *cancel_request;
    Etcdserverpb__WatchCreateRequest *create_request;
    Etcdserverpb__WatchProgressRequest *progress_request;
  };
};
#define ETCDSERVERPB__WATCH_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__watch_request__descriptor) \
    , ETCDSERVERPB__WATCH_REQUEST__REQUEST_UNION__NOT_SET, {0} }


struct  Etcdserverpb__WatchCreateRequest
{
  ProtobufCMessage base;
  ProtobufCBinaryData key;
  ProtobufCBinaryData range_end;
  int64_t start_revision;
  protobuf_c_boolean progress_notify;
  protobuf_c_boolean prev_kv;
  int64_t watch_id;
};
#define ETCDSERVERPB__WATCH_CREATE_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__watch_create_request__descriptor) \
    , {0,NULL}, {0,NULL}, 0, 0, 0, 0 }


struct  Etcdserverpb__WatchCancelRequest
{
  ProtobufCMessage base;
  int64_t watch_id;
};
#define ETCDSERVERPB__WATCH_CANCEL_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__watch_cancel_request__descriptor) \
    , 0 }


struct  Etcdserverpb__WatchProgressRequest
{
  ProtobufCMessage base;
};
#define ETCDSERVERPB__WATCH_PROGRESS_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__watch_progress_request__descriptor) \
     }


struct  Etcdserverpb__WatchResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
  int64_t watch_id;
  protobuf_c_boolean created;
  protobuf_c_boolean canceled;
  int64_t compact_revision;
  char *cancel_reason;
  size_t n_events;
  Mvccpb__Event **events;
};
#define ETCDSERVERPB__WATCH_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__watch_response__descriptor) \
    , NULL, 0, 0, 0, 0, (char *)protobuf_c_empty_string, 0,NULL }


struct  Etcdserverpb__LeaseGrantRequest
{
  ProtobufCMessage base;
  int64_t ttl;
  int64_t id;
};
#define ETCDSERVERPB__LEASE_GRANT_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__lease_grant_request__descriptor) \
    , 0, 0 }


struct  Etcdserverpb__LeaseGrantResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
  int64_t id;
  int64_t ttl;
  char *error;
};
#define ETCDSERVERPB__LEASE_GRANT_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__lease_grant_response__descriptor) \
    , NULL, 0, 0, (char *)protobuf_c_empty_string }


struct  Etcdserverpb__LeaseRevokeRequest
{
  ProtobufCMessage base;
  int64_t id;
};
#define ETCDSERVERPB__LEASE_REVOKE_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__lease_revoke_request__descriptor) \
    , 0 }


struct  Etcdserverpb__LeaseRevokeResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
};
#define ETCDSERVERPB__LEASE_REVOKE_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__lease_revoke_response__descriptor) \
    , NULL }


struct  Etcdserverpb__LeaseKeepAliveRequest
{
  ProtobufCMessage base;
  int64_t id;
};
#define ETCDSERVERPB__LEASE_KEEP_ALIVE_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__lease_keep_alive_request__descriptor) \
    , 0 }


struct  Etcdserverpb__LeaseKeepAliveResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
  int64_t id;
  int64_t ttl;
};
#define ETCDSERVERPB__LEASE_KEEP_ALIVE_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__lease_keep_alive_response__descriptor) \
    , NULL, 0, 0 }


struct  Etcdserverpb__LeaseTimeToLiveRequest
{
  ProtobufCMessage base;
  int64_t id;
  protobuf_c_boolean keys;
};
#define ETCDSERVERPB__LEASE_TIME_TO_LIVE_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__lease_time_to_live_request__descriptor) \
    , 0, 0 }


struct  Etcdserverpb__LeaseTimeToLiveResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
  int64_t id;
  int64_t ttl;
  int64_t grantedttl;
  size_t n_keys;
  ProtobufCBinaryData *keys;
};
#define ETCDSERVERPB__LEASE_TIME_TO_LIVE_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__lease_time_to_live_response__descriptor) \
    , NULL, 0, 0, 0, 0,NULL }


struct  Etcdserverpb__LeaseLeasesRequest
{
  ProtobufCMessage base;
};
#define ETCDSERVERPB__LEASE_LEASES_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__lease_leases_request__descriptor) \
     }


struct  Etcdserverpb__LeaseStatus
{
  ProtobufCMessage base;
  int64_t id;
};
#define ETCDSERVERPB__LEASE_STATUS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__lease_status__descriptor) \
    , 0 }


struct  Etcdserverpb__LeaseLeasesResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
  size_t n_leases;
  Etcdserverpb__LeaseStatus **leases;
};
#define ETCDSERVERPB__LEASE_LEASES_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__lease_leases_response__descriptor) \
    , NULL, 0,NULL }


struct  Etcdserverpb__CompactionRequest
{
  ProtobufCMessage base;
  int64_t revision;
  protobuf_c_boolean physical;
};
#define ETCDSERVERPB__COMPACTION_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__compaction_request__descriptor) \
    , 0, 0 }


struct  Etcdserverpb__CompactionResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
};
#define ETCDSERVERPB__COMPACTION_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__compaction_response__descriptor) \
    , NULL }


struct  Etcdserverpb__StatusRequest
{
  ProtobufCMessage base;
};
#define ETCDSERVERPB__STATUS_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__status_request__descriptor) \
     }


struct  Etcdserverpb__StatusResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
  char *version;
  int64_t dbsize;
  uint64_t leader;
  uint64_t raftindex;
  uint64_t raftterm;
  uint64_t raftappliedindex;
  size_t n_errors;
  char **errors;
  int64_t dbsizeinuse;
  protobuf_c_boolean islearner;
};
#define ETCDSERVERPB__STATUS_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__status_response__descriptor) \
    , NULL, (char *)protobuf_c_empty_string, 0, 0, 0, 0, 0, 0,NULL, 0, 0 }

/* AlarmMember - describes an alarm on a member */
struct  Etcdserverpb__AlarmMember
{
  ProtobufCMessage base;
  uint64_t memberid;
  Etcdserverpb__AlarmType alarm;
};
#define ETCDSERVERPB__ALARM_MEMBER__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__alarm_member__descriptor) \
    , 0, ETCDSERVERPB__ALARM_TYPE__NONE }

/* AlarmRequest */
struct  Etcdserverpb__AlarmRequest
{
  ProtobufCMessage base;
  Etcdserverpb__AlarmRequest__AlarmAction action;
  uint64_t memberid;
  Etcdserverpb__AlarmType alarm;
};
#define ETCDSERVERPB__ALARM_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__alarm_request__descriptor) \
    , ETCDSERVERPB__ALARM_REQUEST__ALARM_ACTION__GET, 0, ETCDSERVERPB__ALARM_TYPE__NONE }

/* AlarmResponse */
struct  Etcdserverpb__AlarmResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
  size_t n_alarms;
  Etcdserverpb__AlarmMember **alarms;
};
#define ETCDSERVERPB__ALARM_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__alarm_response__descriptor) \
    , NULL, 0, NULL }

/* DefragmentRequest - empty */
struct  Etcdserverpb__DefragmentRequest
{
  ProtobufCMessage base;
};
#define ETCDSERVERPB__DEFRAGMENT_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__defragment_request__descriptor) \
     }

/* DefragmentResponse */
struct  Etcdserverpb__DefragmentResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
};
#define ETCDSERVERPB__DEFRAGMENT_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__defragment_response__descriptor) \
    , NULL }

/* HashKVRequest */
struct  Etcdserverpb__HashKVRequest
{
  ProtobufCMessage base;
  int64_t revision;
};
#define ETCDSERVERPB__HASH_KV_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__hash_kv_request__descriptor) \
    , 0 }

/* HashKVResponse */
struct  Etcdserverpb__HashKVResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
  uint32_t hash;
  int64_t compact_revision;
};
#define ETCDSERVERPB__HASH_KV_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__hash_kv_response__descriptor) \
    , NULL, 0, 0 }

/* MoveLeaderRequest */
struct  Etcdserverpb__MoveLeaderRequest
{
  ProtobufCMessage base;
  uint64_t targetid;
};
#define ETCDSERVERPB__MOVE_LEADER_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__move_leader_request__descriptor) \
    , 0 }

/* MoveLeaderResponse */
struct  Etcdserverpb__MoveLeaderResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
};
#define ETCDSERVERPB__MOVE_LEADER_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__move_leader_response__descriptor) \
    , NULL }

/* AuthStatusRequest - empty */
struct  Etcdserverpb__AuthStatusRequest
{
  ProtobufCMessage base;
};
#define ETCDSERVERPB__AUTH_STATUS_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_status_request__descriptor) \
     }

/* AuthStatusResponse */
struct  Etcdserverpb__AuthStatusResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
  protobuf_c_boolean enabled;
  uint64_t authrevision;
};
#define ETCDSERVERPB__AUTH_STATUS_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_status_response__descriptor) \
    , NULL, 0, 0 }


typedef enum {
  ETCDSERVERPB__COMPARE__TARGET_UNION__NOT_SET = 0,
  ETCDSERVERPB__COMPARE__TARGET_UNION_VERSION = 4,
  ETCDSERVERPB__COMPARE__TARGET_UNION_CREATE_REVISION = 5,
  ETCDSERVERPB__COMPARE__TARGET_UNION_MOD_REVISION = 6,
  ETCDSERVERPB__COMPARE__TARGET_UNION_VALUE = 7,
  ETCDSERVERPB__COMPARE__TARGET_UNION_LEASE = 8
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ETCDSERVERPB__COMPARE__TARGET_UNION__CASE)
} Etcdserverpb__Compare__TargetUnionCase;

struct  Etcdserverpb__Compare
{
  ProtobufCMessage base;
  Etcdserverpb__Compare__CompareResult result;
  Etcdserverpb__Compare__CompareTarget target;
  ProtobufCBinaryData key;
  ProtobufCBinaryData range_end;
  Etcdserverpb__Compare__TargetUnionCase target_union_case;
  union {
    ProtobufCBinaryData value;
    int64_t create_revision;
    int64_t lease;
    int64_t mod_revision;
    int64_t version;
  };
};
#define ETCDSERVERPB__COMPARE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__compare__descriptor) \
    , ETCDSERVERPB__COMPARE__COMPARE_RESULT__EQUAL, ETCDSERVERPB__COMPARE__COMPARE_TARGET__VERSION, {0,NULL}, {0,NULL}, ETCDSERVERPB__COMPARE__TARGET_UNION__NOT_SET, { {0} } }


typedef enum {
  ETCDSERVERPB__REQUEST_OP__REQUEST__NOT_SET = 0,
  ETCDSERVERPB__REQUEST_OP__REQUEST_REQUEST_RANGE = 1,
  ETCDSERVERPB__REQUEST_OP__REQUEST_REQUEST_PUT = 2,
  ETCDSERVERPB__REQUEST_OP__REQUEST_REQUEST_DELETE_RANGE = 3
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ETCDSERVERPB__REQUEST_OP__REQUEST__CASE)
} Etcdserverpb__RequestOp__RequestCase;

struct  Etcdserverpb__RequestOp
{
  ProtobufCMessage base;
  Etcdserverpb__RequestOp__RequestCase request_case;
  union {
    Etcdserverpb__DeleteRangeRequest *request_delete_range;
    Etcdserverpb__PutRequest *request_put;
    Etcdserverpb__RangeRequest *request_range;
  };
};
#define ETCDSERVERPB__REQUEST_OP__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__request_op__descriptor) \
    , ETCDSERVERPB__REQUEST_OP__REQUEST__NOT_SET, {0} }


typedef enum {
  ETCDSERVERPB__RESPONSE_OP__RESPONSE__NOT_SET = 0,
  ETCDSERVERPB__RESPONSE_OP__RESPONSE_RESPONSE_RANGE = 1,
  ETCDSERVERPB__RESPONSE_OP__RESPONSE_RESPONSE_PUT = 2,
  ETCDSERVERPB__RESPONSE_OP__RESPONSE_RESPONSE_DELETE_RANGE = 3
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(ETCDSERVERPB__RESPONSE_OP__RESPONSE__CASE)
} Etcdserverpb__ResponseOp__ResponseCase;

struct  Etcdserverpb__ResponseOp
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseOp__ResponseCase response_case;
  union {
    Etcdserverpb__DeleteRangeResponse *response_delete_range;
    Etcdserverpb__PutResponse *response_put;
    Etcdserverpb__RangeResponse *response_range;
  };
};
#define ETCDSERVERPB__RESPONSE_OP__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__response_op__descriptor) \
    , ETCDSERVERPB__RESPONSE_OP__RESPONSE__NOT_SET, {0} }


struct  Etcdserverpb__TxnRequest
{
  ProtobufCMessage base;
  size_t n_compare;
  Etcdserverpb__Compare **compare;
  size_t n_success;
  Etcdserverpb__RequestOp **success;
  size_t n_failure;
  Etcdserverpb__RequestOp **failure;
};
#define ETCDSERVERPB__TXN_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__txn_request__descriptor) \
    , 0,NULL, 0,NULL, 0,NULL }


struct  Etcdserverpb__TxnResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
  protobuf_c_boolean succeeded;
  size_t n_responses;
  Etcdserverpb__ResponseOp **responses;
};
#define ETCDSERVERPB__TXN_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__txn_response__descriptor) \
    , NULL, 0, 0,NULL }


struct  Etcdserverpb__AuthenticateRequest
{
  ProtobufCMessage base;
  char *name;
  char *password;
};
#define ETCDSERVERPB__AUTHENTICATE_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__authenticate_request__descriptor) \
    , (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string }


struct  Etcdserverpb__AuthenticateResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
  char *token;
};
#define ETCDSERVERPB__AUTHENTICATE_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__authenticate_response__descriptor) \
    , NULL, (char *)protobuf_c_empty_string }


struct  Etcdserverpb__AuthUserAddRequest
{
  ProtobufCMessage base;
  char *name;
  char *password;
};
#define ETCDSERVERPB__AUTH_USER_ADD_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_user_add_request__descriptor) \
    , (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string }


struct  Etcdserverpb__AuthUserAddResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
};
#define ETCDSERVERPB__AUTH_USER_ADD_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_user_add_response__descriptor) \
    , NULL }


struct  Etcdserverpb__AuthUserDeleteRequest
{
  ProtobufCMessage base;
  char *name;
};
#define ETCDSERVERPB__AUTH_USER_DELETE_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_user_delete_request__descriptor) \
    , (char *)protobuf_c_empty_string }


struct  Etcdserverpb__AuthUserDeleteResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
};
#define ETCDSERVERPB__AUTH_USER_DELETE_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_user_delete_response__descriptor) \
    , NULL }


struct  Etcdserverpb__AuthUserChangePasswordRequest
{
  ProtobufCMessage base;
  char *name;
  char *password;
};
#define ETCDSERVERPB__AUTH_USER_CHANGE_PASSWORD_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_user_change_password_request__descriptor) \
    , (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string }


struct  Etcdserverpb__AuthUserChangePasswordResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
};
#define ETCDSERVERPB__AUTH_USER_CHANGE_PASSWORD_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_user_change_password_response__descriptor) \
    , NULL }


struct  Etcdserverpb__AuthEnableRequest
{
  ProtobufCMessage base;
};
#define ETCDSERVERPB__AUTH_ENABLE_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_enable_request__descriptor) \
     }


struct  Etcdserverpb__AuthEnableResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
};
#define ETCDSERVERPB__AUTH_ENABLE_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_enable_response__descriptor) \
    , NULL }


struct  Etcdserverpb__AuthDisableRequest
{
  ProtobufCMessage base;
};
#define ETCDSERVERPB__AUTH_DISABLE_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_disable_request__descriptor) \
     }


struct  Etcdserverpb__AuthDisableResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
};
#define ETCDSERVERPB__AUTH_DISABLE_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_disable_response__descriptor) \
    , NULL }


/*
 * Permission type for role permissions
 */
struct  Etcdserverpb__Permission
{
  ProtobufCMessage base;
  Etcdserverpb__Permission__Type permtype;
  ProtobufCBinaryData key;
  ProtobufCBinaryData range_end;
};
#define ETCDSERVERPB__PERMISSION__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__permission__descriptor) \
    , ETCDSERVERPB__PERMISSION__TYPE__READ, {0,NULL}, {0,NULL} }


/*
 * Role represents a role with its permissions
 */
struct  Etcdserverpb__Role
{
  ProtobufCMessage base;
  ProtobufCBinaryData name;
  size_t n_keypermission;
  Etcdserverpb__Permission **keypermission;
};
#define ETCDSERVERPB__ROLE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__role__descriptor) \
    , {0,NULL}, 0,NULL }


/*
 * Role management messages
 */
struct  Etcdserverpb__AuthRoleAddRequest
{
  ProtobufCMessage base;
  char *name;
};
#define ETCDSERVERPB__AUTH_ROLE_ADD_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_role_add_request__descriptor) \
    , (char *)protobuf_c_empty_string }


struct  Etcdserverpb__AuthRoleAddResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
};
#define ETCDSERVERPB__AUTH_ROLE_ADD_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_role_add_response__descriptor) \
    , NULL }


struct  Etcdserverpb__AuthRoleDeleteRequest
{
  ProtobufCMessage base;
  char *role;
};
#define ETCDSERVERPB__AUTH_ROLE_DELETE_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_role_delete_request__descriptor) \
    , (char *)protobuf_c_empty_string }


struct  Etcdserverpb__AuthRoleDeleteResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
};
#define ETCDSERVERPB__AUTH_ROLE_DELETE_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_role_delete_response__descriptor) \
    , NULL }


struct  Etcdserverpb__AuthRoleGetRequest
{
  ProtobufCMessage base;
  char *role;
};
#define ETCDSERVERPB__AUTH_ROLE_GET_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_role_get_request__descriptor) \
    , (char *)protobuf_c_empty_string }


struct  Etcdserverpb__AuthRoleGetResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
  size_t n_perm;
  Etcdserverpb__Permission **perm;
};
#define ETCDSERVERPB__AUTH_ROLE_GET_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_role_get_response__descriptor) \
    , NULL, 0,NULL }


struct  Etcdserverpb__AuthRoleListRequest
{
  ProtobufCMessage base;
};
#define ETCDSERVERPB__AUTH_ROLE_LIST_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_role_list_request__descriptor) \
     }


struct  Etcdserverpb__AuthRoleListResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
  size_t n_roles;
  char **roles;
};
#define ETCDSERVERPB__AUTH_ROLE_LIST_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_role_list_response__descriptor) \
    , NULL, 0,NULL }


struct  Etcdserverpb__AuthRoleGrantPermissionRequest
{
  ProtobufCMessage base;
  char *name;
  Etcdserverpb__Permission *perm;
};
#define ETCDSERVERPB__AUTH_ROLE_GRANT_PERMISSION_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_role_grant_permission_request__descriptor) \
    , (char *)protobuf_c_empty_string, NULL }


struct  Etcdserverpb__AuthRoleGrantPermissionResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
};
#define ETCDSERVERPB__AUTH_ROLE_GRANT_PERMISSION_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_role_grant_permission_response__descriptor) \
    , NULL }


struct  Etcdserverpb__AuthRoleRevokePermissionRequest
{
  ProtobufCMessage base;
  char *role;
  ProtobufCBinaryData key;
  ProtobufCBinaryData range_end;
};
#define ETCDSERVERPB__AUTH_ROLE_REVOKE_PERMISSION_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_role_revoke_permission_request__descriptor) \
    , (char *)protobuf_c_empty_string, {0,NULL}, {0,NULL} }


struct  Etcdserverpb__AuthRoleRevokePermissionResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
};
#define ETCDSERVERPB__AUTH_ROLE_REVOKE_PERMISSION_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_role_revoke_permission_response__descriptor) \
    , NULL }


/*
 * User-role association messages
 */
struct  Etcdserverpb__AuthUserGrantRoleRequest
{
  ProtobufCMessage base;
  char *user;
  char *role;
};
#define ETCDSERVERPB__AUTH_USER_GRANT_ROLE_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_user_grant_role_request__descriptor) \
    , (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string }


struct  Etcdserverpb__AuthUserGrantRoleResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
};
#define ETCDSERVERPB__AUTH_USER_GRANT_ROLE_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_user_grant_role_response__descriptor) \
    , NULL }


struct  Etcdserverpb__AuthUserRevokeRoleRequest
{
  ProtobufCMessage base;
  char *name;
  char *role;
};
#define ETCDSERVERPB__AUTH_USER_REVOKE_ROLE_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_user_revoke_role_request__descriptor) \
    , (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string }


struct  Etcdserverpb__AuthUserRevokeRoleResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
};
#define ETCDSERVERPB__AUTH_USER_REVOKE_ROLE_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_user_revoke_role_response__descriptor) \
    , NULL }


struct  Etcdserverpb__AuthUserGetRequest
{
  ProtobufCMessage base;
  char *name;
};
#define ETCDSERVERPB__AUTH_USER_GET_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_user_get_request__descriptor) \
    , (char *)protobuf_c_empty_string }


struct  Etcdserverpb__AuthUserGetResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
  size_t n_roles;
  char **roles;
};
#define ETCDSERVERPB__AUTH_USER_GET_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_user_get_response__descriptor) \
    , NULL, 0,NULL }


struct  Etcdserverpb__AuthUserListRequest
{
  ProtobufCMessage base;
};
#define ETCDSERVERPB__AUTH_USER_LIST_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_user_list_request__descriptor) \
     }


struct  Etcdserverpb__AuthUserListResponse
{
  ProtobufCMessage base;
  Etcdserverpb__ResponseHeader *header;
  size_t n_users;
  char **users;
};
#define ETCDSERVERPB__AUTH_USER_LIST_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&etcdserverpb__auth_user_list_response__descriptor) \
    , NULL, 0,NULL }


/* Etcdserverpb__ResponseHeader methods */
void   etcdserverpb__response_header__init
                     (Etcdserverpb__ResponseHeader         *message);
size_t etcdserverpb__response_header__get_packed_size
                     (const Etcdserverpb__ResponseHeader   *message);
size_t etcdserverpb__response_header__pack
                     (const Etcdserverpb__ResponseHeader   *message,
                      uint8_t             *out);
size_t etcdserverpb__response_header__pack_to_buffer
                     (const Etcdserverpb__ResponseHeader   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__ResponseHeader *
       etcdserverpb__response_header__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__response_header__free_unpacked
                     (Etcdserverpb__ResponseHeader *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__RangeRequest methods */
void   etcdserverpb__range_request__init
                     (Etcdserverpb__RangeRequest         *message);
size_t etcdserverpb__range_request__get_packed_size
                     (const Etcdserverpb__RangeRequest   *message);
size_t etcdserverpb__range_request__pack
                     (const Etcdserverpb__RangeRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__range_request__pack_to_buffer
                     (const Etcdserverpb__RangeRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__RangeRequest *
       etcdserverpb__range_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__range_request__free_unpacked
                     (Etcdserverpb__RangeRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__RangeResponse methods */
void   etcdserverpb__range_response__init
                     (Etcdserverpb__RangeResponse         *message);
size_t etcdserverpb__range_response__get_packed_size
                     (const Etcdserverpb__RangeResponse   *message);
size_t etcdserverpb__range_response__pack
                     (const Etcdserverpb__RangeResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__range_response__pack_to_buffer
                     (const Etcdserverpb__RangeResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__RangeResponse *
       etcdserverpb__range_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__range_response__free_unpacked
                     (Etcdserverpb__RangeResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__PutRequest methods */
void   etcdserverpb__put_request__init
                     (Etcdserverpb__PutRequest         *message);
size_t etcdserverpb__put_request__get_packed_size
                     (const Etcdserverpb__PutRequest   *message);
size_t etcdserverpb__put_request__pack
                     (const Etcdserverpb__PutRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__put_request__pack_to_buffer
                     (const Etcdserverpb__PutRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__PutRequest *
       etcdserverpb__put_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__put_request__free_unpacked
                     (Etcdserverpb__PutRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__PutResponse methods */
void   etcdserverpb__put_response__init
                     (Etcdserverpb__PutResponse         *message);
size_t etcdserverpb__put_response__get_packed_size
                     (const Etcdserverpb__PutResponse   *message);
size_t etcdserverpb__put_response__pack
                     (const Etcdserverpb__PutResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__put_response__pack_to_buffer
                     (const Etcdserverpb__PutResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__PutResponse *
       etcdserverpb__put_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__put_response__free_unpacked
                     (Etcdserverpb__PutResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__DeleteRangeRequest methods */
void   etcdserverpb__delete_range_request__init
                     (Etcdserverpb__DeleteRangeRequest         *message);
size_t etcdserverpb__delete_range_request__get_packed_size
                     (const Etcdserverpb__DeleteRangeRequest   *message);
size_t etcdserverpb__delete_range_request__pack
                     (const Etcdserverpb__DeleteRangeRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__delete_range_request__pack_to_buffer
                     (const Etcdserverpb__DeleteRangeRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__DeleteRangeRequest *
       etcdserverpb__delete_range_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__delete_range_request__free_unpacked
                     (Etcdserverpb__DeleteRangeRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__DeleteRangeResponse methods */
void   etcdserverpb__delete_range_response__init
                     (Etcdserverpb__DeleteRangeResponse         *message);
size_t etcdserverpb__delete_range_response__get_packed_size
                     (const Etcdserverpb__DeleteRangeResponse   *message);
size_t etcdserverpb__delete_range_response__pack
                     (const Etcdserverpb__DeleteRangeResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__delete_range_response__pack_to_buffer
                     (const Etcdserverpb__DeleteRangeResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__DeleteRangeResponse *
       etcdserverpb__delete_range_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__delete_range_response__free_unpacked
                     (Etcdserverpb__DeleteRangeResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__WatchRequest methods */
void   etcdserverpb__watch_request__init
                     (Etcdserverpb__WatchRequest         *message);
size_t etcdserverpb__watch_request__get_packed_size
                     (const Etcdserverpb__WatchRequest   *message);
size_t etcdserverpb__watch_request__pack
                     (const Etcdserverpb__WatchRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__watch_request__pack_to_buffer
                     (const Etcdserverpb__WatchRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__WatchRequest *
       etcdserverpb__watch_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__watch_request__free_unpacked
                     (Etcdserverpb__WatchRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__WatchCreateRequest methods */
void   etcdserverpb__watch_create_request__init
                     (Etcdserverpb__WatchCreateRequest         *message);
size_t etcdserverpb__watch_create_request__get_packed_size
                     (const Etcdserverpb__WatchCreateRequest   *message);
size_t etcdserverpb__watch_create_request__pack
                     (const Etcdserverpb__WatchCreateRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__watch_create_request__pack_to_buffer
                     (const Etcdserverpb__WatchCreateRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__WatchCreateRequest *
       etcdserverpb__watch_create_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__watch_create_request__free_unpacked
                     (Etcdserverpb__WatchCreateRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__WatchCancelRequest methods */
void   etcdserverpb__watch_cancel_request__init
                     (Etcdserverpb__WatchCancelRequest         *message);
size_t etcdserverpb__watch_cancel_request__get_packed_size
                     (const Etcdserverpb__WatchCancelRequest   *message);
size_t etcdserverpb__watch_cancel_request__pack
                     (const Etcdserverpb__WatchCancelRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__watch_cancel_request__pack_to_buffer
                     (const Etcdserverpb__WatchCancelRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__WatchCancelRequest *
       etcdserverpb__watch_cancel_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__watch_cancel_request__free_unpacked
                     (Etcdserverpb__WatchCancelRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__WatchProgressRequest methods */
void   etcdserverpb__watch_progress_request__init
                     (Etcdserverpb__WatchProgressRequest         *message);
size_t etcdserverpb__watch_progress_request__get_packed_size
                     (const Etcdserverpb__WatchProgressRequest   *message);
size_t etcdserverpb__watch_progress_request__pack
                     (const Etcdserverpb__WatchProgressRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__watch_progress_request__pack_to_buffer
                     (const Etcdserverpb__WatchProgressRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__WatchProgressRequest *
       etcdserverpb__watch_progress_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__watch_progress_request__free_unpacked
                     (Etcdserverpb__WatchProgressRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__WatchResponse methods */
void   etcdserverpb__watch_response__init
                     (Etcdserverpb__WatchResponse         *message);
size_t etcdserverpb__watch_response__get_packed_size
                     (const Etcdserverpb__WatchResponse   *message);
size_t etcdserverpb__watch_response__pack
                     (const Etcdserverpb__WatchResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__watch_response__pack_to_buffer
                     (const Etcdserverpb__WatchResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__WatchResponse *
       etcdserverpb__watch_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__watch_response__free_unpacked
                     (Etcdserverpb__WatchResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__LeaseGrantRequest methods */
void   etcdserverpb__lease_grant_request__init
                     (Etcdserverpb__LeaseGrantRequest         *message);
size_t etcdserverpb__lease_grant_request__get_packed_size
                     (const Etcdserverpb__LeaseGrantRequest   *message);
size_t etcdserverpb__lease_grant_request__pack
                     (const Etcdserverpb__LeaseGrantRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__lease_grant_request__pack_to_buffer
                     (const Etcdserverpb__LeaseGrantRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__LeaseGrantRequest *
       etcdserverpb__lease_grant_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__lease_grant_request__free_unpacked
                     (Etcdserverpb__LeaseGrantRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__LeaseGrantResponse methods */
void   etcdserverpb__lease_grant_response__init
                     (Etcdserverpb__LeaseGrantResponse         *message);
size_t etcdserverpb__lease_grant_response__get_packed_size
                     (const Etcdserverpb__LeaseGrantResponse   *message);
size_t etcdserverpb__lease_grant_response__pack
                     (const Etcdserverpb__LeaseGrantResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__lease_grant_response__pack_to_buffer
                     (const Etcdserverpb__LeaseGrantResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__LeaseGrantResponse *
       etcdserverpb__lease_grant_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__lease_grant_response__free_unpacked
                     (Etcdserverpb__LeaseGrantResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__LeaseRevokeRequest methods */
void   etcdserverpb__lease_revoke_request__init
                     (Etcdserverpb__LeaseRevokeRequest         *message);
size_t etcdserverpb__lease_revoke_request__get_packed_size
                     (const Etcdserverpb__LeaseRevokeRequest   *message);
size_t etcdserverpb__lease_revoke_request__pack
                     (const Etcdserverpb__LeaseRevokeRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__lease_revoke_request__pack_to_buffer
                     (const Etcdserverpb__LeaseRevokeRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__LeaseRevokeRequest *
       etcdserverpb__lease_revoke_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__lease_revoke_request__free_unpacked
                     (Etcdserverpb__LeaseRevokeRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__LeaseRevokeResponse methods */
void   etcdserverpb__lease_revoke_response__init
                     (Etcdserverpb__LeaseRevokeResponse         *message);
size_t etcdserverpb__lease_revoke_response__get_packed_size
                     (const Etcdserverpb__LeaseRevokeResponse   *message);
size_t etcdserverpb__lease_revoke_response__pack
                     (const Etcdserverpb__LeaseRevokeResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__lease_revoke_response__pack_to_buffer
                     (const Etcdserverpb__LeaseRevokeResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__LeaseRevokeResponse *
       etcdserverpb__lease_revoke_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__lease_revoke_response__free_unpacked
                     (Etcdserverpb__LeaseRevokeResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__LeaseKeepAliveRequest methods */
void   etcdserverpb__lease_keep_alive_request__init
                     (Etcdserverpb__LeaseKeepAliveRequest         *message);
size_t etcdserverpb__lease_keep_alive_request__get_packed_size
                     (const Etcdserverpb__LeaseKeepAliveRequest   *message);
size_t etcdserverpb__lease_keep_alive_request__pack
                     (const Etcdserverpb__LeaseKeepAliveRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__lease_keep_alive_request__pack_to_buffer
                     (const Etcdserverpb__LeaseKeepAliveRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__LeaseKeepAliveRequest *
       etcdserverpb__lease_keep_alive_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__lease_keep_alive_request__free_unpacked
                     (Etcdserverpb__LeaseKeepAliveRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__LeaseKeepAliveResponse methods */
void   etcdserverpb__lease_keep_alive_response__init
                     (Etcdserverpb__LeaseKeepAliveResponse         *message);
size_t etcdserverpb__lease_keep_alive_response__get_packed_size
                     (const Etcdserverpb__LeaseKeepAliveResponse   *message);
size_t etcdserverpb__lease_keep_alive_response__pack
                     (const Etcdserverpb__LeaseKeepAliveResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__lease_keep_alive_response__pack_to_buffer
                     (const Etcdserverpb__LeaseKeepAliveResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__LeaseKeepAliveResponse *
       etcdserverpb__lease_keep_alive_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__lease_keep_alive_response__free_unpacked
                     (Etcdserverpb__LeaseKeepAliveResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__LeaseTimeToLiveRequest methods */
void   etcdserverpb__lease_time_to_live_request__init
                     (Etcdserverpb__LeaseTimeToLiveRequest         *message);
size_t etcdserverpb__lease_time_to_live_request__get_packed_size
                     (const Etcdserverpb__LeaseTimeToLiveRequest   *message);
size_t etcdserverpb__lease_time_to_live_request__pack
                     (const Etcdserverpb__LeaseTimeToLiveRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__lease_time_to_live_request__pack_to_buffer
                     (const Etcdserverpb__LeaseTimeToLiveRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__LeaseTimeToLiveRequest *
       etcdserverpb__lease_time_to_live_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__lease_time_to_live_request__free_unpacked
                     (Etcdserverpb__LeaseTimeToLiveRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__LeaseTimeToLiveResponse methods */
void   etcdserverpb__lease_time_to_live_response__init
                     (Etcdserverpb__LeaseTimeToLiveResponse         *message);
size_t etcdserverpb__lease_time_to_live_response__get_packed_size
                     (const Etcdserverpb__LeaseTimeToLiveResponse   *message);
size_t etcdserverpb__lease_time_to_live_response__pack
                     (const Etcdserverpb__LeaseTimeToLiveResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__lease_time_to_live_response__pack_to_buffer
                     (const Etcdserverpb__LeaseTimeToLiveResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__LeaseTimeToLiveResponse *
       etcdserverpb__lease_time_to_live_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__lease_time_to_live_response__free_unpacked
                     (Etcdserverpb__LeaseTimeToLiveResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__LeaseLeasesRequest methods */
void   etcdserverpb__lease_leases_request__init
                     (Etcdserverpb__LeaseLeasesRequest         *message);
size_t etcdserverpb__lease_leases_request__get_packed_size
                     (const Etcdserverpb__LeaseLeasesRequest   *message);
size_t etcdserverpb__lease_leases_request__pack
                     (const Etcdserverpb__LeaseLeasesRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__lease_leases_request__pack_to_buffer
                     (const Etcdserverpb__LeaseLeasesRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__LeaseLeasesRequest *
       etcdserverpb__lease_leases_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__lease_leases_request__free_unpacked
                     (Etcdserverpb__LeaseLeasesRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__LeaseStatus methods */
void   etcdserverpb__lease_status__init
                     (Etcdserverpb__LeaseStatus         *message);
size_t etcdserverpb__lease_status__get_packed_size
                     (const Etcdserverpb__LeaseStatus   *message);
size_t etcdserverpb__lease_status__pack
                     (const Etcdserverpb__LeaseStatus   *message,
                      uint8_t             *out);
size_t etcdserverpb__lease_status__pack_to_buffer
                     (const Etcdserverpb__LeaseStatus   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__LeaseStatus *
       etcdserverpb__lease_status__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__lease_status__free_unpacked
                     (Etcdserverpb__LeaseStatus *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__LeaseLeasesResponse methods */
void   etcdserverpb__lease_leases_response__init
                     (Etcdserverpb__LeaseLeasesResponse         *message);
size_t etcdserverpb__lease_leases_response__get_packed_size
                     (const Etcdserverpb__LeaseLeasesResponse   *message);
size_t etcdserverpb__lease_leases_response__pack
                     (const Etcdserverpb__LeaseLeasesResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__lease_leases_response__pack_to_buffer
                     (const Etcdserverpb__LeaseLeasesResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__LeaseLeasesResponse *
       etcdserverpb__lease_leases_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__lease_leases_response__free_unpacked
                     (Etcdserverpb__LeaseLeasesResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__CompactionRequest methods */
void   etcdserverpb__compaction_request__init
                     (Etcdserverpb__CompactionRequest         *message);
size_t etcdserverpb__compaction_request__get_packed_size
                     (const Etcdserverpb__CompactionRequest   *message);
size_t etcdserverpb__compaction_request__pack
                     (const Etcdserverpb__CompactionRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__compaction_request__pack_to_buffer
                     (const Etcdserverpb__CompactionRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__CompactionRequest *
       etcdserverpb__compaction_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__compaction_request__free_unpacked
                     (Etcdserverpb__CompactionRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__CompactionResponse methods */
void   etcdserverpb__compaction_response__init
                     (Etcdserverpb__CompactionResponse         *message);
size_t etcdserverpb__compaction_response__get_packed_size
                     (const Etcdserverpb__CompactionResponse   *message);
size_t etcdserverpb__compaction_response__pack
                     (const Etcdserverpb__CompactionResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__compaction_response__pack_to_buffer
                     (const Etcdserverpb__CompactionResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__CompactionResponse *
       etcdserverpb__compaction_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__compaction_response__free_unpacked
                     (Etcdserverpb__CompactionResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__StatusRequest methods */
void   etcdserverpb__status_request__init
                     (Etcdserverpb__StatusRequest         *message);
size_t etcdserverpb__status_request__get_packed_size
                     (const Etcdserverpb__StatusRequest   *message);
size_t etcdserverpb__status_request__pack
                     (const Etcdserverpb__StatusRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__status_request__pack_to_buffer
                     (const Etcdserverpb__StatusRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__StatusRequest *
       etcdserverpb__status_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__status_request__free_unpacked
                     (Etcdserverpb__StatusRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__StatusResponse methods */
void   etcdserverpb__status_response__init
                     (Etcdserverpb__StatusResponse         *message);
size_t etcdserverpb__status_response__get_packed_size
                     (const Etcdserverpb__StatusResponse   *message);
size_t etcdserverpb__status_response__pack
                     (const Etcdserverpb__StatusResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__status_response__pack_to_buffer
                     (const Etcdserverpb__StatusResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__StatusResponse *
       etcdserverpb__status_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__status_response__free_unpacked
                     (Etcdserverpb__StatusResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AlarmMember methods */
void   etcdserverpb__alarm_member__init
                     (Etcdserverpb__AlarmMember         *message);
size_t etcdserverpb__alarm_member__get_packed_size
                     (const Etcdserverpb__AlarmMember   *message);
size_t etcdserverpb__alarm_member__pack
                     (const Etcdserverpb__AlarmMember   *message,
                      uint8_t             *out);
size_t etcdserverpb__alarm_member__pack_to_buffer
                     (const Etcdserverpb__AlarmMember   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AlarmMember *
       etcdserverpb__alarm_member__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__alarm_member__free_unpacked
                     (Etcdserverpb__AlarmMember *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AlarmRequest methods */
void   etcdserverpb__alarm_request__init
                     (Etcdserverpb__AlarmRequest         *message);
size_t etcdserverpb__alarm_request__get_packed_size
                     (const Etcdserverpb__AlarmRequest   *message);
size_t etcdserverpb__alarm_request__pack
                     (const Etcdserverpb__AlarmRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__alarm_request__pack_to_buffer
                     (const Etcdserverpb__AlarmRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AlarmRequest *
       etcdserverpb__alarm_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__alarm_request__free_unpacked
                     (Etcdserverpb__AlarmRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AlarmResponse methods */
void   etcdserverpb__alarm_response__init
                     (Etcdserverpb__AlarmResponse         *message);
size_t etcdserverpb__alarm_response__get_packed_size
                     (const Etcdserverpb__AlarmResponse   *message);
size_t etcdserverpb__alarm_response__pack
                     (const Etcdserverpb__AlarmResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__alarm_response__pack_to_buffer
                     (const Etcdserverpb__AlarmResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AlarmResponse *
       etcdserverpb__alarm_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__alarm_response__free_unpacked
                     (Etcdserverpb__AlarmResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__DefragmentRequest methods */
void   etcdserverpb__defragment_request__init
                     (Etcdserverpb__DefragmentRequest         *message);
size_t etcdserverpb__defragment_request__get_packed_size
                     (const Etcdserverpb__DefragmentRequest   *message);
size_t etcdserverpb__defragment_request__pack
                     (const Etcdserverpb__DefragmentRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__defragment_request__pack_to_buffer
                     (const Etcdserverpb__DefragmentRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__DefragmentRequest *
       etcdserverpb__defragment_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__defragment_request__free_unpacked
                     (Etcdserverpb__DefragmentRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__DefragmentResponse methods */
void   etcdserverpb__defragment_response__init
                     (Etcdserverpb__DefragmentResponse         *message);
size_t etcdserverpb__defragment_response__get_packed_size
                     (const Etcdserverpb__DefragmentResponse   *message);
size_t etcdserverpb__defragment_response__pack
                     (const Etcdserverpb__DefragmentResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__defragment_response__pack_to_buffer
                     (const Etcdserverpb__DefragmentResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__DefragmentResponse *
       etcdserverpb__defragment_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__defragment_response__free_unpacked
                     (Etcdserverpb__DefragmentResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__HashKVRequest methods */
void   etcdserverpb__hash_kv_request__init
                     (Etcdserverpb__HashKVRequest         *message);
size_t etcdserverpb__hash_kv_request__get_packed_size
                     (const Etcdserverpb__HashKVRequest   *message);
size_t etcdserverpb__hash_kv_request__pack
                     (const Etcdserverpb__HashKVRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__hash_kv_request__pack_to_buffer
                     (const Etcdserverpb__HashKVRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__HashKVRequest *
       etcdserverpb__hash_kv_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__hash_kv_request__free_unpacked
                     (Etcdserverpb__HashKVRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__HashKVResponse methods */
void   etcdserverpb__hash_kv_response__init
                     (Etcdserverpb__HashKVResponse         *message);
size_t etcdserverpb__hash_kv_response__get_packed_size
                     (const Etcdserverpb__HashKVResponse   *message);
size_t etcdserverpb__hash_kv_response__pack
                     (const Etcdserverpb__HashKVResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__hash_kv_response__pack_to_buffer
                     (const Etcdserverpb__HashKVResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__HashKVResponse *
       etcdserverpb__hash_kv_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__hash_kv_response__free_unpacked
                     (Etcdserverpb__HashKVResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__MoveLeaderRequest methods */
void   etcdserverpb__move_leader_request__init
                     (Etcdserverpb__MoveLeaderRequest         *message);
size_t etcdserverpb__move_leader_request__get_packed_size
                     (const Etcdserverpb__MoveLeaderRequest   *message);
size_t etcdserverpb__move_leader_request__pack
                     (const Etcdserverpb__MoveLeaderRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__move_leader_request__pack_to_buffer
                     (const Etcdserverpb__MoveLeaderRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__MoveLeaderRequest *
       etcdserverpb__move_leader_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__move_leader_request__free_unpacked
                     (Etcdserverpb__MoveLeaderRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__MoveLeaderResponse methods */
void   etcdserverpb__move_leader_response__init
                     (Etcdserverpb__MoveLeaderResponse         *message);
size_t etcdserverpb__move_leader_response__get_packed_size
                     (const Etcdserverpb__MoveLeaderResponse   *message);
size_t etcdserverpb__move_leader_response__pack
                     (const Etcdserverpb__MoveLeaderResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__move_leader_response__pack_to_buffer
                     (const Etcdserverpb__MoveLeaderResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__MoveLeaderResponse *
       etcdserverpb__move_leader_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__move_leader_response__free_unpacked
                     (Etcdserverpb__MoveLeaderResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthStatusRequest methods */
void   etcdserverpb__auth_status_request__init
                     (Etcdserverpb__AuthStatusRequest         *message);
size_t etcdserverpb__auth_status_request__get_packed_size
                     (const Etcdserverpb__AuthStatusRequest   *message);
size_t etcdserverpb__auth_status_request__pack
                     (const Etcdserverpb__AuthStatusRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_status_request__pack_to_buffer
                     (const Etcdserverpb__AuthStatusRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthStatusRequest *
       etcdserverpb__auth_status_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_status_request__free_unpacked
                     (Etcdserverpb__AuthStatusRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthStatusResponse methods */
void   etcdserverpb__auth_status_response__init
                     (Etcdserverpb__AuthStatusResponse         *message);
size_t etcdserverpb__auth_status_response__get_packed_size
                     (const Etcdserverpb__AuthStatusResponse   *message);
size_t etcdserverpb__auth_status_response__pack
                     (const Etcdserverpb__AuthStatusResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_status_response__pack_to_buffer
                     (const Etcdserverpb__AuthStatusResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthStatusResponse *
       etcdserverpb__auth_status_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_status_response__free_unpacked
                     (Etcdserverpb__AuthStatusResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__Compare methods */
void   etcdserverpb__compare__init
                     (Etcdserverpb__Compare         *message);
size_t etcdserverpb__compare__get_packed_size
                     (const Etcdserverpb__Compare   *message);
size_t etcdserverpb__compare__pack
                     (const Etcdserverpb__Compare   *message,
                      uint8_t             *out);
size_t etcdserverpb__compare__pack_to_buffer
                     (const Etcdserverpb__Compare   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__Compare *
       etcdserverpb__compare__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__compare__free_unpacked
                     (Etcdserverpb__Compare *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__RequestOp methods */
void   etcdserverpb__request_op__init
                     (Etcdserverpb__RequestOp         *message);
size_t etcdserverpb__request_op__get_packed_size
                     (const Etcdserverpb__RequestOp   *message);
size_t etcdserverpb__request_op__pack
                     (const Etcdserverpb__RequestOp   *message,
                      uint8_t             *out);
size_t etcdserverpb__request_op__pack_to_buffer
                     (const Etcdserverpb__RequestOp   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__RequestOp *
       etcdserverpb__request_op__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__request_op__free_unpacked
                     (Etcdserverpb__RequestOp *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__ResponseOp methods */
void   etcdserverpb__response_op__init
                     (Etcdserverpb__ResponseOp         *message);
size_t etcdserverpb__response_op__get_packed_size
                     (const Etcdserverpb__ResponseOp   *message);
size_t etcdserverpb__response_op__pack
                     (const Etcdserverpb__ResponseOp   *message,
                      uint8_t             *out);
size_t etcdserverpb__response_op__pack_to_buffer
                     (const Etcdserverpb__ResponseOp   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__ResponseOp *
       etcdserverpb__response_op__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__response_op__free_unpacked
                     (Etcdserverpb__ResponseOp *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__TxnRequest methods */
void   etcdserverpb__txn_request__init
                     (Etcdserverpb__TxnRequest         *message);
size_t etcdserverpb__txn_request__get_packed_size
                     (const Etcdserverpb__TxnRequest   *message);
size_t etcdserverpb__txn_request__pack
                     (const Etcdserverpb__TxnRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__txn_request__pack_to_buffer
                     (const Etcdserverpb__TxnRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__TxnRequest *
       etcdserverpb__txn_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__txn_request__free_unpacked
                     (Etcdserverpb__TxnRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__TxnResponse methods */
void   etcdserverpb__txn_response__init
                     (Etcdserverpb__TxnResponse         *message);
size_t etcdserverpb__txn_response__get_packed_size
                     (const Etcdserverpb__TxnResponse   *message);
size_t etcdserverpb__txn_response__pack
                     (const Etcdserverpb__TxnResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__txn_response__pack_to_buffer
                     (const Etcdserverpb__TxnResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__TxnResponse *
       etcdserverpb__txn_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__txn_response__free_unpacked
                     (Etcdserverpb__TxnResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthenticateRequest methods */
void   etcdserverpb__authenticate_request__init
                     (Etcdserverpb__AuthenticateRequest         *message);
size_t etcdserverpb__authenticate_request__get_packed_size
                     (const Etcdserverpb__AuthenticateRequest   *message);
size_t etcdserverpb__authenticate_request__pack
                     (const Etcdserverpb__AuthenticateRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__authenticate_request__pack_to_buffer
                     (const Etcdserverpb__AuthenticateRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthenticateRequest *
       etcdserverpb__authenticate_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__authenticate_request__free_unpacked
                     (Etcdserverpb__AuthenticateRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthenticateResponse methods */
void   etcdserverpb__authenticate_response__init
                     (Etcdserverpb__AuthenticateResponse         *message);
size_t etcdserverpb__authenticate_response__get_packed_size
                     (const Etcdserverpb__AuthenticateResponse   *message);
size_t etcdserverpb__authenticate_response__pack
                     (const Etcdserverpb__AuthenticateResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__authenticate_response__pack_to_buffer
                     (const Etcdserverpb__AuthenticateResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthenticateResponse *
       etcdserverpb__authenticate_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__authenticate_response__free_unpacked
                     (Etcdserverpb__AuthenticateResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthUserAddRequest methods */
void   etcdserverpb__auth_user_add_request__init
                     (Etcdserverpb__AuthUserAddRequest         *message);
size_t etcdserverpb__auth_user_add_request__get_packed_size
                     (const Etcdserverpb__AuthUserAddRequest   *message);
size_t etcdserverpb__auth_user_add_request__pack
                     (const Etcdserverpb__AuthUserAddRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_user_add_request__pack_to_buffer
                     (const Etcdserverpb__AuthUserAddRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthUserAddRequest *
       etcdserverpb__auth_user_add_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_user_add_request__free_unpacked
                     (Etcdserverpb__AuthUserAddRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthUserAddResponse methods */
void   etcdserverpb__auth_user_add_response__init
                     (Etcdserverpb__AuthUserAddResponse         *message);
size_t etcdserverpb__auth_user_add_response__get_packed_size
                     (const Etcdserverpb__AuthUserAddResponse   *message);
size_t etcdserverpb__auth_user_add_response__pack
                     (const Etcdserverpb__AuthUserAddResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_user_add_response__pack_to_buffer
                     (const Etcdserverpb__AuthUserAddResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthUserAddResponse *
       etcdserverpb__auth_user_add_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_user_add_response__free_unpacked
                     (Etcdserverpb__AuthUserAddResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthUserDeleteRequest methods */
void   etcdserverpb__auth_user_delete_request__init
                     (Etcdserverpb__AuthUserDeleteRequest         *message);
size_t etcdserverpb__auth_user_delete_request__get_packed_size
                     (const Etcdserverpb__AuthUserDeleteRequest   *message);
size_t etcdserverpb__auth_user_delete_request__pack
                     (const Etcdserverpb__AuthUserDeleteRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_user_delete_request__pack_to_buffer
                     (const Etcdserverpb__AuthUserDeleteRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthUserDeleteRequest *
       etcdserverpb__auth_user_delete_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_user_delete_request__free_unpacked
                     (Etcdserverpb__AuthUserDeleteRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthUserDeleteResponse methods */
void   etcdserverpb__auth_user_delete_response__init
                     (Etcdserverpb__AuthUserDeleteResponse         *message);
size_t etcdserverpb__auth_user_delete_response__get_packed_size
                     (const Etcdserverpb__AuthUserDeleteResponse   *message);
size_t etcdserverpb__auth_user_delete_response__pack
                     (const Etcdserverpb__AuthUserDeleteResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_user_delete_response__pack_to_buffer
                     (const Etcdserverpb__AuthUserDeleteResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthUserDeleteResponse *
       etcdserverpb__auth_user_delete_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_user_delete_response__free_unpacked
                     (Etcdserverpb__AuthUserDeleteResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthUserChangePasswordRequest methods */
void   etcdserverpb__auth_user_change_password_request__init
                     (Etcdserverpb__AuthUserChangePasswordRequest         *message);
size_t etcdserverpb__auth_user_change_password_request__get_packed_size
                     (const Etcdserverpb__AuthUserChangePasswordRequest   *message);
size_t etcdserverpb__auth_user_change_password_request__pack
                     (const Etcdserverpb__AuthUserChangePasswordRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_user_change_password_request__pack_to_buffer
                     (const Etcdserverpb__AuthUserChangePasswordRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthUserChangePasswordRequest *
       etcdserverpb__auth_user_change_password_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_user_change_password_request__free_unpacked
                     (Etcdserverpb__AuthUserChangePasswordRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthUserChangePasswordResponse methods */
void   etcdserverpb__auth_user_change_password_response__init
                     (Etcdserverpb__AuthUserChangePasswordResponse         *message);
size_t etcdserverpb__auth_user_change_password_response__get_packed_size
                     (const Etcdserverpb__AuthUserChangePasswordResponse   *message);
size_t etcdserverpb__auth_user_change_password_response__pack
                     (const Etcdserverpb__AuthUserChangePasswordResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_user_change_password_response__pack_to_buffer
                     (const Etcdserverpb__AuthUserChangePasswordResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthUserChangePasswordResponse *
       etcdserverpb__auth_user_change_password_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_user_change_password_response__free_unpacked
                     (Etcdserverpb__AuthUserChangePasswordResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthEnableRequest methods */
void   etcdserverpb__auth_enable_request__init
                     (Etcdserverpb__AuthEnableRequest         *message);
size_t etcdserverpb__auth_enable_request__get_packed_size
                     (const Etcdserverpb__AuthEnableRequest   *message);
size_t etcdserverpb__auth_enable_request__pack
                     (const Etcdserverpb__AuthEnableRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_enable_request__pack_to_buffer
                     (const Etcdserverpb__AuthEnableRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthEnableRequest *
       etcdserverpb__auth_enable_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_enable_request__free_unpacked
                     (Etcdserverpb__AuthEnableRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthEnableResponse methods */
void   etcdserverpb__auth_enable_response__init
                     (Etcdserverpb__AuthEnableResponse         *message);
size_t etcdserverpb__auth_enable_response__get_packed_size
                     (const Etcdserverpb__AuthEnableResponse   *message);
size_t etcdserverpb__auth_enable_response__pack
                     (const Etcdserverpb__AuthEnableResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_enable_response__pack_to_buffer
                     (const Etcdserverpb__AuthEnableResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthEnableResponse *
       etcdserverpb__auth_enable_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_enable_response__free_unpacked
                     (Etcdserverpb__AuthEnableResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthDisableRequest methods */
void   etcdserverpb__auth_disable_request__init
                     (Etcdserverpb__AuthDisableRequest         *message);
size_t etcdserverpb__auth_disable_request__get_packed_size
                     (const Etcdserverpb__AuthDisableRequest   *message);
size_t etcdserverpb__auth_disable_request__pack
                     (const Etcdserverpb__AuthDisableRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_disable_request__pack_to_buffer
                     (const Etcdserverpb__AuthDisableRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthDisableRequest *
       etcdserverpb__auth_disable_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_disable_request__free_unpacked
                     (Etcdserverpb__AuthDisableRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthDisableResponse methods */
void   etcdserverpb__auth_disable_response__init
                     (Etcdserverpb__AuthDisableResponse         *message);
size_t etcdserverpb__auth_disable_response__get_packed_size
                     (const Etcdserverpb__AuthDisableResponse   *message);
size_t etcdserverpb__auth_disable_response__pack
                     (const Etcdserverpb__AuthDisableResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_disable_response__pack_to_buffer
                     (const Etcdserverpb__AuthDisableResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthDisableResponse *
       etcdserverpb__auth_disable_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_disable_response__free_unpacked
                     (Etcdserverpb__AuthDisableResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__Permission methods */
void   etcdserverpb__permission__init
                     (Etcdserverpb__Permission         *message);
size_t etcdserverpb__permission__get_packed_size
                     (const Etcdserverpb__Permission   *message);
size_t etcdserverpb__permission__pack
                     (const Etcdserverpb__Permission   *message,
                      uint8_t             *out);
size_t etcdserverpb__permission__pack_to_buffer
                     (const Etcdserverpb__Permission   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__Permission *
       etcdserverpb__permission__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__permission__free_unpacked
                     (Etcdserverpb__Permission *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__Role methods */
void   etcdserverpb__role__init
                     (Etcdserverpb__Role         *message);
size_t etcdserverpb__role__get_packed_size
                     (const Etcdserverpb__Role   *message);
size_t etcdserverpb__role__pack
                     (const Etcdserverpb__Role   *message,
                      uint8_t             *out);
size_t etcdserverpb__role__pack_to_buffer
                     (const Etcdserverpb__Role   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__Role *
       etcdserverpb__role__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__role__free_unpacked
                     (Etcdserverpb__Role *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthRoleAddRequest methods */
void   etcdserverpb__auth_role_add_request__init
                     (Etcdserverpb__AuthRoleAddRequest         *message);
size_t etcdserverpb__auth_role_add_request__get_packed_size
                     (const Etcdserverpb__AuthRoleAddRequest   *message);
size_t etcdserverpb__auth_role_add_request__pack
                     (const Etcdserverpb__AuthRoleAddRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_role_add_request__pack_to_buffer
                     (const Etcdserverpb__AuthRoleAddRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthRoleAddRequest *
       etcdserverpb__auth_role_add_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_role_add_request__free_unpacked
                     (Etcdserverpb__AuthRoleAddRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthRoleAddResponse methods */
void   etcdserverpb__auth_role_add_response__init
                     (Etcdserverpb__AuthRoleAddResponse         *message);
size_t etcdserverpb__auth_role_add_response__get_packed_size
                     (const Etcdserverpb__AuthRoleAddResponse   *message);
size_t etcdserverpb__auth_role_add_response__pack
                     (const Etcdserverpb__AuthRoleAddResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_role_add_response__pack_to_buffer
                     (const Etcdserverpb__AuthRoleAddResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthRoleAddResponse *
       etcdserverpb__auth_role_add_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_role_add_response__free_unpacked
                     (Etcdserverpb__AuthRoleAddResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthRoleDeleteRequest methods */
void   etcdserverpb__auth_role_delete_request__init
                     (Etcdserverpb__AuthRoleDeleteRequest         *message);
size_t etcdserverpb__auth_role_delete_request__get_packed_size
                     (const Etcdserverpb__AuthRoleDeleteRequest   *message);
size_t etcdserverpb__auth_role_delete_request__pack
                     (const Etcdserverpb__AuthRoleDeleteRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_role_delete_request__pack_to_buffer
                     (const Etcdserverpb__AuthRoleDeleteRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthRoleDeleteRequest *
       etcdserverpb__auth_role_delete_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_role_delete_request__free_unpacked
                     (Etcdserverpb__AuthRoleDeleteRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthRoleDeleteResponse methods */
void   etcdserverpb__auth_role_delete_response__init
                     (Etcdserverpb__AuthRoleDeleteResponse         *message);
size_t etcdserverpb__auth_role_delete_response__get_packed_size
                     (const Etcdserverpb__AuthRoleDeleteResponse   *message);
size_t etcdserverpb__auth_role_delete_response__pack
                     (const Etcdserverpb__AuthRoleDeleteResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_role_delete_response__pack_to_buffer
                     (const Etcdserverpb__AuthRoleDeleteResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthRoleDeleteResponse *
       etcdserverpb__auth_role_delete_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_role_delete_response__free_unpacked
                     (Etcdserverpb__AuthRoleDeleteResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthRoleGetRequest methods */
void   etcdserverpb__auth_role_get_request__init
                     (Etcdserverpb__AuthRoleGetRequest         *message);
size_t etcdserverpb__auth_role_get_request__get_packed_size
                     (const Etcdserverpb__AuthRoleGetRequest   *message);
size_t etcdserverpb__auth_role_get_request__pack
                     (const Etcdserverpb__AuthRoleGetRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_role_get_request__pack_to_buffer
                     (const Etcdserverpb__AuthRoleGetRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthRoleGetRequest *
       etcdserverpb__auth_role_get_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_role_get_request__free_unpacked
                     (Etcdserverpb__AuthRoleGetRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthRoleGetResponse methods */
void   etcdserverpb__auth_role_get_response__init
                     (Etcdserverpb__AuthRoleGetResponse         *message);
size_t etcdserverpb__auth_role_get_response__get_packed_size
                     (const Etcdserverpb__AuthRoleGetResponse   *message);
size_t etcdserverpb__auth_role_get_response__pack
                     (const Etcdserverpb__AuthRoleGetResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_role_get_response__pack_to_buffer
                     (const Etcdserverpb__AuthRoleGetResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthRoleGetResponse *
       etcdserverpb__auth_role_get_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_role_get_response__free_unpacked
                     (Etcdserverpb__AuthRoleGetResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthRoleListRequest methods */
void   etcdserverpb__auth_role_list_request__init
                     (Etcdserverpb__AuthRoleListRequest         *message);
size_t etcdserverpb__auth_role_list_request__get_packed_size
                     (const Etcdserverpb__AuthRoleListRequest   *message);
size_t etcdserverpb__auth_role_list_request__pack
                     (const Etcdserverpb__AuthRoleListRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_role_list_request__pack_to_buffer
                     (const Etcdserverpb__AuthRoleListRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthRoleListRequest *
       etcdserverpb__auth_role_list_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_role_list_request__free_unpacked
                     (Etcdserverpb__AuthRoleListRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthRoleListResponse methods */
void   etcdserverpb__auth_role_list_response__init
                     (Etcdserverpb__AuthRoleListResponse         *message);
size_t etcdserverpb__auth_role_list_response__get_packed_size
                     (const Etcdserverpb__AuthRoleListResponse   *message);
size_t etcdserverpb__auth_role_list_response__pack
                     (const Etcdserverpb__AuthRoleListResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_role_list_response__pack_to_buffer
                     (const Etcdserverpb__AuthRoleListResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthRoleListResponse *
       etcdserverpb__auth_role_list_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_role_list_response__free_unpacked
                     (Etcdserverpb__AuthRoleListResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthRoleGrantPermissionRequest methods */
void   etcdserverpb__auth_role_grant_permission_request__init
                     (Etcdserverpb__AuthRoleGrantPermissionRequest         *message);
size_t etcdserverpb__auth_role_grant_permission_request__get_packed_size
                     (const Etcdserverpb__AuthRoleGrantPermissionRequest   *message);
size_t etcdserverpb__auth_role_grant_permission_request__pack
                     (const Etcdserverpb__AuthRoleGrantPermissionRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_role_grant_permission_request__pack_to_buffer
                     (const Etcdserverpb__AuthRoleGrantPermissionRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthRoleGrantPermissionRequest *
       etcdserverpb__auth_role_grant_permission_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_role_grant_permission_request__free_unpacked
                     (Etcdserverpb__AuthRoleGrantPermissionRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthRoleGrantPermissionResponse methods */
void   etcdserverpb__auth_role_grant_permission_response__init
                     (Etcdserverpb__AuthRoleGrantPermissionResponse         *message);
size_t etcdserverpb__auth_role_grant_permission_response__get_packed_size
                     (const Etcdserverpb__AuthRoleGrantPermissionResponse   *message);
size_t etcdserverpb__auth_role_grant_permission_response__pack
                     (const Etcdserverpb__AuthRoleGrantPermissionResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_role_grant_permission_response__pack_to_buffer
                     (const Etcdserverpb__AuthRoleGrantPermissionResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthRoleGrantPermissionResponse *
       etcdserverpb__auth_role_grant_permission_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_role_grant_permission_response__free_unpacked
                     (Etcdserverpb__AuthRoleGrantPermissionResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthRoleRevokePermissionRequest methods */
void   etcdserverpb__auth_role_revoke_permission_request__init
                     (Etcdserverpb__AuthRoleRevokePermissionRequest         *message);
size_t etcdserverpb__auth_role_revoke_permission_request__get_packed_size
                     (const Etcdserverpb__AuthRoleRevokePermissionRequest   *message);
size_t etcdserverpb__auth_role_revoke_permission_request__pack
                     (const Etcdserverpb__AuthRoleRevokePermissionRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_role_revoke_permission_request__pack_to_buffer
                     (const Etcdserverpb__AuthRoleRevokePermissionRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthRoleRevokePermissionRequest *
       etcdserverpb__auth_role_revoke_permission_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_role_revoke_permission_request__free_unpacked
                     (Etcdserverpb__AuthRoleRevokePermissionRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthRoleRevokePermissionResponse methods */
void   etcdserverpb__auth_role_revoke_permission_response__init
                     (Etcdserverpb__AuthRoleRevokePermissionResponse         *message);
size_t etcdserverpb__auth_role_revoke_permission_response__get_packed_size
                     (const Etcdserverpb__AuthRoleRevokePermissionResponse   *message);
size_t etcdserverpb__auth_role_revoke_permission_response__pack
                     (const Etcdserverpb__AuthRoleRevokePermissionResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_role_revoke_permission_response__pack_to_buffer
                     (const Etcdserverpb__AuthRoleRevokePermissionResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthRoleRevokePermissionResponse *
       etcdserverpb__auth_role_revoke_permission_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_role_revoke_permission_response__free_unpacked
                     (Etcdserverpb__AuthRoleRevokePermissionResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthUserGrantRoleRequest methods */
void   etcdserverpb__auth_user_grant_role_request__init
                     (Etcdserverpb__AuthUserGrantRoleRequest         *message);
size_t etcdserverpb__auth_user_grant_role_request__get_packed_size
                     (const Etcdserverpb__AuthUserGrantRoleRequest   *message);
size_t etcdserverpb__auth_user_grant_role_request__pack
                     (const Etcdserverpb__AuthUserGrantRoleRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_user_grant_role_request__pack_to_buffer
                     (const Etcdserverpb__AuthUserGrantRoleRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthUserGrantRoleRequest *
       etcdserverpb__auth_user_grant_role_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_user_grant_role_request__free_unpacked
                     (Etcdserverpb__AuthUserGrantRoleRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthUserGrantRoleResponse methods */
void   etcdserverpb__auth_user_grant_role_response__init
                     (Etcdserverpb__AuthUserGrantRoleResponse         *message);
size_t etcdserverpb__auth_user_grant_role_response__get_packed_size
                     (const Etcdserverpb__AuthUserGrantRoleResponse   *message);
size_t etcdserverpb__auth_user_grant_role_response__pack
                     (const Etcdserverpb__AuthUserGrantRoleResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_user_grant_role_response__pack_to_buffer
                     (const Etcdserverpb__AuthUserGrantRoleResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthUserGrantRoleResponse *
       etcdserverpb__auth_user_grant_role_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_user_grant_role_response__free_unpacked
                     (Etcdserverpb__AuthUserGrantRoleResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthUserRevokeRoleRequest methods */
void   etcdserverpb__auth_user_revoke_role_request__init
                     (Etcdserverpb__AuthUserRevokeRoleRequest         *message);
size_t etcdserverpb__auth_user_revoke_role_request__get_packed_size
                     (const Etcdserverpb__AuthUserRevokeRoleRequest   *message);
size_t etcdserverpb__auth_user_revoke_role_request__pack
                     (const Etcdserverpb__AuthUserRevokeRoleRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_user_revoke_role_request__pack_to_buffer
                     (const Etcdserverpb__AuthUserRevokeRoleRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthUserRevokeRoleRequest *
       etcdserverpb__auth_user_revoke_role_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_user_revoke_role_request__free_unpacked
                     (Etcdserverpb__AuthUserRevokeRoleRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthUserRevokeRoleResponse methods */
void   etcdserverpb__auth_user_revoke_role_response__init
                     (Etcdserverpb__AuthUserRevokeRoleResponse         *message);
size_t etcdserverpb__auth_user_revoke_role_response__get_packed_size
                     (const Etcdserverpb__AuthUserRevokeRoleResponse   *message);
size_t etcdserverpb__auth_user_revoke_role_response__pack
                     (const Etcdserverpb__AuthUserRevokeRoleResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_user_revoke_role_response__pack_to_buffer
                     (const Etcdserverpb__AuthUserRevokeRoleResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthUserRevokeRoleResponse *
       etcdserverpb__auth_user_revoke_role_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_user_revoke_role_response__free_unpacked
                     (Etcdserverpb__AuthUserRevokeRoleResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthUserGetRequest methods */
void   etcdserverpb__auth_user_get_request__init
                     (Etcdserverpb__AuthUserGetRequest         *message);
size_t etcdserverpb__auth_user_get_request__get_packed_size
                     (const Etcdserverpb__AuthUserGetRequest   *message);
size_t etcdserverpb__auth_user_get_request__pack
                     (const Etcdserverpb__AuthUserGetRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_user_get_request__pack_to_buffer
                     (const Etcdserverpb__AuthUserGetRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthUserGetRequest *
       etcdserverpb__auth_user_get_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_user_get_request__free_unpacked
                     (Etcdserverpb__AuthUserGetRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthUserGetResponse methods */
void   etcdserverpb__auth_user_get_response__init
                     (Etcdserverpb__AuthUserGetResponse         *message);
size_t etcdserverpb__auth_user_get_response__get_packed_size
                     (const Etcdserverpb__AuthUserGetResponse   *message);
size_t etcdserverpb__auth_user_get_response__pack
                     (const Etcdserverpb__AuthUserGetResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_user_get_response__pack_to_buffer
                     (const Etcdserverpb__AuthUserGetResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthUserGetResponse *
       etcdserverpb__auth_user_get_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_user_get_response__free_unpacked
                     (Etcdserverpb__AuthUserGetResponse *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthUserListRequest methods */
void   etcdserverpb__auth_user_list_request__init
                     (Etcdserverpb__AuthUserListRequest         *message);
size_t etcdserverpb__auth_user_list_request__get_packed_size
                     (const Etcdserverpb__AuthUserListRequest   *message);
size_t etcdserverpb__auth_user_list_request__pack
                     (const Etcdserverpb__AuthUserListRequest   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_user_list_request__pack_to_buffer
                     (const Etcdserverpb__AuthUserListRequest   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthUserListRequest *
       etcdserverpb__auth_user_list_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_user_list_request__free_unpacked
                     (Etcdserverpb__AuthUserListRequest *message,
                      ProtobufCAllocator *allocator);
/* Etcdserverpb__AuthUserListResponse methods */
void   etcdserverpb__auth_user_list_response__init
                     (Etcdserverpb__AuthUserListResponse         *message);
size_t etcdserverpb__auth_user_list_response__get_packed_size
                     (const Etcdserverpb__AuthUserListResponse   *message);
size_t etcdserverpb__auth_user_list_response__pack
                     (const Etcdserverpb__AuthUserListResponse   *message,
                      uint8_t             *out);
size_t etcdserverpb__auth_user_list_response__pack_to_buffer
                     (const Etcdserverpb__AuthUserListResponse   *message,
                      ProtobufCBuffer     *buffer);
Etcdserverpb__AuthUserListResponse *
       etcdserverpb__auth_user_list_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   etcdserverpb__auth_user_list_response__free_unpacked
                     (Etcdserverpb__AuthUserListResponse *message,
                      ProtobufCAllocator *allocator);
/* --- per-message closures --- */

typedef void (*Etcdserverpb__ResponseHeader_Closure)
                 (const Etcdserverpb__ResponseHeader *message,
                  void *closure_data);
typedef void (*Etcdserverpb__RangeRequest_Closure)
                 (const Etcdserverpb__RangeRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__RangeResponse_Closure)
                 (const Etcdserverpb__RangeResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__PutRequest_Closure)
                 (const Etcdserverpb__PutRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__PutResponse_Closure)
                 (const Etcdserverpb__PutResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__DeleteRangeRequest_Closure)
                 (const Etcdserverpb__DeleteRangeRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__DeleteRangeResponse_Closure)
                 (const Etcdserverpb__DeleteRangeResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__WatchRequest_Closure)
                 (const Etcdserverpb__WatchRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__WatchCreateRequest_Closure)
                 (const Etcdserverpb__WatchCreateRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__WatchCancelRequest_Closure)
                 (const Etcdserverpb__WatchCancelRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__WatchProgressRequest_Closure)
                 (const Etcdserverpb__WatchProgressRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__WatchResponse_Closure)
                 (const Etcdserverpb__WatchResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__LeaseGrantRequest_Closure)
                 (const Etcdserverpb__LeaseGrantRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__LeaseGrantResponse_Closure)
                 (const Etcdserverpb__LeaseGrantResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__LeaseRevokeRequest_Closure)
                 (const Etcdserverpb__LeaseRevokeRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__LeaseRevokeResponse_Closure)
                 (const Etcdserverpb__LeaseRevokeResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__LeaseKeepAliveRequest_Closure)
                 (const Etcdserverpb__LeaseKeepAliveRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__LeaseKeepAliveResponse_Closure)
                 (const Etcdserverpb__LeaseKeepAliveResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__LeaseTimeToLiveRequest_Closure)
                 (const Etcdserverpb__LeaseTimeToLiveRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__LeaseTimeToLiveResponse_Closure)
                 (const Etcdserverpb__LeaseTimeToLiveResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__LeaseLeasesRequest_Closure)
                 (const Etcdserverpb__LeaseLeasesRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__LeaseStatus_Closure)
                 (const Etcdserverpb__LeaseStatus *message,
                  void *closure_data);
typedef void (*Etcdserverpb__LeaseLeasesResponse_Closure)
                 (const Etcdserverpb__LeaseLeasesResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__CompactionRequest_Closure)
                 (const Etcdserverpb__CompactionRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__CompactionResponse_Closure)
                 (const Etcdserverpb__CompactionResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__StatusRequest_Closure)
                 (const Etcdserverpb__StatusRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__StatusResponse_Closure)
                 (const Etcdserverpb__StatusResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__Compare_Closure)
                 (const Etcdserverpb__Compare *message,
                  void *closure_data);
typedef void (*Etcdserverpb__RequestOp_Closure)
                 (const Etcdserverpb__RequestOp *message,
                  void *closure_data);
typedef void (*Etcdserverpb__ResponseOp_Closure)
                 (const Etcdserverpb__ResponseOp *message,
                  void *closure_data);
typedef void (*Etcdserverpb__TxnRequest_Closure)
                 (const Etcdserverpb__TxnRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__TxnResponse_Closure)
                 (const Etcdserverpb__TxnResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthenticateRequest_Closure)
                 (const Etcdserverpb__AuthenticateRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthenticateResponse_Closure)
                 (const Etcdserverpb__AuthenticateResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthUserAddRequest_Closure)
                 (const Etcdserverpb__AuthUserAddRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthUserAddResponse_Closure)
                 (const Etcdserverpb__AuthUserAddResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthUserDeleteRequest_Closure)
                 (const Etcdserverpb__AuthUserDeleteRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthUserDeleteResponse_Closure)
                 (const Etcdserverpb__AuthUserDeleteResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthUserChangePasswordRequest_Closure)
                 (const Etcdserverpb__AuthUserChangePasswordRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthUserChangePasswordResponse_Closure)
                 (const Etcdserverpb__AuthUserChangePasswordResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthEnableRequest_Closure)
                 (const Etcdserverpb__AuthEnableRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthEnableResponse_Closure)
                 (const Etcdserverpb__AuthEnableResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthDisableRequest_Closure)
                 (const Etcdserverpb__AuthDisableRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthDisableResponse_Closure)
                 (const Etcdserverpb__AuthDisableResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__Permission_Closure)
                 (const Etcdserverpb__Permission *message,
                  void *closure_data);
typedef void (*Etcdserverpb__Role_Closure)
                 (const Etcdserverpb__Role *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthRoleAddRequest_Closure)
                 (const Etcdserverpb__AuthRoleAddRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthRoleAddResponse_Closure)
                 (const Etcdserverpb__AuthRoleAddResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthRoleDeleteRequest_Closure)
                 (const Etcdserverpb__AuthRoleDeleteRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthRoleDeleteResponse_Closure)
                 (const Etcdserverpb__AuthRoleDeleteResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthRoleGetRequest_Closure)
                 (const Etcdserverpb__AuthRoleGetRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthRoleGetResponse_Closure)
                 (const Etcdserverpb__AuthRoleGetResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthRoleListRequest_Closure)
                 (const Etcdserverpb__AuthRoleListRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthRoleListResponse_Closure)
                 (const Etcdserverpb__AuthRoleListResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthRoleGrantPermissionRequest_Closure)
                 (const Etcdserverpb__AuthRoleGrantPermissionRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthRoleGrantPermissionResponse_Closure)
                 (const Etcdserverpb__AuthRoleGrantPermissionResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthRoleRevokePermissionRequest_Closure)
                 (const Etcdserverpb__AuthRoleRevokePermissionRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthRoleRevokePermissionResponse_Closure)
                 (const Etcdserverpb__AuthRoleRevokePermissionResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthUserGrantRoleRequest_Closure)
                 (const Etcdserverpb__AuthUserGrantRoleRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthUserGrantRoleResponse_Closure)
                 (const Etcdserverpb__AuthUserGrantRoleResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthUserRevokeRoleRequest_Closure)
                 (const Etcdserverpb__AuthUserRevokeRoleRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthUserRevokeRoleResponse_Closure)
                 (const Etcdserverpb__AuthUserRevokeRoleResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthUserGetRequest_Closure)
                 (const Etcdserverpb__AuthUserGetRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthUserGetResponse_Closure)
                 (const Etcdserverpb__AuthUserGetResponse *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthUserListRequest_Closure)
                 (const Etcdserverpb__AuthUserListRequest *message,
                  void *closure_data);
typedef void (*Etcdserverpb__AuthUserListResponse_Closure)
                 (const Etcdserverpb__AuthUserListResponse *message,
                  void *closure_data);

/* --- services --- */


/* --- descriptors --- */

extern const ProtobufCMessageDescriptor etcdserverpb__response_header__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__range_request__descriptor;
extern const ProtobufCEnumDescriptor    etcdserverpb__range_request__sort_order__descriptor;
extern const ProtobufCEnumDescriptor    etcdserverpb__range_request__sort_target__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__range_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__put_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__put_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__delete_range_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__delete_range_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__watch_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__watch_create_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__watch_cancel_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__watch_progress_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__watch_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__lease_grant_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__lease_grant_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__lease_revoke_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__lease_revoke_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__lease_keep_alive_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__lease_keep_alive_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__lease_time_to_live_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__lease_time_to_live_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__lease_leases_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__lease_status__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__lease_leases_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__compaction_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__compaction_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__status_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__status_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__alarm_member__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__alarm_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__alarm_response__descriptor;
extern const ProtobufCEnumDescriptor    etcdserverpb__alarm_type__descriptor;
extern const ProtobufCEnumDescriptor    etcdserverpb__alarm_request__alarm_action__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__defragment_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__defragment_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__hash_kv_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__hash_kv_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__move_leader_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__move_leader_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_status_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_status_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__compare__descriptor;
extern const ProtobufCEnumDescriptor    etcdserverpb__compare__compare_result__descriptor;
extern const ProtobufCEnumDescriptor    etcdserverpb__compare__compare_target__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__request_op__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__response_op__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__txn_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__txn_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__authenticate_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__authenticate_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_user_add_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_user_add_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_user_delete_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_user_delete_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_user_change_password_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_user_change_password_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_enable_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_enable_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_disable_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_disable_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__permission__descriptor;
extern const ProtobufCEnumDescriptor    etcdserverpb__permission__type__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__role__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_role_add_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_role_add_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_role_delete_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_role_delete_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_role_get_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_role_get_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_role_list_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_role_list_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_role_grant_permission_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_role_grant_permission_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_role_revoke_permission_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_role_revoke_permission_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_user_grant_role_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_user_grant_role_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_user_revoke_role_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_user_revoke_role_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_user_get_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_user_get_response__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_user_list_request__descriptor;
extern const ProtobufCMessageDescriptor etcdserverpb__auth_user_list_response__descriptor;

PROTOBUF_C__END_DECLS


#endif  /* PROTOBUF_C_rpc_2eproto__INCLUDED */
