// Code generated by protoc-gen-go. DO NOT EDIT.
// source: content_manifest.proto

package protobuf

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	math "math"
)

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

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

type EContentDeltaChunkDataLocation int32

const (
	EContentDeltaChunkDataLocation_k_EContentDeltaChunkDataLocationInProtobuf    EContentDeltaChunkDataLocation = 0
	EContentDeltaChunkDataLocation_k_EContentDeltaChunkDataLocationAfterProtobuf EContentDeltaChunkDataLocation = 1
)

var EContentDeltaChunkDataLocation_name = map[int32]string{
	0: "k_EContentDeltaChunkDataLocationInProtobuf",
	1: "k_EContentDeltaChunkDataLocationAfterProtobuf",
}

var EContentDeltaChunkDataLocation_value = map[string]int32{
	"k_EContentDeltaChunkDataLocationInProtobuf":    0,
	"k_EContentDeltaChunkDataLocationAfterProtobuf": 1,
}

func (x EContentDeltaChunkDataLocation) Enum() *EContentDeltaChunkDataLocation {
	p := new(EContentDeltaChunkDataLocation)
	*p = x
	return p
}

func (x EContentDeltaChunkDataLocation) String() string {
	return proto.EnumName(EContentDeltaChunkDataLocation_name, int32(x))
}

func (x *EContentDeltaChunkDataLocation) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(EContentDeltaChunkDataLocation_value, data, "EContentDeltaChunkDataLocation")
	if err != nil {
		return err
	}
	*x = EContentDeltaChunkDataLocation(value)
	return nil
}

func (EContentDeltaChunkDataLocation) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_e3cda137a29253ba, []int{0}
}

type ContentManifestPayload struct {
	Mappings             []*ContentManifestPayload_FileMapping `protobuf:"bytes,1,rep,name=mappings" json:"mappings,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                              `json:"-"`
	XXX_unrecognized     []byte                                `json:"-"`
	XXX_sizecache        int32                                 `json:"-"`
}

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

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

var xxx_messageInfo_ContentManifestPayload proto.InternalMessageInfo

func (m *ContentManifestPayload) GetMappings() []*ContentManifestPayload_FileMapping {
	if m != nil {
		return m.Mappings
	}
	return nil
}

type ContentManifestPayload_FileMapping struct {
	Filename             *string                                         `protobuf:"bytes,1,opt,name=filename" json:"filename,omitempty"`
	Size                 *uint64                                         `protobuf:"varint,2,opt,name=size" json:"size,omitempty"`
	Flags                *uint32                                         `protobuf:"varint,3,opt,name=flags" json:"flags,omitempty"`
	ShaFilename          []byte                                          `protobuf:"bytes,4,opt,name=sha_filename,json=shaFilename" json:"sha_filename,omitempty"`
	ShaContent           []byte                                          `protobuf:"bytes,5,opt,name=sha_content,json=shaContent" json:"sha_content,omitempty"`
	Chunks               []*ContentManifestPayload_FileMapping_ChunkData `protobuf:"bytes,6,rep,name=chunks" json:"chunks,omitempty"`
	Linktarget           *string                                         `protobuf:"bytes,7,opt,name=linktarget" json:"linktarget,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                        `json:"-"`
	XXX_unrecognized     []byte                                          `json:"-"`
	XXX_sizecache        int32                                           `json:"-"`
}

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

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

var xxx_messageInfo_ContentManifestPayload_FileMapping proto.InternalMessageInfo

func (m *ContentManifestPayload_FileMapping) GetFilename() string {
	if m != nil && m.Filename != nil {
		return *m.Filename
	}
	return ""
}

func (m *ContentManifestPayload_FileMapping) GetSize() uint64 {
	if m != nil && m.Size != nil {
		return *m.Size
	}
	return 0
}

func (m *ContentManifestPayload_FileMapping) GetFlags() uint32 {
	if m != nil && m.Flags != nil {
		return *m.Flags
	}
	return 0
}

func (m *ContentManifestPayload_FileMapping) GetShaFilename() []byte {
	if m != nil {
		return m.ShaFilename
	}
	return nil
}

func (m *ContentManifestPayload_FileMapping) GetShaContent() []byte {
	if m != nil {
		return m.ShaContent
	}
	return nil
}

func (m *ContentManifestPayload_FileMapping) GetChunks() []*ContentManifestPayload_FileMapping_ChunkData {
	if m != nil {
		return m.Chunks
	}
	return nil
}

func (m *ContentManifestPayload_FileMapping) GetLinktarget() string {
	if m != nil && m.Linktarget != nil {
		return *m.Linktarget
	}
	return ""
}

type ContentManifestPayload_FileMapping_ChunkData struct {
	Sha                  []byte   `protobuf:"bytes,1,opt,name=sha" json:"sha,omitempty"`
	Crc                  *uint32  `protobuf:"fixed32,2,opt,name=crc" json:"crc,omitempty"`
	Offset               *uint64  `protobuf:"varint,3,opt,name=offset" json:"offset,omitempty"`
	CbOriginal           *uint32  `protobuf:"varint,4,opt,name=cb_original,json=cbOriginal" json:"cb_original,omitempty"`
	CbCompressed         *uint32  `protobuf:"varint,5,opt,name=cb_compressed,json=cbCompressed" json:"cb_compressed,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ContentManifestPayload_FileMapping_ChunkData proto.InternalMessageInfo

func (m *ContentManifestPayload_FileMapping_ChunkData) GetSha() []byte {
	if m != nil {
		return m.Sha
	}
	return nil
}

func (m *ContentManifestPayload_FileMapping_ChunkData) GetCrc() uint32 {
	if m != nil && m.Crc != nil {
		return *m.Crc
	}
	return 0
}

func (m *ContentManifestPayload_FileMapping_ChunkData) GetOffset() uint64 {
	if m != nil && m.Offset != nil {
		return *m.Offset
	}
	return 0
}

func (m *ContentManifestPayload_FileMapping_ChunkData) GetCbOriginal() uint32 {
	if m != nil && m.CbOriginal != nil {
		return *m.CbOriginal
	}
	return 0
}

func (m *ContentManifestPayload_FileMapping_ChunkData) GetCbCompressed() uint32 {
	if m != nil && m.CbCompressed != nil {
		return *m.CbCompressed
	}
	return 0
}

type ContentManifestMetadata struct {
	DepotId              *uint32  `protobuf:"varint,1,opt,name=depot_id,json=depotId" json:"depot_id,omitempty"`
	GidManifest          *uint64  `protobuf:"varint,2,opt,name=gid_manifest,json=gidManifest" json:"gid_manifest,omitempty"`
	CreationTime         *uint32  `protobuf:"varint,3,opt,name=creation_time,json=creationTime" json:"creation_time,omitempty"`
	FilenamesEncrypted   *bool    `protobuf:"varint,4,opt,name=filenames_encrypted,json=filenamesEncrypted" json:"filenames_encrypted,omitempty"`
	CbDiskOriginal       *uint64  `protobuf:"varint,5,opt,name=cb_disk_original,json=cbDiskOriginal" json:"cb_disk_original,omitempty"`
	CbDiskCompressed     *uint64  `protobuf:"varint,6,opt,name=cb_disk_compressed,json=cbDiskCompressed" json:"cb_disk_compressed,omitempty"`
	UniqueChunks         *uint32  `protobuf:"varint,7,opt,name=unique_chunks,json=uniqueChunks" json:"unique_chunks,omitempty"`
	CrcEncrypted         *uint32  `protobuf:"varint,8,opt,name=crc_encrypted,json=crcEncrypted" json:"crc_encrypted,omitempty"`
	CrcClear             *uint32  `protobuf:"varint,9,opt,name=crc_clear,json=crcClear" json:"crc_clear,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ContentManifestMetadata proto.InternalMessageInfo

func (m *ContentManifestMetadata) GetDepotId() uint32 {
	if m != nil && m.DepotId != nil {
		return *m.DepotId
	}
	return 0
}

func (m *ContentManifestMetadata) GetGidManifest() uint64 {
	if m != nil && m.GidManifest != nil {
		return *m.GidManifest
	}
	return 0
}

func (m *ContentManifestMetadata) GetCreationTime() uint32 {
	if m != nil && m.CreationTime != nil {
		return *m.CreationTime
	}
	return 0
}

func (m *ContentManifestMetadata) GetFilenamesEncrypted() bool {
	if m != nil && m.FilenamesEncrypted != nil {
		return *m.FilenamesEncrypted
	}
	return false
}

func (m *ContentManifestMetadata) GetCbDiskOriginal() uint64 {
	if m != nil && m.CbDiskOriginal != nil {
		return *m.CbDiskOriginal
	}
	return 0
}

func (m *ContentManifestMetadata) GetCbDiskCompressed() uint64 {
	if m != nil && m.CbDiskCompressed != nil {
		return *m.CbDiskCompressed
	}
	return 0
}

func (m *ContentManifestMetadata) GetUniqueChunks() uint32 {
	if m != nil && m.UniqueChunks != nil {
		return *m.UniqueChunks
	}
	return 0
}

func (m *ContentManifestMetadata) GetCrcEncrypted() uint32 {
	if m != nil && m.CrcEncrypted != nil {
		return *m.CrcEncrypted
	}
	return 0
}

func (m *ContentManifestMetadata) GetCrcClear() uint32 {
	if m != nil && m.CrcClear != nil {
		return *m.CrcClear
	}
	return 0
}

type ContentManifestSignature struct {
	Signature            []byte   `protobuf:"bytes,1,opt,name=signature" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ContentManifestSignature proto.InternalMessageInfo

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

type ContentDeltaChunks struct {
	DepotId              *uint32                          `protobuf:"varint,1,opt,name=depot_id,json=depotId" json:"depot_id,omitempty"`
	ManifestIdSource     *uint64                          `protobuf:"varint,2,opt,name=manifest_id_source,json=manifestIdSource" json:"manifest_id_source,omitempty"`
	ManifestIdTarget     *uint64                          `protobuf:"varint,3,opt,name=manifest_id_target,json=manifestIdTarget" json:"manifest_id_target,omitempty"`
	DeltaChunks          []*ContentDeltaChunks_DeltaChunk `protobuf:"bytes,4,rep,name=deltaChunks" json:"deltaChunks,omitempty"`
	ChunkDataLocation    *EContentDeltaChunkDataLocation  `protobuf:"varint,5,opt,name=chunk_data_location,json=chunkDataLocation,enum=EContentDeltaChunkDataLocation,def=0" json:"chunk_data_location,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                         `json:"-"`
	XXX_unrecognized     []byte                           `json:"-"`
	XXX_sizecache        int32                            `json:"-"`
}

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

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

var xxx_messageInfo_ContentDeltaChunks proto.InternalMessageInfo

const Default_ContentDeltaChunks_ChunkDataLocation EContentDeltaChunkDataLocation = EContentDeltaChunkDataLocation_k_EContentDeltaChunkDataLocationInProtobuf

func (m *ContentDeltaChunks) GetDepotId() uint32 {
	if m != nil && m.DepotId != nil {
		return *m.DepotId
	}
	return 0
}

func (m *ContentDeltaChunks) GetManifestIdSource() uint64 {
	if m != nil && m.ManifestIdSource != nil {
		return *m.ManifestIdSource
	}
	return 0
}

func (m *ContentDeltaChunks) GetManifestIdTarget() uint64 {
	if m != nil && m.ManifestIdTarget != nil {
		return *m.ManifestIdTarget
	}
	return 0
}

func (m *ContentDeltaChunks) GetDeltaChunks() []*ContentDeltaChunks_DeltaChunk {
	if m != nil {
		return m.DeltaChunks
	}
	return nil
}

func (m *ContentDeltaChunks) GetChunkDataLocation() EContentDeltaChunkDataLocation {
	if m != nil && m.ChunkDataLocation != nil {
		return *m.ChunkDataLocation
	}
	return Default_ContentDeltaChunks_ChunkDataLocation
}

type ContentDeltaChunks_DeltaChunk struct {
	ShaSource            []byte   `protobuf:"bytes,1,opt,name=sha_source,json=shaSource" json:"sha_source,omitempty"`
	ShaTarget            []byte   `protobuf:"bytes,2,opt,name=sha_target,json=shaTarget" json:"sha_target,omitempty"`
	SizeOriginal         *uint32  `protobuf:"varint,3,opt,name=size_original,json=sizeOriginal" json:"size_original,omitempty"`
	PatchMethod          *uint32  `protobuf:"varint,4,opt,name=patch_method,json=patchMethod" json:"patch_method,omitempty"`
	Chunk                []byte   `protobuf:"bytes,5,opt,name=chunk" json:"chunk,omitempty"`
	SizeDelta            *uint32  `protobuf:"varint,6,opt,name=size_delta,json=sizeDelta" json:"size_delta,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ContentDeltaChunks_DeltaChunk proto.InternalMessageInfo

func (m *ContentDeltaChunks_DeltaChunk) GetShaSource() []byte {
	if m != nil {
		return m.ShaSource
	}
	return nil
}

func (m *ContentDeltaChunks_DeltaChunk) GetShaTarget() []byte {
	if m != nil {
		return m.ShaTarget
	}
	return nil
}

func (m *ContentDeltaChunks_DeltaChunk) GetSizeOriginal() uint32 {
	if m != nil && m.SizeOriginal != nil {
		return *m.SizeOriginal
	}
	return 0
}

func (m *ContentDeltaChunks_DeltaChunk) GetPatchMethod() uint32 {
	if m != nil && m.PatchMethod != nil {
		return *m.PatchMethod
	}
	return 0
}

func (m *ContentDeltaChunks_DeltaChunk) GetChunk() []byte {
	if m != nil {
		return m.Chunk
	}
	return nil
}

func (m *ContentDeltaChunks_DeltaChunk) GetSizeDelta() uint32 {
	if m != nil && m.SizeDelta != nil {
		return *m.SizeDelta
	}
	return 0
}

func init() {
	proto.RegisterEnum("EContentDeltaChunkDataLocation", EContentDeltaChunkDataLocation_name, EContentDeltaChunkDataLocation_value)
	proto.RegisterType((*ContentManifestPayload)(nil), "ContentManifestPayload")
	proto.RegisterType((*ContentManifestPayload_FileMapping)(nil), "ContentManifestPayload.FileMapping")
	proto.RegisterType((*ContentManifestPayload_FileMapping_ChunkData)(nil), "ContentManifestPayload.FileMapping.ChunkData")
	proto.RegisterType((*ContentManifestMetadata)(nil), "ContentManifestMetadata")
	proto.RegisterType((*ContentManifestSignature)(nil), "ContentManifestSignature")
	proto.RegisterType((*ContentDeltaChunks)(nil), "ContentDeltaChunks")
	proto.RegisterType((*ContentDeltaChunks_DeltaChunk)(nil), "ContentDeltaChunks.DeltaChunk")
}

func init() { proto.RegisterFile("content_manifest.proto", fileDescriptor_e3cda137a29253ba) }

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