*
     * @param ref the referral response
     * @param reqPath the requested path
     * @param expire the expiration time
     * @param consumed the number of characters consumed from the path
     * @return referral data
     */
    public static DfsReferralDataImpl fromReferral(final Referral ref, final String reqPath, final long expire, final int consumed) {
        final DfsReferralDataImpl dr = new DfsReferralDataImpl();

	if err != nil {
		return err
	}
	if numDays <= 0 {
		return errLifecycleInvalidDays
	}
	*eDays = ExpirationDays(numDays)
	return nil
}

// MarshalXML encodes number of days to expire if it is non-zero and
// encodes empty string otherwise
func (eDays ExpirationDays) MarshalXML(e *xml.Encoder, startElement xml.StartElement) error {
	if eDays == 0 {
		return nil
	}

		w.Header()[xhttp.ETag] = []string{"\"" + objInfo.ETag + "\""}
	}

	if objInfo.VersionID != "" {
		w.Header()[xhttp.AmzVersionID] = []string{objInfo.VersionID}
	}

	if !objInfo.Expires.IsZero() {
		w.Header().Set(xhttp.Expires, objInfo.Expires.UTC().Format(http.TimeFormat))
	}

	if objInfo.CacheControl != "" {
		w.Header().Set(xhttp.CacheControl, objInfo.CacheControl)
	}
}

	ID      string `json:"id"`
	Enabled bool   `json:"enabled"`
}

// Standard errors.
var (
	ErrNotImplemented     = errors.New("function not implemented")
	ErrAccessTokenExpired = errors.New("access_token expired or unauthorized")
)

// Provider implements identity provider specific admin operations, such as
// looking up users, fetching additional attributes etc.
type Provider interface {

   * Load cookies from the jar for an HTTP request to [url]. This method returns a possibly
   * empty list of cookies for the network request.
   *
   * Simple implementations will return the accepted cookies that have not yet expired and that
   * [match][Cookie.matches] [url].
   */
  fun loadForRequest(url: HttpUrl): List<Cookie>

  companion object {
    /** A cookie jar that never accepts any cookies. */
    @JvmField

    className: String,
    cause: Throwable,
  ): Boolean =
    when (className) {
      "okhttp3.recipes.CheckHandshake" -> true // by design
      "okhttp3.recipes.RequestBodyCompression" -> true // expired token
      else -> false
    }

            changeNotifier.stopWatching(path);
        }

        // Clear caches
        directoryCache.clear();
        leaseToPath.clear();
    }

    /**
     * Clean up expired cache entries
     */
    private void cleanupExpiredEntries() {
        List<String> expiredPaths = new ArrayList<>();

        for (Map.Entry<String, DirectoryCacheEntry> entry : directoryCache.entrySet()) {

	if resp.StatusCode != http.StatusOK {
		return errors.New(resp.Status)
	}

	return r.pubKeys.parseAndAdd(resp.Body)
}

// ErrTokenExpired - error token expired
var (
	ErrTokenExpired = errors.New("token expired")
)

func updateClaimsExpiry(dsecs string, claims map[string]any) error {
	expStr := claims["exp"]
	if expStr == "" {
		return ErrTokenExpired
	}

  }

  /**
   * Returns a future that delegates to this future but will finish early (via a {@link
   * TimeoutException} wrapped in an {@link ExecutionException}) if the specified timeout expires.
   * If the timeout expires, not only will the output future finish, but also the input future
   * ({@code this}) will be cancelled and interrupted.
   *
   * @param timeout when to time out the future

     */
    protected String[] dataConfigIds;

    /**
     * Document expiration setting in days.
     * -2: use system default, -1: never expire, 0 or positive: expire after specified days.
     */
    protected int documentExpires = -2;

    /**
     * Hot thread monitoring interval in seconds.