// (copied over from enforceRetentionForDeletion)
func (e *Evaluator) IsObjectLocked(obj ObjectOpts) bool {
	if e.lockRetention == nil || !e.lockRetention.LockEnabled {
		return false
	}

	if obj.DeleteMarker {
		return false
	}

	lhold := objlock.GetObjectLegalHoldMeta(obj.UserDefined)
	if lhold.Status.Valid() && lhold.Status == objlock.LegalHoldOn {
		return true
	}

`xl.meta` carries three types of object entries which designate the type of version object stored.

- ObjectType (default)
- LegacyObjectType (preserves existing deployments and older xl.json format)
- DeleteMarker (a versionId to capture the DELETE sequences implemented primarily for AWS spec compatibility)

	defer auditLogLifecycle(ctx, *oi, ILMExpiry, tags, traceFn)

	eventName := event.ObjectRemovedDelete
	if oi.DeleteMarker {
		eventName = event.ObjectRemovedDeleteMarkerCreated
	}
	objInfo := ObjectInfo{
		Name:         oi.Name,
		VersionID:    oi.VersionID,
		DeleteMarker: oi.DeleteMarker,
	}
	// Notify object deleted event.
	sendEvent(eventArgs{
		EventName:  eventName,
		BucketName: oi.Bucket,

}

// NextDue returns upcoming DelMarkerExpiration date for obj if
// applicable, returns false otherwise.
func (de DelMarkerExpiration) NextDue(obj ObjectOpts) (time.Time, bool) {
	if !obj.IsLatest || !obj.DeleteMarker {
		return time.Time{}, false
	}

	return ExpectedExpiryTime(obj.ModTime, de.Days), true

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

			z.IsLatest, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "IsLatest")
				return
			}
		case "DeleteMarker":
			z.DeleteMarker, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "DeleteMarker")
				return
			}
		case "TransitionedObject":
			bts, err = z.TransitionedObject.UnmarshalMsg(bts)
			if err != nil {

		// if present set the headers, no idea why AWS S3 sets these headers.
		if objInfo.VersionID != "" && objInfo.DeleteMarker {
			w.Header()[xhttp.AmzVersionID] = []string{objInfo.VersionID}
			w.Header()[xhttp.AmzDeleteMarker] = []string{strconv.FormatBool(objInfo.DeleteMarker)}
		}
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	}
	opts.PartNumber = partNumber
	opts.VersionID = vid

	delMarker, err := parseBoolHeader(bucket, object, r.Header, xhttp.MinIOSourceDeleteMarker)
	if err != nil {
		return opts, err
	}
	opts.DeleteMarker = delMarker

	replReadyCheck, err := parseBoolHeader(bucket, object, r.Header, xhttp.MinIOCheckDMReplicationReady)
	if err != nil {
		return opts, err
	}
	opts.CheckDMReplicationReady = replReadyCheck

// ObjectOpts provides information to deduce whether replication
// can be triggered on the resultant object.
type ObjectOpts struct {
	Name           string
	UserTags       string
	VersionID      string
	DeleteMarker   bool
	SSEC           bool
	OpType         Type
	Replica        bool
	ExistingObject bool
	TargetArn      string
}

in [AWS V1 Configuration](https://aws.amazon.com/blogs/storage/managing-delete-marker-replication-in-amazon-s3/) but not in V2 configuration. The MinIO implementation above is based on V2 configuration, however it has been extended to allow both DeleteMarker replication and replication of versioned deletes with the `DeleteMarkerReplication` and `DeleteReplication` fields in the replication configuration above. By default, this is set to `Disabled` unless the user specifies it while adding a replication...