for _, svc := range serviceAccounts {
		expiryTime := svc.Expiration
		serviceAccountList = append(serviceAccountList, madmin.ServiceAccountInfo{
			AccessKey:   svc.AccessKey,
			Expiration:  &expiryTime,
			Name:        svc.Name,
			Description: svc.Description,
		})
	}
	for _, sts := range stsKeys {
		expiryTime := sts.Expiration
		stsKeyList = append(stsKeyList, madmin.ServiceAccountInfo{

)

const (
	iso8601DateFormat = "20060102T150405Z"
)

func newPostPolicyBytesV4WithContentRange(credential, bucketName, objectKey string, expiration time.Time) []byte {
	t := UTCNow()
	// Add the expiration date.
	expirationStr := fmt.Sprintf(`"expiration": "%s"`, expiration.Format(iso8601TimeFormat))
	// Add the bucket condition, only accept buckets equal to the one passed.

This is available only on MinIO as an extension to the Expiration feature. The following rule makes it possible to remove all versions of an object under 
the prefix `user-uploads/` as soon as the latest object satisfies the expiration criteria. 

> NOTE: If the latest object is a delete marker then filtering based on `Filter.Tags` is ignored and 
> if the DELETE marker modTime satisfies the `Expiration.Days` then all versions of the object are 

    void testSetExpiration() {
        // Given
        Long expiration = System.currentTimeMillis() + 60000L;
        doNothing().when(response).setExpiration(expiration);

        // When
        response.setExpiration(expiration);

        // Then
        verify(response).setExpiration(expiration);
    }

    @Test
    @DisplayName("Test Response interface methods - getException")

    static final class CacheEntry {
        Name hostName;
        NbtAddress address;
        long expiration;

        CacheEntry(final Name hostName, final NbtAddress address, final long expiration) {
            this.hostName = hostName;
            this.address = address;
            this.expiration = expiration;
        }
    }

    static NbtAddress localhost;

    static {

    /**
     * Default constructor for Response.
     */
    public Response() {
        // Default constructor
    }

    /**
     * The expiration time for this response in milliseconds.
     */
    public long expiration;
    /**
     * Flag indicating whether this response has been received.
     */
    public boolean isReceived;

    public String path; // Path relative to tree from which this referral was thrown
    /** Whether to resolve hashes in the path */
    public boolean resolveHashes;
    /** Expiration time for this referral entry */
    public long expiration;

    /** The next DFS referral in the chain */
    DfsReferral next;
    /** Map containing DFS referral entries */
    Map map;
    /** The cache key for this referral */

        }
    }

    @Nested
    @DisplayName("Expiration Tests")
    class ExpirationTests {

        @Test
        @DisplayName("Should manage expiration time")
        void testExpiration() {
            assertNull(echoResponse.getExpiration());

            Long expiration = System.currentTimeMillis() + 10000L;
            echoResponse.setExpiration(expiration);

     */
    public Dfs() {
        // Default constructor
    }

    static class CacheEntry {
        long expiration;
        HashMap map;

        CacheEntry(long ttl) {
            if (ttl == 0) {
                ttl = Dfs.TTL;
            }
            expiration = System.currentTimeMillis() + ttl * 1000L;
            map = new HashMap();
        }
    }

	// EnvILMTransitionWorkers env variable to configure number of transition workers
	EnvILMTransitionWorkers = "MINIO_ILM_TRANSITION_WORKERS"
	// EnvILMExpirationWorkers env variable to configure number of expiration workers
	EnvILMExpirationWorkers = "MINIO_ILM_EXPIRATION_WORKERS"
)

var (
	defaultHelpPostfix = func(key string) string {
		return config.DefaultHelpPostfix(DefaultKVS, key)
	}