}
	var replStatuses, vpurgeStatuses string
	replStatuses = rinfos.ReplicationStatusInternal()
	rs.Targets = replicationStatusesMap(replStatuses)
	rs.ReplicationStatusInternal = replStatuses
	rs.ReplicationTimeStamp = rinfos.ReplicationTimeStamp

	vpurgeStatuses = rinfos.VersionPurgeStatusInternal()
	rs.VersionPurgeStatusInternal = vpurgeStatuses
	rs.PurgeTargets = versionPurgeStatusesMap(vpurgeStatuses)

	if err == nil && j.Type == DeleteType && v < 2 {
		if val, ok := j.DeleteMarker.MetaSys[ReservedMetadataPrefixLower+ReplicationTimestamp]; ok {
			tm, err := time.Parse(time.RFC3339Nano, string(val))
			if err == nil {
				j.DeleteMarker.MetaSys[ReservedMetadataPrefixLower+ReplicationTimestamp] = []byte(tm.UTC().Format(time.RFC3339Nano))
			}
		}

			z.DeleteMarker, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "DeleteMarker")
				return
			}
		case "ReplicationTimeStamp":
			z.ReplicationTimeStamp, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "ReplicationTimeStamp")
				return
			}
		case "ReplicationStatusInternal":
			z.ReplicationStatusInternal, err = dc.ReadString()
			if err != nil {

	ExistingObjResync    ResyncDecision
	TargetArn            string
	TargetStatuses       map[string]replication.StatusType
	TargetPurgeStatuses  map[string]VersionPurgeStatusType
	ReplicationTimestamp time.Time
	Checksum             []byte
}

// MultipartInfo captures metadata information about the uploadId
// this data structure is used primarily for some internal purposes

			Type: DeleteType,
			DeleteMarker: &xlMetaV2DeleteMarker{
				VersionID: uuid.New(),
				ModTime:   time.Now().UnixNano(),
				MetaSys:   map[string][]byte{ReservedMetadataPrefixLower + ReplicationTimestamp: []byte("2022-10-27T15:40:53.195813291+08:00"), ReservedMetadataPrefixLower + ReplicaTimestamp: []byte("2022-10-27T15:40:53.195813291+08:00")},
			},
			WrittenByVersion: globalVersionUnix,
		}
		xl.data = nil

					return
				}
				z.TargetPurgeStatuses[za0003] = za0004
			}
		case "ReplicationTimestamp":
			z.ReplicationTimestamp, bts, err = msgp.ReadTimeBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ReplicationTimestamp")
				return
			}
		case "Checksum":
			z.Checksum, bts, err = msgp.ReadBytesBytes(bts, z.Checksum)
			if err != nil {

	// activity initiated from this cluster
	ReplicationStatus = "replication-status"
	// ReplicationTimestamp - the last time replication was initiated on this cluster for this object version
	ReplicationTimestamp = "replication-timestamp"
	// ReplicaStatus - this header is present if a replica was received by this cluster for this object version
	ReplicaStatus = "replica-status"

				ventry.DeleteMarker.MetaSys[ReservedMetadataPrefixLower+ReplicationStatus] = []byte(fi.ReplicationState.ReplicationStatusInternal)
				ventry.DeleteMarker.MetaSys[ReservedMetadataPrefixLower+ReplicationTimestamp] = []byte(fi.ReplicationState.ReplicationTimeStamp.UTC().Format(time.RFC3339Nano))
			}
		}
		if !fi.VersionPurgeStatus().Empty() {

		srcInfo.UserDefined[ReservedMetadataPrefixLower+ReplicationStatus] = dsc.PendingStatus()
		srcInfo.UserDefined[ReservedMetadataPrefixLower+ReplicationTimestamp] = UTCNow().Format(time.RFC3339Nano)
	}
	// Store the preserved compression metadata.
	for k, v := range compressMetadata {
		srcInfo.UserDefined[k] = v
	}

func getInternalReplicationState(m map[string]string) ReplicationState {
	d := ReplicationState{}
	for k, v := range m {
		switch {
		case equals(k, ReservedMetadataPrefixLower+ReplicationTimestamp):
			d.ReplicaTimeStamp, _ = amztime.ParseReplicationTS(v)
		case equals(k, ReservedMetadataPrefixLower+ReplicaTimestamp):
			d.ReplicaTimeStamp, _ = amztime.ParseReplicationTS(v)