types.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: greenfield/virtualgroup/types.proto

package types

import (
	fmt "fmt"
	_ "github.com/cosmos/cosmos-proto"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/cosmos/gogoproto/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

// A global virtual group consists of one primary SP (SP) and multiple secondary SP.
// Every global virtual group must belong to a GVG family, and the objects of each
// bucket must be stored in a GVG within a group family.
type GlobalVirtualGroup struct {
	// ID represents the unique identifier of the global virtual group.
	Id uint32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// Family ID represents the identifier of the GVG family that the group belongs to.
	FamilyId uint32 `protobuf:"varint,2,opt,name=family_id,json=familyId,proto3" json:"family_id,omitempty"`
	// Primary SP ID represents the unique identifier of the primary storage provider in the group.
	PrimarySpId uint32 `protobuf:"varint,3,opt,name=primary_sp_id,json=primarySpId,proto3" json:"primary_sp_id,omitempty"`
	// Secondary SP IDs represents the list of unique identifiers of the secondary storage providers in the group.
	SecondarySpIds []uint32 `protobuf:"varint,4,rep,packed,name=secondary_sp_ids,json=secondarySpIds,proto3" json:"secondary_sp_ids,omitempty"`
	// Stored size represents the size of the stored objects within the group.
	StoredSize uint64 `protobuf:"varint,5,opt,name=stored_size,json=storedSize,proto3" json:"stored_size,omitempty"`
	// Virtual payment address represents the payment address associated with the group.
	VirtualPaymentAddress string `protobuf:"bytes,6,opt,name=virtual_payment_address,json=virtualPaymentAddress,proto3" json:"virtual_payment_address,omitempty"`
	// Total deposit represents the number of tokens deposited by this storage provider for staking.
	TotalDeposit github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,7,opt,name=total_deposit,json=totalDeposit,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"total_deposit"`
}

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

var xxx_messageInfo_GlobalVirtualGroup proto.InternalMessageInfo

func (m *GlobalVirtualGroup) GetId() uint32 {
	if m != nil {
		return m.Id
	}
	return 0
}

func (m *GlobalVirtualGroup) GetFamilyId() uint32 {
	if m != nil {
		return m.FamilyId
	}
	return 0
}

func (m *GlobalVirtualGroup) GetPrimarySpId() uint32 {
	if m != nil {
		return m.PrimarySpId
	}
	return 0
}

func (m *GlobalVirtualGroup) GetSecondarySpIds() []uint32 {
	if m != nil {
		return m.SecondarySpIds
	}
	return nil
}

func (m *GlobalVirtualGroup) GetStoredSize() uint64 {
	if m != nil {
		return m.StoredSize
	}
	return 0
}

func (m *GlobalVirtualGroup) GetVirtualPaymentAddress() string {
	if m != nil {
		return m.VirtualPaymentAddress
	}
	return ""
}

// Global virtual group family serve as a means of grouping global virtual groups.
// Each bucket must be associated with a unique global virtual group family and cannot cross families.
type GlobalVirtualGroupFamily struct {
	// id is the identifier of the global virtual group family.
	Id uint32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// primary_sp_id
	PrimarySpId uint32 `protobuf:"varint,2,opt,name=primary_sp_id,json=primarySpId,proto3" json:"primary_sp_id,omitempty"`
	// global_virtual_group_ids is a list of identifiers of the global virtual groups associated with the family.
	GlobalVirtualGroupIds []uint32 `protobuf:"varint,3,rep,packed,name=global_virtual_group_ids,json=globalVirtualGroupIds,proto3" json:"global_virtual_group_ids,omitempty"`
	// virtual_payment_address is the payment address associated with the global virtual group family.
	VirtualPaymentAddress string `protobuf:"bytes,4,opt,name=virtual_payment_address,json=virtualPaymentAddress,proto3" json:"virtual_payment_address,omitempty"`
}

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

var xxx_messageInfo_GlobalVirtualGroupFamily proto.InternalMessageInfo

func (m *GlobalVirtualGroupFamily) GetId() uint32 {
	if m != nil {
		return m.Id
	}
	return 0
}

func (m *GlobalVirtualGroupFamily) GetPrimarySpId() uint32 {
	if m != nil {
		return m.PrimarySpId
	}
	return 0
}

func (m *GlobalVirtualGroupFamily) GetGlobalVirtualGroupIds() []uint32 {
	if m != nil {
		return m.GlobalVirtualGroupIds
	}
	return nil
}

func (m *GlobalVirtualGroupFamily) GetVirtualPaymentAddress() string {
	if m != nil {
		return m.VirtualPaymentAddress
	}
	return ""
}

type GlobalVirtualGroupsBindingOnBucket struct {
	// bucket_id is the unique identification for the bucket.
	BucketId Uint `protobuf:"bytes,1,opt,name=bucket_id,json=bucketId,proto3,customtype=Uint" json:"bucket_id"`
	// global_virtual_group_ids is a list of identifiers of the global virtual groups associated with the bucket.
	GlobalVirtualGroupIds []uint32 `protobuf:"varint,2,rep,packed,name=global_virtual_group_ids,json=globalVirtualGroupIds,proto3" json:"global_virtual_group_ids,omitempty"`
	// local_virtual_group_ids is a list of identifiers of the local virtual groups associated with the bucket.
	LocalVirtualGroupIds []uint32 `protobuf:"varint,3,rep,packed,name=local_virtual_group_ids,json=localVirtualGroupIds,proto3" json:"local_virtual_group_ids,omitempty"`
}

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

var xxx_messageInfo_GlobalVirtualGroupsBindingOnBucket proto.InternalMessageInfo

func (m *GlobalVirtualGroupsBindingOnBucket) GetGlobalVirtualGroupIds() []uint32 {
	if m != nil {
		return m.GlobalVirtualGroupIds
	}
	return nil
}

func (m *GlobalVirtualGroupsBindingOnBucket) GetLocalVirtualGroupIds() []uint32 {
	if m != nil {
		return m.LocalVirtualGroupIds
	}
	return nil
}

type GVGStatisticsWithinSP struct {
	// storage_provider_id defines the id of the sp which the statistics associated to
	StorageProviderId uint32 `protobuf:"varint,1,opt,name=storage_provider_id,json=storageProviderId,proto3" json:"storage_provider_id,omitempty"`
	// primary_count defines the number of global virtual groups (GVGs) which this sp serves as primary sp
	PrimaryCount uint32 `protobuf:"varint,2,opt,name=primary_count,json=primaryCount,proto3" json:"primary_count,omitempty"`
	// secondary_count defines the number of global virtual groups (GVGs) in
	// which this storage provider serves as a secondary storage provider.
	SecondaryCount uint32 `protobuf:"varint,3,opt,name=secondary_count,json=secondaryCount,proto3" json:"secondary_count,omitempty"`
	// Redundancy defines the number of gvg that sp serves as sp and secondary sp, which breaks the data redundancy requirement.
	// In most case, this should not happen,
	// during sp exit, a successor sp might need to swapIn GVG(s) that it is already a secondary and become the primary SP
	// of whole family.
	// a successor sp which need to swapIn a GVG as secondary must be unique to all other SP. So this will not be used for
	// swapIn individual GVG as secondary
	BreakRedundancyReqmtGvgCount uint32 `protobuf:"varint,4,opt,name=break_redundancy_reqmt_gvg_count,json=breakRedundancyReqmtGvgCount,proto3" json:"break_redundancy_reqmt_gvg_count,omitempty"`
}

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

var xxx_messageInfo_GVGStatisticsWithinSP proto.InternalMessageInfo

func (m *GVGStatisticsWithinSP) GetStorageProviderId() uint32 {
	if m != nil {
		return m.StorageProviderId
	}
	return 0
}

func (m *GVGStatisticsWithinSP) GetPrimaryCount() uint32 {
	if m != nil {
		return m.PrimaryCount
	}
	return 0
}

func (m *GVGStatisticsWithinSP) GetSecondaryCount() uint32 {
	if m != nil {
		return m.SecondaryCount
	}
	return 0
}

func (m *GVGStatisticsWithinSP) GetBreakRedundancyReqmtGvgCount() uint32 {
	if m != nil {
		return m.BreakRedundancyReqmtGvgCount
	}
	return 0
}

type GVGFamilyStatisticsWithinSP struct {
	// sp_id defines the id of the sp which the statistics associated to
	SpId uint32 `protobuf:"varint,1,opt,name=sp_id,json=spId,proto3" json:"sp_id,omitempty"`
	// global_virtual_group_family_ids is a list of identifiers of the global virtual group family associated with the SP.
	GlobalVirtualGroupFamilyIds []uint32 `protobuf:"varint,2,rep,packed,name=global_virtual_group_family_ids,json=globalVirtualGroupFamilyIds,proto3" json:"global_virtual_group_family_ids,omitempty"`
}

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

var xxx_messageInfo_GVGFamilyStatisticsWithinSP proto.InternalMessageInfo

func (m *GVGFamilyStatisticsWithinSP) GetSpId() uint32 {
	if m != nil {
		return m.SpId
	}
	return 0
}

func (m *GVGFamilyStatisticsWithinSP) GetGlobalVirtualGroupFamilyIds() []uint32 {
	if m != nil {
		return m.GlobalVirtualGroupFamilyIds
	}
	return nil
}

type SwapOutInfo struct {
	// sp_id is the unique id of the storage provider who want to swap out.
	SpId uint32 `protobuf:"varint,1,opt,name=sp_id,json=spId,proto3" json:"sp_id,omitempty"`
	// successor_sp_id is the id of the successor storage provider.
	SuccessorSpId uint32 `protobuf:"varint,2,opt,name=successor_sp_id,json=successorSpId,proto3" json:"successor_sp_id,omitempty"`
}

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

var xxx_messageInfo_SwapOutInfo proto.InternalMessageInfo

func (m *SwapOutInfo) GetSpId() uint32 {
	if m != nil {
		return m.SpId
	}
	return 0
}

func (m *SwapOutInfo) GetSuccessorSpId() uint32 {
	if m != nil {
		return m.SuccessorSpId
	}
	return 0
}

type SwapInInfo struct {
	// successor_sp_id defines the id of SP who wants to join the family or GVG
	SuccessorSpId uint32 `protobuf:"varint,1,opt,name=successor_sp_id,json=successorSpId,proto3" json:"successor_sp_id,omitempty"`
	// target_sp_id is the id of SP in the family or GVG to be swapped.
	TargetSpId uint32 `protobuf:"varint,2,opt,name=target_sp_id,json=targetSpId,proto3" json:"target_sp_id,omitempty"`
	// expiration_time is the expiration of epoch time for the swapInInfo
	ExpirationTime uint64 `protobuf:"varint,3,opt,name=expiration_time,json=expirationTime,proto3" json:"expiration_time,omitempty"`
}

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

var xxx_messageInfo_SwapInInfo proto.InternalMessageInfo

func (m *SwapInInfo) GetSuccessorSpId() uint32 {
	if m != nil {
		return m.SuccessorSpId
	}
	return 0
}

func (m *SwapInInfo) GetTargetSpId() uint32 {
	if m != nil {
		return m.TargetSpId
	}
	return 0
}

func (m *SwapInInfo) GetExpirationTime() uint64 {
	if m != nil {
		return m.ExpirationTime
	}
	return 0
}

func init() {
	proto.RegisterType((*GlobalVirtualGroup)(nil), "greenfield.virtualgroup.GlobalVirtualGroup")
	proto.RegisterType((*GlobalVirtualGroupFamily)(nil), "greenfield.virtualgroup.GlobalVirtualGroupFamily")
	proto.RegisterType((*GlobalVirtualGroupsBindingOnBucket)(nil), "greenfield.virtualgroup.GlobalVirtualGroupsBindingOnBucket")
	proto.RegisterType((*GVGStatisticsWithinSP)(nil), "greenfield.virtualgroup.GVGStatisticsWithinSP")
	proto.RegisterType((*GVGFamilyStatisticsWithinSP)(nil), "greenfield.virtualgroup.GVGFamilyStatisticsWithinSP")
	proto.RegisterType((*SwapOutInfo)(nil), "greenfield.virtualgroup.SwapOutInfo")
	proto.RegisterType((*SwapInInfo)(nil), "greenfield.virtualgroup.SwapInInfo")
}

func init() {
	proto.RegisterFile("greenfield/virtualgroup/types.proto", fileDescriptor_1fe6fc664532d0c3)
}

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

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

func (m *GlobalVirtualGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.TotalDeposit.Size()
		i -= size
		if _, err := m.TotalDeposit.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	if len(m.VirtualPaymentAddress) > 0 {
		i -= len(m.VirtualPaymentAddress)
		copy(dAtA[i:], m.VirtualPaymentAddress)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.VirtualPaymentAddress)))
		i--
		dAtA[i] = 0x32
	}
	if m.StoredSize != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.StoredSize))
		i--
		dAtA[i] = 0x28
	}
	if len(m.SecondarySpIds) > 0 {
		dAtA2 := make([]byte, len(m.SecondarySpIds)*10)
		var j1 int
		for _, num := range m.SecondarySpIds {
			for num >= 1<<7 {
				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA2[j1] = uint8(num)
			j1++
		}
		i -= j1
		copy(dAtA[i:], dAtA2[:j1])
		i = encodeVarintTypes(dAtA, i, uint64(j1))
		i--
		dAtA[i] = 0x22
	}
	if m.PrimarySpId != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.PrimarySpId))
		i--
		dAtA[i] = 0x18
	}
	if m.FamilyId != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.FamilyId))
		i--
		dAtA[i] = 0x10
	}
	if m.Id != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *GlobalVirtualGroupFamily) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.VirtualPaymentAddress) > 0 {
		i -= len(m.VirtualPaymentAddress)
		copy(dAtA[i:], m.VirtualPaymentAddress)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.VirtualPaymentAddress)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.GlobalVirtualGroupIds) > 0 {
		dAtA4 := make([]byte, len(m.GlobalVirtualGroupIds)*10)
		var j3 int
		for _, num := range m.GlobalVirtualGroupIds {
			for num >= 1<<7 {
				dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j3++
			}
			dAtA4[j3] = uint8(num)
			j3++
		}
		i -= j3
		copy(dAtA[i:], dAtA4[:j3])
		i = encodeVarintTypes(dAtA, i, uint64(j3))
		i--
		dAtA[i] = 0x1a
	}
	if m.PrimarySpId != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.PrimarySpId))
		i--
		dAtA[i] = 0x10
	}
	if m.Id != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *GlobalVirtualGroupsBindingOnBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.LocalVirtualGroupIds) > 0 {
		dAtA6 := make([]byte, len(m.LocalVirtualGroupIds)*10)
		var j5 int
		for _, num := range m.LocalVirtualGroupIds {
			for num >= 1<<7 {
				dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j5++
			}
			dAtA6[j5] = uint8(num)
			j5++
		}
		i -= j5
		copy(dAtA[i:], dAtA6[:j5])
		i = encodeVarintTypes(dAtA, i, uint64(j5))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.GlobalVirtualGroupIds) > 0 {
		dAtA8 := make([]byte, len(m.GlobalVirtualGroupIds)*10)
		var j7 int
		for _, num := range m.GlobalVirtualGroupIds {
			for num >= 1<<7 {
				dAtA8[j7] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j7++
			}
			dAtA8[j7] = uint8(num)
			j7++
		}
		i -= j7
		copy(dAtA[i:], dAtA8[:j7])
		i = encodeVarintTypes(dAtA, i, uint64(j7))
		i--
		dAtA[i] = 0x12
	}
	{
		size := m.BucketId.Size()
		i -= size
		if _, err := m.BucketId.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *GVGStatisticsWithinSP) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.BreakRedundancyReqmtGvgCount != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.BreakRedundancyReqmtGvgCount))
		i--
		dAtA[i] = 0x20
	}
	if m.SecondaryCount != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.SecondaryCount))
		i--
		dAtA[i] = 0x18
	}
	if m.PrimaryCount != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.PrimaryCount))
		i--
		dAtA[i] = 0x10
	}
	if m.StorageProviderId != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.StorageProviderId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *GVGFamilyStatisticsWithinSP) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.GlobalVirtualGroupFamilyIds) > 0 {
		dAtA10 := make([]byte, len(m.GlobalVirtualGroupFamilyIds)*10)
		var j9 int
		for _, num := range m.GlobalVirtualGroupFamilyIds {
			for num >= 1<<7 {
				dAtA10[j9] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j9++
			}
			dAtA10[j9] = uint8(num)
			j9++
		}
		i -= j9
		copy(dAtA[i:], dAtA10[:j9])
		i = encodeVarintTypes(dAtA, i, uint64(j9))
		i--
		dAtA[i] = 0x12
	}
	if m.SpId != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.SpId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *SwapOutInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SuccessorSpId != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.SuccessorSpId))
		i--
		dAtA[i] = 0x10
	}
	if m.SpId != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.SpId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *SwapInInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ExpirationTime != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.ExpirationTime))
		i--
		dAtA[i] = 0x18
	}
	if m.TargetSpId != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.TargetSpId))
		i--
		dAtA[i] = 0x10
	}
	if m.SuccessorSpId != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.SuccessorSpId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
	offset -= sovTypes(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *GlobalVirtualGroup) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovTypes(uint64(m.Id))
	}
	if m.FamilyId != 0 {
		n += 1 + sovTypes(uint64(m.FamilyId))
	}
	if m.PrimarySpId != 0 {
		n += 1 + sovTypes(uint64(m.PrimarySpId))
	}
	if len(m.SecondarySpIds) > 0 {
		l = 0
		for _, e := range m.SecondarySpIds {
			l += sovTypes(uint64(e))
		}
		n += 1 + sovTypes(uint64(l)) + l
	}
	if m.StoredSize != 0 {
		n += 1 + sovTypes(uint64(m.StoredSize))
	}
	l = len(m.VirtualPaymentAddress)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.TotalDeposit.Size()
	n += 1 + l + sovTypes(uint64(l))
	return n
}

func (m *GlobalVirtualGroupFamily) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovTypes(uint64(m.Id))
	}
	if m.PrimarySpId != 0 {
		n += 1 + sovTypes(uint64(m.PrimarySpId))
	}
	if len(m.GlobalVirtualGroupIds) > 0 {
		l = 0
		for _, e := range m.GlobalVirtualGroupIds {
			l += sovTypes(uint64(e))
		}
		n += 1 + sovTypes(uint64(l)) + l
	}
	l = len(m.VirtualPaymentAddress)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

func (m *GlobalVirtualGroupsBindingOnBucket) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.BucketId.Size()
	n += 1 + l + sovTypes(uint64(l))
	if len(m.GlobalVirtualGroupIds) > 0 {
		l = 0
		for _, e := range m.GlobalVirtualGroupIds {
			l += sovTypes(uint64(e))
		}
		n += 1 + sovTypes(uint64(l)) + l
	}
	if len(m.LocalVirtualGroupIds) > 0 {
		l = 0
		for _, e := range m.LocalVirtualGroupIds {
			l += sovTypes(uint64(e))
		}
		n += 1 + sovTypes(uint64(l)) + l
	}
	return n
}

func (m *GVGStatisticsWithinSP) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StorageProviderId != 0 {
		n += 1 + sovTypes(uint64(m.StorageProviderId))
	}
	if m.PrimaryCount != 0 {
		n += 1 + sovTypes(uint64(m.PrimaryCount))
	}
	if m.SecondaryCount != 0 {
		n += 1 + sovTypes(uint64(m.SecondaryCount))
	}
	if m.BreakRedundancyReqmtGvgCount != 0 {
		n += 1 + sovTypes(uint64(m.BreakRedundancyReqmtGvgCount))
	}
	return n
}

func (m *GVGFamilyStatisticsWithinSP) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SpId != 0 {
		n += 1 + sovTypes(uint64(m.SpId))
	}
	if len(m.GlobalVirtualGroupFamilyIds) > 0 {
		l = 0
		for _, e := range m.GlobalVirtualGroupFamilyIds {
			l += sovTypes(uint64(e))
		}
		n += 1 + sovTypes(uint64(l)) + l
	}
	return n
}

func (m *SwapOutInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SpId != 0 {
		n += 1 + sovTypes(uint64(m.SpId))
	}
	if m.SuccessorSpId != 0 {
		n += 1 + sovTypes(uint64(m.SuccessorSpId))
	}
	return n
}

func (m *SwapInInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SuccessorSpId != 0 {
		n += 1 + sovTypes(uint64(m.SuccessorSpId))
	}
	if m.TargetSpId != 0 {
		n += 1 + sovTypes(uint64(m.TargetSpId))
	}
	if m.ExpirationTime != 0 {
		n += 1 + sovTypes(uint64(m.ExpirationTime))
	}
	return n
}

func sovTypes(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTypes(x uint64) (n int) {
	return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *GlobalVirtualGroup) 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 ErrIntOverflowTypes
			}
			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: GlobalVirtualGroup: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalVirtualGroup: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FamilyId", wireType)
			}
			m.FamilyId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FamilyId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrimarySpId", wireType)
			}
			m.PrimarySpId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PrimarySpId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.SecondarySpIds = append(m.SecondarySpIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.SecondarySpIds) == 0 {
					m.SecondarySpIds = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.SecondarySpIds = append(m.SecondarySpIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field SecondarySpIds", wireType)
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StoredSize", wireType)
			}
			m.StoredSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StoredSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VirtualPaymentAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.VirtualPaymentAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalDeposit", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TotalDeposit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GlobalVirtualGroupFamily) 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 ErrIntOverflowTypes
			}
			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: GlobalVirtualGroupFamily: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalVirtualGroupFamily: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrimarySpId", wireType)
			}
			m.PrimarySpId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PrimarySpId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.GlobalVirtualGroupIds = append(m.GlobalVirtualGroupIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.GlobalVirtualGroupIds) == 0 {
					m.GlobalVirtualGroupIds = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.GlobalVirtualGroupIds = append(m.GlobalVirtualGroupIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalVirtualGroupIds", wireType)
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VirtualPaymentAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.VirtualPaymentAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GlobalVirtualGroupsBindingOnBucket) 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 ErrIntOverflowTypes
			}
			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: GlobalVirtualGroupsBindingOnBucket: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalVirtualGroupsBindingOnBucket: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BucketId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.BucketId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.GlobalVirtualGroupIds = append(m.GlobalVirtualGroupIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.GlobalVirtualGroupIds) == 0 {
					m.GlobalVirtualGroupIds = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.GlobalVirtualGroupIds = append(m.GlobalVirtualGroupIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalVirtualGroupIds", wireType)
			}
		case 3:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.LocalVirtualGroupIds = append(m.LocalVirtualGroupIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.LocalVirtualGroupIds) == 0 {
					m.LocalVirtualGroupIds = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.LocalVirtualGroupIds = append(m.LocalVirtualGroupIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field LocalVirtualGroupIds", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GVGStatisticsWithinSP) 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 ErrIntOverflowTypes
			}
			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: GVGStatisticsWithinSP: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GVGStatisticsWithinSP: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageProviderId", wireType)
			}
			m.StorageProviderId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StorageProviderId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrimaryCount", wireType)
			}
			m.PrimaryCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PrimaryCount |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecondaryCount", wireType)
			}
			m.SecondaryCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SecondaryCount |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BreakRedundancyReqmtGvgCount", wireType)
			}
			m.BreakRedundancyReqmtGvgCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BreakRedundancyReqmtGvgCount |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GVGFamilyStatisticsWithinSP) 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 ErrIntOverflowTypes
			}
			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: GVGFamilyStatisticsWithinSP: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GVGFamilyStatisticsWithinSP: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpId", wireType)
			}
			m.SpId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SpId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.GlobalVirtualGroupFamilyIds = append(m.GlobalVirtualGroupFamilyIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.GlobalVirtualGroupFamilyIds) == 0 {
					m.GlobalVirtualGroupFamilyIds = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.GlobalVirtualGroupFamilyIds = append(m.GlobalVirtualGroupFamilyIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalVirtualGroupFamilyIds", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SwapInInfo) 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 ErrIntOverflowTypes
			}
			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: SwapInInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SwapInInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SuccessorSpId", wireType)
			}
			m.SuccessorSpId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SuccessorSpId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetSpId", wireType)
			}
			m.TargetSpId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TargetSpId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpirationTime", wireType)
			}
			m.ExpirationTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExpirationTime |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthTypes        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTypes          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group")
)