if hr != 0 || m != 0 || sec != 0 || nsec != 0 || loc.String() != time.UTC.String() {
		return errTransitionDateNotMidnight
	}

	*tDate = TransitionDate{trnDate}
	return nil
}

// MarshalXML encodes expiration date if it is non-zero and encodes
// empty string otherwise
func (tDate TransitionDate) MarshalXML(e *xml.Encoder, startElement xml.StartElement) error {
	if tDate.IsZero() {
		return nil
	}

				MinioAccessKey: accessKey.ParentUser,
				ID:             id,
				ReadableName:   readableClaim,
			}
		}
		svcAccInfo := madmin.ServiceAccountInfo{
			AccessKey:  accessKey.AccessKey,
			Expiration: &accessKey.Expiration,
		}
		if accessKey.IsServiceAccount() {
			openIDUserAccessKeys.ServiceAccounts = append(openIDUserAccessKeys.ServiceAccounts, svcAccInfo)
		} else {

     * @return this session's UID
     */
    public int getUid() {
        return this.uid;
    }

    /**
     * @return this session's expiration time
     */
    public Long getExpiration() {
        return this.expiration > 0 ? this.expiration : null;
    }

    /**
     * @return this session's credentials
     */
    public CredentialsInternal getCredentials() {

            public void store(CrawlingInfo entity) {
                assertEquals("Test Crawl", entity.getName());
                // Don't check exact expiration time, just verify it's reasonable
                assertNotNull(entity.getExpiredTime());
                assertTrue("Expiration time should be in the future", entity.getExpiredTime().longValue() > currentTime);
            }

            @Override

    private final UniAddress address;
    private final int port, localPort;
    private final InetAddress localAddr;

    SmbTransport transport = null;
    NtlmPasswordAuthentication auth;
    long expiration;
    String netbiosName = null;

    SmbSession(final UniAddress address, final int port, final InetAddress localAddr, final int localPort,
            final NtlmPasswordAuthentication auth) {

    </AssumedRoleUser>
    <Credentials>
      <AccessKeyId>Y4RJU1RNFGK48LGO9I2S</AccessKeyId>
      <SecretAccessKey>sYLRKS1Z7hSjluf6gEbb9066hnx315wHTiACPAjg</SecretAccessKey>
      <Expiration>2019-08-08T20:26:12Z</Expiration>

        // Set a very short max age
        entry.setMaxAge(100); // 100ms

        assertFalse(entry.isExpired());
        assertFalse(entry.needsRefresh());

        // Wait for expiration
        try {
            Thread.sleep(150);
        } catch (InterruptedException e) {
            // Ignore
        }

        assertTrue(entry.isExpired());
        assertTrue(entry.needsRefresh());

     *
     * @param activeSessionId the session ID to exclude from deletion (can be null)
     * @param name optional name filter for sessions to delete (can be null or blank)
     * @param date the expiration time threshold - sessions expired before this time will be deleted
     */
    public void deleteSessionIdsBefore(final String activeSessionId, final String name, final long date) {

	return xxh3.HashString(j.TierName + j.ObjName)
}

func (e expiryTask) OpHash() uint64 {
	return xxh3.HashString(e.objInfo.Bucket + e.objInfo.Name)
}

// expiryState manages all ILM related expiration activities.
type expiryState struct {
	mu      sync.RWMutex
	workers atomic.Pointer[[]chan expiryOp]

	ctx    context.Context
	objAPI ObjectLayer

	stats expiryStats
}

		return BatchJobYamlErr{
			line: ef.line,
			col:  ef.col,
			msg:  "CreatedBefore is in the future",
		}
	}
	return nil
}

// BatchJobExpire represents configuration parameters for a batch expiration
// job typically supplied in yaml form
type BatchJobExpire struct {
	line, col       int
	APIVersion      string                 `yaml:"apiVersion" json:"apiVersion"`