@IgnoreJRERequirement // Users will use this only if they're already using Duration.
  public static <V extends @Nullable Object> ListenableFuture<V> withTimeout(
      ListenableFuture<V> delegate, Duration time, ScheduledExecutorService scheduledExecutor) {
    return withTimeout(delegate, toNanosSaturated(time), TimeUnit.NANOSECONDS, scheduledExecutor);
  }

  /**

		if err != nil {
			return err
		}
		ctx = lkctx.Context()
		defer lk.Unlock(lkctx)
	}

	if !opts.Force {
		results := make(chan itemOrErr[ObjectInfo])

		ctx, cancel := context.WithTimeout(ctx, time.Minute)
		defer cancel()
		err := z.Walk(ctx, bucket, "", results, WalkOptions{Limit: 1})
		if err != nil {
			s3LogIf(ctx, fmt.Errorf("unable to verify if the bucket %s is empty: %w", bucket, err))

	if endpoint == "" {
		return nil
	}

	buf, err := json.Marshal(ri)
	if err != nil {
		return err
	}

	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
	defer cancel()

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(buf))
	if err != nil {
		return err
	}

	if token != "" {

		}
		srvCfg, err := getValidConfig(objAPI)
		if err != nil {
			return np, grid.NewRemoteErr(err)
		}
		subSys := vars.Get(peerRESTSubSys)
		// Apply dynamic values.
		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
		defer cancel()
		if subSys == "" {
			err = applyDynamicConfig(ctx, objAPI, srvCfg)
		} else {
			err = applyDynamicConfigForSubSys(ctx, objAPI, srvCfg, subSys)
		}

	policyDBSTSUsersPrefix := strings.HasPrefix(event.keyPath, iamConfigPolicyDBSTSUsersPrefix)
	policyDBGroupsPrefix := strings.HasPrefix(event.keyPath, iamConfigPolicyDBGroupsPrefix)

	ctx, cancel := context.WithTimeout(ctx, defaultContextTimeout)
	defer cancel()

	switch {
	case usersPrefix:
		accessKey := path.Dir(strings.TrimPrefix(event.keyPath, iamConfigUsersPrefix))

		toMerge = append(toMerge, p.Policy)
	}
	store.runlock()

	if len(missingPolicies) > 0 {
		m := make(map[string]PolicyDoc)
		for _, policy := range missingPolicies {
			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
			_ = store.loadPolicyDoc(ctx, policy, m)
			cancel()
		}

		cache := store.lock()
		maps.Copy(cache.iamPolicyDocsMap, m)
		store.unlock()