*/
  @Override
  ListenableScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);

  /**
   * @since 15.0 (previously returned ScheduledFuture)
   */
  @Override
  <V extends @Nullable Object> ListenableScheduledFuture<V> schedule(
      Callable<V> callable, long delay, TimeUnit unit);

  /**
   * @since 15.0 (previously returned ScheduledFuture)
   */
  @Override

            try {
                // Wait before retry (except first attempt)
                if (attempt > 0) {
                    long delay = retryDelay * (1L << attempt); // Exponential backoff
                    Thread.sleep(delay);
                    log.debug("Reconnection attempt {} for {}", attempt + 1, info.getPath());
                }

                // Perform the actual reconnection

 * task should not be executed again. Otherwise it returns a delay until the next execution.
 *
 * A task has at most one next execution. If the same task instance is scheduled multiple times, the
 * earliest one wins. This applies to both executions scheduled with [TaskRunner.Queue.schedule] and
 * those implied by the returned execution delay.
 *
 * Cancellation
 * ------------
 *

  fun setBodyDelay(
    delay: Long,
    unit: TimeUnit,
  ) = apply {
    bodyDelayAmount = delay
    bodyDelayUnit = unit
  }

  fun getBodyDelay(unit: TimeUnit): Long = unit.convert(bodyDelayAmount, bodyDelayUnit)

  fun setHeadersDelay(
    delay: Long,
    unit: TimeUnit,
  ) = apply {
    headersDelayAmount = delay
    headersDelayUnit = unit
  }

    }

    private void scheduleRecovery(ChannelInfo channel, FailoverState state) {
        state.incrementRetry();

        // For test purposes, execute recovery immediately without delay
        // In production, this might use the delay from getNextRetryTime()
        executor.submit(() -> attemptRecovery(channel, state));
    }

		case "Attempts":
			z.Attempts, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Attempts")
				return
			}
		case "Delay":
			z.Delay, err = dc.ReadDuration()
			if err != nil {
				err = msgp.WrapError(err, "Delay")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

    token: Bearer xxxxx # optional authentication token for the notification endpoint
  
  retry:
    attempts: 10 # number of retries for the job before giving up
    delay: 500ms # least amount of delay between each retry
`
	var job BatchJobRequest
	err := yaml.Unmarshal([]byte(expireYaml), &job)
	if err != nil {
		t.Fatal("Failed to parse batch-job-expire yaml", err)
	}

type BatchJobRetry struct {
	line, col int
	Attempts  int           `yaml:"attempts" json:"attempts"` // number of retry attempts
	Delay     time.Duration `yaml:"delay" json:"delay"`       // delay between each retries
}

var _ yaml.Unmarshaler = &BatchJobRetry{}

// UnmarshalYAML - BatchJobRetry extends unmarshal to extract line, column information

            if (!exponentialBackoff) {
                return initialDelayMs;
            }

            long delay = initialDelayMs;
            for (int i = 1; i < attemptNumber; i++) {
                delay = (long) (delay * backoffMultiplier);
            }

            return Math.min(delay, maxDelayMs);
        }

        public int getMaxAttempts() {
            return maxAttempts;
        }

      .callTimeout(10, TimeUnit.SECONDS)
      .build()

  fun run() {
    val request =
      Request
        .Builder()
        .url("http://httpbin.org/delay/2") // This URL is served with a 2 second delay.
        .build()

    client.newCall(request).execute().use { response ->
      println("Response completed: $response")
    }
  }
}

fun main() {
  ConfigureTimeouts().run()