repo_description: Distributed reliable key-value store for the most critical data of a distributed system
repo_topics: cncf consensus database distributed-database distributed-systems etcd go key-value kubernetes raft
code: // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
  // versions:
  // - protoc-gen-go-grpc v1.6.1
  // - protoc             v3.20.3
  // source: rpc.proto
  
  package etcdserverpb
  
  import (
  	context "context"
  
  	grpc "google.golang.org/grpc"
  	codes "google.golang.org/grpc/codes"
  	status "google.golang.org/grpc/status"
  )
  
  // This is a compile-time assertion to ensure that this generated file
  // is compatible with the grpc package it is being compiled against.
  // Requires gRPC-Go v1.64.0 or later.
  const _ = grpc.SupportPackageIsVersion9
  
  const (
  	KV_Range_FullMethodName       = "/etcdserverpb.KV/Range"
  	KV_Put_FullMethodName         = "/etcdserverpb.KV/Put"
  	KV_DeleteRange_FullMethodName = "/etcdserverpb.KV/DeleteRange"
  	KV_Txn_FullMethodName         = "/etcdserverpb.KV/Txn"
  	KV_Compact_FullMethodName     = "/etcdserverpb.KV/Compact"
  )
  
  // KVClient is the client API for KV service.
  //
  // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
  type KVClient interface {
  	// Range gets the keys in the range from the key-value store.
  	Range(ctx context.Context, in *RangeRequest, opts ...grpc.CallOption) (*RangeResponse, error)
  	// Put puts the given key into the key-value store.
  	// A put request increments the revision of the key-value store
  	// and generates one event in the event history.
  	Put(ctx context.Context, in *PutRequest, opts ...grpc.CallOption) (*PutResponse, error)
  	// DeleteRange deletes the given range from the key-value store.
  	// A delete request increments the revision of the key-value store
  	// and generates a delete event in the event history for every deleted key.
  	DeleteRange(ctx context.Context, in *DeleteRangeRequest, opts ...grpc.CallOption) (*DeleteRangeResponse, error)
  	// Txn processes multiple requests in a single transaction.
  	// A txn request increments the revision of the key-value store
  	// and generates events with the same revision for every completed request.
  	// It is not allowed to modify the same key several times within one txn.
  	Txn(ctx context.Context, in *TxnRequest, opts ...grpc.CallOption) (*TxnResponse, error)
  	// Compact compacts the event history in the etcd key-value store. The key-value
  	// store should be periodically compacted or the event history will continue to grow
  	// indefinitely.
  	Compact(ctx context.Context, in *CompactionRequest, opts ...grpc.CallOption) (*CompactionResponse, error)
  }
  
  type kVClient struct {
  	cc grpc.ClientConnInterface
  }
  
  func NewKVClient(cc grpc.ClientConnInterface) KVClient {
  	return &kVClient{cc}
  }
  
  func (c *kVClient) Range(ctx context.Context, in *RangeRequest, opts ...grpc.CallOption) (*RangeResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(RangeResponse)
  	err := c.cc.Invoke(ctx, KV_Range_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *kVClient) Put(ctx context.Context, in *PutRequest, opts ...grpc.CallOption) (*PutResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(PutResponse)
  	err := c.cc.Invoke(ctx, KV_Put_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *kVClient) DeleteRange(ctx context.Context, in *DeleteRangeRequest, opts ...grpc.CallOption) (*DeleteRangeResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(DeleteRangeResponse)
  	err := c.cc.Invoke(ctx, KV_DeleteRange_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *kVClient) Txn(ctx context.Context, in *TxnRequest, opts ...grpc.CallOption) (*TxnResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(TxnResponse)
  	err := c.cc.Invoke(ctx, KV_Txn_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *kVClient) Compact(ctx context.Context, in *CompactionRequest, opts ...grpc.CallOption) (*CompactionResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(CompactionResponse)
  	err := c.cc.Invoke(ctx, KV_Compact_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  // KVServer is the server API for KV service.
  // All implementations must embed UnimplementedKVServer
  // for forward compatibility.
  type KVServer interface {
  	// Range gets the keys in the range from the key-value store.
  	Range(context.Context, *RangeRequest) (*RangeResponse, error)
  	// Put puts the given key into the key-value store.
  	// A put request increments the revision of the key-value store
  	// and generates one event in the event history.
  	Put(context.Context, *PutRequest) (*PutResponse, error)
  	// DeleteRange deletes the given range from the key-value store.
  	// A delete request increments the revision of the key-value store
  	// and generates a delete event in the event history for every deleted key.
  	DeleteRange(context.Context, *DeleteRangeRequest) (*DeleteRangeResponse, error)
  	// Txn processes multiple requests in a single transaction.
  	// A txn request increments the revision of the key-value store
  	// and generates events with the same revision for every completed request.
  	// It is not allowed to modify the same key several times within one txn.
  	Txn(context.Context, *TxnRequest) (*TxnResponse, error)
  	// Compact compacts the event history in the etcd key-value store. The key-value
  	// store should be periodically compacted or the event history will continue to grow
  	// indefinitely.
  	Compact(context.Context, *CompactionRequest) (*CompactionResponse, error)
  	mustEmbedUnimplementedKVServer()
  }
  
  // UnimplementedKVServer must be embedded to have
  // forward compatible implementations.
  //
  // NOTE: this should be embedded by value instead of pointer to avoid a nil
  // pointer dereference when methods are called.
  type UnimplementedKVServer struct{}
  
  func (UnimplementedKVServer) Range(context.Context, *RangeRequest) (*RangeResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method Range not implemented")
  }
  func (UnimplementedKVServer) Put(context.Context, *PutRequest) (*PutResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method Put not implemented")
  }
  func (UnimplementedKVServer) DeleteRange(context.Context, *DeleteRangeRequest) (*DeleteRangeResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method DeleteRange not implemented")
  }
  func (UnimplementedKVServer) Txn(context.Context, *TxnRequest) (*TxnResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method Txn not implemented")
  }
  func (UnimplementedKVServer) Compact(context.Context, *CompactionRequest) (*CompactionResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method Compact not implemented")
  }
  func (UnimplementedKVServer) mustEmbedUnimplementedKVServer() {}
  func (UnimplementedKVServer) testEmbeddedByValue()            {}
  
  // UnsafeKVServer may be embedded to opt out of forward compatibility for this service.
  // Use of this interface is not recommended, as added methods to KVServer will
  // result in compilation errors.
  type UnsafeKVServer interface {
  	mustEmbedUnimplementedKVServer()
  }
  
  func RegisterKVServer(s grpc.ServiceRegistrar, srv KVServer) {
  	// If the following call panics, it indicates UnimplementedKVServer was
  	// embedded by pointer and is nil.  This will cause panics if an
  	// unimplemented method is ever invoked, so we test this at initialization
  	// time to prevent it from happening at runtime later due to I/O.
  	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
  		t.testEmbeddedByValue()
  	}
  	s.RegisterService(&KV_ServiceDesc, srv)
  }
  
  func _KV_Range_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(RangeRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(KVServer).Range(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: KV_Range_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(KVServer).Range(ctx, req.(*RangeRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _KV_Put_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(PutRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(KVServer).Put(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: KV_Put_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(KVServer).Put(ctx, req.(*PutRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _KV_DeleteRange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(DeleteRangeRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(KVServer).DeleteRange(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: KV_DeleteRange_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(KVServer).DeleteRange(ctx, req.(*DeleteRangeRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _KV_Txn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(TxnRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(KVServer).Txn(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: KV_Txn_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(KVServer).Txn(ctx, req.(*TxnRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _KV_Compact_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(CompactionRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(KVServer).Compact(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: KV_Compact_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(KVServer).Compact(ctx, req.(*CompactionRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  // KV_ServiceDesc is the grpc.ServiceDesc for KV service.
  // It's only intended for direct use with grpc.RegisterService,
  // and not to be introspected or modified (even as a copy)
  var KV_ServiceDesc = grpc.ServiceDesc{
  	ServiceName: "etcdserverpb.KV",
  	HandlerType: (*KVServer)(nil),
  	Methods: []grpc.MethodDesc{
  		{
  			MethodName: "Range",
  			Handler:    _KV_Range_Handler,
  		},
  		{
  			MethodName: "Put",
  			Handler:    _KV_Put_Handler,
  		},
  		{
  			MethodName: "DeleteRange",
  			Handler:    _KV_DeleteRange_Handler,
  		},
  		{
  			MethodName: "Txn",
  			Handler:    _KV_Txn_Handler,
  		},
  		{
  			MethodName: "Compact",
  			Handler:    _KV_Compact_Handler,
  		},
  	},
  	Streams:  []grpc.StreamDesc{},
  	Metadata: "rpc.proto",
  }
  
  const (
  	Watch_Watch_FullMethodName = "/etcdserverpb.Watch/Watch"
  )
  
  // WatchClient is the client API for Watch service.
  //
  // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
  type WatchClient interface {
  	// Watch watches for events happening or that have happened. Both input and output
  	// are streams; the input stream is for creating and canceling watchers and the output
  	// stream sends events. One watch RPC can watch on multiple key ranges, streaming events
  	// for several watches at once. The entire event history can be watched starting from the
  	// last compaction revision.
  	Watch(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[WatchRequest, WatchResponse], error)
  }
  
  type watchClient struct {
  	cc grpc.ClientConnInterface
  }
  
  func NewWatchClient(cc grpc.ClientConnInterface) WatchClient {
  	return &watchClient{cc}
  }
  
  func (c *watchClient) Watch(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[WatchRequest, WatchResponse], error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	stream, err := c.cc.NewStream(ctx, &Watch_ServiceDesc.Streams[0], Watch_Watch_FullMethodName, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	x := &grpc.GenericClientStream[WatchRequest, WatchResponse]{ClientStream: stream}
  	return x, nil
  }
  
  // This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
  type Watch_WatchClient = grpc.BidiStreamingClient[WatchRequest, WatchResponse]
  
  // WatchServer is the server API for Watch service.
  // All implementations must embed UnimplementedWatchServer
  // for forward compatibility.
  type WatchServer interface {
  	// Watch watches for events happening or that have happened. Both input and output
  	// are streams; the input stream is for creating and canceling watchers and the output
  	// stream sends events. One watch RPC can watch on multiple key ranges, streaming events
  	// for several watches at once. The entire event history can be watched starting from the
  	// last compaction revision.
  	Watch(grpc.BidiStreamingServer[WatchRequest, WatchResponse]) error
  	mustEmbedUnimplementedWatchServer()
  }
  
  // UnimplementedWatchServer must be embedded to have
  // forward compatible implementations.
  //
  // NOTE: this should be embedded by value instead of pointer to avoid a nil
  // pointer dereference when methods are called.
  type UnimplementedWatchServer struct{}
  
  func (UnimplementedWatchServer) Watch(grpc.BidiStreamingServer[WatchRequest, WatchResponse]) error {
  	return status.Error(codes.Unimplemented, "method Watch not implemented")
  }
  func (UnimplementedWatchServer) mustEmbedUnimplementedWatchServer() {}
  func (UnimplementedWatchServer) testEmbeddedByValue()               {}
  
  // UnsafeWatchServer may be embedded to opt out of forward compatibility for this service.
  // Use of this interface is not recommended, as added methods to WatchServer will
  // result in compilation errors.
  type UnsafeWatchServer interface {
  	mustEmbedUnimplementedWatchServer()
  }
  
  func RegisterWatchServer(s grpc.ServiceRegistrar, srv WatchServer) {
  	// If the following call panics, it indicates UnimplementedWatchServer was
  	// embedded by pointer and is nil.  This will cause panics if an
  	// unimplemented method is ever invoked, so we test this at initialization
  	// time to prevent it from happening at runtime later due to I/O.
  	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
  		t.testEmbeddedByValue()
  	}
  	s.RegisterService(&Watch_ServiceDesc, srv)
  }
  
  func _Watch_Watch_Handler(srv interface{}, stream grpc.ServerStream) error {
  	return srv.(WatchServer).Watch(&grpc.GenericServerStream[WatchRequest, WatchResponse]{ServerStream: stream})
  }
  
  // This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
  type Watch_WatchServer = grpc.BidiStreamingServer[WatchRequest, WatchResponse]
  
  // Watch_ServiceDesc is the grpc.ServiceDesc for Watch service.
  // It's only intended for direct use with grpc.RegisterService,
  // and not to be introspected or modified (even as a copy)
  var Watch_ServiceDesc = grpc.ServiceDesc{
  	ServiceName: "etcdserverpb.Watch",
  	HandlerType: (*WatchServer)(nil),
  	Methods:     []grpc.MethodDesc{},
  	Streams: []grpc.StreamDesc{
  		{
  			StreamName:    "Watch",
  			Handler:       _Watch_Watch_Handler,
  			ServerStreams: true,
  			ClientStreams: true,
  		},
  	},
  	Metadata: "rpc.proto",
  }
  
  const (
  	Lease_LeaseGrant_FullMethodName      = "/etcdserverpb.Lease/LeaseGrant"
  	Lease_LeaseRevoke_FullMethodName     = "/etcdserverpb.Lease/LeaseRevoke"
  	Lease_LeaseKeepAlive_FullMethodName  = "/etcdserverpb.Lease/LeaseKeepAlive"
  	Lease_LeaseTimeToLive_FullMethodName = "/etcdserverpb.Lease/LeaseTimeToLive"
  	Lease_LeaseLeases_FullMethodName     = "/etcdserverpb.Lease/LeaseLeases"
  )
  
  // LeaseClient is the client API for Lease service.
  //
  // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
  type LeaseClient interface {
  	// LeaseGrant creates a lease which expires if the server does not receive a keepAlive
  	// within a given time to live period. All keys attached to the lease will be expired and
  	// deleted if the lease expires. Each expired key generates a delete event in the event history.
  	LeaseGrant(ctx context.Context, in *LeaseGrantRequest, opts ...grpc.CallOption) (*LeaseGrantResponse, error)
  	// LeaseRevoke revokes a lease. All keys attached to the lease will expire and be deleted.
  	LeaseRevoke(ctx context.Context, in *LeaseRevokeRequest, opts ...grpc.CallOption) (*LeaseRevokeResponse, error)
  	// LeaseKeepAlive keeps the lease alive by streaming keep alive requests from the client
  	// to the server and streaming keep alive responses from the server to the client.
  	LeaseKeepAlive(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[LeaseKeepAliveRequest, LeaseKeepAliveResponse], error)
  	// LeaseTimeToLive retrieves lease information.
  	LeaseTimeToLive(ctx context.Context, in *LeaseTimeToLiveRequest, opts ...grpc.CallOption) (*LeaseTimeToLiveResponse, error)
  	// LeaseLeases lists all existing leases.
  	LeaseLeases(ctx context.Context, in *LeaseLeasesRequest, opts ...grpc.CallOption) (*LeaseLeasesResponse, error)
  }
  
  type leaseClient struct {
  	cc grpc.ClientConnInterface
  }
  
  func NewLeaseClient(cc grpc.ClientConnInterface) LeaseClient {
  	return &leaseClient{cc}
  }
  
  func (c *leaseClient) LeaseGrant(ctx context.Context, in *LeaseGrantRequest, opts ...grpc.CallOption) (*LeaseGrantResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(LeaseGrantResponse)
  	err := c.cc.Invoke(ctx, Lease_LeaseGrant_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *leaseClient) LeaseRevoke(ctx context.Context, in *LeaseRevokeRequest, opts ...grpc.CallOption) (*LeaseRevokeResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(LeaseRevokeResponse)
  	err := c.cc.Invoke(ctx, Lease_LeaseRevoke_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *leaseClient) LeaseKeepAlive(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[LeaseKeepAliveRequest, LeaseKeepAliveResponse], error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	stream, err := c.cc.NewStream(ctx, &Lease_ServiceDesc.Streams[0], Lease_LeaseKeepAlive_FullMethodName, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	x := &grpc.GenericClientStream[LeaseKeepAliveRequest, LeaseKeepAliveResponse]{ClientStream: stream}
  	return x, nil
  }
  
  // This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
  type Lease_LeaseKeepAliveClient = grpc.BidiStreamingClient[LeaseKeepAliveRequest, LeaseKeepAliveResponse]
  
  func (c *leaseClient) LeaseTimeToLive(ctx context.Context, in *LeaseTimeToLiveRequest, opts ...grpc.CallOption) (*LeaseTimeToLiveResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(LeaseTimeToLiveResponse)
  	err := c.cc.Invoke(ctx, Lease_LeaseTimeToLive_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *leaseClient) LeaseLeases(ctx context.Context, in *LeaseLeasesRequest, opts ...grpc.CallOption) (*LeaseLeasesResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(LeaseLeasesResponse)
  	err := c.cc.Invoke(ctx, Lease_LeaseLeases_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  // LeaseServer is the server API for Lease service.
  // All implementations must embed UnimplementedLeaseServer
  // for forward compatibility.
  type LeaseServer interface {
  	// LeaseGrant creates a lease which expires if the server does not receive a keepAlive
  	// within a given time to live period. All keys attached to the lease will be expired and
  	// deleted if the lease expires. Each expired key generates a delete event in the event history.
  	LeaseGrant(context.Context, *LeaseGrantRequest) (*LeaseGrantResponse, error)
  	// LeaseRevoke revokes a lease. All keys attached to the lease will expire and be deleted.
  	LeaseRevoke(context.Context, *LeaseRevokeRequest) (*LeaseRevokeResponse, error)
  	// LeaseKeepAlive keeps the lease alive by streaming keep alive requests from the client
  	// to the server and streaming keep alive responses from the server to the client.
  	LeaseKeepAlive(grpc.BidiStreamingServer[LeaseKeepAliveRequest, LeaseKeepAliveResponse]) error
  	// LeaseTimeToLive retrieves lease information.
  	LeaseTimeToLive(context.Context, *LeaseTimeToLiveRequest) (*LeaseTimeToLiveResponse, error)
  	// LeaseLeases lists all existing leases.
  	LeaseLeases(context.Context, *LeaseLeasesRequest) (*LeaseLeasesResponse, error)
  	mustEmbedUnimplementedLeaseServer()
  }
  
  // UnimplementedLeaseServer must be embedded to have
  // forward compatible implementations.
  //
  // NOTE: this should be embedded by value instead of pointer to avoid a nil
  // pointer dereference when methods are called.
  type UnimplementedLeaseServer struct{}
  
  func (UnimplementedLeaseServer) LeaseGrant(context.Context, *LeaseGrantRequest) (*LeaseGrantResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method LeaseGrant not implemented")
  }
  func (UnimplementedLeaseServer) LeaseRevoke(context.Context, *LeaseRevokeRequest) (*LeaseRevokeResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method LeaseRevoke not implemented")
  }
  func (UnimplementedLeaseServer) LeaseKeepAlive(grpc.BidiStreamingServer[LeaseKeepAliveRequest, LeaseKeepAliveResponse]) error {
  	return status.Error(codes.Unimplemented, "method LeaseKeepAlive not implemented")
  }
  func (UnimplementedLeaseServer) LeaseTimeToLive(context.Context, *LeaseTimeToLiveRequest) (*LeaseTimeToLiveResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method LeaseTimeToLive not implemented")
  }
  func (UnimplementedLeaseServer) LeaseLeases(context.Context, *LeaseLeasesRequest) (*LeaseLeasesResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method LeaseLeases not implemented")
  }
  func (UnimplementedLeaseServer) mustEmbedUnimplementedLeaseServer() {}
  func (UnimplementedLeaseServer) testEmbeddedByValue()               {}
  
  // UnsafeLeaseServer may be embedded to opt out of forward compatibility for this service.
  // Use of this interface is not recommended, as added methods to LeaseServer will
  // result in compilation errors.
  type UnsafeLeaseServer interface {
  	mustEmbedUnimplementedLeaseServer()
  }
  
  func RegisterLeaseServer(s grpc.ServiceRegistrar, srv LeaseServer) {
  	// If the following call panics, it indicates UnimplementedLeaseServer was
  	// embedded by pointer and is nil.  This will cause panics if an
  	// unimplemented method is ever invoked, so we test this at initialization
  	// time to prevent it from happening at runtime later due to I/O.
  	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
  		t.testEmbeddedByValue()
  	}
  	s.RegisterService(&Lease_ServiceDesc, srv)
  }
  
  func _Lease_LeaseGrant_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(LeaseGrantRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(LeaseServer).LeaseGrant(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Lease_LeaseGrant_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(LeaseServer).LeaseGrant(ctx, req.(*LeaseGrantRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Lease_LeaseRevoke_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(LeaseRevokeRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(LeaseServer).LeaseRevoke(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Lease_LeaseRevoke_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(LeaseServer).LeaseRevoke(ctx, req.(*LeaseRevokeRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Lease_LeaseKeepAlive_Handler(srv interface{}, stream grpc.ServerStream) error {
  	return srv.(LeaseServer).LeaseKeepAlive(&grpc.GenericServerStream[LeaseKeepAliveRequest, LeaseKeepAliveResponse]{ServerStream: stream})
  }
  
  // This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
  type Lease_LeaseKeepAliveServer = grpc.BidiStreamingServer[LeaseKeepAliveRequest, LeaseKeepAliveResponse]
  
  func _Lease_LeaseTimeToLive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(LeaseTimeToLiveRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(LeaseServer).LeaseTimeToLive(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Lease_LeaseTimeToLive_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(LeaseServer).LeaseTimeToLive(ctx, req.(*LeaseTimeToLiveRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Lease_LeaseLeases_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(LeaseLeasesRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(LeaseServer).LeaseLeases(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Lease_LeaseLeases_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(LeaseServer).LeaseLeases(ctx, req.(*LeaseLeasesRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  // Lease_ServiceDesc is the grpc.ServiceDesc for Lease service.
  // It's only intended for direct use with grpc.RegisterService,
  // and not to be introspected or modified (even as a copy)
  var Lease_ServiceDesc = grpc.ServiceDesc{
  	ServiceName: "etcdserverpb.Lease",
  	HandlerType: (*LeaseServer)(nil),
  	Methods: []grpc.MethodDesc{
  		{
  			MethodName: "LeaseGrant",
  			Handler:    _Lease_LeaseGrant_Handler,
  		},
  		{
  			MethodName: "LeaseRevoke",
  			Handler:    _Lease_LeaseRevoke_Handler,
  		},
  		{
  			MethodName: "LeaseTimeToLive",
  			Handler:    _Lease_LeaseTimeToLive_Handler,
  		},
  		{
  			MethodName: "LeaseLeases",
  			Handler:    _Lease_LeaseLeases_Handler,
  		},
  	},
  	Streams: []grpc.StreamDesc{
  		{
  			StreamName:    "LeaseKeepAlive",
  			Handler:       _Lease_LeaseKeepAlive_Handler,
  			ServerStreams: true,
  			ClientStreams: true,
  		},
  	},
  	Metadata: "rpc.proto",
  }
  
  const (
  	Cluster_MemberAdd_FullMethodName     = "/etcdserverpb.Cluster/MemberAdd"
  	Cluster_MemberRemove_FullMethodName  = "/etcdserverpb.Cluster/MemberRemove"
  	Cluster_MemberUpdate_FullMethodName  = "/etcdserverpb.Cluster/MemberUpdate"
  	Cluster_MemberList_FullMethodName    = "/etcdserverpb.Cluster/MemberList"
  	Cluster_MemberPromote_FullMethodName = "/etcdserverpb.Cluster/MemberPromote"
  )
  
  // ClusterClient is the client API for Cluster service.
  //
  // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
  type ClusterClient interface {
  	// MemberAdd adds a member into the cluster.
  	MemberAdd(ctx context.Context, in *MemberAddRequest, opts ...grpc.CallOption) (*MemberAddResponse, error)
  	// MemberRemove removes an existing member from the cluster.
  	MemberRemove(ctx context.Context, in *MemberRemoveRequest, opts ...grpc.CallOption) (*MemberRemoveResponse, error)
  	// MemberUpdate updates the member configuration.
  	MemberUpdate(ctx context.Context, in *MemberUpdateRequest, opts ...grpc.CallOption) (*MemberUpdateResponse, error)
  	// MemberList lists all the members in the cluster.
  	MemberList(ctx context.Context, in *MemberListRequest, opts ...grpc.CallOption) (*MemberListResponse, error)
  	// MemberPromote promotes a member from raft learner (non-voting) to raft voting member.
  	MemberPromote(ctx context.Context, in *MemberPromoteRequest, opts ...grpc.CallOption) (*MemberPromoteResponse, error)
  }
  
  type clusterClient struct {
  	cc grpc.ClientConnInterface
  }
  
  func NewClusterClient(cc grpc.ClientConnInterface) ClusterClient {
  	return &clusterClient{cc}
  }
  
  func (c *clusterClient) MemberAdd(ctx context.Context, in *MemberAddRequest, opts ...grpc.CallOption) (*MemberAddResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(MemberAddResponse)
  	err := c.cc.Invoke(ctx, Cluster_MemberAdd_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *clusterClient) MemberRemove(ctx context.Context, in *MemberRemoveRequest, opts ...grpc.CallOption) (*MemberRemoveResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(MemberRemoveResponse)
  	err := c.cc.Invoke(ctx, Cluster_MemberRemove_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *clusterClient) MemberUpdate(ctx context.Context, in *MemberUpdateRequest, opts ...grpc.CallOption) (*MemberUpdateResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(MemberUpdateResponse)
  	err := c.cc.Invoke(ctx, Cluster_MemberUpdate_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *clusterClient) MemberList(ctx context.Context, in *MemberListRequest, opts ...grpc.CallOption) (*MemberListResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(MemberListResponse)
  	err := c.cc.Invoke(ctx, Cluster_MemberList_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *clusterClient) MemberPromote(ctx context.Context, in *MemberPromoteRequest, opts ...grpc.CallOption) (*MemberPromoteResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(MemberPromoteResponse)
  	err := c.cc.Invoke(ctx, Cluster_MemberPromote_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  // ClusterServer is the server API for Cluster service.
  // All implementations must embed UnimplementedClusterServer
  // for forward compatibility.
  type ClusterServer interface {
  	// MemberAdd adds a member into the cluster.
  	MemberAdd(context.Context, *MemberAddRequest) (*MemberAddResponse, error)
  	// MemberRemove removes an existing member from the cluster.
  	MemberRemove(context.Context, *MemberRemoveRequest) (*MemberRemoveResponse, error)
  	// MemberUpdate updates the member configuration.
  	MemberUpdate(context.Context, *MemberUpdateRequest) (*MemberUpdateResponse, error)
  	// MemberList lists all the members in the cluster.
  	MemberList(context.Context, *MemberListRequest) (*MemberListResponse, error)
  	// MemberPromote promotes a member from raft learner (non-voting) to raft voting member.
  	MemberPromote(context.Context, *MemberPromoteRequest) (*MemberPromoteResponse, error)
  	mustEmbedUnimplementedClusterServer()
  }
  
  // UnimplementedClusterServer must be embedded to have
  // forward compatible implementations.
  //
  // NOTE: this should be embedded by value instead of pointer to avoid a nil
  // pointer dereference when methods are called.
  type UnimplementedClusterServer struct{}
  
  func (UnimplementedClusterServer) MemberAdd(context.Context, *MemberAddRequest) (*MemberAddResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method MemberAdd not implemented")
  }
  func (UnimplementedClusterServer) MemberRemove(context.Context, *MemberRemoveRequest) (*MemberRemoveResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method MemberRemove not implemented")
  }
  func (UnimplementedClusterServer) MemberUpdate(context.Context, *MemberUpdateRequest) (*MemberUpdateResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method MemberUpdate not implemented")
  }
  func (UnimplementedClusterServer) MemberList(context.Context, *MemberListRequest) (*MemberListResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method MemberList not implemented")
  }
  func (UnimplementedClusterServer) MemberPromote(context.Context, *MemberPromoteRequest) (*MemberPromoteResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method MemberPromote not implemented")
  }
  func (UnimplementedClusterServer) mustEmbedUnimplementedClusterServer() {}
  func (UnimplementedClusterServer) testEmbeddedByValue()                 {}
  
  // UnsafeClusterServer may be embedded to opt out of forward compatibility for this service.
  // Use of this interface is not recommended, as added methods to ClusterServer will
  // result in compilation errors.
  type UnsafeClusterServer interface {
  	mustEmbedUnimplementedClusterServer()
  }
  
  func RegisterClusterServer(s grpc.ServiceRegistrar, srv ClusterServer) {
  	// If the following call panics, it indicates UnimplementedClusterServer was
  	// embedded by pointer and is nil.  This will cause panics if an
  	// unimplemented method is ever invoked, so we test this at initialization
  	// time to prevent it from happening at runtime later due to I/O.
  	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
  		t.testEmbeddedByValue()
  	}
  	s.RegisterService(&Cluster_ServiceDesc, srv)
  }
  
  func _Cluster_MemberAdd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(MemberAddRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(ClusterServer).MemberAdd(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Cluster_MemberAdd_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(ClusterServer).MemberAdd(ctx, req.(*MemberAddRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Cluster_MemberRemove_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(MemberRemoveRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(ClusterServer).MemberRemove(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Cluster_MemberRemove_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(ClusterServer).MemberRemove(ctx, req.(*MemberRemoveRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Cluster_MemberUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(MemberUpdateRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(ClusterServer).MemberUpdate(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Cluster_MemberUpdate_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(ClusterServer).MemberUpdate(ctx, req.(*MemberUpdateRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Cluster_MemberList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(MemberListRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(ClusterServer).MemberList(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Cluster_MemberList_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(ClusterServer).MemberList(ctx, req.(*MemberListRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Cluster_MemberPromote_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(MemberPromoteRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(ClusterServer).MemberPromote(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Cluster_MemberPromote_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(ClusterServer).MemberPromote(ctx, req.(*MemberPromoteRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  // Cluster_ServiceDesc is the grpc.ServiceDesc for Cluster service.
  // It's only intended for direct use with grpc.RegisterService,
  // and not to be introspected or modified (even as a copy)
  var Cluster_ServiceDesc = grpc.ServiceDesc{
  	ServiceName: "etcdserverpb.Cluster",
  	HandlerType: (*ClusterServer)(nil),
  	Methods: []grpc.MethodDesc{
  		{
  			MethodName: "MemberAdd",
  			Handler:    _Cluster_MemberAdd_Handler,
  		},
  		{
  			MethodName: "MemberRemove",
  			Handler:    _Cluster_MemberRemove_Handler,
  		},
  		{
  			MethodName: "MemberUpdate",
  			Handler:    _Cluster_MemberUpdate_Handler,
  		},
  		{
  			MethodName: "MemberList",
  			Handler:    _Cluster_MemberList_Handler,
  		},
  		{
  			MethodName: "MemberPromote",
  			Handler:    _Cluster_MemberPromote_Handler,
  		},
  	},
  	Streams:  []grpc.StreamDesc{},
  	Metadata: "rpc.proto",
  }
  
  const (
  	Maintenance_Alarm_FullMethodName      = "/etcdserverpb.Maintenance/Alarm"
  	Maintenance_Status_FullMethodName     = "/etcdserverpb.Maintenance/Status"
  	Maintenance_Defragment_FullMethodName = "/etcdserverpb.Maintenance/Defragment"
  	Maintenance_Hash_FullMethodName       = "/etcdserverpb.Maintenance/Hash"
  	Maintenance_HashKV_FullMethodName     = "/etcdserverpb.Maintenance/HashKV"
  	Maintenance_Snapshot_FullMethodName   = "/etcdserverpb.Maintenance/Snapshot"
  	Maintenance_MoveLeader_FullMethodName = "/etcdserverpb.Maintenance/MoveLeader"
  	Maintenance_Downgrade_FullMethodName  = "/etcdserverpb.Maintenance/Downgrade"
  )
  
  // MaintenanceClient is the client API for Maintenance service.
  //
  // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
  type MaintenanceClient interface {
  	// Alarm activates, deactivates, and queries alarms regarding cluster health.
  	Alarm(ctx context.Context, in *AlarmRequest, opts ...grpc.CallOption) (*AlarmResponse, error)
  	// Status gets the status of the member.
  	Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error)
  	// Defragment defragments a member's backend database to recover storage space.
  	Defragment(ctx context.Context, in *DefragmentRequest, opts ...grpc.CallOption) (*DefragmentResponse, error)
  	// Hash computes the hash of whole backend keyspace,
  	// including key, lease, and other buckets in storage.
  	// This is designed for testing ONLY!
  	// Do not rely on this in production with ongoing transactions,
  	// since Hash operation does not hold MVCC locks.
  	// Use "HashKV" API instead for "key" bucket consistency checks.
  	Hash(ctx context.Context, in *HashRequest, opts ...grpc.CallOption) (*HashResponse, error)
  	// HashKV computes the hash of all MVCC keys up to a given revision.
  	// It only iterates "key" bucket in backend storage.
  	HashKV(ctx context.Context, in *HashKVRequest, opts ...grpc.CallOption) (*HashKVResponse, error)
  	// Snapshot sends a snapshot of the entire backend from a member over a stream to a client.
  	Snapshot(ctx context.Context, in *SnapshotRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[SnapshotResponse], error)
  	// MoveLeader requests current leader node to transfer its leadership to transferee.
  	MoveLeader(ctx context.Context, in *MoveLeaderRequest, opts ...grpc.CallOption) (*MoveLeaderResponse, error)
  	// Downgrade requests downgrades, verifies feasibility or cancels downgrade
  	// on the cluster version.
  	// Supported since etcd 3.5.
  	Downgrade(ctx context.Context, in *DowngradeRequest, opts ...grpc.CallOption) (*DowngradeResponse, error)
  }
  
  type maintenanceClient struct {
  	cc grpc.ClientConnInterface
  }
  
  func NewMaintenanceClient(cc grpc.ClientConnInterface) MaintenanceClient {
  	return &maintenanceClient{cc}
  }
  
  func (c *maintenanceClient) Alarm(ctx context.Context, in *AlarmRequest, opts ...grpc.CallOption) (*AlarmResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(AlarmResponse)
  	err := c.cc.Invoke(ctx, Maintenance_Alarm_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *maintenanceClient) Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(StatusResponse)
  	err := c.cc.Invoke(ctx, Maintenance_Status_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *maintenanceClient) Defragment(ctx context.Context, in *DefragmentRequest, opts ...grpc.CallOption) (*DefragmentResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(DefragmentResponse)
  	err := c.cc.Invoke(ctx, Maintenance_Defragment_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *maintenanceClient) Hash(ctx context.Context, in *HashRequest, opts ...grpc.CallOption) (*HashResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(HashResponse)
  	err := c.cc.Invoke(ctx, Maintenance_Hash_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *maintenanceClient) HashKV(ctx context.Context, in *HashKVRequest, opts ...grpc.CallOption) (*HashKVResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(HashKVResponse)
  	err := c.cc.Invoke(ctx, Maintenance_HashKV_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *maintenanceClient) Snapshot(ctx context.Context, in *SnapshotRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[SnapshotResponse], error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	stream, err := c.cc.NewStream(ctx, &Maintenance_ServiceDesc.Streams[0], Maintenance_Snapshot_FullMethodName, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	x := &grpc.GenericClientStream[SnapshotRequest, SnapshotResponse]{ClientStream: stream}
  	if err := x.ClientStream.SendMsg(in); err != nil {
  		return nil, err
  	}
  	if err := x.ClientStream.CloseSend(); err != nil {
  		return nil, err
  	}
  	return x, nil
  }
  
  // This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
  type Maintenance_SnapshotClient = grpc.ServerStreamingClient[SnapshotResponse]
  
  func (c *maintenanceClient) MoveLeader(ctx context.Context, in *MoveLeaderRequest, opts ...grpc.CallOption) (*MoveLeaderResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(MoveLeaderResponse)
  	err := c.cc.Invoke(ctx, Maintenance_MoveLeader_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *maintenanceClient) Downgrade(ctx context.Context, in *DowngradeRequest, opts ...grpc.CallOption) (*DowngradeResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(DowngradeResponse)
  	err := c.cc.Invoke(ctx, Maintenance_Downgrade_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  // MaintenanceServer is the server API for Maintenance service.
  // All implementations must embed UnimplementedMaintenanceServer
  // for forward compatibility.
  type MaintenanceServer interface {
  	// Alarm activates, deactivates, and queries alarms regarding cluster health.
  	Alarm(context.Context, *AlarmRequest) (*AlarmResponse, error)
  	// Status gets the status of the member.
  	Status(context.Context, *StatusRequest) (*StatusResponse, error)
  	// Defragment defragments a member's backend database to recover storage space.
  	Defragment(context.Context, *DefragmentRequest) (*DefragmentResponse, error)
  	// Hash computes the hash of whole backend keyspace,
  	// including key, lease, and other buckets in storage.
  	// This is designed for testing ONLY!
  	// Do not rely on this in production with ongoing transactions,
  	// since Hash operation does not hold MVCC locks.
  	// Use "HashKV" API instead for "key" bucket consistency checks.
  	Hash(context.Context, *HashRequest) (*HashResponse, error)
  	// HashKV computes the hash of all MVCC keys up to a given revision.
  	// It only iterates "key" bucket in backend storage.
  	HashKV(context.Context, *HashKVRequest) (*HashKVResponse, error)
  	// Snapshot sends a snapshot of the entire backend from a member over a stream to a client.
  	Snapshot(*SnapshotRequest, grpc.ServerStreamingServer[SnapshotResponse]) error
  	// MoveLeader requests current leader node to transfer its leadership to transferee.
  	MoveLeader(context.Context, *MoveLeaderRequest) (*MoveLeaderResponse, error)
  	// Downgrade requests downgrades, verifies feasibility or cancels downgrade
  	// on the cluster version.
  	// Supported since etcd 3.5.
  	Downgrade(context.Context, *DowngradeRequest) (*DowngradeResponse, error)
  	mustEmbedUnimplementedMaintenanceServer()
  }
  
  // UnimplementedMaintenanceServer must be embedded to have
  // forward compatible implementations.
  //
  // NOTE: this should be embedded by value instead of pointer to avoid a nil
  // pointer dereference when methods are called.
  type UnimplementedMaintenanceServer struct{}
  
  func (UnimplementedMaintenanceServer) Alarm(context.Context, *AlarmRequest) (*AlarmResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method Alarm not implemented")
  }
  func (UnimplementedMaintenanceServer) Status(context.Context, *StatusRequest) (*StatusResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method Status not implemented")
  }
  func (UnimplementedMaintenanceServer) Defragment(context.Context, *DefragmentRequest) (*DefragmentResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method Defragment not implemented")
  }
  func (UnimplementedMaintenanceServer) Hash(context.Context, *HashRequest) (*HashResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method Hash not implemented")
  }
  func (UnimplementedMaintenanceServer) HashKV(context.Context, *HashKVRequest) (*HashKVResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method HashKV not implemented")
  }
  func (UnimplementedMaintenanceServer) Snapshot(*SnapshotRequest, grpc.ServerStreamingServer[SnapshotResponse]) error {
  	return status.Error(codes.Unimplemented, "method Snapshot not implemented")
  }
  func (UnimplementedMaintenanceServer) MoveLeader(context.Context, *MoveLeaderRequest) (*MoveLeaderResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method MoveLeader not implemented")
  }
  func (UnimplementedMaintenanceServer) Downgrade(context.Context, *DowngradeRequest) (*DowngradeResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method Downgrade not implemented")
  }
  func (UnimplementedMaintenanceServer) mustEmbedUnimplementedMaintenanceServer() {}
  func (UnimplementedMaintenanceServer) testEmbeddedByValue()                     {}
  
  // UnsafeMaintenanceServer may be embedded to opt out of forward compatibility for this service.
  // Use of this interface is not recommended, as added methods to MaintenanceServer will
  // result in compilation errors.
  type UnsafeMaintenanceServer interface {
  	mustEmbedUnimplementedMaintenanceServer()
  }
  
  func RegisterMaintenanceServer(s grpc.ServiceRegistrar, srv MaintenanceServer) {
  	// If the following call panics, it indicates UnimplementedMaintenanceServer was
  	// embedded by pointer and is nil.  This will cause panics if an
  	// unimplemented method is ever invoked, so we test this at initialization
  	// time to prevent it from happening at runtime later due to I/O.
  	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
  		t.testEmbeddedByValue()
  	}
  	s.RegisterService(&Maintenance_ServiceDesc, srv)
  }
  
  func _Maintenance_Alarm_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(AlarmRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(MaintenanceServer).Alarm(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Maintenance_Alarm_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(MaintenanceServer).Alarm(ctx, req.(*AlarmRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Maintenance_Status_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(StatusRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(MaintenanceServer).Status(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Maintenance_Status_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(MaintenanceServer).Status(ctx, req.(*StatusRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Maintenance_Defragment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(DefragmentRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(MaintenanceServer).Defragment(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Maintenance_Defragment_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(MaintenanceServer).Defragment(ctx, req.(*DefragmentRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Maintenance_Hash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(HashRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(MaintenanceServer).Hash(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Maintenance_Hash_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(MaintenanceServer).Hash(ctx, req.(*HashRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Maintenance_HashKV_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(HashKVRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(MaintenanceServer).HashKV(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Maintenance_HashKV_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(MaintenanceServer).HashKV(ctx, req.(*HashKVRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Maintenance_Snapshot_Handler(srv interface{}, stream grpc.ServerStream) error {
  	m := new(SnapshotRequest)
  	if err := stream.RecvMsg(m); err != nil {
  		return err
  	}
  	return srv.(MaintenanceServer).Snapshot(m, &grpc.GenericServerStream[SnapshotRequest, SnapshotResponse]{ServerStream: stream})
  }
  
  // This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
  type Maintenance_SnapshotServer = grpc.ServerStreamingServer[SnapshotResponse]
  
  func _Maintenance_MoveLeader_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(MoveLeaderRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(MaintenanceServer).MoveLeader(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Maintenance_MoveLeader_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(MaintenanceServer).MoveLeader(ctx, req.(*MoveLeaderRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Maintenance_Downgrade_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(DowngradeRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(MaintenanceServer).Downgrade(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Maintenance_Downgrade_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(MaintenanceServer).Downgrade(ctx, req.(*DowngradeRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  // Maintenance_ServiceDesc is the grpc.ServiceDesc for Maintenance service.
  // It's only intended for direct use with grpc.RegisterService,
  // and not to be introspected or modified (even as a copy)
  var Maintenance_ServiceDesc = grpc.ServiceDesc{
  	ServiceName: "etcdserverpb.Maintenance",
  	HandlerType: (*MaintenanceServer)(nil),
  	Methods: []grpc.MethodDesc{
  		{
  			MethodName: "Alarm",
  			Handler:    _Maintenance_Alarm_Handler,
  		},
  		{
  			MethodName: "Status",
  			Handler:    _Maintenance_Status_Handler,
  		},
  		{
  			MethodName: "Defragment",
  			Handler:    _Maintenance_Defragment_Handler,
  		},
  		{
  			MethodName: "Hash",
  			Handler:    _Maintenance_Hash_Handler,
  		},
  		{
  			MethodName: "HashKV",
  			Handler:    _Maintenance_HashKV_Handler,
  		},
  		{
  			MethodName: "MoveLeader",
  			Handler:    _Maintenance_MoveLeader_Handler,
  		},
  		{
  			MethodName: "Downgrade",
  			Handler:    _Maintenance_Downgrade_Handler,
  		},
  	},
  	Streams: []grpc.StreamDesc{
  		{
  			StreamName:    "Snapshot",
  			Handler:       _Maintenance_Snapshot_Handler,
  			ServerStreams: true,
  		},
  	},
  	Metadata: "rpc.proto",
  }
  
  const (
  	Auth_AuthEnable_FullMethodName           = "/etcdserverpb.Auth/AuthEnable"
  	Auth_AuthDisable_FullMethodName          = "/etcdserverpb.Auth/AuthDisable"
  	Auth_AuthStatus_FullMethodName           = "/etcdserverpb.Auth/AuthStatus"
  	Auth_Authenticate_FullMethodName         = "/etcdserverpb.Auth/Authenticate"
  	Auth_UserAdd_FullMethodName              = "/etcdserverpb.Auth/UserAdd"
  	Auth_UserGet_FullMethodName              = "/etcdserverpb.Auth/UserGet"
  	Auth_UserList_FullMethodName             = "/etcdserverpb.Auth/UserList"
  	Auth_UserDelete_FullMethodName           = "/etcdserverpb.Auth/UserDelete"
  	Auth_UserChangePassword_FullMethodName   = "/etcdserverpb.Auth/UserChangePassword"
  	Auth_UserGrantRole_FullMethodName        = "/etcdserverpb.Auth/UserGrantRole"
  	Auth_UserRevokeRole_FullMethodName       = "/etcdserverpb.Auth/UserRevokeRole"
  	Auth_RoleAdd_FullMethodName              = "/etcdserverpb.Auth/RoleAdd"
  	Auth_RoleGet_FullMethodName              = "/etcdserverpb.Auth/RoleGet"
  	Auth_RoleList_FullMethodName             = "/etcdserverpb.Auth/RoleList"
  	Auth_RoleDelete_FullMethodName           = "/etcdserverpb.Auth/RoleDelete"
  	Auth_RoleGrantPermission_FullMethodName  = "/etcdserverpb.Auth/RoleGrantPermission"
  	Auth_RoleRevokePermission_FullMethodName = "/etcdserverpb.Auth/RoleRevokePermission"
  )
  
  // AuthClient is the client API for Auth service.
  //
  // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
  type AuthClient interface {
  	// AuthEnable enables authentication.
  	AuthEnable(ctx context.Context, in *AuthEnableRequest, opts ...grpc.CallOption) (*AuthEnableResponse, error)
  	// AuthDisable disables authentication.
  	AuthDisable(ctx context.Context, in *AuthDisableRequest, opts ...grpc.CallOption) (*AuthDisableResponse, error)
  	// AuthStatus displays authentication status.
  	AuthStatus(ctx context.Context, in *AuthStatusRequest, opts ...grpc.CallOption) (*AuthStatusResponse, error)
  	// Authenticate processes an authenticate request.
  	Authenticate(ctx context.Context, in *AuthenticateRequest, opts ...grpc.CallOption) (*AuthenticateResponse, error)
  	// UserAdd adds a new user. User name cannot be empty.
  	UserAdd(ctx context.Context, in *AuthUserAddRequest, opts ...grpc.CallOption) (*AuthUserAddResponse, error)
  	// UserGet gets detailed user information.
  	UserGet(ctx context.Context, in *AuthUserGetRequest, opts ...grpc.CallOption) (*AuthUserGetResponse, error)
  	// UserList gets a list of all users.
  	UserList(ctx context.Context, in *AuthUserListRequest, opts ...grpc.CallOption) (*AuthUserListResponse, error)
  	// UserDelete deletes a specified user.
  	UserDelete(ctx context.Context, in *AuthUserDeleteRequest, opts ...grpc.CallOption) (*AuthUserDeleteResponse, error)
  	// UserChangePassword changes the password of a specified user.
  	UserChangePassword(ctx context.Context, in *AuthUserChangePasswordRequest, opts ...grpc.CallOption) (*AuthUserChangePasswordResponse, error)
  	// UserGrantRole grants a role to a specified user.
  	UserGrantRole(ctx context.Context, in *AuthUserGrantRoleRequest, opts ...grpc.CallOption) (*AuthUserGrantRoleResponse, error)
  	// UserRevokeRole revokes a role of specified user.
  	UserRevokeRole(ctx context.Context, in *AuthUserRevokeRoleRequest, opts ...grpc.CallOption) (*AuthUserRevokeRoleResponse, error)
  	// RoleAdd adds a new role. Role name cannot be empty.
  	RoleAdd(ctx context.Context, in *AuthRoleAddRequest, opts ...grpc.CallOption) (*AuthRoleAddResponse, error)
  	// RoleGet gets detailed role information.
  	RoleGet(ctx context.Context, in *AuthRoleGetRequest, opts ...grpc.CallOption) (*AuthRoleGetResponse, error)
  	// RoleList gets lists of all roles.
  	RoleList(ctx context.Context, in *AuthRoleListRequest, opts ...grpc.CallOption) (*AuthRoleListResponse, error)
  	// RoleDelete deletes a specified role.
  	RoleDelete(ctx context.Context, in *AuthRoleDeleteRequest, opts ...grpc.CallOption) (*AuthRoleDeleteResponse, error)
  	// RoleGrantPermission grants a permission of a specified key or range to a specified role.
  	RoleGrantPermission(ctx context.Context, in *AuthRoleGrantPermissionRequest, opts ...grpc.CallOption) (*AuthRoleGrantPermissionResponse, error)
  	// RoleRevokePermission revokes a key or range permission of a specified role.
  	RoleRevokePermission(ctx context.Context, in *AuthRoleRevokePermissionRequest, opts ...grpc.CallOption) (*AuthRoleRevokePermissionResponse, error)
  }
  
  type authClient struct {
  	cc grpc.ClientConnInterface
  }
  
  func NewAuthClient(cc grpc.ClientConnInterface) AuthClient {
  	return &authClient{cc}
  }
  
  func (c *authClient) AuthEnable(ctx context.Context, in *AuthEnableRequest, opts ...grpc.CallOption) (*AuthEnableResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(AuthEnableResponse)
  	err := c.cc.Invoke(ctx, Auth_AuthEnable_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *authClient) AuthDisable(ctx context.Context, in *AuthDisableRequest, opts ...grpc.CallOption) (*AuthDisableResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(AuthDisableResponse)
  	err := c.cc.Invoke(ctx, Auth_AuthDisable_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *authClient) AuthStatus(ctx context.Context, in *AuthStatusRequest, opts ...grpc.CallOption) (*AuthStatusResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(AuthStatusResponse)
  	err := c.cc.Invoke(ctx, Auth_AuthStatus_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *authClient) Authenticate(ctx context.Context, in *AuthenticateRequest, opts ...grpc.CallOption) (*AuthenticateResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(AuthenticateResponse)
  	err := c.cc.Invoke(ctx, Auth_Authenticate_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *authClient) UserAdd(ctx context.Context, in *AuthUserAddRequest, opts ...grpc.CallOption) (*AuthUserAddResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(AuthUserAddResponse)
  	err := c.cc.Invoke(ctx, Auth_UserAdd_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *authClient) UserGet(ctx context.Context, in *AuthUserGetRequest, opts ...grpc.CallOption) (*AuthUserGetResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(AuthUserGetResponse)
  	err := c.cc.Invoke(ctx, Auth_UserGet_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *authClient) UserList(ctx context.Context, in *AuthUserListRequest, opts ...grpc.CallOption) (*AuthUserListResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(AuthUserListResponse)
  	err := c.cc.Invoke(ctx, Auth_UserList_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *authClient) UserDelete(ctx context.Context, in *AuthUserDeleteRequest, opts ...grpc.CallOption) (*AuthUserDeleteResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(AuthUserDeleteResponse)
  	err := c.cc.Invoke(ctx, Auth_UserDelete_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *authClient) UserChangePassword(ctx context.Context, in *AuthUserChangePasswordRequest, opts ...grpc.CallOption) (*AuthUserChangePasswordResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(AuthUserChangePasswordResponse)
  	err := c.cc.Invoke(ctx, Auth_UserChangePassword_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *authClient) UserGrantRole(ctx context.Context, in *AuthUserGrantRoleRequest, opts ...grpc.CallOption) (*AuthUserGrantRoleResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(AuthUserGrantRoleResponse)
  	err := c.cc.Invoke(ctx, Auth_UserGrantRole_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *authClient) UserRevokeRole(ctx context.Context, in *AuthUserRevokeRoleRequest, opts ...grpc.CallOption) (*AuthUserRevokeRoleResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(AuthUserRevokeRoleResponse)
  	err := c.cc.Invoke(ctx, Auth_UserRevokeRole_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *authClient) RoleAdd(ctx context.Context, in *AuthRoleAddRequest, opts ...grpc.CallOption) (*AuthRoleAddResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(AuthRoleAddResponse)
  	err := c.cc.Invoke(ctx, Auth_RoleAdd_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *authClient) RoleGet(ctx context.Context, in *AuthRoleGetRequest, opts ...grpc.CallOption) (*AuthRoleGetResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(AuthRoleGetResponse)
  	err := c.cc.Invoke(ctx, Auth_RoleGet_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *authClient) RoleList(ctx context.Context, in *AuthRoleListRequest, opts ...grpc.CallOption) (*AuthRoleListResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(AuthRoleListResponse)
  	err := c.cc.Invoke(ctx, Auth_RoleList_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *authClient) RoleDelete(ctx context.Context, in *AuthRoleDeleteRequest, opts ...grpc.CallOption) (*AuthRoleDeleteResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(AuthRoleDeleteResponse)
  	err := c.cc.Invoke(ctx, Auth_RoleDelete_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *authClient) RoleGrantPermission(ctx context.Context, in *AuthRoleGrantPermissionRequest, opts ...grpc.CallOption) (*AuthRoleGrantPermissionResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(AuthRoleGrantPermissionResponse)
  	err := c.cc.Invoke(ctx, Auth_RoleGrantPermission_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  func (c *authClient) RoleRevokePermission(ctx context.Context, in *AuthRoleRevokePermissionRequest, opts ...grpc.CallOption) (*AuthRoleRevokePermissionResponse, error) {
  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
  	out := new(AuthRoleRevokePermissionResponse)
  	err := c.cc.Invoke(ctx, Auth_RoleRevokePermission_FullMethodName, in, out, cOpts...)
  	if err != nil {
  		return nil, err
  	}
  	return out, nil
  }
  
  // AuthServer is the server API for Auth service.
  // All implementations must embed UnimplementedAuthServer
  // for forward compatibility.
  type AuthServer interface {
  	// AuthEnable enables authentication.
  	AuthEnable(context.Context, *AuthEnableRequest) (*AuthEnableResponse, error)
  	// AuthDisable disables authentication.
  	AuthDisable(context.Context, *AuthDisableRequest) (*AuthDisableResponse, error)
  	// AuthStatus displays authentication status.
  	AuthStatus(context.Context, *AuthStatusRequest) (*AuthStatusResponse, error)
  	// Authenticate processes an authenticate request.
  	Authenticate(context.Context, *AuthenticateRequest) (*AuthenticateResponse, error)
  	// UserAdd adds a new user. User name cannot be empty.
  	UserAdd(context.Context, *AuthUserAddRequest) (*AuthUserAddResponse, error)
  	// UserGet gets detailed user information.
  	UserGet(context.Context, *AuthUserGetRequest) (*AuthUserGetResponse, error)
  	// UserList gets a list of all users.
  	UserList(context.Context, *AuthUserListRequest) (*AuthUserListResponse, error)
  	// UserDelete deletes a specified user.
  	UserDelete(context.Context, *AuthUserDeleteRequest) (*AuthUserDeleteResponse, error)
  	// UserChangePassword changes the password of a specified user.
  	UserChangePassword(context.Context, *AuthUserChangePasswordRequest) (*AuthUserChangePasswordResponse, error)
  	// UserGrantRole grants a role to a specified user.
  	UserGrantRole(context.Context, *AuthUserGrantRoleRequest) (*AuthUserGrantRoleResponse, error)
  	// UserRevokeRole revokes a role of specified user.
  	UserRevokeRole(context.Context, *AuthUserRevokeRoleRequest) (*AuthUserRevokeRoleResponse, error)
  	// RoleAdd adds a new role. Role name cannot be empty.
  	RoleAdd(context.Context, *AuthRoleAddRequest) (*AuthRoleAddResponse, error)
  	// RoleGet gets detailed role information.
  	RoleGet(context.Context, *AuthRoleGetRequest) (*AuthRoleGetResponse, error)
  	// RoleList gets lists of all roles.
  	RoleList(context.Context, *AuthRoleListRequest) (*AuthRoleListResponse, error)
  	// RoleDelete deletes a specified role.
  	RoleDelete(context.Context, *AuthRoleDeleteRequest) (*AuthRoleDeleteResponse, error)
  	// RoleGrantPermission grants a permission of a specified key or range to a specified role.
  	RoleGrantPermission(context.Context, *AuthRoleGrantPermissionRequest) (*AuthRoleGrantPermissionResponse, error)
  	// RoleRevokePermission revokes a key or range permission of a specified role.
  	RoleRevokePermission(context.Context, *AuthRoleRevokePermissionRequest) (*AuthRoleRevokePermissionResponse, error)
  	mustEmbedUnimplementedAuthServer()
  }
  
  // UnimplementedAuthServer must be embedded to have
  // forward compatible implementations.
  //
  // NOTE: this should be embedded by value instead of pointer to avoid a nil
  // pointer dereference when methods are called.
  type UnimplementedAuthServer struct{}
  
  func (UnimplementedAuthServer) AuthEnable(context.Context, *AuthEnableRequest) (*AuthEnableResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method AuthEnable not implemented")
  }
  func (UnimplementedAuthServer) AuthDisable(context.Context, *AuthDisableRequest) (*AuthDisableResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method AuthDisable not implemented")
  }
  func (UnimplementedAuthServer) AuthStatus(context.Context, *AuthStatusRequest) (*AuthStatusResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method AuthStatus not implemented")
  }
  func (UnimplementedAuthServer) Authenticate(context.Context, *AuthenticateRequest) (*AuthenticateResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method Authenticate not implemented")
  }
  func (UnimplementedAuthServer) UserAdd(context.Context, *AuthUserAddRequest) (*AuthUserAddResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method UserAdd not implemented")
  }
  func (UnimplementedAuthServer) UserGet(context.Context, *AuthUserGetRequest) (*AuthUserGetResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method UserGet not implemented")
  }
  func (UnimplementedAuthServer) UserList(context.Context, *AuthUserListRequest) (*AuthUserListResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method UserList not implemented")
  }
  func (UnimplementedAuthServer) UserDelete(context.Context, *AuthUserDeleteRequest) (*AuthUserDeleteResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method UserDelete not implemented")
  }
  func (UnimplementedAuthServer) UserChangePassword(context.Context, *AuthUserChangePasswordRequest) (*AuthUserChangePasswordResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method UserChangePassword not implemented")
  }
  func (UnimplementedAuthServer) UserGrantRole(context.Context, *AuthUserGrantRoleRequest) (*AuthUserGrantRoleResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method UserGrantRole not implemented")
  }
  func (UnimplementedAuthServer) UserRevokeRole(context.Context, *AuthUserRevokeRoleRequest) (*AuthUserRevokeRoleResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method UserRevokeRole not implemented")
  }
  func (UnimplementedAuthServer) RoleAdd(context.Context, *AuthRoleAddRequest) (*AuthRoleAddResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method RoleAdd not implemented")
  }
  func (UnimplementedAuthServer) RoleGet(context.Context, *AuthRoleGetRequest) (*AuthRoleGetResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method RoleGet not implemented")
  }
  func (UnimplementedAuthServer) RoleList(context.Context, *AuthRoleListRequest) (*AuthRoleListResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method RoleList not implemented")
  }
  func (UnimplementedAuthServer) RoleDelete(context.Context, *AuthRoleDeleteRequest) (*AuthRoleDeleteResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method RoleDelete not implemented")
  }
  func (UnimplementedAuthServer) RoleGrantPermission(context.Context, *AuthRoleGrantPermissionRequest) (*AuthRoleGrantPermissionResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method RoleGrantPermission not implemented")
  }
  func (UnimplementedAuthServer) RoleRevokePermission(context.Context, *AuthRoleRevokePermissionRequest) (*AuthRoleRevokePermissionResponse, error) {
  	return nil, status.Error(codes.Unimplemented, "method RoleRevokePermission not implemented")
  }
  func (UnimplementedAuthServer) mustEmbedUnimplementedAuthServer() {}
  func (UnimplementedAuthServer) testEmbeddedByValue()              {}
  
  // UnsafeAuthServer may be embedded to opt out of forward compatibility for this service.
  // Use of this interface is not recommended, as added methods to AuthServer will
  // result in compilation errors.
  type UnsafeAuthServer interface {
  	mustEmbedUnimplementedAuthServer()
  }
  
  func RegisterAuthServer(s grpc.ServiceRegistrar, srv AuthServer) {
  	// If the following call panics, it indicates UnimplementedAuthServer was
  	// embedded by pointer and is nil.  This will cause panics if an
  	// unimplemented method is ever invoked, so we test this at initialization
  	// time to prevent it from happening at runtime later due to I/O.
  	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
  		t.testEmbeddedByValue()
  	}
  	s.RegisterService(&Auth_ServiceDesc, srv)
  }
  
  func _Auth_AuthEnable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(AuthEnableRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(AuthServer).AuthEnable(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Auth_AuthEnable_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(AuthServer).AuthEnable(ctx, req.(*AuthEnableRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Auth_AuthDisable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(AuthDisableRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(AuthServer).AuthDisable(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Auth_AuthDisable_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(AuthServer).AuthDisable(ctx, req.(*AuthDisableRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Auth_AuthStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(AuthStatusRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(AuthServer).AuthStatus(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Auth_AuthStatus_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(AuthServer).AuthStatus(ctx, req.(*AuthStatusRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Auth_Authenticate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(AuthenticateRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(AuthServer).Authenticate(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Auth_Authenticate_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(AuthServer).Authenticate(ctx, req.(*AuthenticateRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Auth_UserAdd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(AuthUserAddRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(AuthServer).UserAdd(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Auth_UserAdd_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(AuthServer).UserAdd(ctx, req.(*AuthUserAddRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Auth_UserGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(AuthUserGetRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(AuthServer).UserGet(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Auth_UserGet_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(AuthServer).UserGet(ctx, req.(*AuthUserGetRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Auth_UserList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(AuthUserListRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(AuthServer).UserList(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Auth_UserList_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(AuthServer).UserList(ctx, req.(*AuthUserListRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Auth_UserDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(AuthUserDeleteRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(AuthServer).UserDelete(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Auth_UserDelete_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(AuthServer).UserDelete(ctx, req.(*AuthUserDeleteRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Auth_UserChangePassword_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(AuthUserChangePasswordRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(AuthServer).UserChangePassword(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Auth_UserChangePassword_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(AuthServer).UserChangePassword(ctx, req.(*AuthUserChangePasswordRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Auth_UserGrantRole_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(AuthUserGrantRoleRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(AuthServer).UserGrantRole(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Auth_UserGrantRole_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(AuthServer).UserGrantRole(ctx, req.(*AuthUserGrantRoleRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Auth_UserRevokeRole_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(AuthUserRevokeRoleRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(AuthServer).UserRevokeRole(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Auth_UserRevokeRole_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(AuthServer).UserRevokeRole(ctx, req.(*AuthUserRevokeRoleRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Auth_RoleAdd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(AuthRoleAddRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(AuthServer).RoleAdd(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Auth_RoleAdd_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(AuthServer).RoleAdd(ctx, req.(*AuthRoleAddRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Auth_RoleGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(AuthRoleGetRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(AuthServer).RoleGet(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Auth_RoleGet_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(AuthServer).RoleGet(ctx, req.(*AuthRoleGetRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Auth_RoleList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(AuthRoleListRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(AuthServer).RoleList(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Auth_RoleList_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(AuthServer).RoleList(ctx, req.(*AuthRoleListRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Auth_RoleDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(AuthRoleDeleteRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(AuthServer).RoleDelete(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Auth_RoleDelete_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(AuthServer).RoleDelete(ctx, req.(*AuthRoleDeleteRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Auth_RoleGrantPermission_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(AuthRoleGrantPermissionRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(AuthServer).RoleGrantPermission(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Auth_RoleGrantPermission_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(AuthServer).RoleGrantPermission(ctx, req.(*AuthRoleGrantPermissionRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  func _Auth_RoleRevokePermission_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  	in := new(AuthRoleRevokePermissionRequest)
  	if err := dec(in); err != nil {
  		return nil, err
  	}
  	if interceptor == nil {
  		return srv.(AuthServer).RoleRevokePermission(ctx, in)
  	}
  	info := &grpc.UnaryServerInfo{
  		Server:     srv,
  		FullMethod: Auth_RoleRevokePermission_FullMethodName,
  	}
  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
  		return srv.(AuthServer).RoleRevokePermission(ctx, req.(*AuthRoleRevokePermissionRequest))
  	}
  	return interceptor(ctx, in, info, handler)
  }
  
  // Auth_ServiceDesc is the grpc.ServiceDesc for Auth service.
  // It's only intended for direct use with grpc.RegisterService,
  // and not to be introspected or modified (even as a copy)
  var Auth_ServiceDesc = grpc.ServiceDesc{
  	ServiceName: "etcdserverpb.Auth",
  	HandlerType: (*AuthServer)(nil),
  	Methods: []grpc.MethodDesc{
  		{
  			MethodName: "AuthEnable",
  			Handler:    _Auth_AuthEnable_Handler,
  		},
  		{
  			MethodName: "AuthDisable",
  			Handler:    _Auth_AuthDisable_Handler,
  		},
  		{
  			MethodName: "AuthStatus",
  			Handler:    _Auth_AuthStatus_Handler,
  		},
  		{
  			MethodName: "Authenticate",
  			Handler:    _Auth_Authenticate_Handler,
  		},
  		{
  			MethodName: "UserAdd",
  			Handler:    _Auth_UserAdd_Handler,
  		},
  		{
  			MethodName: "UserGet",
  			Handler:    _Auth_UserGet_Handler,
  		},
  		{
  			MethodName: "UserList",
  			Handler:    _Auth_UserList_Handler,
  		},
  		{
  			MethodName: "UserDelete",
  			Handler:    _Auth_UserDelete_Handler,
  		},
  		{
  			MethodName: "UserChangePassword",
  			Handler:    _Auth_UserChangePassword_Handler,
  		},
  		{
  			MethodName: "UserGrantRole",
  			Handler:    _Auth_UserGrantRole_Handler,
  		},
  		{
  			MethodName: "UserRevokeRole",
  			Handler:    _Auth_UserRevokeRole_Handler,
  		},
  		{
  			MethodName: "RoleAdd",
  			Handler:    _Auth_RoleAdd_Handler,
  		},
  		{
  			MethodName: "RoleGet",
  			Handler:    _Auth_RoleGet_Handler,
  		},
  		{
  			MethodName: "RoleList",
  			Handler:    _Auth_RoleList_Handler,
  		},
  		{
  			MethodName: "RoleDelete",
  			Handler:    _Auth_RoleDelete_Handler,
  		},
  		{
  			MethodName: "RoleGrantPermission",
  			Handler:    _Auth_RoleGrantPermission_Handler,
  		},
  		{
  			MethodName: "RoleRevokePermission",
  			Handler:    _Auth_RoleRevokePermission_Handler,
  		},
  	},
  	Streams:  []grpc.StreamDesc{},
  	Metadata: "rpc.proto",
  }
  