// Code generated by protoc-gen-go. DO NOT EDIT.
// source: proto/beacon/rpc/v1/debug.proto

package ethereum_beacon_rpc_v1

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	empty "github.com/golang/protobuf/ptypes/empty"
	v1alpha1 "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
	v1 "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type LoggingLevelRequest_Level int32

const (
	LoggingLevelRequest_INFO  LoggingLevelRequest_Level = 0
	LoggingLevelRequest_DEBUG LoggingLevelRequest_Level = 1
	LoggingLevelRequest_TRACE LoggingLevelRequest_Level = 2
)

var LoggingLevelRequest_Level_name = map[int32]string{
	0: "INFO",
	1: "DEBUG",
	2: "TRACE",
}

var LoggingLevelRequest_Level_value = map[string]int32{
	"INFO":  0,
	"DEBUG": 1,
	"TRACE": 2,
}

func (x LoggingLevelRequest_Level) String() string {
	return proto.EnumName(LoggingLevelRequest_Level_name, int32(x))
}

func (LoggingLevelRequest_Level) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_851e5cb2de3d61dd, []int{3, 0}
}

type BeaconStateRequest struct {
	// Types that are valid to be assigned to QueryFilter:
	//	*BeaconStateRequest_Slot
	//	*BeaconStateRequest_BlockRoot
	QueryFilter          isBeaconStateRequest_QueryFilter `protobuf_oneof:"query_filter"`
	XXX_NoUnkeyedLiteral struct{}                         `json:"-"`
	XXX_unrecognized     []byte                           `json:"-"`
	XXX_sizecache        int32                            `json:"-"`
}

func (m *BeaconStateRequest) Reset()         { *m = BeaconStateRequest{} }
func (m *BeaconStateRequest) String() string { return proto.CompactTextString(m) }
func (*BeaconStateRequest) ProtoMessage()    {}
func (*BeaconStateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_851e5cb2de3d61dd, []int{0}
}

func (m *BeaconStateRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BeaconStateRequest.Unmarshal(m, b)
}
func (m *BeaconStateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BeaconStateRequest.Marshal(b, m, deterministic)
}
func (m *BeaconStateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BeaconStateRequest.Merge(m, src)
}
func (m *BeaconStateRequest) XXX_Size() int {
	return xxx_messageInfo_BeaconStateRequest.Size(m)
}
func (m *BeaconStateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_BeaconStateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_BeaconStateRequest proto.InternalMessageInfo

type isBeaconStateRequest_QueryFilter interface {
	isBeaconStateRequest_QueryFilter()
}

type BeaconStateRequest_Slot struct {
	Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3,oneof"`
}

type BeaconStateRequest_BlockRoot struct {
	BlockRoot []byte `protobuf:"bytes,2,opt,name=block_root,json=blockRoot,proto3,oneof"`
}

func (*BeaconStateRequest_Slot) isBeaconStateRequest_QueryFilter() {}

func (*BeaconStateRequest_BlockRoot) isBeaconStateRequest_QueryFilter() {}

func (m *BeaconStateRequest) GetQueryFilter() isBeaconStateRequest_QueryFilter {
	if m != nil {
		return m.QueryFilter
	}
	return nil
}

func (m *BeaconStateRequest) GetSlot() uint64 {
	if x, ok := m.GetQueryFilter().(*BeaconStateRequest_Slot); ok {
		return x.Slot
	}
	return 0
}

func (m *BeaconStateRequest) GetBlockRoot() []byte {
	if x, ok := m.GetQueryFilter().(*BeaconStateRequest_BlockRoot); ok {
		return x.BlockRoot
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*BeaconStateRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*BeaconStateRequest_Slot)(nil),
		(*BeaconStateRequest_BlockRoot)(nil),
	}
}

type BlockRequest struct {
	BlockRoot            []byte   `protobuf:"bytes,1,opt,name=block_root,json=blockRoot,proto3" json:"block_root,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BlockRequest) Reset()         { *m = BlockRequest{} }
func (m *BlockRequest) String() string { return proto.CompactTextString(m) }
func (*BlockRequest) ProtoMessage()    {}
func (*BlockRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_851e5cb2de3d61dd, []int{1}
}

func (m *BlockRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BlockRequest.Unmarshal(m, b)
}
func (m *BlockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BlockRequest.Marshal(b, m, deterministic)
}
func (m *BlockRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockRequest.Merge(m, src)
}
func (m *BlockRequest) XXX_Size() int {
	return xxx_messageInfo_BlockRequest.Size(m)
}
func (m *BlockRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockRequest.DiscardUnknown(m)
}

var xxx_messageInfo_BlockRequest proto.InternalMessageInfo

func (m *BlockRequest) GetBlockRoot() []byte {
	if m != nil {
		return m.BlockRoot
	}
	return nil
}

type SSZResponse struct {
	Encoded              []byte   `protobuf:"bytes,1,opt,name=encoded,proto3" json:"encoded,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SSZResponse) Reset()         { *m = SSZResponse{} }
func (m *SSZResponse) String() string { return proto.CompactTextString(m) }
func (*SSZResponse) ProtoMessage()    {}
func (*SSZResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_851e5cb2de3d61dd, []int{2}
}

func (m *SSZResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SSZResponse.Unmarshal(m, b)
}
func (m *SSZResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SSZResponse.Marshal(b, m, deterministic)
}
func (m *SSZResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SSZResponse.Merge(m, src)
}
func (m *SSZResponse) XXX_Size() int {
	return xxx_messageInfo_SSZResponse.Size(m)
}
func (m *SSZResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_SSZResponse.DiscardUnknown(m)
}

var xxx_messageInfo_SSZResponse proto.InternalMessageInfo

func (m *SSZResponse) GetEncoded() []byte {
	if m != nil {
		return m.Encoded
	}
	return nil
}

type LoggingLevelRequest struct {
	Level                LoggingLevelRequest_Level `protobuf:"varint,1,opt,name=level,proto3,enum=ethereum.beacon.rpc.v1.LoggingLevelRequest_Level" json:"level,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

func (m *LoggingLevelRequest) Reset()         { *m = LoggingLevelRequest{} }
func (m *LoggingLevelRequest) String() string { return proto.CompactTextString(m) }
func (*LoggingLevelRequest) ProtoMessage()    {}
func (*LoggingLevelRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_851e5cb2de3d61dd, []int{3}
}

func (m *LoggingLevelRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LoggingLevelRequest.Unmarshal(m, b)
}
func (m *LoggingLevelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LoggingLevelRequest.Marshal(b, m, deterministic)
}
func (m *LoggingLevelRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoggingLevelRequest.Merge(m, src)
}
func (m *LoggingLevelRequest) XXX_Size() int {
	return xxx_messageInfo_LoggingLevelRequest.Size(m)
}
func (m *LoggingLevelRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_LoggingLevelRequest.DiscardUnknown(m)
}

var xxx_messageInfo_LoggingLevelRequest proto.InternalMessageInfo

func (m *LoggingLevelRequest) GetLevel() LoggingLevelRequest_Level {
	if m != nil {
		return m.Level
	}
	return LoggingLevelRequest_INFO
}

type ProtoArrayForkChoiceResponse struct {
	PruneThreshold       uint64            `protobuf:"varint,1,opt,name=prune_threshold,json=pruneThreshold,proto3" json:"prune_threshold,omitempty"`
	JustifiedEpoch       uint64            `protobuf:"varint,2,opt,name=justified_epoch,json=justifiedEpoch,proto3" json:"justified_epoch,omitempty"`
	FinalizedEpoch       uint64            `protobuf:"varint,3,opt,name=finalized_epoch,json=finalizedEpoch,proto3" json:"finalized_epoch,omitempty"`
	ProtoArrayNodes      []*ProtoArrayNode `protobuf:"bytes,4,rep,name=proto_array_nodes,json=protoArrayNodes,proto3" json:"proto_array_nodes,omitempty"`
	Indices              map[string]uint64 `protobuf:"bytes,5,rep,name=indices,proto3" json:"indices,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *ProtoArrayForkChoiceResponse) Reset()         { *m = ProtoArrayForkChoiceResponse{} }
func (m *ProtoArrayForkChoiceResponse) String() string { return proto.CompactTextString(m) }
func (*ProtoArrayForkChoiceResponse) ProtoMessage()    {}
func (*ProtoArrayForkChoiceResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_851e5cb2de3d61dd, []int{4}
}

func (m *ProtoArrayForkChoiceResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ProtoArrayForkChoiceResponse.Unmarshal(m, b)
}
func (m *ProtoArrayForkChoiceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ProtoArrayForkChoiceResponse.Marshal(b, m, deterministic)
}
func (m *ProtoArrayForkChoiceResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProtoArrayForkChoiceResponse.Merge(m, src)
}
func (m *ProtoArrayForkChoiceResponse) XXX_Size() int {
	return xxx_messageInfo_ProtoArrayForkChoiceResponse.Size(m)
}
func (m *ProtoArrayForkChoiceResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ProtoArrayForkChoiceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ProtoArrayForkChoiceResponse proto.InternalMessageInfo

func (m *ProtoArrayForkChoiceResponse) GetPruneThreshold() uint64 {
	if m != nil {
		return m.PruneThreshold
	}
	return 0
}

func (m *ProtoArrayForkChoiceResponse) GetJustifiedEpoch() uint64 {
	if m != nil {
		return m.JustifiedEpoch
	}
	return 0
}

func (m *ProtoArrayForkChoiceResponse) GetFinalizedEpoch() uint64 {
	if m != nil {
		return m.FinalizedEpoch
	}
	return 0
}

func (m *ProtoArrayForkChoiceResponse) GetProtoArrayNodes() []*ProtoArrayNode {
	if m != nil {
		return m.ProtoArrayNodes
	}
	return nil
}

func (m *ProtoArrayForkChoiceResponse) GetIndices() map[string]uint64 {
	if m != nil {
		return m.Indices
	}
	return nil
}

type ProtoArrayNode struct {
	Slot                 uint64   `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"`
	Root                 []byte   `protobuf:"bytes,2,opt,name=root,proto3" json:"root,omitempty"`
	Parent               uint64   `protobuf:"varint,3,opt,name=parent,proto3" json:"parent,omitempty"`
	JustifiedEpoch       uint64   `protobuf:"varint,4,opt,name=justified_epoch,json=justifiedEpoch,proto3" json:"justified_epoch,omitempty"`
	FinalizedEpoch       uint64   `protobuf:"varint,5,opt,name=finalized_epoch,json=finalizedEpoch,proto3" json:"finalized_epoch,omitempty"`
	Weight               uint64   `protobuf:"varint,6,opt,name=weight,proto3" json:"weight,omitempty"`
	BestChild            uint64   `protobuf:"varint,7,opt,name=best_child,json=bestChild,proto3" json:"best_child,omitempty"`
	BestDescendant       uint64   `protobuf:"varint,8,opt,name=best_descendant,json=bestDescendant,proto3" json:"best_descendant,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ProtoArrayNode) Reset()         { *m = ProtoArrayNode{} }
func (m *ProtoArrayNode) String() string { return proto.CompactTextString(m) }
func (*ProtoArrayNode) ProtoMessage()    {}
func (*ProtoArrayNode) Descriptor() ([]byte, []int) {
	return fileDescriptor_851e5cb2de3d61dd, []int{5}
}

func (m *ProtoArrayNode) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ProtoArrayNode.Unmarshal(m, b)
}
func (m *ProtoArrayNode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ProtoArrayNode.Marshal(b, m, deterministic)
}
func (m *ProtoArrayNode) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProtoArrayNode.Merge(m, src)
}
func (m *ProtoArrayNode) XXX_Size() int {
	return xxx_messageInfo_ProtoArrayNode.Size(m)
}
func (m *ProtoArrayNode) XXX_DiscardUnknown() {
	xxx_messageInfo_ProtoArrayNode.DiscardUnknown(m)
}

var xxx_messageInfo_ProtoArrayNode proto.InternalMessageInfo

func (m *ProtoArrayNode) GetSlot() uint64 {
	if m != nil {
		return m.Slot
	}
	return 0
}

func (m *ProtoArrayNode) GetRoot() []byte {
	if m != nil {
		return m.Root
	}
	return nil
}

func (m *ProtoArrayNode) GetParent() uint64 {
	if m != nil {
		return m.Parent
	}
	return 0
}

func (m *ProtoArrayNode) GetJustifiedEpoch() uint64 {
	if m != nil {
		return m.JustifiedEpoch
	}
	return 0
}

func (m *ProtoArrayNode) GetFinalizedEpoch() uint64 {
	if m != nil {
		return m.FinalizedEpoch
	}
	return 0
}

func (m *ProtoArrayNode) GetWeight() uint64 {
	if m != nil {
		return m.Weight
	}
	return 0
}

func (m *ProtoArrayNode) GetBestChild() uint64 {
	if m != nil {
		return m.BestChild
	}
	return 0
}

func (m *ProtoArrayNode) GetBestDescendant() uint64 {
	if m != nil {
		return m.BestDescendant
	}
	return 0
}

type DebugPeerResponses struct {
	Responses            []*DebugPeerResponse `protobuf:"bytes,1,rep,name=responses,proto3" json:"responses,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *DebugPeerResponses) Reset()         { *m = DebugPeerResponses{} }
func (m *DebugPeerResponses) String() string { return proto.CompactTextString(m) }
func (*DebugPeerResponses) ProtoMessage()    {}
func (*DebugPeerResponses) Descriptor() ([]byte, []int) {
	return fileDescriptor_851e5cb2de3d61dd, []int{6}
}

func (m *DebugPeerResponses) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DebugPeerResponses.Unmarshal(m, b)
}
func (m *DebugPeerResponses) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DebugPeerResponses.Marshal(b, m, deterministic)
}
func (m *DebugPeerResponses) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DebugPeerResponses.Merge(m, src)
}
func (m *DebugPeerResponses) XXX_Size() int {
	return xxx_messageInfo_DebugPeerResponses.Size(m)
}
func (m *DebugPeerResponses) XXX_DiscardUnknown() {
	xxx_messageInfo_DebugPeerResponses.DiscardUnknown(m)
}

var xxx_messageInfo_DebugPeerResponses proto.InternalMessageInfo

func (m *DebugPeerResponses) GetResponses() []*DebugPeerResponse {
	if m != nil {
		return m.Responses
	}
	return nil
}

type DebugPeerResponse struct {
	ListeningAddresses   []string                    `protobuf:"bytes,1,rep,name=listening_addresses,json=listeningAddresses,proto3" json:"listening_addresses,omitempty"`
	Direction            v1alpha1.PeerDirection      `protobuf:"varint,2,opt,name=direction,proto3,enum=ethereum.eth.v1alpha1.PeerDirection" json:"direction,omitempty"`
	ConnectionState      v1alpha1.ConnectionState    `protobuf:"varint,3,opt,name=connection_state,json=connectionState,proto3,enum=ethereum.eth.v1alpha1.ConnectionState" json:"connection_state,omitempty"`
	PeerId               string                      `protobuf:"bytes,4,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	Enr                  string                      `protobuf:"bytes,5,opt,name=enr,proto3" json:"enr,omitempty"`
	PeerInfo             *DebugPeerResponse_PeerInfo `protobuf:"bytes,6,opt,name=peer_info,json=peerInfo,proto3" json:"peer_info,omitempty"`
	PeerStatus           *v1.Status                  `protobuf:"bytes,7,opt,name=peer_status,json=peerStatus,proto3" json:"peer_status,omitempty"`
	LastUpdated          uint64                      `protobuf:"varint,8,opt,name=last_updated,json=lastUpdated,proto3" json:"last_updated,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

func (m *DebugPeerResponse) Reset()         { *m = DebugPeerResponse{} }
func (m *DebugPeerResponse) String() string { return proto.CompactTextString(m) }
func (*DebugPeerResponse) ProtoMessage()    {}
func (*DebugPeerResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_851e5cb2de3d61dd, []int{7}
}

func (m *DebugPeerResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DebugPeerResponse.Unmarshal(m, b)
}
func (m *DebugPeerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DebugPeerResponse.Marshal(b, m, deterministic)
}
func (m *DebugPeerResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DebugPeerResponse.Merge(m, src)
}
func (m *DebugPeerResponse) XXX_Size() int {
	return xxx_messageInfo_DebugPeerResponse.Size(m)
}
func (m *DebugPeerResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DebugPeerResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DebugPeerResponse proto.InternalMessageInfo

func (m *DebugPeerResponse) GetListeningAddresses() []string {
	if m != nil {
		return m.ListeningAddresses
	}
	return nil
}

func (m *DebugPeerResponse) GetDirection() v1alpha1.PeerDirection {
	if m != nil {
		return m.Direction
	}
	return v1alpha1.PeerDirection_UNKNOWN
}

func (m *DebugPeerResponse) GetConnectionState() v1alpha1.ConnectionState {
	if m != nil {
		return m.ConnectionState
	}
	return v1alpha1.ConnectionState_DISCONNECTED
}

func (m *DebugPeerResponse) GetPeerId() string {
	if m != nil {
		return m.PeerId
	}
	return ""
}

func (m *DebugPeerResponse) GetEnr() string {
	if m != nil {
		return m.Enr
	}
	return ""
}

func (m *DebugPeerResponse) GetPeerInfo() *DebugPeerResponse_PeerInfo {
	if m != nil {
		return m.PeerInfo
	}
	return nil
}

func (m *DebugPeerResponse) GetPeerStatus() *v1.Status {
	if m != nil {
		return m.PeerStatus
	}
	return nil
}

func (m *DebugPeerResponse) GetLastUpdated() uint64 {
	if m != nil {
		return m.LastUpdated
	}
	return 0
}

type DebugPeerResponse_PeerInfo struct {
	Metadata             *v1.MetaData `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	Protocols            []string     `protobuf:"bytes,2,rep,name=protocols,proto3" json:"protocols,omitempty"`
	FaultCount           uint64       `protobuf:"varint,3,opt,name=fault_count,json=faultCount,proto3" json:"fault_count,omitempty"`
	ProtocolVersion      string       `protobuf:"bytes,4,opt,name=protocol_version,json=protocolVersion,proto3" json:"protocol_version,omitempty"`
	AgentVersion         string       `protobuf:"bytes,5,opt,name=agent_version,json=agentVersion,proto3" json:"agent_version,omitempty"`
	PeerLatency          uint64       `protobuf:"varint,6,opt,name=peer_latency,json=peerLatency,proto3" json:"peer_latency,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *DebugPeerResponse_PeerInfo) Reset()         { *m = DebugPeerResponse_PeerInfo{} }
func (m *DebugPeerResponse_PeerInfo) String() string { return proto.CompactTextString(m) }
func (*DebugPeerResponse_PeerInfo) ProtoMessage()    {}
func (*DebugPeerResponse_PeerInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_851e5cb2de3d61dd, []int{7, 0}
}

func (m *DebugPeerResponse_PeerInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DebugPeerResponse_PeerInfo.Unmarshal(m, b)
}
func (m *DebugPeerResponse_PeerInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DebugPeerResponse_PeerInfo.Marshal(b, m, deterministic)
}
func (m *DebugPeerResponse_PeerInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DebugPeerResponse_PeerInfo.Merge(m, src)
}
func (m *DebugPeerResponse_PeerInfo) XXX_Size() int {
	return xxx_messageInfo_DebugPeerResponse_PeerInfo.Size(m)
}
func (m *DebugPeerResponse_PeerInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_DebugPeerResponse_PeerInfo.DiscardUnknown(m)
}

var xxx_messageInfo_DebugPeerResponse_PeerInfo proto.InternalMessageInfo

func (m *DebugPeerResponse_PeerInfo) GetMetadata() *v1.MetaData {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *DebugPeerResponse_PeerInfo) GetProtocols() []string {
	if m != nil {
		return m.Protocols
	}
	return nil
}

func (m *DebugPeerResponse_PeerInfo) GetFaultCount() uint64 {
	if m != nil {
		return m.FaultCount
	}
	return 0
}

func (m *DebugPeerResponse_PeerInfo) GetProtocolVersion() string {
	if m != nil {
		return m.ProtocolVersion
	}
	return ""
}

func (m *DebugPeerResponse_PeerInfo) GetAgentVersion() string {
	if m != nil {
		return m.AgentVersion
	}
	return ""
}

func (m *DebugPeerResponse_PeerInfo) GetPeerLatency() uint64 {
	if m != nil {
		return m.PeerLatency
	}
	return 0
}

func init() {
	proto.RegisterEnum("ethereum.beacon.rpc.v1.LoggingLevelRequest_Level", LoggingLevelRequest_Level_name, LoggingLevelRequest_Level_value)
	proto.RegisterType((*BeaconStateRequest)(nil), "ethereum.beacon.rpc.v1.BeaconStateRequest")
	proto.RegisterType((*BlockRequest)(nil), "ethereum.beacon.rpc.v1.BlockRequest")
	proto.RegisterType((*SSZResponse)(nil), "ethereum.beacon.rpc.v1.SSZResponse")
	proto.RegisterType((*LoggingLevelRequest)(nil), "ethereum.beacon.rpc.v1.LoggingLevelRequest")
	proto.RegisterType((*ProtoArrayForkChoiceResponse)(nil), "ethereum.beacon.rpc.v1.ProtoArrayForkChoiceResponse")
	proto.RegisterMapType((map[string]uint64)(nil), "ethereum.beacon.rpc.v1.ProtoArrayForkChoiceResponse.IndicesEntry")
	proto.RegisterType((*ProtoArrayNode)(nil), "ethereum.beacon.rpc.v1.ProtoArrayNode")
	proto.RegisterType((*DebugPeerResponses)(nil), "ethereum.beacon.rpc.v1.DebugPeerResponses")
	proto.RegisterType((*DebugPeerResponse)(nil), "ethereum.beacon.rpc.v1.DebugPeerResponse")
	proto.RegisterType((*DebugPeerResponse_PeerInfo)(nil), "ethereum.beacon.rpc.v1.DebugPeerResponse.PeerInfo")
}

func init() { proto.RegisterFile("proto/beacon/rpc/v1/debug.proto", fileDescriptor_851e5cb2de3d61dd) }

var fileDescriptor_851e5cb2de3d61dd = []byte{
	// 1132 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcd, 0x6e, 0x1b, 0xb7,
	0x13, 0x8f, 0x6c, 0xc9, 0xf6, 0x8e, 0xf4, 0x97, 0x15, 0x26, 0x70, 0xf4, 0x57, 0xbe, 0x94, 0x4d,
	0x90, 0x38, 0x29, 0xba, 0x0b, 0xab, 0x3d, 0x14, 0x41, 0x81, 0xc2, 0x5f, 0x71, 0x0c, 0xb8, 0x49,
	0xba, 0x4e, 0x7a, 0x68, 0x50, 0x2c, 0xe8, 0xdd, 0x91, 0xb4, 0xf5, 0x9a, 0xdc, 0x90, 0x5c, 0xb5,
	0x4a, 0x6f, 0x41, 0xd1, 0x1c, 0x7b, 0xe8, 0xcb, 0xf4, 0x3d, 0xfa, 0x0a, 0x7d, 0x8a, 0x9e, 0x0a,
	0x92, 0x5a, 0x7d, 0xc0, 0x52, 0xea, 0x16, 0xbd, 0x71, 0x7e, 0x33, 0xf3, 0x1b, 0x72, 0x66, 0xc8,
	0x21, 0xdc, 0xce, 0x04, 0x57, 0xdc, 0x3f, 0x41, 0x1a, 0x71, 0xe6, 0x8b, 0x2c, 0xf2, 0x07, 0x5b,
	0x7e, 0x8c, 0x27, 0x79, 0xcf, 0x33, 0x1a, 0xb2, 0x81, 0xaa, 0x8f, 0x02, 0xf3, 0x33, 0xcf, 0xda,
	0x78, 0x22, 0x8b, 0xbc, 0xc1, 0x56, 0xeb, 0x1a, 0xaa, 0xbe, 0x3f, 0xd8, 0xa2, 0x69, 0xd6, 0xa7,
	0x5b, 0x3e, 0xe3, 0x31, 0x5a, 0x87, 0x96, 0x3b, 0xc3, 0x98, 0x75, 0x32, 0xcd, 0x78, 0x86, 0x52,
	0xd2, 0x1e, 0xca, 0x91, 0xcd, 0x8d, 0x1e, 0xe7, 0xbd, 0x14, 0x7d, 0x9a, 0x25, 0x3e, 0x65, 0x8c,
	0x2b, 0xaa, 0x12, 0xce, 0x0a, 0xed, 0xf5, 0x91, 0xd6, 0x48, 0x27, 0x79, 0xd7, 0xc7, 0xb3, 0x4c,
	0x0d, 0xad, 0xd2, 0x7d, 0x0d, 0x64, 0xc7, 0x50, 0x1f, 0x2b, 0xaa, 0x30, 0xc0, 0x37, 0x39, 0x4a,
	0x45, 0xae, 0x42, 0x59, 0xa6, 0x5c, 0x35, 0x4b, 0xed, 0xd2, 0x66, 0xf9, 0xe9, 0xa5, 0xc0, 0x48,
	0xe4, 0x36, 0xc0, 0x49, 0xca, 0xa3, 0xd3, 0x50, 0x70, 0xae, 0x9a, 0x4b, 0xed, 0xd2, 0x66, 0xed,
	0xe9, 0xa5, 0xc0, 0x31, 0x58, 0xc0, 0xb9, 0xda, 0xa9, 0x43, 0xed, 0x4d, 0x8e, 0x62, 0x18, 0x76,
	0x93, 0x54, 0xa1, 0x70, 0x3f, 0x86, 0xda, 0x8e, 0x51, 0x8e, 0x68, 0x6f, 0xce, 0x10, 0x68, 0xf2,
	0xda, 0x94, 0xbb, 0xfb, 0x00, 0xaa, 0xc7, 0xc7, 0xdf, 0x04, 0x28, 0x33, 0xce, 0x24, 0x92, 0x26,
	0xac, 0x22, 0x8b, 0x78, 0x8c, 0xf1, 0xc8, 0xb4, 0x10, 0xdd, 0xf7, 0x25, 0xb8, 0x72, 0xc4, 0x7b,
	0xbd, 0x84, 0xf5, 0x8e, 0x70, 0x80, 0x69, 0xc1, 0x7f, 0x00, 0x95, 0x54, 0xcb, 0xc6, 0xbe, 0xde,
	0xd9, 0xf2, 0xe6, 0x27, 0xdb, 0x9b, 0xe3, 0xeb, 0x59, 0xc1, 0xfa, 0xbb, 0x0f, 0xa0, 0x62, 0x64,
	0xb2, 0x06, 0xe5, 0xc3, 0x67, 0x4f, 0x9e, 0x37, 0x2e, 0x11, 0x07, 0x2a, 0x7b, 0xfb, 0x3b, 0xaf,
	0x0e, 0x1a, 0x25, 0xbd, 0x7c, 0x19, 0x6c, 0xef, 0xee, 0x37, 0x96, 0xdc, 0x9f, 0x97, 0xe1, 0xc6,
	0x0b, 0x9d, 0xc8, 0x6d, 0x21, 0xe8, 0xf0, 0x09, 0x17, 0xa7, 0xbb, 0x7d, 0x9e, 0x44, 0x38, 0x3e,
	0xc4, 0x03, 0x58, 0xcf, 0x44, 0xce, 0x30, 0x54, 0x7d, 0x81, 0xb2, 0xcf, 0x53, 0x7b, 0x98, 0x72,
	0x50, 0x37, 0xf0, 0xcb, 0x02, 0xd5, 0x86, 0xdf, 0xe5, 0x52, 0x25, 0xdd, 0x04, 0xe3, 0x10, 0x33,
	0x1e, 0xf5, 0x4d, 0x86, 0xcb, 0x41, 0x7d, 0x0c, 0xef, 0x6b, 0x54, 0x1b, 0x76, 0x13, 0x46, 0xd3,
	0xe4, 0xed, 0xd8, 0x70, 0xd9, 0x1a, 0x8e, 0x61, 0x6b, 0x18, 0xc0, 0x65, 0x53, 0xe3, 0x90, 0xea,
	0xbd, 0x85, 0xba, 0xa7, 0x64, 0xb3, 0xdc, 0x5e, 0xde, 0xac, 0x76, 0xee, 0x2f, 0xca, 0xcc, 0xe4,
	0x2c, 0xcf, 0x78, 0x8c, 0xc1, 0x7a, 0x36, 0x23, 0x4b, 0xf2, 0x1a, 0x56, 0x13, 0x16, 0x27, 0x11,
	0xca, 0x66, 0xc5, 0x30, 0x6d, 0xff, 0x3d, 0xd3, 0xf9, 0xac, 0x78, 0x87, 0x96, 0x63, 0x9f, 0x29,
	0x31, 0x0c, 0x0a, 0xc6, 0xd6, 0x63, 0xa8, 0x4d, 0x2b, 0x48, 0x03, 0x96, 0x4f, 0x71, 0x68, 0xf2,
	0xe5, 0x04, 0x7a, 0x49, 0xae, 0x42, 0x65, 0x40, 0xd3, 0x1c, 0x47, 0xa9, 0xb1, 0xc2, 0xe3, 0xa5,
	0xcf, 0x4a, 0xee, 0xbb, 0x25, 0xa8, 0xcf, 0x6e, 0x9e, 0x90, 0xe9, 0x26, 0x1e, 0xb5, 0x30, 0x81,
	0xf2, 0xa4, 0x79, 0x03, 0xb3, 0x26, 0x1b, 0xb0, 0x92, 0x51, 0x81, 0x4c, 0x8d, 0xf2, 0x38, 0x92,
	0xe6, 0x55, 0xa4, 0x7c, 0xd1, 0x8a, 0x54, 0xe6, 0x56, 0x64, 0x03, 0x56, 0xbe, 0xc7, 0xa4, 0xd7,
	0x57, 0xcd, 0x15, 0x1b, 0xc9, 0x4a, 0xe6, 0x5e, 0xa0, 0x54, 0x61, 0xd4, 0x4f, 0xd2, 0xb8, 0xb9,
	0x6a, 0x74, 0x8e, 0x46, 0x76, 0x35, 0xa0, 0xf9, 0x8d, 0x3a, 0x46, 0x19, 0x21, 0x8b, 0x29, 0x53,
	0xcd, 0x35, 0xcb, 0xaf, 0xe1, 0xbd, 0x31, 0xea, 0x7e, 0x0b, 0x64, 0x4f, 0xbf, 0x35, 0x2f, 0x10,
	0x45, 0x91, 0x6b, 0x49, 0x0e, 0xc0, 0x11, 0x85, 0xd0, 0x2c, 0x99, 0xaa, 0x3d, 0x5c, 0x54, 0xb5,
	0x73, 0xee, 0xc1, 0xc4, 0xd7, 0xfd, 0xad, 0x02, 0x97, 0xcf, 0x19, 0x10, 0x1f, 0xae, 0xa4, 0x89,
	0x54, 0xc8, 0x12, 0xd6, 0x0b, 0x69, 0x1c, 0x0b, 0x94, 0x45, 0x20, 0x27, 0x20, 0x63, 0xd5, 0x76,
	0xa1, 0x21, 0x3b, 0xe0, 0xc4, 0x89, 0xc0, 0x48, 0xbf, 0x51, 0xa6, 0x10, 0xf5, 0xce, 0xbd, 0xc9,
	0x7e, 0x50, 0xf5, 0xbd, 0xe2, 0x1d, 0xf4, 0x74, 0xa0, 0xbd, 0xc2, 0x36, 0x98, 0xb8, 0x91, 0xaf,
	0xa0, 0x11, 0x71, 0xc6, 0xac, 0x14, 0x4a, 0xfd, 0x76, 0x99, 0xea, 0xd5, 0xa7, 0x5b, 0x7b, 0x86,
	0x6a, 0x77, 0x6c, 0x6e, 0x5f, 0xba, 0xf5, 0x68, 0x16, 0x20, 0xd7, 0x60, 0x35, 0x43, 0x14, 0x61,
	0x12, 0x9b, 0x32, 0x3b, 0xc1, 0x8a, 0x16, 0x0f, 0x63, 0xdd, 0x86, 0xc8, 0x84, 0x29, 0xa9, 0x13,
	0xe8, 0x25, 0x79, 0x0e, 0x8e, 0x35, 0x65, 0x5d, 0x6e, 0x4a, 0x59, 0xed, 0x74, 0x2e, 0x9c, 0x51,
	0x73, 0xa8, 0x43, 0xd6, 0xe5, 0xc1, 0x5a, 0x36, 0x5a, 0x91, 0x2f, 0xa0, 0x6a, 0x08, 0xf5, 0x41,
	0x72, 0x69, 0x3a, 0xa0, 0xda, 0xb9, 0x75, 0x8e, 0x32, 0xeb, 0x64, 0x9a, 0xf2, 0xd8, 0x58, 0x05,
	0xa0, 0x5d, 0xec, 0x9a, 0xdc, 0x81, 0x5a, 0x4a, 0xa5, 0x0a, 0xf3, 0x2c, 0xa6, 0x0a, 0xe3, 0x51,
	0x7f, 0x54, 0x35, 0xf6, 0xca, 0x42, 0xad, 0x3f, 0x4b, 0xb0, 0x56, 0x84, 0x26, 0x9f, 0xc3, 0xda,
	0x19, 0x2a, 0x1a, 0x53, 0x45, 0xcd, 0xfd, 0xa8, 0x76, 0xda, 0x8b, 0xa2, 0x7d, 0x89, 0x8a, 0xee,
	0x51, 0x45, 0x83, 0xb1, 0x07, 0xb9, 0x01, 0x8e, 0x79, 0x18, 0x22, 0x9e, 0xca, 0xe6, 0x92, 0x29,
	0xf4, 0x04, 0x20, 0xb7, 0xa1, 0xda, 0xa5, 0x79, 0xaa, 0xc2, 0x88, 0xe7, 0xe3, 0x4b, 0x05, 0x06,
	0xda, 0xd5, 0x08, 0x79, 0x08, 0x8d, 0xc2, 0x3a, 0x1c, 0xa0, 0x90, 0xba, 0x0f, 0x6c, 0xca, 0xd7,
	0x0b, 0xfc, 0x6b, 0x0b, 0x93, 0xbb, 0xf0, 0x3f, 0xda, 0x43, 0xa6, 0xc6, 0x76, 0xb6, 0x0a, 0x35,
	0x03, 0x16, 0x46, 0x77, 0xa0, 0x66, 0xb2, 0x97, 0x52, 0x85, 0x2c, 0x1a, 0x8e, 0x2e, 0x97, 0xc9,
	0xe8, 0x91, 0x85, 0x3a, 0xef, 0x57, 0xa0, 0x62, 0x2a, 0x41, 0x7e, 0x2a, 0x41, 0xfd, 0x00, 0xd5,
	0xd4, 0xd0, 0x23, 0x8f, 0x16, 0xd5, 0xee, 0xfc, 0x64, 0x6c, 0xdd, 0x5d, 0x64, 0x3b, 0x35, 0xb9,
	0xdc, 0x3b, 0xef, 0x7e, 0xff, 0xe3, 0xd7, 0xa5, 0xeb, 0xe4, 0xff, 0xfe, 0xcc, 0x54, 0x37, 0xff,
	0x00, 0xdf, 0x34, 0x2b, 0xf9, 0x01, 0xd6, 0xf4, 0x2e, 0xf4, 0xec, 0x23, 0xf7, 0x16, 0xc6, 0x9f,
	0x1a, 0x9e, 0xff, 0x41, 0x64, 0x33, 0x69, 0xc9, 0x8f, 0xb0, 0x7e, 0x8c, 0x6a, 0x7a, 0x04, 0x92,
	0x8f, 0xfe, 0xc1, 0xa0, 0x6c, 0x6d, 0x78, 0xf6, 0x3f, 0xe1, 0x15, 0xff, 0x09, 0x6f, 0x5f, 0xff,
	0x27, 0xdc, 0xbb, 0x26, 0xf4, 0x4d, 0xf7, 0xfa, 0xbc, 0xd0, 0xa9, 0x25, 0x22, 0xbf, 0x94, 0xe0,
	0xda, 0x01, 0xaa, 0x79, 0xc3, 0x81, 0x2c, 0x20, 0x6e, 0x7d, 0xfa, 0x6f, 0x46, 0x8c, 0x7b, 0xdf,
	0x6c, 0xa7, 0x4d, 0x6e, 0xcd, 0xdb, 0x4e, 0x97, 0x8b, 0xd3, 0xc8, 0x46, 0x15, 0xe0, 0x1c, 0x25,
	0x52, 0xe9, 0x9b, 0x21, 0x17, 0x6e, 0xe1, 0xd1, 0x85, 0x6f, 0xb7, 0xfc, 0x70, 0x09, 0x32, 0x13,
	0xe6, 0x2d, 0xac, 0xea, 0x24, 0x20, 0x0a, 0xe2, 0x7e, 0xe0, 0xe5, 0x2b, 0x32, 0x7e, 0xf1, 0xd7,
	0xda, 0x6d, 0x9b, 0xe0, 0x2d, 0xd2, 0x5c, 0x14, 0xfc, 0x64, 0xc5, 0x1c, 0xed, 0x93, 0xbf, 0x02,
	0x00, 0x00, 0xff, 0xff, 0x6f, 0x05, 0xb2, 0xc5, 0xaa, 0x0a, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6

// DebugClient is the client API for Debug service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type DebugClient interface {
	GetBeaconState(ctx context.Context, in *BeaconStateRequest, opts ...grpc.CallOption) (*SSZResponse, error)
	GetBlock(ctx context.Context, in *BlockRequest, opts ...grpc.CallOption) (*SSZResponse, error)
	SetLoggingLevel(ctx context.Context, in *LoggingLevelRequest, opts ...grpc.CallOption) (*empty.Empty, error)
	GetProtoArrayForkChoice(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*ProtoArrayForkChoiceResponse, error)
	ListPeers(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*DebugPeerResponses, error)
	GetPeer(ctx context.Context, in *v1alpha1.PeerRequest, opts ...grpc.CallOption) (*DebugPeerResponse, error)
}

type debugClient struct {
	cc grpc.ClientConnInterface
}

func NewDebugClient(cc grpc.ClientConnInterface) DebugClient {
	return &debugClient{cc}
}

func (c *debugClient) GetBeaconState(ctx context.Context, in *BeaconStateRequest, opts ...grpc.CallOption) (*SSZResponse, error) {
	out := new(SSZResponse)
	err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.Debug/GetBeaconState", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugClient) GetBlock(ctx context.Context, in *BlockRequest, opts ...grpc.CallOption) (*SSZResponse, error) {
	out := new(SSZResponse)
	err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.Debug/GetBlock", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugClient) SetLoggingLevel(ctx context.Context, in *LoggingLevelRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.Debug/SetLoggingLevel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugClient) GetProtoArrayForkChoice(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*ProtoArrayForkChoiceResponse, error) {
	out := new(ProtoArrayForkChoiceResponse)
	err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.Debug/GetProtoArrayForkChoice", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugClient) ListPeers(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*DebugPeerResponses, error) {
	out := new(DebugPeerResponses)
	err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.Debug/ListPeers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugClient) GetPeer(ctx context.Context, in *v1alpha1.PeerRequest, opts ...grpc.CallOption) (*DebugPeerResponse, error) {
	out := new(DebugPeerResponse)
	err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.Debug/GetPeer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DebugServer is the server API for Debug service.
type DebugServer interface {
	GetBeaconState(context.Context, *BeaconStateRequest) (*SSZResponse, error)
	GetBlock(context.Context, *BlockRequest) (*SSZResponse, error)
	SetLoggingLevel(context.Context, *LoggingLevelRequest) (*empty.Empty, error)
	GetProtoArrayForkChoice(context.Context, *empty.Empty) (*ProtoArrayForkChoiceResponse, error)
	ListPeers(context.Context, *empty.Empty) (*DebugPeerResponses, error)
	GetPeer(context.Context, *v1alpha1.PeerRequest) (*DebugPeerResponse, error)
}

// UnimplementedDebugServer can be embedded to have forward compatible implementations.
type UnimplementedDebugServer struct {
}

func (*UnimplementedDebugServer) GetBeaconState(ctx context.Context, req *BeaconStateRequest) (*SSZResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetBeaconState not implemented")
}
func (*UnimplementedDebugServer) GetBlock(ctx context.Context, req *BlockRequest) (*SSZResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetBlock not implemented")
}
func (*UnimplementedDebugServer) SetLoggingLevel(ctx context.Context, req *LoggingLevelRequest) (*empty.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetLoggingLevel not implemented")
}
func (*UnimplementedDebugServer) GetProtoArrayForkChoice(ctx context.Context, req *empty.Empty) (*ProtoArrayForkChoiceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetProtoArrayForkChoice not implemented")
}
func (*UnimplementedDebugServer) ListPeers(ctx context.Context, req *empty.Empty) (*DebugPeerResponses, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListPeers not implemented")
}
func (*UnimplementedDebugServer) GetPeer(ctx context.Context, req *v1alpha1.PeerRequest) (*DebugPeerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPeer not implemented")
}

func RegisterDebugServer(s *grpc.Server, srv DebugServer) {
	s.RegisterService(&_Debug_serviceDesc, srv)
}

func _Debug_GetBeaconState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BeaconStateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServer).GetBeaconState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.beacon.rpc.v1.Debug/GetBeaconState",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServer).GetBeaconState(ctx, req.(*BeaconStateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Debug_GetBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BlockRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServer).GetBlock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.beacon.rpc.v1.Debug/GetBlock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServer).GetBlock(ctx, req.(*BlockRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Debug_SetLoggingLevel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LoggingLevelRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServer).SetLoggingLevel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.beacon.rpc.v1.Debug/SetLoggingLevel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServer).SetLoggingLevel(ctx, req.(*LoggingLevelRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Debug_GetProtoArrayForkChoice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServer).GetProtoArrayForkChoice(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.beacon.rpc.v1.Debug/GetProtoArrayForkChoice",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServer).GetProtoArrayForkChoice(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Debug_ListPeers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServer).ListPeers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.beacon.rpc.v1.Debug/ListPeers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServer).ListPeers(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Debug_GetPeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1alpha1.PeerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServer).GetPeer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.beacon.rpc.v1.Debug/GetPeer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServer).GetPeer(ctx, req.(*v1alpha1.PeerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Debug_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ethereum.beacon.rpc.v1.Debug",
	HandlerType: (*DebugServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetBeaconState",
			Handler:    _Debug_GetBeaconState_Handler,
		},
		{
			MethodName: "GetBlock",
			Handler:    _Debug_GetBlock_Handler,
		},
		{
			MethodName: "SetLoggingLevel",
			Handler:    _Debug_SetLoggingLevel_Handler,
		},
		{
			MethodName: "GetProtoArrayForkChoice",
			Handler:    _Debug_GetProtoArrayForkChoice_Handler,
		},
		{
			MethodName: "ListPeers",
			Handler:    _Debug_ListPeers_Handler,
		},
		{
			MethodName: "GetPeer",
			Handler:    _Debug_GetPeer_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/beacon/rpc/v1/debug.proto",
}
