// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: heartbeat.proto

package data

import (
	bytes "bytes"
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strings "strings"
)

// 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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// Heartbeat represents the heartbeat message that is sent between peers
type Heartbeat struct {
	Payload         []byte `protobuf:"bytes,1,opt,name=Payload,proto3" json:"Payload,omitempty"`
	Pubkey          []byte `protobuf:"bytes,2,opt,name=Pubkey,proto3" json:"Pubkey,omitempty"`
	Signature       []byte `protobuf:"bytes,3,opt,name=Signature,proto3" json:"Signature,omitempty"`
	ShardID         uint32 `protobuf:"varint,4,opt,name=ShardID,proto3" json:"ShardID,omitempty"`
	VersionNumber   string `protobuf:"bytes,5,opt,name=VersionNumber,proto3" json:"VersionNumber,omitempty"`
	NodeDisplayName string `protobuf:"bytes,6,opt,name=NodeDisplayName,proto3" json:"NodeDisplayName,omitempty"`
	Identity        string `protobuf:"bytes,7,opt,name=Identity,proto3" json:"Identity,omitempty"`
	Pid             []byte `protobuf:"bytes,8,opt,name=Pid,proto3" json:"Pid,omitempty"`
	Nonce           uint64 `protobuf:"varint,9,opt,name=Nonce,proto3" json:"Nonce,omitempty"`
	PeerSubType     uint32 `protobuf:"varint,10,opt,name=PeerSubType,proto3" json:"PeerSubType,omitempty"`
}

func (m *Heartbeat) Reset()      { *m = Heartbeat{} }
func (*Heartbeat) ProtoMessage() {}
func (*Heartbeat) Descriptor() ([]byte, []int) {
	return fileDescriptor_3c667767fb9826a9, []int{0}
}
func (m *Heartbeat) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Heartbeat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Heartbeat.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Heartbeat) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Heartbeat.Merge(m, src)
}
func (m *Heartbeat) XXX_Size() int {
	return m.Size()
}
func (m *Heartbeat) XXX_DiscardUnknown() {
	xxx_messageInfo_Heartbeat.DiscardUnknown(m)
}

var xxx_messageInfo_Heartbeat proto.InternalMessageInfo

func (m *Heartbeat) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *Heartbeat) GetPubkey() []byte {
	if m != nil {
		return m.Pubkey
	}
	return nil
}

func (m *Heartbeat) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *Heartbeat) GetShardID() uint32 {
	if m != nil {
		return m.ShardID
	}
	return 0
}

func (m *Heartbeat) GetVersionNumber() string {
	if m != nil {
		return m.VersionNumber
	}
	return ""
}

func (m *Heartbeat) GetNodeDisplayName() string {
	if m != nil {
		return m.NodeDisplayName
	}
	return ""
}

func (m *Heartbeat) GetIdentity() string {
	if m != nil {
		return m.Identity
	}
	return ""
}

func (m *Heartbeat) GetPid() []byte {
	if m != nil {
		return m.Pid
	}
	return nil
}

func (m *Heartbeat) GetNonce() uint64 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

func (m *Heartbeat) GetPeerSubType() uint32 {
	if m != nil {
		return m.PeerSubType
	}
	return 0
}

// HeartbeatDTO is the struct used for handling DB operations for heartbeatMessageInfo struct
type HeartbeatDTO struct {
	MaxDurationPeerUnresponsive int64  `protobuf:"varint,1,opt,name=MaxDurationPeerUnresponsive,proto3" json:"MaxDurationPeerUnresponsive,omitempty"`
	MaxInactiveTime             int64  `protobuf:"varint,2,opt,name=MaxInactiveTime,proto3" json:"MaxInactiveTime,omitempty"`
	TotalUpTime                 int64  `protobuf:"varint,3,opt,name=TotalUpTime,proto3" json:"TotalUpTime,omitempty"`
	TotalDownTime               int64  `protobuf:"varint,4,opt,name=TotalDownTime,proto3" json:"TotalDownTime,omitempty"`
	TimeStamp                   int64  `protobuf:"varint,5,opt,name=TimeStamp,proto3" json:"TimeStamp,omitempty"`
	IsActive                    bool   `protobuf:"varint,6,opt,name=IsActive,proto3" json:"IsActive,omitempty"`
	ReceivedShardID             uint32 `protobuf:"varint,7,opt,name=ReceivedShardID,proto3" json:"ReceivedShardID,omitempty"`
	ComputedShardID             uint32 `protobuf:"varint,8,opt,name=ComputedShardID,proto3" json:"ComputedShardID,omitempty"`
	VersionNumber               string `protobuf:"bytes,9,opt,name=VersionNumber,proto3" json:"VersionNumber,omitempty"`
	NodeDisplayName             string `protobuf:"bytes,10,opt,name=NodeDisplayName,proto3" json:"NodeDisplayName,omitempty"`
	PeerType                    string `protobuf:"bytes,11,opt,name=PeerType,proto3" json:"PeerType,omitempty"`
	Identity                    string `protobuf:"bytes,12,opt,name=Identity,proto3" json:"Identity,omitempty"`
	IsValidator                 bool   `protobuf:"varint,13,opt,name=IsValidator,proto3" json:"IsValidator,omitempty"`
	LastUptimeDowntime          int64  `protobuf:"varint,14,opt,name=LastUptimeDowntime,proto3" json:"LastUptimeDowntime,omitempty"`
	GenesisTime                 int64  `protobuf:"varint,15,opt,name=GenesisTime,proto3" json:"GenesisTime,omitempty"`
	Nonce                       uint64 `protobuf:"varint,16,opt,name=Nonce,proto3" json:"Nonce,omitempty"`
	NumInstances                uint64 `protobuf:"varint,17,opt,name=NumInstances,proto3" json:"NumInstances,omitempty"`
	PeerSubType                 uint32 `protobuf:"varint,18,opt,name=PeerSubType,proto3" json:"PeerSubType,omitempty"`
	PidString                   string `protobuf:"bytes,19,opt,name=PidString,proto3" json:"PidString,omitempty"`
}

func (m *HeartbeatDTO) Reset()      { *m = HeartbeatDTO{} }
func (*HeartbeatDTO) ProtoMessage() {}
func (*HeartbeatDTO) Descriptor() ([]byte, []int) {
	return fileDescriptor_3c667767fb9826a9, []int{1}
}
func (m *HeartbeatDTO) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HeartbeatDTO) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HeartbeatDTO.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *HeartbeatDTO) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HeartbeatDTO.Merge(m, src)
}
func (m *HeartbeatDTO) XXX_Size() int {
	return m.Size()
}
func (m *HeartbeatDTO) XXX_DiscardUnknown() {
	xxx_messageInfo_HeartbeatDTO.DiscardUnknown(m)
}

var xxx_messageInfo_HeartbeatDTO proto.InternalMessageInfo

func (m *HeartbeatDTO) GetMaxDurationPeerUnresponsive() int64 {
	if m != nil {
		return m.MaxDurationPeerUnresponsive
	}
	return 0
}

func (m *HeartbeatDTO) GetMaxInactiveTime() int64 {
	if m != nil {
		return m.MaxInactiveTime
	}
	return 0
}

func (m *HeartbeatDTO) GetTotalUpTime() int64 {
	if m != nil {
		return m.TotalUpTime
	}
	return 0
}

func (m *HeartbeatDTO) GetTotalDownTime() int64 {
	if m != nil {
		return m.TotalDownTime
	}
	return 0
}

func (m *HeartbeatDTO) GetTimeStamp() int64 {
	if m != nil {
		return m.TimeStamp
	}
	return 0
}

func (m *HeartbeatDTO) GetIsActive() bool {
	if m != nil {
		return m.IsActive
	}
	return false
}

func (m *HeartbeatDTO) GetReceivedShardID() uint32 {
	if m != nil {
		return m.ReceivedShardID
	}
	return 0
}

func (m *HeartbeatDTO) GetComputedShardID() uint32 {
	if m != nil {
		return m.ComputedShardID
	}
	return 0
}

func (m *HeartbeatDTO) GetVersionNumber() string {
	if m != nil {
		return m.VersionNumber
	}
	return ""
}

func (m *HeartbeatDTO) GetNodeDisplayName() string {
	if m != nil {
		return m.NodeDisplayName
	}
	return ""
}

func (m *HeartbeatDTO) GetPeerType() string {
	if m != nil {
		return m.PeerType
	}
	return ""
}

func (m *HeartbeatDTO) GetIdentity() string {
	if m != nil {
		return m.Identity
	}
	return ""
}

func (m *HeartbeatDTO) GetIsValidator() bool {
	if m != nil {
		return m.IsValidator
	}
	return false
}

func (m *HeartbeatDTO) GetLastUptimeDowntime() int64 {
	if m != nil {
		return m.LastUptimeDowntime
	}
	return 0
}

func (m *HeartbeatDTO) GetGenesisTime() int64 {
	if m != nil {
		return m.GenesisTime
	}
	return 0
}

func (m *HeartbeatDTO) GetNonce() uint64 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

func (m *HeartbeatDTO) GetNumInstances() uint64 {
	if m != nil {
		return m.NumInstances
	}
	return 0
}

func (m *HeartbeatDTO) GetPeerSubType() uint32 {
	if m != nil {
		return m.PeerSubType
	}
	return 0
}

func (m *HeartbeatDTO) GetPidString() string {
	if m != nil {
		return m.PidString
	}
	return ""
}

type DbTimeStamp struct {
	Timestamp int64 `protobuf:"varint,1,opt,name=Timestamp,proto3" json:"Timestamp,omitempty"`
}

func (m *DbTimeStamp) Reset()      { *m = DbTimeStamp{} }
func (*DbTimeStamp) ProtoMessage() {}
func (*DbTimeStamp) Descriptor() ([]byte, []int) {
	return fileDescriptor_3c667767fb9826a9, []int{2}
}
func (m *DbTimeStamp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DbTimeStamp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DbTimeStamp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DbTimeStamp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DbTimeStamp.Merge(m, src)
}
func (m *DbTimeStamp) XXX_Size() int {
	return m.Size()
}
func (m *DbTimeStamp) XXX_DiscardUnknown() {
	xxx_messageInfo_DbTimeStamp.DiscardUnknown(m)
}

var xxx_messageInfo_DbTimeStamp proto.InternalMessageInfo

func (m *DbTimeStamp) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

func init() {
	proto.RegisterType((*Heartbeat)(nil), "proto.Heartbeat")
	proto.RegisterType((*HeartbeatDTO)(nil), "proto.HeartbeatDTO")
	proto.RegisterType((*DbTimeStamp)(nil), "proto.DbTimeStamp")
}

func init() { proto.RegisterFile("heartbeat.proto", fileDescriptor_3c667767fb9826a9) }

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

func (this *Heartbeat) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Heartbeat)
	if !ok {
		that2, ok := that.(Heartbeat)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Payload, that1.Payload) {
		return false
	}
	if !bytes.Equal(this.Pubkey, that1.Pubkey) {
		return false
	}
	if !bytes.Equal(this.Signature, that1.Signature) {
		return false
	}
	if this.ShardID != that1.ShardID {
		return false
	}
	if this.VersionNumber != that1.VersionNumber {
		return false
	}
	if this.NodeDisplayName != that1.NodeDisplayName {
		return false
	}
	if this.Identity != that1.Identity {
		return false
	}
	if !bytes.Equal(this.Pid, that1.Pid) {
		return false
	}
	if this.Nonce != that1.Nonce {
		return false
	}
	if this.PeerSubType != that1.PeerSubType {
		return false
	}
	return true
}
func (this *HeartbeatDTO) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*HeartbeatDTO)
	if !ok {
		that2, ok := that.(HeartbeatDTO)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.MaxDurationPeerUnresponsive != that1.MaxDurationPeerUnresponsive {
		return false
	}
	if this.MaxInactiveTime != that1.MaxInactiveTime {
		return false
	}
	if this.TotalUpTime != that1.TotalUpTime {
		return false
	}
	if this.TotalDownTime != that1.TotalDownTime {
		return false
	}
	if this.TimeStamp != that1.TimeStamp {
		return false
	}
	if this.IsActive != that1.IsActive {
		return false
	}
	if this.ReceivedShardID != that1.ReceivedShardID {
		return false
	}
	if this.ComputedShardID != that1.ComputedShardID {
		return false
	}
	if this.VersionNumber != that1.VersionNumber {
		return false
	}
	if this.NodeDisplayName != that1.NodeDisplayName {
		return false
	}
	if this.PeerType != that1.PeerType {
		return false
	}
	if this.Identity != that1.Identity {
		return false
	}
	if this.IsValidator != that1.IsValidator {
		return false
	}
	if this.LastUptimeDowntime != that1.LastUptimeDowntime {
		return false
	}
	if this.GenesisTime != that1.GenesisTime {
		return false
	}
	if this.Nonce != that1.Nonce {
		return false
	}
	if this.NumInstances != that1.NumInstances {
		return false
	}
	if this.PeerSubType != that1.PeerSubType {
		return false
	}
	if this.PidString != that1.PidString {
		return false
	}
	return true
}
func (this *DbTimeStamp) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DbTimeStamp)
	if !ok {
		that2, ok := that.(DbTimeStamp)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Timestamp != that1.Timestamp {
		return false
	}
	return true
}
func (this *Heartbeat) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 14)
	s = append(s, "&data.Heartbeat{")
	s = append(s, "Payload: "+fmt.Sprintf("%#v", this.Payload)+",\n")
	s = append(s, "Pubkey: "+fmt.Sprintf("%#v", this.Pubkey)+",\n")
	s = append(s, "Signature: "+fmt.Sprintf("%#v", this.Signature)+",\n")
	s = append(s, "ShardID: "+fmt.Sprintf("%#v", this.ShardID)+",\n")
	s = append(s, "VersionNumber: "+fmt.Sprintf("%#v", this.VersionNumber)+",\n")
	s = append(s, "NodeDisplayName: "+fmt.Sprintf("%#v", this.NodeDisplayName)+",\n")
	s = append(s, "Identity: "+fmt.Sprintf("%#v", this.Identity)+",\n")
	s = append(s, "Pid: "+fmt.Sprintf("%#v", this.Pid)+",\n")
	s = append(s, "Nonce: "+fmt.Sprintf("%#v", this.Nonce)+",\n")
	s = append(s, "PeerSubType: "+fmt.Sprintf("%#v", this.PeerSubType)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *HeartbeatDTO) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 23)
	s = append(s, "&data.HeartbeatDTO{")
	s = append(s, "MaxDurationPeerUnresponsive: "+fmt.Sprintf("%#v", this.MaxDurationPeerUnresponsive)+",\n")
	s = append(s, "MaxInactiveTime: "+fmt.Sprintf("%#v", this.MaxInactiveTime)+",\n")
	s = append(s, "TotalUpTime: "+fmt.Sprintf("%#v", this.TotalUpTime)+",\n")
	s = append(s, "TotalDownTime: "+fmt.Sprintf("%#v", this.TotalDownTime)+",\n")
	s = append(s, "TimeStamp: "+fmt.Sprintf("%#v", this.TimeStamp)+",\n")
	s = append(s, "IsActive: "+fmt.Sprintf("%#v", this.IsActive)+",\n")
	s = append(s, "ReceivedShardID: "+fmt.Sprintf("%#v", this.ReceivedShardID)+",\n")
	s = append(s, "ComputedShardID: "+fmt.Sprintf("%#v", this.ComputedShardID)+",\n")
	s = append(s, "VersionNumber: "+fmt.Sprintf("%#v", this.VersionNumber)+",\n")
	s = append(s, "NodeDisplayName: "+fmt.Sprintf("%#v", this.NodeDisplayName)+",\n")
	s = append(s, "PeerType: "+fmt.Sprintf("%#v", this.PeerType)+",\n")
	s = append(s, "Identity: "+fmt.Sprintf("%#v", this.Identity)+",\n")
	s = append(s, "IsValidator: "+fmt.Sprintf("%#v", this.IsValidator)+",\n")
	s = append(s, "LastUptimeDowntime: "+fmt.Sprintf("%#v", this.LastUptimeDowntime)+",\n")
	s = append(s, "GenesisTime: "+fmt.Sprintf("%#v", this.GenesisTime)+",\n")
	s = append(s, "Nonce: "+fmt.Sprintf("%#v", this.Nonce)+",\n")
	s = append(s, "NumInstances: "+fmt.Sprintf("%#v", this.NumInstances)+",\n")
	s = append(s, "PeerSubType: "+fmt.Sprintf("%#v", this.PeerSubType)+",\n")
	s = append(s, "PidString: "+fmt.Sprintf("%#v", this.PidString)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DbTimeStamp) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&data.DbTimeStamp{")
	s = append(s, "Timestamp: "+fmt.Sprintf("%#v", this.Timestamp)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringHeartbeat(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *Heartbeat) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Heartbeat) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Heartbeat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.PeerSubType != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.PeerSubType))
		i--
		dAtA[i] = 0x50
	}
	if m.Nonce != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Nonce))
		i--
		dAtA[i] = 0x48
	}
	if len(m.Pid) > 0 {
		i -= len(m.Pid)
		copy(dAtA[i:], m.Pid)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.Pid)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.Identity) > 0 {
		i -= len(m.Identity)
		copy(dAtA[i:], m.Identity)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.Identity)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.NodeDisplayName) > 0 {
		i -= len(m.NodeDisplayName)
		copy(dAtA[i:], m.NodeDisplayName)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.NodeDisplayName)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.VersionNumber) > 0 {
		i -= len(m.VersionNumber)
		copy(dAtA[i:], m.VersionNumber)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.VersionNumber)))
		i--
		dAtA[i] = 0x2a
	}
	if m.ShardID != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.ShardID))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Signature) > 0 {
		i -= len(m.Signature)
		copy(dAtA[i:], m.Signature)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Pubkey) > 0 {
		i -= len(m.Pubkey)
		copy(dAtA[i:], m.Pubkey)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.Pubkey)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *HeartbeatDTO) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HeartbeatDTO) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HeartbeatDTO) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PidString) > 0 {
		i -= len(m.PidString)
		copy(dAtA[i:], m.PidString)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.PidString)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x9a
	}
	if m.PeerSubType != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.PeerSubType))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x90
	}
	if m.NumInstances != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.NumInstances))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x88
	}
	if m.Nonce != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Nonce))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x80
	}
	if m.GenesisTime != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.GenesisTime))
		i--
		dAtA[i] = 0x78
	}
	if m.LastUptimeDowntime != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.LastUptimeDowntime))
		i--
		dAtA[i] = 0x70
	}
	if m.IsValidator {
		i--
		if m.IsValidator {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x68
	}
	if len(m.Identity) > 0 {
		i -= len(m.Identity)
		copy(dAtA[i:], m.Identity)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.Identity)))
		i--
		dAtA[i] = 0x62
	}
	if len(m.PeerType) > 0 {
		i -= len(m.PeerType)
		copy(dAtA[i:], m.PeerType)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.PeerType)))
		i--
		dAtA[i] = 0x5a
	}
	if len(m.NodeDisplayName) > 0 {
		i -= len(m.NodeDisplayName)
		copy(dAtA[i:], m.NodeDisplayName)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.NodeDisplayName)))
		i--
		dAtA[i] = 0x52
	}
	if len(m.VersionNumber) > 0 {
		i -= len(m.VersionNumber)
		copy(dAtA[i:], m.VersionNumber)
		i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.VersionNumber)))
		i--
		dAtA[i] = 0x4a
	}
	if m.ComputedShardID != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.ComputedShardID))
		i--
		dAtA[i] = 0x40
	}
	if m.ReceivedShardID != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.ReceivedShardID))
		i--
		dAtA[i] = 0x38
	}
	if m.IsActive {
		i--
		if m.IsActive {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.TimeStamp != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.TimeStamp))
		i--
		dAtA[i] = 0x28
	}
	if m.TotalDownTime != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.TotalDownTime))
		i--
		dAtA[i] = 0x20
	}
	if m.TotalUpTime != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.TotalUpTime))
		i--
		dAtA[i] = 0x18
	}
	if m.MaxInactiveTime != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.MaxInactiveTime))
		i--
		dAtA[i] = 0x10
	}
	if m.MaxDurationPeerUnresponsive != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.MaxDurationPeerUnresponsive))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *DbTimeStamp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DbTimeStamp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DbTimeStamp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Timestamp != 0 {
		i = encodeVarintHeartbeat(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintHeartbeat(dAtA []byte, offset int, v uint64) int {
	offset -= sovHeartbeat(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Heartbeat) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	l = len(m.Pubkey)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.ShardID != 0 {
		n += 1 + sovHeartbeat(uint64(m.ShardID))
	}
	l = len(m.VersionNumber)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	l = len(m.NodeDisplayName)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	l = len(m.Identity)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	l = len(m.Pid)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.Nonce != 0 {
		n += 1 + sovHeartbeat(uint64(m.Nonce))
	}
	if m.PeerSubType != 0 {
		n += 1 + sovHeartbeat(uint64(m.PeerSubType))
	}
	return n
}

func (m *HeartbeatDTO) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MaxDurationPeerUnresponsive != 0 {
		n += 1 + sovHeartbeat(uint64(m.MaxDurationPeerUnresponsive))
	}
	if m.MaxInactiveTime != 0 {
		n += 1 + sovHeartbeat(uint64(m.MaxInactiveTime))
	}
	if m.TotalUpTime != 0 {
		n += 1 + sovHeartbeat(uint64(m.TotalUpTime))
	}
	if m.TotalDownTime != 0 {
		n += 1 + sovHeartbeat(uint64(m.TotalDownTime))
	}
	if m.TimeStamp != 0 {
		n += 1 + sovHeartbeat(uint64(m.TimeStamp))
	}
	if m.IsActive {
		n += 2
	}
	if m.ReceivedShardID != 0 {
		n += 1 + sovHeartbeat(uint64(m.ReceivedShardID))
	}
	if m.ComputedShardID != 0 {
		n += 1 + sovHeartbeat(uint64(m.ComputedShardID))
	}
	l = len(m.VersionNumber)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	l = len(m.NodeDisplayName)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	l = len(m.PeerType)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	l = len(m.Identity)
	if l > 0 {
		n += 1 + l + sovHeartbeat(uint64(l))
	}
	if m.IsValidator {
		n += 2
	}
	if m.LastUptimeDowntime != 0 {
		n += 1 + sovHeartbeat(uint64(m.LastUptimeDowntime))
	}
	if m.GenesisTime != 0 {
		n += 1 + sovHeartbeat(uint64(m.GenesisTime))
	}
	if m.Nonce != 0 {
		n += 2 + sovHeartbeat(uint64(m.Nonce))
	}
	if m.NumInstances != 0 {
		n += 2 + sovHeartbeat(uint64(m.NumInstances))
	}
	if m.PeerSubType != 0 {
		n += 2 + sovHeartbeat(uint64(m.PeerSubType))
	}
	l = len(m.PidString)
	if l > 0 {
		n += 2 + l + sovHeartbeat(uint64(l))
	}
	return n
}

func (m *DbTimeStamp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Timestamp != 0 {
		n += 1 + sovHeartbeat(uint64(m.Timestamp))
	}
	return n
}

func sovHeartbeat(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozHeartbeat(x uint64) (n int) {
	return sovHeartbeat(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Heartbeat) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Heartbeat{`,
		`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
		`Pubkey:` + fmt.Sprintf("%v", this.Pubkey) + `,`,
		`Signature:` + fmt.Sprintf("%v", this.Signature) + `,`,
		`ShardID:` + fmt.Sprintf("%v", this.ShardID) + `,`,
		`VersionNumber:` + fmt.Sprintf("%v", this.VersionNumber) + `,`,
		`NodeDisplayName:` + fmt.Sprintf("%v", this.NodeDisplayName) + `,`,
		`Identity:` + fmt.Sprintf("%v", this.Identity) + `,`,
		`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
		`Nonce:` + fmt.Sprintf("%v", this.Nonce) + `,`,
		`PeerSubType:` + fmt.Sprintf("%v", this.PeerSubType) + `,`,
		`}`,
	}, "")
	return s
}
func (this *HeartbeatDTO) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&HeartbeatDTO{`,
		`MaxDurationPeerUnresponsive:` + fmt.Sprintf("%v", this.MaxDurationPeerUnresponsive) + `,`,
		`MaxInactiveTime:` + fmt.Sprintf("%v", this.MaxInactiveTime) + `,`,
		`TotalUpTime:` + fmt.Sprintf("%v", this.TotalUpTime) + `,`,
		`TotalDownTime:` + fmt.Sprintf("%v", this.TotalDownTime) + `,`,
		`TimeStamp:` + fmt.Sprintf("%v", this.TimeStamp) + `,`,
		`IsActive:` + fmt.Sprintf("%v", this.IsActive) + `,`,
		`ReceivedShardID:` + fmt.Sprintf("%v", this.ReceivedShardID) + `,`,
		`ComputedShardID:` + fmt.Sprintf("%v", this.ComputedShardID) + `,`,
		`VersionNumber:` + fmt.Sprintf("%v", this.VersionNumber) + `,`,
		`NodeDisplayName:` + fmt.Sprintf("%v", this.NodeDisplayName) + `,`,
		`PeerType:` + fmt.Sprintf("%v", this.PeerType) + `,`,
		`Identity:` + fmt.Sprintf("%v", this.Identity) + `,`,
		`IsValidator:` + fmt.Sprintf("%v", this.IsValidator) + `,`,
		`LastUptimeDowntime:` + fmt.Sprintf("%v", this.LastUptimeDowntime) + `,`,
		`GenesisTime:` + fmt.Sprintf("%v", this.GenesisTime) + `,`,
		`Nonce:` + fmt.Sprintf("%v", this.Nonce) + `,`,
		`NumInstances:` + fmt.Sprintf("%v", this.NumInstances) + `,`,
		`PeerSubType:` + fmt.Sprintf("%v", this.PeerSubType) + `,`,
		`PidString:` + fmt.Sprintf("%v", this.PidString) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DbTimeStamp) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DbTimeStamp{`,
		`Timestamp:` + fmt.Sprintf("%v", this.Timestamp) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringHeartbeat(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Heartbeat) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Heartbeat: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Heartbeat: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
			if m.Payload == nil {
				m.Payload = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pubkey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Pubkey = append(m.Pubkey[:0], dAtA[iNdEx:postIndex]...)
			if m.Pubkey == nil {
				m.Pubkey = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
			if m.Signature == nil {
				m.Signature = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShardID", wireType)
			}
			m.ShardID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ShardID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VersionNumber", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.VersionNumber = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeDisplayName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeDisplayName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Identity = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Pid = append(m.Pid[:0], dAtA[iNdEx:postIndex]...)
			if m.Pid == nil {
				m.Pid = []byte{}
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			m.Nonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Nonce |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerSubType", wireType)
			}
			m.PeerSubType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerSubType |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HeartbeatDTO) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HeartbeatDTO: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HeartbeatDTO: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxDurationPeerUnresponsive", wireType)
			}
			m.MaxDurationPeerUnresponsive = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxDurationPeerUnresponsive |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxInactiveTime", wireType)
			}
			m.MaxInactiveTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxInactiveTime |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalUpTime", wireType)
			}
			m.TotalUpTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalUpTime |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalDownTime", wireType)
			}
			m.TotalDownTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalDownTime |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeStamp", wireType)
			}
			m.TimeStamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TimeStamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsActive", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsActive = bool(v != 0)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReceivedShardID", wireType)
			}
			m.ReceivedShardID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReceivedShardID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ComputedShardID", wireType)
			}
			m.ComputedShardID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ComputedShardID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VersionNumber", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.VersionNumber = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeDisplayName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeDisplayName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PeerType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Identity = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsValidator", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsValidator = bool(v != 0)
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastUptimeDowntime", wireType)
			}
			m.LastUptimeDowntime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastUptimeDowntime |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 15:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GenesisTime", wireType)
			}
			m.GenesisTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GenesisTime |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 16:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			m.Nonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Nonce |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 17:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumInstances", wireType)
			}
			m.NumInstances = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumInstances |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 18:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerSubType", wireType)
			}
			m.PeerSubType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerSubType |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PidString", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthHeartbeat
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PidString = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DbTimeStamp) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DbTimeStamp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DbTimeStamp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			m.Timestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHeartbeat(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHeartbeat
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipHeartbeat(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowHeartbeat
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowHeartbeat
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthHeartbeat
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupHeartbeat
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthHeartbeat
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthHeartbeat        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowHeartbeat          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupHeartbeat = fmt.Errorf("proto: unexpected end of group")
)
