types.pb.go

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

package types

import (
	fmt "fmt"
	_ "github.com/bnb-chain/greenfield/x/payment/types"
	_ "github.com/cosmos/cosmos-proto"
	_ "github.com/cosmos/cosmos-sdk/types"
	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

type BucketInfo struct {
	// owner is the account address of bucket creator, it is also the bucket owner.
	Owner string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"`
	// bucket_name is a globally unique name of bucket
	BucketName string `protobuf:"bytes,2,opt,name=bucket_name,json=bucketName,proto3" json:"bucket_name,omitempty"`
	// visibility defines the highest permissions for bucket. When a bucket is public, everyone can get storage objects in it.
	Visibility VisibilityType `protobuf:"varint,3,opt,name=visibility,proto3,enum=greenfield.storage.VisibilityType" json:"visibility,omitempty"`
	// id is the unique identification for bucket.
	Id Uint `protobuf:"bytes,4,opt,name=id,proto3,customtype=Uint" json:"id"`
	// source_type defines which chain the user should send the bucket management transactions to
	SourceType SourceType `protobuf:"varint,5,opt,name=source_type,json=sourceType,proto3,enum=greenfield.storage.SourceType" json:"source_type,omitempty"`
	// create_at define the block timestamp when the bucket created.
	CreateAt int64 `protobuf:"varint,6,opt,name=create_at,json=createAt,proto3" json:"create_at,omitempty"`
	// payment_address is the address of the payment account
	PaymentAddress string `protobuf:"bytes,7,opt,name=payment_address,json=paymentAddress,proto3" json:"payment_address,omitempty"`
	// global_virtual_group_family_id defines the unique id of gvg family
	GlobalVirtualGroupFamilyId uint32 `protobuf:"varint,8,opt,name=global_virtual_group_family_id,json=globalVirtualGroupFamilyId,proto3" json:"global_virtual_group_family_id,omitempty"`
	// charged_read_quota defines the traffic quota for read in bytes per month.
	// The available read data for each user is the sum of the free read data provided by SP and
	// the ChargeReadQuota specified here.
	ChargedReadQuota uint64 `protobuf:"varint,9,opt,name=charged_read_quota,json=chargedReadQuota,proto3" json:"charged_read_quota,omitempty"`
	// bucket_status define the status of the bucket.
	BucketStatus BucketStatus `protobuf:"varint,10,opt,name=bucket_status,json=bucketStatus,proto3,enum=greenfield.storage.BucketStatus" json:"bucket_status,omitempty"`
	// tags defines a list of tags the bucket has
	Tags *ResourceTags `protobuf:"bytes,11,opt,name=tags,proto3" json:"tags,omitempty"`
	// sp_as_delegated_agent_disabled indicates that whether bucket owner disable SP as the upload agent.
	// when a bucket is created, by default, this is false, means SP is allowed to create object for delegator
	SpAsDelegatedAgentDisabled bool `protobuf:"varint,12,opt,name=sp_as_delegated_agent_disabled,json=spAsDelegatedAgentDisabled,proto3" json:"sp_as_delegated_agent_disabled,omitempty"`
}

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

var xxx_messageInfo_BucketInfo proto.InternalMessageInfo

func (m *BucketInfo) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

func (m *BucketInfo) GetBucketName() string {
	if m != nil {
		return m.BucketName
	}
	return ""
}

func (m *BucketInfo) GetVisibility() VisibilityType {
	if m != nil {
		return m.Visibility
	}
	return VISIBILITY_TYPE_UNSPECIFIED
}

func (m *BucketInfo) GetSourceType() SourceType {
	if m != nil {
		return m.SourceType
	}
	return SOURCE_TYPE_ORIGIN
}

func (m *BucketInfo) GetCreateAt() int64 {
	if m != nil {
		return m.CreateAt
	}
	return 0
}

func (m *BucketInfo) GetPaymentAddress() string {
	if m != nil {
		return m.PaymentAddress
	}
	return ""
}

func (m *BucketInfo) GetGlobalVirtualGroupFamilyId() uint32 {
	if m != nil {
		return m.GlobalVirtualGroupFamilyId
	}
	return 0
}

func (m *BucketInfo) GetChargedReadQuota() uint64 {
	if m != nil {
		return m.ChargedReadQuota
	}
	return 0
}

func (m *BucketInfo) GetBucketStatus() BucketStatus {
	if m != nil {
		return m.BucketStatus
	}
	return BUCKET_STATUS_CREATED
}

func (m *BucketInfo) GetTags() *ResourceTags {
	if m != nil {
		return m.Tags
	}
	return nil
}

func (m *BucketInfo) GetSpAsDelegatedAgentDisabled() bool {
	if m != nil {
		return m.SpAsDelegatedAgentDisabled
	}
	return false
}

type InternalBucketInfo struct {
	// the time of the payment price, used to calculate the charge rate of the bucket
	PriceTime int64 `protobuf:"varint,1,opt,name=price_time,json=priceTime,proto3" json:"price_time,omitempty"`
	// the total size of the objects in the bucket, used to calculate the charge rate of the bucket
	TotalChargeSize uint64 `protobuf:"varint,2,opt,name=total_charge_size,json=totalChargeSize,proto3" json:"total_charge_size,omitempty"`
	// local_virtual_groups contains all the lvg of this bucket.
	LocalVirtualGroups []*LocalVirtualGroup `protobuf:"bytes,3,rep,name=local_virtual_groups,json=localVirtualGroups,proto3" json:"local_virtual_groups,omitempty"`
	// next_local_virtual_group_id store the next id used by local virtual group
	NextLocalVirtualGroupId uint32 `protobuf:"varint,4,opt,name=next_local_virtual_group_id,json=nextLocalVirtualGroupId,proto3" json:"next_local_virtual_group_id,omitempty"`
}

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

var xxx_messageInfo_InternalBucketInfo proto.InternalMessageInfo

func (m *InternalBucketInfo) GetPriceTime() int64 {
	if m != nil {
		return m.PriceTime
	}
	return 0
}

func (m *InternalBucketInfo) GetTotalChargeSize() uint64 {
	if m != nil {
		return m.TotalChargeSize
	}
	return 0
}

func (m *InternalBucketInfo) GetLocalVirtualGroups() []*LocalVirtualGroup {
	if m != nil {
		return m.LocalVirtualGroups
	}
	return nil
}

func (m *InternalBucketInfo) GetNextLocalVirtualGroupId() uint32 {
	if m != nil {
		return m.NextLocalVirtualGroupId
	}
	return 0
}

type ObjectInfo struct {
	// owner is the object owner
	Owner string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"`
	// creator is the address of the uploader, it always be same as owner address
	Creator string `protobuf:"bytes,2,opt,name=creator,proto3" json:"creator,omitempty"`
	// bucket_name is the name of the bucket
	BucketName string `protobuf:"bytes,3,opt,name=bucket_name,json=bucketName,proto3" json:"bucket_name,omitempty"`
	// object_name is the name of object
	ObjectName string `protobuf:"bytes,4,opt,name=object_name,json=objectName,proto3" json:"object_name,omitempty"`
	// id is the unique identifier of object
	Id                  Uint   `protobuf:"bytes,5,opt,name=id,proto3,customtype=Uint" json:"id"`
	LocalVirtualGroupId uint32 `protobuf:"varint,6,opt,name=local_virtual_group_id,json=localVirtualGroupId,proto3" json:"local_virtual_group_id,omitempty"`
	// payloadSize is the total size of the object payload
	PayloadSize uint64 `protobuf:"varint,7,opt,name=payload_size,json=payloadSize,proto3" json:"payload_size,omitempty"`
	// visibility defines the highest permissions for object. When an object is public, everyone can access it.
	Visibility VisibilityType `protobuf:"varint,8,opt,name=visibility,proto3,enum=greenfield.storage.VisibilityType" json:"visibility,omitempty"`
	// content_type define the format of the object which should be a standard MIME type.
	ContentType string `protobuf:"bytes,9,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"`
	// create_at define the block timestamp when the object is created
	CreateAt int64 `protobuf:"varint,10,opt,name=create_at,json=createAt,proto3" json:"create_at,omitempty"`
	// object_status define the upload status of the object.
	ObjectStatus ObjectStatus `protobuf:"varint,11,opt,name=object_status,json=objectStatus,proto3,enum=greenfield.storage.ObjectStatus" json:"object_status,omitempty"`
	// redundancy_type define the type of the redundancy which can be multi-replication or EC.
	RedundancyType RedundancyType `protobuf:"varint,12,opt,name=redundancy_type,json=redundancyType,proto3,enum=greenfield.storage.RedundancyType" json:"redundancy_type,omitempty"`
	// source_type define the source of the object.
	SourceType SourceType `protobuf:"varint,13,opt,name=source_type,json=sourceType,proto3,enum=greenfield.storage.SourceType" json:"source_type,omitempty"`
	// checksums define the root hash of the pieces which stored in a SP.
	// add omit tag to omit the field when converting to NFT metadata
	Checksums [][]byte `protobuf:"bytes,14,rep,name=checksums,proto3" json:"checksums,omitempty" traits:"omit"`
	// tags defines a list of tags the object has
	Tags *ResourceTags `protobuf:"bytes,15,opt,name=tags,proto3" json:"tags,omitempty"`
	// is_updating indicates whether a object is being updated.
	IsUpdating bool `protobuf:"varint,16,opt,name=is_updating,json=isUpdating,proto3" json:"is_updating,omitempty"`
	// updated_at define the block timestamp when the object is updated. Will not be visible until object is re-sealed.
	UpdatedAt int64 `protobuf:"varint,17,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// updated_by defined the account address of updater(if there is). Will not be visible until object is re-sealed.
	UpdatedBy string `protobuf:"bytes,18,opt,name=updated_by,json=updatedBy,proto3" json:"updated_by,omitempty"`
	// version define the version of object
	Version int64 `protobuf:"varint,19,opt,name=version,proto3" json:"version,omitempty"`
}

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

var xxx_messageInfo_ObjectInfo proto.InternalMessageInfo

func (m *ObjectInfo) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

func (m *ObjectInfo) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *ObjectInfo) GetBucketName() string {
	if m != nil {
		return m.BucketName
	}
	return ""
}

func (m *ObjectInfo) GetObjectName() string {
	if m != nil {
		return m.ObjectName
	}
	return ""
}

func (m *ObjectInfo) GetLocalVirtualGroupId() uint32 {
	if m != nil {
		return m.LocalVirtualGroupId
	}
	return 0
}

func (m *ObjectInfo) GetPayloadSize() uint64 {
	if m != nil {
		return m.PayloadSize
	}
	return 0
}

func (m *ObjectInfo) GetVisibility() VisibilityType {
	if m != nil {
		return m.Visibility
	}
	return VISIBILITY_TYPE_UNSPECIFIED
}

func (m *ObjectInfo) GetContentType() string {
	if m != nil {
		return m.ContentType
	}
	return ""
}

func (m *ObjectInfo) GetCreateAt() int64 {
	if m != nil {
		return m.CreateAt
	}
	return 0
}

func (m *ObjectInfo) GetObjectStatus() ObjectStatus {
	if m != nil {
		return m.ObjectStatus
	}
	return OBJECT_STATUS_CREATED
}

func (m *ObjectInfo) GetRedundancyType() RedundancyType {
	if m != nil {
		return m.RedundancyType
	}
	return REDUNDANCY_EC_TYPE
}

func (m *ObjectInfo) GetSourceType() SourceType {
	if m != nil {
		return m.SourceType
	}
	return SOURCE_TYPE_ORIGIN
}

func (m *ObjectInfo) GetChecksums() [][]byte {
	if m != nil {
		return m.Checksums
	}
	return nil
}

func (m *ObjectInfo) GetTags() *ResourceTags {
	if m != nil {
		return m.Tags
	}
	return nil
}

func (m *ObjectInfo) GetIsUpdating() bool {
	if m != nil {
		return m.IsUpdating
	}
	return false
}

func (m *ObjectInfo) GetUpdatedAt() int64 {
	if m != nil {
		return m.UpdatedAt
	}
	return 0
}

func (m *ObjectInfo) GetUpdatedBy() string {
	if m != nil {
		return m.UpdatedBy
	}
	return ""
}

func (m *ObjectInfo) GetVersion() int64 {
	if m != nil {
		return m.Version
	}
	return 0
}

type GroupInfo struct {
	// owner is the owner of the group. It can not changed once it created.
	Owner string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"`
	// group_name is the name of group which is unique under an account.
	GroupName string `protobuf:"bytes,2,opt,name=group_name,json=groupName,proto3" json:"group_name,omitempty"`
	// source_type
	SourceType SourceType `protobuf:"varint,3,opt,name=source_type,json=sourceType,proto3,enum=greenfield.storage.SourceType" json:"source_type,omitempty"`
	// id is the unique identifier of group
	Id Uint `protobuf:"bytes,4,opt,name=id,proto3,customtype=Uint" json:"id"`
	// extra is used to store extra info for the group
	Extra string `protobuf:"bytes,5,opt,name=extra,proto3" json:"extra,omitempty"`
	// tags defines a list of tags the group has
	Tags *ResourceTags `protobuf:"bytes,6,opt,name=tags,proto3" json:"tags,omitempty"`
}

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

var xxx_messageInfo_GroupInfo proto.InternalMessageInfo

func (m *GroupInfo) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

func (m *GroupInfo) GetGroupName() string {
	if m != nil {
		return m.GroupName
	}
	return ""
}

func (m *GroupInfo) GetSourceType() SourceType {
	if m != nil {
		return m.SourceType
	}
	return SOURCE_TYPE_ORIGIN
}

func (m *GroupInfo) GetExtra() string {
	if m != nil {
		return m.Extra
	}
	return ""
}

func (m *GroupInfo) GetTags() *ResourceTags {
	if m != nil {
		return m.Tags
	}
	return nil
}

type Trait struct {
	TraitType string `protobuf:"bytes,1,opt,name=trait_type,json=traitType,proto3" json:"trait_type,omitempty"`
	Value     string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_Trait proto.InternalMessageInfo

func (m *Trait) GetTraitType() string {
	if m != nil {
		return m.TraitType
	}
	return ""
}

func (m *Trait) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type BucketMetaData struct {
	// description
	Description string `protobuf:"bytes,1,opt,name=description,proto3" json:"description,omitempty"`
	// externalUrl a link to external site to view NFT
	ExternalUrl string `protobuf:"bytes,2,opt,name=external_url,json=externalUrl,proto3" json:"external_url,omitempty"`
	// name of bucket NFT
	BucketName string `protobuf:"bytes,3,opt,name=bucket_name,json=bucketName,proto3" json:"bucket_name,omitempty"`
	// image is the link to image
	Image string `protobuf:"bytes,4,opt,name=image,proto3" json:"image,omitempty"`
	// attributes
	Attributes []Trait `protobuf:"bytes,5,rep,name=attributes,proto3" json:"attributes"`
}

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

var xxx_messageInfo_BucketMetaData proto.InternalMessageInfo

func (m *BucketMetaData) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *BucketMetaData) GetExternalUrl() string {
	if m != nil {
		return m.ExternalUrl
	}
	return ""
}

func (m *BucketMetaData) GetBucketName() string {
	if m != nil {
		return m.BucketName
	}
	return ""
}

func (m *BucketMetaData) GetImage() string {
	if m != nil {
		return m.Image
	}
	return ""
}

func (m *BucketMetaData) GetAttributes() []Trait {
	if m != nil {
		return m.Attributes
	}
	return nil
}

type ObjectMetaData struct {
	// description
	Description string `protobuf:"bytes,1,opt,name=description,proto3" json:"description,omitempty"`
	// externalUrl a link to external site to view NFT
	ExternalUrl string `protobuf:"bytes,2,opt,name=external_url,json=externalUrl,proto3" json:"external_url,omitempty"`
	// name of object NFT
	ObjectName string `protobuf:"bytes,3,opt,name=object_name,json=objectName,proto3" json:"object_name,omitempty"`
	// image is the link to image
	Image string `protobuf:"bytes,4,opt,name=image,proto3" json:"image,omitempty"`
	// attributes
	Attributes []Trait `protobuf:"bytes,5,rep,name=attributes,proto3" json:"attributes"`
}

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

var xxx_messageInfo_ObjectMetaData proto.InternalMessageInfo

func (m *ObjectMetaData) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *ObjectMetaData) GetExternalUrl() string {
	if m != nil {
		return m.ExternalUrl
	}
	return ""
}

func (m *ObjectMetaData) GetObjectName() string {
	if m != nil {
		return m.ObjectName
	}
	return ""
}

func (m *ObjectMetaData) GetImage() string {
	if m != nil {
		return m.Image
	}
	return ""
}

func (m *ObjectMetaData) GetAttributes() []Trait {
	if m != nil {
		return m.Attributes
	}
	return nil
}

type GroupMetaData struct {
	// description
	Description string `protobuf:"bytes,1,opt,name=description,proto3" json:"description,omitempty"`
	// externalUrl a link to external site to view NFT
	ExternalUrl string `protobuf:"bytes,2,opt,name=external_url,json=externalUrl,proto3" json:"external_url,omitempty"`
	// name of group NFT
	GroupName string `protobuf:"bytes,3,opt,name=group_name,json=groupName,proto3" json:"group_name,omitempty"`
	// image is the link to image
	Image string `protobuf:"bytes,4,opt,name=image,proto3" json:"image,omitempty"`
	// attributes
	Attributes []Trait `protobuf:"bytes,5,rep,name=attributes,proto3" json:"attributes"`
}

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

var xxx_messageInfo_GroupMetaData proto.InternalMessageInfo

func (m *GroupMetaData) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *GroupMetaData) GetExternalUrl() string {
	if m != nil {
		return m.ExternalUrl
	}
	return ""
}

func (m *GroupMetaData) GetGroupName() string {
	if m != nil {
		return m.GroupName
	}
	return ""
}

func (m *GroupMetaData) GetImage() string {
	if m != nil {
		return m.Image
	}
	return ""
}

func (m *GroupMetaData) GetAttributes() []Trait {
	if m != nil {
		return m.Attributes
	}
	return nil
}

type Ids struct {
	// ids of the objects or buckets
	Id []Uint `protobuf:"bytes,1,rep,name=id,proto3,customtype=Uint" json:"id"`
}

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

var xxx_messageInfo_Ids proto.InternalMessageInfo

type DeleteInfo struct {
	BucketIds *Ids `protobuf:"bytes,1,opt,name=bucket_ids,json=bucketIds,proto3" json:"bucket_ids,omitempty"`
	ObjectIds *Ids `protobuf:"bytes,2,opt,name=object_ids,json=objectIds,proto3" json:"object_ids,omitempty"`
	GroupIds  *Ids `protobuf:"bytes,3,opt,name=group_ids,json=groupIds,proto3" json:"group_ids,omitempty"`
}

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

var xxx_messageInfo_DeleteInfo proto.InternalMessageInfo

func (m *DeleteInfo) GetBucketIds() *Ids {
	if m != nil {
		return m.BucketIds
	}
	return nil
}

func (m *DeleteInfo) GetObjectIds() *Ids {
	if m != nil {
		return m.ObjectIds
	}
	return nil
}

func (m *DeleteInfo) GetGroupIds() *Ids {
	if m != nil {
		return m.GroupIds
	}
	return nil
}

type MigrationBucketInfo struct {
	SrcSpId                       uint32 `protobuf:"varint,1,opt,name=src_sp_id,json=srcSpId,proto3" json:"src_sp_id,omitempty"`
	SrcGlobalVirtualGroupFamilyId uint32 `protobuf:"varint,2,opt,name=src_global_virtual_group_family_id,json=srcGlobalVirtualGroupFamilyId,proto3" json:"src_global_virtual_group_family_id,omitempty"`
	DstSpId                       uint32 `protobuf:"varint,3,opt,name=dst_sp_id,json=dstSpId,proto3" json:"dst_sp_id,omitempty"`
	// id is the unique identifier of bucket
	BucketId Uint `protobuf:"bytes,4,opt,name=bucket_id,json=bucketId,proto3,customtype=Uint" json:"bucket_id"`
}

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

var xxx_messageInfo_MigrationBucketInfo proto.InternalMessageInfo

func (m *MigrationBucketInfo) GetSrcSpId() uint32 {
	if m != nil {
		return m.SrcSpId
	}
	return 0
}

func (m *MigrationBucketInfo) GetSrcGlobalVirtualGroupFamilyId() uint32 {
	if m != nil {
		return m.SrcGlobalVirtualGroupFamilyId
	}
	return 0
}

func (m *MigrationBucketInfo) GetDstSpId() uint32 {
	if m != nil {
		return m.DstSpId
	}
	return 0
}

type ResourceTags struct {
	// tags defines a list of tags the resource has
	Tags []ResourceTags_Tag `protobuf:"bytes,1,rep,name=tags,proto3" json:"tags"`
}

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

var xxx_messageInfo_ResourceTags proto.InternalMessageInfo

func (m *ResourceTags) GetTags() []ResourceTags_Tag {
	if m != nil {
		return m.Tags
	}
	return nil
}

type ResourceTags_Tag struct {
	Key   string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_ResourceTags_Tag proto.InternalMessageInfo

func (m *ResourceTags_Tag) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *ResourceTags_Tag) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type ShadowObjectInfo struct {
	// operator defines the account address of the operator, either the object owner or the updater with granted permission.
	Operator string `protobuf:"bytes,1,opt,name=operator,proto3" json:"operator,omitempty"`
	// id defines the object id
	Id Uint `protobuf:"bytes,2,opt,name=id,proto3,customtype=Uint" json:"id"`
	// content_type define the content type of the payload data
	ContentType string `protobuf:"bytes,3,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"`
	// payload_size is the total size of the object payload
	PayloadSize uint64 `protobuf:"varint,4,opt,name=payload_size,json=payloadSize,proto3" json:"payload_size,omitempty"`
	// checksums define the root hash of the pieces which stored in a SP.
	Checksums [][]byte `protobuf:"bytes,5,rep,name=checksums,proto3" json:"checksums,omitempty" traits:"omit"`
	// updated_at define the block timestamp when the object is updated
	UpdatedAt int64 `protobuf:"varint,6,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// version define the version of object
	Version int64 `protobuf:"varint,7,opt,name=version,proto3" json:"version,omitempty"`
}

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

var xxx_messageInfo_ShadowObjectInfo proto.InternalMessageInfo

func (m *ShadowObjectInfo) GetOperator() string {
	if m != nil {
		return m.Operator
	}
	return ""
}

func (m *ShadowObjectInfo) GetContentType() string {
	if m != nil {
		return m.ContentType
	}
	return ""
}

func (m *ShadowObjectInfo) GetPayloadSize() uint64 {
	if m != nil {
		return m.PayloadSize
	}
	return 0
}

func (m *ShadowObjectInfo) GetChecksums() [][]byte {
	if m != nil {
		return m.Checksums
	}
	return nil
}

func (m *ShadowObjectInfo) GetUpdatedAt() int64 {
	if m != nil {
		return m.UpdatedAt
	}
	return 0
}

func (m *ShadowObjectInfo) GetVersion() int64 {
	if m != nil {
		return m.Version
	}
	return 0
}

type BucketExtraInfo struct {
	IsRateLimited   bool                                   `protobuf:"varint,1,opt,name=is_rate_limited,json=isRateLimited,proto3" json:"is_rate_limited,omitempty"`
	FlowRateLimit   github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=flow_rate_limit,json=flowRateLimit,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"flow_rate_limit"`
	CurrentFlowRate github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=current_flow_rate,json=currentFlowRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"current_flow_rate"`
}

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

var xxx_messageInfo_BucketExtraInfo proto.InternalMessageInfo

func (m *BucketExtraInfo) GetIsRateLimited() bool {
	if m != nil {
		return m.IsRateLimited
	}
	return false
}

func init() {
	proto.RegisterType((*BucketInfo)(nil), "greenfield.storage.BucketInfo")
	proto.RegisterType((*InternalBucketInfo)(nil), "greenfield.storage.InternalBucketInfo")
	proto.RegisterType((*ObjectInfo)(nil), "greenfield.storage.ObjectInfo")
	proto.RegisterType((*GroupInfo)(nil), "greenfield.storage.GroupInfo")
	proto.RegisterType((*Trait)(nil), "greenfield.storage.Trait")
	proto.RegisterType((*BucketMetaData)(nil), "greenfield.storage.BucketMetaData")
	proto.RegisterType((*ObjectMetaData)(nil), "greenfield.storage.ObjectMetaData")
	proto.RegisterType((*GroupMetaData)(nil), "greenfield.storage.GroupMetaData")
	proto.RegisterType((*Ids)(nil), "greenfield.storage.Ids")
	proto.RegisterType((*DeleteInfo)(nil), "greenfield.storage.DeleteInfo")
	proto.RegisterType((*MigrationBucketInfo)(nil), "greenfield.storage.MigrationBucketInfo")
	proto.RegisterType((*ResourceTags)(nil), "greenfield.storage.ResourceTags")
	proto.RegisterType((*ResourceTags_Tag)(nil), "greenfield.storage.ResourceTags.Tag")
	proto.RegisterType((*ShadowObjectInfo)(nil), "greenfield.storage.ShadowObjectInfo")
	proto.RegisterType((*BucketExtraInfo)(nil), "greenfield.storage.BucketExtraInfo")
}

func init() { proto.RegisterFile("greenfield/storage/types.proto", fileDescriptor_bf95fa2efdc74d97) }

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

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

func (m *BucketInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SpAsDelegatedAgentDisabled {
		i--
		if m.SpAsDelegatedAgentDisabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x60
	}
	if m.Tags != nil {
		{
			size, err := m.Tags.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	if m.BucketStatus != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.BucketStatus))
		i--
		dAtA[i] = 0x50
	}
	if m.ChargedReadQuota != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.ChargedReadQuota))
		i--
		dAtA[i] = 0x48
	}
	if m.GlobalVirtualGroupFamilyId != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.GlobalVirtualGroupFamilyId))
		i--
		dAtA[i] = 0x40
	}
	if len(m.PaymentAddress) > 0 {
		i -= len(m.PaymentAddress)
		copy(dAtA[i:], m.PaymentAddress)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.PaymentAddress)))
		i--
		dAtA[i] = 0x3a
	}
	if m.CreateAt != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.CreateAt))
		i--
		dAtA[i] = 0x30
	}
	if m.SourceType != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.SourceType))
		i--
		dAtA[i] = 0x28
	}
	{
		size := m.Id.Size()
		i -= size
		if _, err := m.Id.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.Visibility != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Visibility))
		i--
		dAtA[i] = 0x18
	}
	if len(m.BucketName) > 0 {
		i -= len(m.BucketName)
		copy(dAtA[i:], m.BucketName)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.BucketName)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Owner) > 0 {
		i -= len(m.Owner)
		copy(dAtA[i:], m.Owner)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Owner)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *InternalBucketInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NextLocalVirtualGroupId != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.NextLocalVirtualGroupId))
		i--
		dAtA[i] = 0x20
	}
	if len(m.LocalVirtualGroups) > 0 {
		for iNdEx := len(m.LocalVirtualGroups) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LocalVirtualGroups[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.TotalChargeSize != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.TotalChargeSize))
		i--
		dAtA[i] = 0x10
	}
	if m.PriceTime != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.PriceTime))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *ObjectInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Version != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Version))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x98
	}
	if len(m.UpdatedBy) > 0 {
		i -= len(m.UpdatedBy)
		copy(dAtA[i:], m.UpdatedBy)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.UpdatedBy)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x92
	}
	if m.UpdatedAt != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.UpdatedAt))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x88
	}
	if m.IsUpdating {
		i--
		if m.IsUpdating {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x80
	}
	if m.Tags != nil {
		{
			size, err := m.Tags.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7a
	}
	if len(m.Checksums) > 0 {
		for iNdEx := len(m.Checksums) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Checksums[iNdEx])
			copy(dAtA[i:], m.Checksums[iNdEx])
			i = encodeVarintTypes(dAtA, i, uint64(len(m.Checksums[iNdEx])))
			i--
			dAtA[i] = 0x72
		}
	}
	if m.SourceType != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.SourceType))
		i--
		dAtA[i] = 0x68
	}
	if m.RedundancyType != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.RedundancyType))
		i--
		dAtA[i] = 0x60
	}
	if m.ObjectStatus != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.ObjectStatus))
		i--
		dAtA[i] = 0x58
	}
	if m.CreateAt != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.CreateAt))
		i--
		dAtA[i] = 0x50
	}
	if len(m.ContentType) > 0 {
		i -= len(m.ContentType)
		copy(dAtA[i:], m.ContentType)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.ContentType)))
		i--
		dAtA[i] = 0x4a
	}
	if m.Visibility != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Visibility))
		i--
		dAtA[i] = 0x40
	}
	if m.PayloadSize != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.PayloadSize))
		i--
		dAtA[i] = 0x38
	}
	if m.LocalVirtualGroupId != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.LocalVirtualGroupId))
		i--
		dAtA[i] = 0x30
	}
	{
		size := m.Id.Size()
		i -= size
		if _, err := m.Id.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if len(m.ObjectName) > 0 {
		i -= len(m.ObjectName)
		copy(dAtA[i:], m.ObjectName)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.ObjectName)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.BucketName) > 0 {
		i -= len(m.BucketName)
		copy(dAtA[i:], m.BucketName)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.BucketName)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Owner) > 0 {
		i -= len(m.Owner)
		copy(dAtA[i:], m.Owner)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Owner)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *GroupInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Tags != nil {
		{
			size, err := m.Tags.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if len(m.Extra) > 0 {
		i -= len(m.Extra)
		copy(dAtA[i:], m.Extra)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Extra)))
		i--
		dAtA[i] = 0x2a
	}
	{
		size := m.Id.Size()
		i -= size
		if _, err := m.Id.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.SourceType != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.SourceType))
		i--
		dAtA[i] = 0x18
	}
	if len(m.GroupName) > 0 {
		i -= len(m.GroupName)
		copy(dAtA[i:], m.GroupName)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.GroupName)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Owner) > 0 {
		i -= len(m.Owner)
		copy(dAtA[i:], m.Owner)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Owner)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Trait) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.TraitType) > 0 {
		i -= len(m.TraitType)
		copy(dAtA[i:], m.TraitType)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.TraitType)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *BucketMetaData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Attributes) > 0 {
		for iNdEx := len(m.Attributes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Attributes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Image) > 0 {
		i -= len(m.Image)
		copy(dAtA[i:], m.Image)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Image)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.BucketName) > 0 {
		i -= len(m.BucketName)
		copy(dAtA[i:], m.BucketName)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.BucketName)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ExternalUrl) > 0 {
		i -= len(m.ExternalUrl)
		copy(dAtA[i:], m.ExternalUrl)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.ExternalUrl)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ObjectMetaData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Attributes) > 0 {
		for iNdEx := len(m.Attributes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Attributes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Image) > 0 {
		i -= len(m.Image)
		copy(dAtA[i:], m.Image)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Image)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ObjectName) > 0 {
		i -= len(m.ObjectName)
		copy(dAtA[i:], m.ObjectName)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.ObjectName)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ExternalUrl) > 0 {
		i -= len(m.ExternalUrl)
		copy(dAtA[i:], m.ExternalUrl)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.ExternalUrl)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *GroupMetaData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Attributes) > 0 {
		for iNdEx := len(m.Attributes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Attributes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Image) > 0 {
		i -= len(m.Image)
		copy(dAtA[i:], m.Image)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Image)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.GroupName) > 0 {
		i -= len(m.GroupName)
		copy(dAtA[i:], m.GroupName)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.GroupName)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ExternalUrl) > 0 {
		i -= len(m.ExternalUrl)
		copy(dAtA[i:], m.ExternalUrl)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.ExternalUrl)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Ids) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		for iNdEx := len(m.Id) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Id[iNdEx].Size()
				i -= size
				if _, err := m.Id[iNdEx].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 *DeleteInfo) 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 *DeleteInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeleteInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.GroupIds != nil {
		{
			size, err := m.GroupIds.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ObjectIds != nil {
		{
			size, err := m.ObjectIds.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.BucketIds != nil {
		{
			size, err := m.BucketIds.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MigrationBucketInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		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] = 0x22
	if m.DstSpId != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.DstSpId))
		i--
		dAtA[i] = 0x18
	}
	if m.SrcGlobalVirtualGroupFamilyId != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.SrcGlobalVirtualGroupFamilyId))
		i--
		dAtA[i] = 0x10
	}
	if m.SrcSpId != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.SrcSpId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *ResourceTags) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Tags) > 0 {
		for iNdEx := len(m.Tags) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Tags[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *ResourceTags_Tag) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ShadowObjectInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Version != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Version))
		i--
		dAtA[i] = 0x38
	}
	if m.UpdatedAt != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.UpdatedAt))
		i--
		dAtA[i] = 0x30
	}
	if len(m.Checksums) > 0 {
		for iNdEx := len(m.Checksums) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Checksums[iNdEx])
			copy(dAtA[i:], m.Checksums[iNdEx])
			i = encodeVarintTypes(dAtA, i, uint64(len(m.Checksums[iNdEx])))
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.PayloadSize != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.PayloadSize))
		i--
		dAtA[i] = 0x20
	}
	if len(m.ContentType) > 0 {
		i -= len(m.ContentType)
		copy(dAtA[i:], m.ContentType)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.ContentType)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size := m.Id.Size()
		i -= size
		if _, err := m.Id.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Operator) > 0 {
		i -= len(m.Operator)
		copy(dAtA[i:], m.Operator)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Operator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *BucketExtraInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.CurrentFlowRate.Size()
		i -= size
		if _, err := m.CurrentFlowRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.FlowRateLimit.Size()
		i -= size
		if _, err := m.FlowRateLimit.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.IsRateLimited {
		i--
		if m.IsRateLimited {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		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 *BucketInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.BucketName)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Visibility != 0 {
		n += 1 + sovTypes(uint64(m.Visibility))
	}
	l = m.Id.Size()
	n += 1 + l + sovTypes(uint64(l))
	if m.SourceType != 0 {
		n += 1 + sovTypes(uint64(m.SourceType))
	}
	if m.CreateAt != 0 {
		n += 1 + sovTypes(uint64(m.CreateAt))
	}
	l = len(m.PaymentAddress)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.GlobalVirtualGroupFamilyId != 0 {
		n += 1 + sovTypes(uint64(m.GlobalVirtualGroupFamilyId))
	}
	if m.ChargedReadQuota != 0 {
		n += 1 + sovTypes(uint64(m.ChargedReadQuota))
	}
	if m.BucketStatus != 0 {
		n += 1 + sovTypes(uint64(m.BucketStatus))
	}
	if m.Tags != nil {
		l = m.Tags.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.SpAsDelegatedAgentDisabled {
		n += 2
	}
	return n
}

func (m *InternalBucketInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PriceTime != 0 {
		n += 1 + sovTypes(uint64(m.PriceTime))
	}
	if m.TotalChargeSize != 0 {
		n += 1 + sovTypes(uint64(m.TotalChargeSize))
	}
	if len(m.LocalVirtualGroups) > 0 {
		for _, e := range m.LocalVirtualGroups {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if m.NextLocalVirtualGroupId != 0 {
		n += 1 + sovTypes(uint64(m.NextLocalVirtualGroupId))
	}
	return n
}

func (m *ObjectInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.BucketName)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.ObjectName)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.Id.Size()
	n += 1 + l + sovTypes(uint64(l))
	if m.LocalVirtualGroupId != 0 {
		n += 1 + sovTypes(uint64(m.LocalVirtualGroupId))
	}
	if m.PayloadSize != 0 {
		n += 1 + sovTypes(uint64(m.PayloadSize))
	}
	if m.Visibility != 0 {
		n += 1 + sovTypes(uint64(m.Visibility))
	}
	l = len(m.ContentType)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.CreateAt != 0 {
		n += 1 + sovTypes(uint64(m.CreateAt))
	}
	if m.ObjectStatus != 0 {
		n += 1 + sovTypes(uint64(m.ObjectStatus))
	}
	if m.RedundancyType != 0 {
		n += 1 + sovTypes(uint64(m.RedundancyType))
	}
	if m.SourceType != 0 {
		n += 1 + sovTypes(uint64(m.SourceType))
	}
	if len(m.Checksums) > 0 {
		for _, b := range m.Checksums {
			l = len(b)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if m.Tags != nil {
		l = m.Tags.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.IsUpdating {
		n += 3
	}
	if m.UpdatedAt != 0 {
		n += 2 + sovTypes(uint64(m.UpdatedAt))
	}
	l = len(m.UpdatedBy)
	if l > 0 {
		n += 2 + l + sovTypes(uint64(l))
	}
	if m.Version != 0 {
		n += 2 + sovTypes(uint64(m.Version))
	}
	return n
}

func (m *GroupInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.GroupName)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.SourceType != 0 {
		n += 1 + sovTypes(uint64(m.SourceType))
	}
	l = m.Id.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = len(m.Extra)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Tags != nil {
		l = m.Tags.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

func (m *Trait) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TraitType)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

func (m *BucketMetaData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.ExternalUrl)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.BucketName)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.Image)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if len(m.Attributes) > 0 {
		for _, e := range m.Attributes {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	return n
}

func (m *ObjectMetaData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.ExternalUrl)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.ObjectName)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.Image)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if len(m.Attributes) > 0 {
		for _, e := range m.Attributes {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	return n
}

func (m *GroupMetaData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.ExternalUrl)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.GroupName)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.Image)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if len(m.Attributes) > 0 {
		for _, e := range m.Attributes {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	return n
}

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

func (m *DeleteInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BucketIds != nil {
		l = m.BucketIds.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.ObjectIds != nil {
		l = m.ObjectIds.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.GroupIds != nil {
		l = m.GroupIds.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

func (m *MigrationBucketInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SrcSpId != 0 {
		n += 1 + sovTypes(uint64(m.SrcSpId))
	}
	if m.SrcGlobalVirtualGroupFamilyId != 0 {
		n += 1 + sovTypes(uint64(m.SrcGlobalVirtualGroupFamilyId))
	}
	if m.DstSpId != 0 {
		n += 1 + sovTypes(uint64(m.DstSpId))
	}
	l = m.BucketId.Size()
	n += 1 + l + sovTypes(uint64(l))
	return n
}

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

func (m *ResourceTags_Tag) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

func (m *ShadowObjectInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Operator)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.Id.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = len(m.ContentType)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.PayloadSize != 0 {
		n += 1 + sovTypes(uint64(m.PayloadSize))
	}
	if len(m.Checksums) > 0 {
		for _, b := range m.Checksums {
			l = len(b)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if m.UpdatedAt != 0 {
		n += 1 + sovTypes(uint64(m.UpdatedAt))
	}
	if m.Version != 0 {
		n += 1 + sovTypes(uint64(m.Version))
	}
	return n
}

func (m *BucketExtraInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IsRateLimited {
		n += 2
	}
	l = m.FlowRateLimit.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = m.CurrentFlowRate.Size()
	n += 1 + l + sovTypes(uint64(l))
	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 *BucketInfo) 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: BucketInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BucketInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", 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.Owner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BucketName", 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.BucketName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Visibility", wireType)
			}
			m.Visibility = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Visibility |= VisibilityType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SourceType", wireType)
			}
			m.SourceType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SourceType |= SourceType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateAt", wireType)
			}
			m.CreateAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreateAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PaymentAddress", 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.PaymentAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalVirtualGroupFamilyId", wireType)
			}
			m.GlobalVirtualGroupFamilyId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GlobalVirtualGroupFamilyId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChargedReadQuota", wireType)
			}
			m.ChargedReadQuota = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChargedReadQuota |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BucketStatus", wireType)
			}
			m.BucketStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BucketStatus |= BucketStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tags", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Tags == nil {
				m.Tags = &ResourceTags{}
			}
			if err := m.Tags.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpAsDelegatedAgentDisabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SpAsDelegatedAgentDisabled = bool(v != 0)
		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 *InternalBucketInfo) 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: InternalBucketInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InternalBucketInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PriceTime", wireType)
			}
			m.PriceTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PriceTime |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalChargeSize", wireType)
			}
			m.TotalChargeSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalChargeSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LocalVirtualGroups", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LocalVirtualGroups = append(m.LocalVirtualGroups, &LocalVirtualGroup{})
			if err := m.LocalVirtualGroups[len(m.LocalVirtualGroups)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextLocalVirtualGroupId", wireType)
			}
			m.NextLocalVirtualGroupId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NextLocalVirtualGroupId |= 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 *ObjectInfo) 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: ObjectInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ObjectInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", 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.Owner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BucketName", 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.BucketName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", 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.ObjectName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LocalVirtualGroupId", wireType)
			}
			m.LocalVirtualGroupId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LocalVirtualGroupId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PayloadSize", wireType)
			}
			m.PayloadSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PayloadSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Visibility", wireType)
			}
			m.Visibility = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Visibility |= VisibilityType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContentType", 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.ContentType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateAt", wireType)
			}
			m.CreateAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreateAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectStatus", wireType)
			}
			m.ObjectStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ObjectStatus |= ObjectStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RedundancyType", wireType)
			}
			m.RedundancyType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RedundancyType |= RedundancyType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SourceType", wireType)
			}
			m.SourceType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SourceType |= SourceType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Checksums", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Checksums = append(m.Checksums, make([]byte, postIndex-iNdEx))
			copy(m.Checksums[len(m.Checksums)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tags", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Tags == nil {
				m.Tags = &ResourceTags{}
			}
			if err := m.Tags.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsUpdating", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsUpdating = bool(v != 0)
		case 17:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType)
			}
			m.UpdatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UpdatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedBy", 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.UpdatedBy = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= int64(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 *GroupInfo) 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: GroupInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GroupInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", 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.Owner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupName", 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.GroupName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SourceType", wireType)
			}
			m.SourceType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SourceType |= SourceType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Extra", 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.Extra = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tags", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Tags == nil {
				m.Tags = &ResourceTags{}
			}
			if err := m.Tags.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 *Trait) 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: Trait: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Trait: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TraitType", 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.TraitType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", 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.Value = 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 *BucketMetaData) 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: BucketMetaData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BucketMetaData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", 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.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExternalUrl", 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.ExternalUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BucketName", 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.BucketName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Image", 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.Image = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Attributes = append(m.Attributes, Trait{})
			if err := m.Attributes[len(m.Attributes)-1].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 *ObjectMetaData) 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: ObjectMetaData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ObjectMetaData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", 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.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExternalUrl", 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.ExternalUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", 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.ObjectName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Image", 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.Image = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Attributes = append(m.Attributes, Trait{})
			if err := m.Attributes[len(m.Attributes)-1].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 *GroupMetaData) 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: GroupMetaData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GroupMetaData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", 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.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExternalUrl", 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.ExternalUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupName", 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.GroupName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Image", 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.Image = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Attributes = append(m.Attributes, Trait{})
			if err := m.Attributes[len(m.Attributes)-1].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 *Ids) 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: Ids: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Ids: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", 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
			}
			var v Uint
			m.Id = append(m.Id, v)
			if err := m.Id[len(m.Id)-1].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 *DeleteInfo) 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: DeleteInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BucketIds", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.BucketIds == nil {
				m.BucketIds = &Ids{}
			}
			if err := m.BucketIds.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectIds", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectIds == nil {
				m.ObjectIds = &Ids{}
			}
			if err := m.ObjectIds.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupIds", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GroupIds == nil {
				m.GroupIds = &Ids{}
			}
			if err := m.GroupIds.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 *MigrationBucketInfo) 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: MigrationBucketInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MigrationBucketInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SrcSpId", wireType)
			}
			m.SrcSpId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SrcSpId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SrcGlobalVirtualGroupFamilyId", wireType)
			}
			m.SrcGlobalVirtualGroupFamilyId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SrcGlobalVirtualGroupFamilyId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DstSpId", wireType)
			}
			m.DstSpId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DstSpId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			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
		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 *ResourceTags) 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: ResourceTags: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceTags: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tags", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tags = append(m.Tags, ResourceTags_Tag{})
			if err := m.Tags[len(m.Tags)-1].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 *ResourceTags_Tag) 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: Tag: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Tag: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", 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.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", 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.Value = 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 *ShadowObjectInfo) 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: ShadowObjectInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ShadowObjectInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Operator", 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.Operator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContentType", 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.ContentType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PayloadSize", wireType)
			}
			m.PayloadSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PayloadSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Checksums", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Checksums = append(m.Checksums, make([]byte, postIndex-iNdEx))
			copy(m.Checksums[len(m.Checksums)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType)
			}
			m.UpdatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UpdatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= int64(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 *BucketExtraInfo) 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: BucketExtraInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BucketExtraInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsRateLimited", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsRateLimited = bool(v != 0)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FlowRateLimit", 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.FlowRateLimit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentFlowRate", 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.CurrentFlowRate.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 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")
)