// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: uber/cadence/sharddistributor/v1/executor.proto

package sharddistributorv1

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"

	proto "github.com/gogo/protobuf/proto"
)

// 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

type ExecutorStatus int32

const (
	ExecutorStatus_EXECUTOR_STATUS_INVALID  ExecutorStatus = 0
	ExecutorStatus_EXECUTOR_STATUS_ACTIVE   ExecutorStatus = 1
	ExecutorStatus_EXECUTOR_STATUS_DRAINING ExecutorStatus = 2
	ExecutorStatus_EXECUTOR_STATUS_DRAINED  ExecutorStatus = 3
)

var ExecutorStatus_name = map[int32]string{
	0: "EXECUTOR_STATUS_INVALID",
	1: "EXECUTOR_STATUS_ACTIVE",
	2: "EXECUTOR_STATUS_DRAINING",
	3: "EXECUTOR_STATUS_DRAINED",
}

var ExecutorStatus_value = map[string]int32{
	"EXECUTOR_STATUS_INVALID":  0,
	"EXECUTOR_STATUS_ACTIVE":   1,
	"EXECUTOR_STATUS_DRAINING": 2,
	"EXECUTOR_STATUS_DRAINED":  3,
}

func (x ExecutorStatus) String() string {
	return proto.EnumName(ExecutorStatus_name, int32(x))
}

func (ExecutorStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5aab034437d08cca, []int{0}
}

// We only have one status for now, but when adding
// graceful handover, we will need to add more statuses.
// We do not need an "inactive" status, as we will not include
// inactive shards in the heartbeat request.
type ShardStatus int32

const (
	ShardStatus_SHARD_STATUS_INVALID ShardStatus = 0
	ShardStatus_SHARD_STATUS_READY   ShardStatus = 1
	ShardStatus_SHARD_STATUS_DONE    ShardStatus = 2
)

var ShardStatus_name = map[int32]string{
	0: "SHARD_STATUS_INVALID",
	1: "SHARD_STATUS_READY",
	2: "SHARD_STATUS_DONE",
}

var ShardStatus_value = map[string]int32{
	"SHARD_STATUS_INVALID": 0,
	"SHARD_STATUS_READY":   1,
	"SHARD_STATUS_DONE":    2,
}

func (x ShardStatus) String() string {
	return proto.EnumName(ShardStatus_name, int32(x))
}

func (ShardStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5aab034437d08cca, []int{1}
}

// We only have one status for now, but when adding
// graceful handover, we will need to add more statuses.
// We do not need an "inactive" status, as we will not include
// inactive shards in the heartbeat request.
type AssignmentStatus int32

const (
	AssignmentStatus_ASSIGNMENT_STATUS_INVALID AssignmentStatus = 0
	AssignmentStatus_ASSIGNMENT_STATUS_READY   AssignmentStatus = 1
)

var AssignmentStatus_name = map[int32]string{
	0: "ASSIGNMENT_STATUS_INVALID",
	1: "ASSIGNMENT_STATUS_READY",
}

var AssignmentStatus_value = map[string]int32{
	"ASSIGNMENT_STATUS_INVALID": 0,
	"ASSIGNMENT_STATUS_READY":   1,
}

func (x AssignmentStatus) String() string {
	return proto.EnumName(AssignmentStatus_name, int32(x))
}

func (AssignmentStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5aab034437d08cca, []int{2}
}

// We handle  the migration steps from SD side
type MigrationMode int32

const (
	MigrationMode_MIGRATION_MODE_INVALID                  MigrationMode = 0
	MigrationMode_MIGRATION_MODE_LOCAL_PASSTHROUGH        MigrationMode = 1
	MigrationMode_MIGRATION_MODE_LOCAL_PASSTHROUGH_SHADOW MigrationMode = 2
	MigrationMode_MIGRATION_MODE_DISTRIBUTED_PASSTHROUGH  MigrationMode = 3
	MigrationMode_MIGRATION_MODE_ONBOARDED                MigrationMode = 4
)

var MigrationMode_name = map[int32]string{
	0: "MIGRATION_MODE_INVALID",
	1: "MIGRATION_MODE_LOCAL_PASSTHROUGH",
	2: "MIGRATION_MODE_LOCAL_PASSTHROUGH_SHADOW",
	3: "MIGRATION_MODE_DISTRIBUTED_PASSTHROUGH",
	4: "MIGRATION_MODE_ONBOARDED",
}

var MigrationMode_value = map[string]int32{
	"MIGRATION_MODE_INVALID":                  0,
	"MIGRATION_MODE_LOCAL_PASSTHROUGH":        1,
	"MIGRATION_MODE_LOCAL_PASSTHROUGH_SHADOW": 2,
	"MIGRATION_MODE_DISTRIBUTED_PASSTHROUGH":  3,
	"MIGRATION_MODE_ONBOARDED":                4,
}

func (x MigrationMode) String() string {
	return proto.EnumName(MigrationMode_name, int32(x))
}

func (MigrationMode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5aab034437d08cca, []int{3}
}

type HeartbeatRequest struct {
	Namespace            string                        `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	ExecutorId           string                        `protobuf:"bytes,2,opt,name=executor_id,json=executorId,proto3" json:"executor_id,omitempty"`
	Status               ExecutorStatus                `protobuf:"varint,3,opt,name=status,proto3,enum=uber.cadence.sharddistributor.v1.ExecutorStatus" json:"status,omitempty"`
	ShardStatusReports   map[string]*ShardStatusReport `protobuf:"bytes,4,rep,name=shard_status_reports,json=shardStatusReports,proto3" json:"shard_status_reports,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

func (m *HeartbeatRequest) Reset()         { *m = HeartbeatRequest{} }
func (m *HeartbeatRequest) String() string { return proto.CompactTextString(m) }
func (*HeartbeatRequest) ProtoMessage()    {}
func (*HeartbeatRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_5aab034437d08cca, []int{0}
}
func (m *HeartbeatRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HeartbeatRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HeartbeatRequest.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 *HeartbeatRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HeartbeatRequest.Merge(m, src)
}
func (m *HeartbeatRequest) XXX_Size() int {
	return m.Size()
}
func (m *HeartbeatRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_HeartbeatRequest.DiscardUnknown(m)
}

var xxx_messageInfo_HeartbeatRequest proto.InternalMessageInfo

func (m *HeartbeatRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *HeartbeatRequest) GetExecutorId() string {
	if m != nil {
		return m.ExecutorId
	}
	return ""
}

func (m *HeartbeatRequest) GetStatus() ExecutorStatus {
	if m != nil {
		return m.Status
	}
	return ExecutorStatus_EXECUTOR_STATUS_INVALID
}

func (m *HeartbeatRequest) GetShardStatusReports() map[string]*ShardStatusReport {
	if m != nil {
		return m.ShardStatusReports
	}
	return nil
}

type ShardStatusReport struct {
	Status               ShardStatus `protobuf:"varint,1,opt,name=status,proto3,enum=uber.cadence.sharddistributor.v1.ShardStatus" json:"status,omitempty"`
	ShardLoad            float64     `protobuf:"fixed64,2,opt,name=shard_load,json=shardLoad,proto3" json:"shard_load,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *ShardStatusReport) Reset()         { *m = ShardStatusReport{} }
func (m *ShardStatusReport) String() string { return proto.CompactTextString(m) }
func (*ShardStatusReport) ProtoMessage()    {}
func (*ShardStatusReport) Descriptor() ([]byte, []int) {
	return fileDescriptor_5aab034437d08cca, []int{1}
}
func (m *ShardStatusReport) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ShardStatusReport) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ShardStatusReport.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 *ShardStatusReport) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShardStatusReport.Merge(m, src)
}
func (m *ShardStatusReport) XXX_Size() int {
	return m.Size()
}
func (m *ShardStatusReport) XXX_DiscardUnknown() {
	xxx_messageInfo_ShardStatusReport.DiscardUnknown(m)
}

var xxx_messageInfo_ShardStatusReport proto.InternalMessageInfo

func (m *ShardStatusReport) GetStatus() ShardStatus {
	if m != nil {
		return m.Status
	}
	return ShardStatus_SHARD_STATUS_INVALID
}

func (m *ShardStatusReport) GetShardLoad() float64 {
	if m != nil {
		return m.ShardLoad
	}
	return 0
}

type HeartbeatResponse struct {
	ShardAssignments     map[string]*ShardAssignment `protobuf:"bytes,1,rep,name=shard_assignments,json=shardAssignments,proto3" json:"shard_assignments,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	MigrationMode        MigrationMode               `protobuf:"varint,2,opt,name=migration_mode,json=migrationMode,proto3,enum=uber.cadence.sharddistributor.v1.MigrationMode" json:"migration_mode,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

func (m *HeartbeatResponse) Reset()         { *m = HeartbeatResponse{} }
func (m *HeartbeatResponse) String() string { return proto.CompactTextString(m) }
func (*HeartbeatResponse) ProtoMessage()    {}
func (*HeartbeatResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_5aab034437d08cca, []int{2}
}
func (m *HeartbeatResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HeartbeatResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HeartbeatResponse.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 *HeartbeatResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HeartbeatResponse.Merge(m, src)
}
func (m *HeartbeatResponse) XXX_Size() int {
	return m.Size()
}
func (m *HeartbeatResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_HeartbeatResponse.DiscardUnknown(m)
}

var xxx_messageInfo_HeartbeatResponse proto.InternalMessageInfo

func (m *HeartbeatResponse) GetShardAssignments() map[string]*ShardAssignment {
	if m != nil {
		return m.ShardAssignments
	}
	return nil
}

func (m *HeartbeatResponse) GetMigrationMode() MigrationMode {
	if m != nil {
		return m.MigrationMode
	}
	return MigrationMode_MIGRATION_MODE_INVALID
}

type ShardAssignment struct {
	Status               AssignmentStatus `protobuf:"varint,1,opt,name=status,proto3,enum=uber.cadence.sharddistributor.v1.AssignmentStatus" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *ShardAssignment) Reset()         { *m = ShardAssignment{} }
func (m *ShardAssignment) String() string { return proto.CompactTextString(m) }
func (*ShardAssignment) ProtoMessage()    {}
func (*ShardAssignment) Descriptor() ([]byte, []int) {
	return fileDescriptor_5aab034437d08cca, []int{3}
}
func (m *ShardAssignment) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ShardAssignment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ShardAssignment.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 *ShardAssignment) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShardAssignment.Merge(m, src)
}
func (m *ShardAssignment) XXX_Size() int {
	return m.Size()
}
func (m *ShardAssignment) XXX_DiscardUnknown() {
	xxx_messageInfo_ShardAssignment.DiscardUnknown(m)
}

var xxx_messageInfo_ShardAssignment proto.InternalMessageInfo

func (m *ShardAssignment) GetStatus() AssignmentStatus {
	if m != nil {
		return m.Status
	}
	return AssignmentStatus_ASSIGNMENT_STATUS_INVALID
}

func init() {
	proto.RegisterEnum("uber.cadence.sharddistributor.v1.ExecutorStatus", ExecutorStatus_name, ExecutorStatus_value)
	proto.RegisterEnum("uber.cadence.sharddistributor.v1.ShardStatus", ShardStatus_name, ShardStatus_value)
	proto.RegisterEnum("uber.cadence.sharddistributor.v1.AssignmentStatus", AssignmentStatus_name, AssignmentStatus_value)
	proto.RegisterEnum("uber.cadence.sharddistributor.v1.MigrationMode", MigrationMode_name, MigrationMode_value)
	proto.RegisterType((*HeartbeatRequest)(nil), "uber.cadence.sharddistributor.v1.HeartbeatRequest")
	proto.RegisterMapType((map[string]*ShardStatusReport)(nil), "uber.cadence.sharddistributor.v1.HeartbeatRequest.ShardStatusReportsEntry")
	proto.RegisterType((*ShardStatusReport)(nil), "uber.cadence.sharddistributor.v1.ShardStatusReport")
	proto.RegisterType((*HeartbeatResponse)(nil), "uber.cadence.sharddistributor.v1.HeartbeatResponse")
	proto.RegisterMapType((map[string]*ShardAssignment)(nil), "uber.cadence.sharddistributor.v1.HeartbeatResponse.ShardAssignmentsEntry")
	proto.RegisterType((*ShardAssignment)(nil), "uber.cadence.sharddistributor.v1.ShardAssignment")
}

func init() {
	proto.RegisterFile("uber/cadence/sharddistributor/v1/executor.proto", fileDescriptor_5aab034437d08cca)
}

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

func (m *HeartbeatRequest) 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 *HeartbeatRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HeartbeatRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.ShardStatusReports) > 0 {
		for k := range m.ShardStatusReports {
			v := m.ShardStatusReports[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintExecutor(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintExecutor(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintExecutor(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Status != 0 {
		i = encodeVarintExecutor(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x18
	}
	if len(m.ExecutorId) > 0 {
		i -= len(m.ExecutorId)
		copy(dAtA[i:], m.ExecutorId)
		i = encodeVarintExecutor(dAtA, i, uint64(len(m.ExecutorId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintExecutor(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ShardStatusReport) 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 *ShardStatusReport) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ShardStatusReport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ShardLoad != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ShardLoad))))
		i--
		dAtA[i] = 0x11
	}
	if m.Status != 0 {
		i = encodeVarintExecutor(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *HeartbeatResponse) 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 *HeartbeatResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HeartbeatResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.MigrationMode != 0 {
		i = encodeVarintExecutor(dAtA, i, uint64(m.MigrationMode))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ShardAssignments) > 0 {
		for k := range m.ShardAssignments {
			v := m.ShardAssignments[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintExecutor(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintExecutor(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintExecutor(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *ShardAssignment) 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 *ShardAssignment) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ShardAssignment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Status != 0 {
		i = encodeVarintExecutor(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintExecutor(dAtA []byte, offset int, v uint64) int {
	offset -= sovExecutor(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *HeartbeatRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovExecutor(uint64(l))
	}
	l = len(m.ExecutorId)
	if l > 0 {
		n += 1 + l + sovExecutor(uint64(l))
	}
	if m.Status != 0 {
		n += 1 + sovExecutor(uint64(m.Status))
	}
	if len(m.ShardStatusReports) > 0 {
		for k, v := range m.ShardStatusReports {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovExecutor(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovExecutor(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovExecutor(uint64(mapEntrySize))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ShardStatusReport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status != 0 {
		n += 1 + sovExecutor(uint64(m.Status))
	}
	if m.ShardLoad != 0 {
		n += 9
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *HeartbeatResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ShardAssignments) > 0 {
		for k, v := range m.ShardAssignments {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovExecutor(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovExecutor(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovExecutor(uint64(mapEntrySize))
		}
	}
	if m.MigrationMode != 0 {
		n += 1 + sovExecutor(uint64(m.MigrationMode))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ShardAssignment) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status != 0 {
		n += 1 + sovExecutor(uint64(m.Status))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovExecutor(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozExecutor(x uint64) (n int) {
	return sovExecutor(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *HeartbeatRequest) 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 ErrIntOverflowExecutor
			}
			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: HeartbeatRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HeartbeatRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExecutor
				}
				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 ErrInvalidLengthExecutor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExecutor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecutorId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExecutor
				}
				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 ErrInvalidLengthExecutor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExecutor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExecutorId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExecutor
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= ExecutorStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShardStatusReports", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExecutor
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExecutor
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExecutor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ShardStatusReports == nil {
				m.ShardStatusReports = make(map[string]*ShardStatusReport)
			}
			var mapkey string
			var mapvalue *ShardStatusReport
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowExecutor
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowExecutor
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthExecutor
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthExecutor
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowExecutor
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthExecutor
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthExecutor
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &ShardStatusReport{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipExecutor(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthExecutor
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.ShardStatusReports[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExecutor(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExecutor
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ShardStatusReport) 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 ErrIntOverflowExecutor
			}
			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: ShardStatusReport: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ShardStatusReport: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExecutor
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= ShardStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShardLoad", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.ShardLoad = float64(math.Float64frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipExecutor(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExecutor
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HeartbeatResponse) 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 ErrIntOverflowExecutor
			}
			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: HeartbeatResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HeartbeatResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShardAssignments", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExecutor
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExecutor
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExecutor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ShardAssignments == nil {
				m.ShardAssignments = make(map[string]*ShardAssignment)
			}
			var mapkey string
			var mapvalue *ShardAssignment
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowExecutor
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowExecutor
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthExecutor
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthExecutor
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowExecutor
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthExecutor
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthExecutor
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &ShardAssignment{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipExecutor(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthExecutor
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.ShardAssignments[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MigrationMode", wireType)
			}
			m.MigrationMode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExecutor
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MigrationMode |= MigrationMode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipExecutor(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExecutor
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ShardAssignment) 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 ErrIntOverflowExecutor
			}
			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: ShardAssignment: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ShardAssignment: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExecutor
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= AssignmentStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipExecutor(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExecutor
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipExecutor(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, ErrIntOverflowExecutor
			}
			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, ErrIntOverflowExecutor
				}
				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, ErrIntOverflowExecutor
				}
				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, ErrInvalidLengthExecutor
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupExecutor
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthExecutor
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthExecutor        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowExecutor          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupExecutor = fmt.Errorf("proto: unexpected end of group")
)
