{ObjectRemovedDeleteAllVersions, "s3:ObjectRemoved:DeleteAllVersions"},
		{ILMDelMarkerExpirationDelete, "s3:LifecycleDelMarkerExpiration:Delete"},
		{ObjectRemovedNoOP, "s3:ObjectRemoved:NoOP"},
		{ObjectCreatedPutRetention, "s3:ObjectCreated:PutRetention"},
		{ObjectCreatedPutLegalHold, "s3:ObjectCreated:PutLegalHold"},
		{ObjectAccessedGetRetention, "s3:ObjectAccessed:GetRetention"},

            result.setAvailable(true);
        }

        return result;
    }

    public void add(RepositorySystemSession session, LocalArtifactRegistration request) {
        // noop
    }

    public LocalMetadataResult find(RepositorySystemSession session, LocalMetadataRequest request) {
        LocalMetadataResult result = new LocalMetadataResult(request);

        String path;

	case ObjectRemovedDelete:
		return "s3:ObjectRemoved:Delete"
	case ObjectRemovedDeleteMarkerCreated:
		return "s3:ObjectRemoved:DeleteMarkerCreated"
	case ObjectRemovedNoOP:
		return "s3:ObjectRemoved:NoOP"
	case ObjectRemovedDeleteAllVersions:
		return "s3:ObjectRemoved:DeleteAllVersions"
	case ILMDelMarkerExpirationDelete:
		return "s3:LifecycleDelMarkerExpiration:Delete"
	case ObjectReplicationAll:

		// - this change attempts to avoid stale information if the underlying
		// transport is already down.
		return info, errDiskNotFound
	}

	// if 'NoOp' we do not cache the value.
	if opts.NoOp {
		ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
		defer cancel()

		opts.DiskID = *client.diskID.Load()

		infop, err := storageDiskInfoRPC.Call(ctx, client.gridConn, &opts)

			}
		case "m":
			z.Metrics, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "Metrics")
				return
			}
		case "np":
			z.NoOp, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "NoOp")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

	Purge SRBucketDeleteOp = "Purge"
	// NoOp no action needed
	NoOp SRBucketDeleteOp = "NoOp"
)

// Empty returns true if this Op is not set
func (s SRBucketDeleteOp) Empty() bool {
	return string(s) == "" || string(s) == string(NoOp)
}

func getSRBucketDeleteOp(isSiteReplicated bool) SRBucketDeleteOp {
	if !isSiteReplicated {
		return NoOp
	}
	return MarkDelete
}

type RenameOptions struct {
	BaseOptions
}

// DiskInfoOptions options for requesting custom results.
type DiskInfoOptions struct {
	DiskID  string `msg:"id"`
	Metrics bool   `msg:"m"`
	NoOp    bool   `msg:"np"`
}

// DiskInfo is an extended type which returns current
// disk usage per path.
// The above means that any added/deleted fields are incompatible.
//

	format = &formatErasureV3{}
	if err = json.Unmarshal(data, format); err != nil {
		return nil, err
	}

	if heal {
		info, err := disk.DiskInfo(context.Background(), DiskInfoOptions{NoOp: heal})
		if err != nil {
			return nil, err
		}
		format.Info = info
	}

	// Success.
	return format, nil
}

// Valid formatErasure basic versions.

	if contextCanceled(ctx) {
		return DiskInfo{}, ctx.Err()
	}

	si := p.updateStorageMetrics(storageMetricDiskInfo)
	defer si(&err)

	if opts.NoOp {
		if opts.Metrics {
			info.Metrics = p.getMetrics()
		}
		info.Metrics.TotalWrites = p.totalWrites.Load()
		info.Metrics.TotalDeletes = p.totalDeletes.Load()

## Known Caveats

*   TF Core:
    *   A longstanding bug in `tf.while_loop`, which caused it to execute
        sequentially, even when `parallel_iterations>1`, has now been fixed.
        However, the increased parallelism may result in increased memory use.
        Users who experience unwanted regressions should reset their
        `while_loop`'s `parallel_iterations` value to 1, which is consistent
        with prior behavior.