"schema": {
                                        "title": "Square",
                                        "maxItems": 2,
                                        "minItems": 2,
                                        "type": "array",
                                        "prefixItems": [
                                            {"$ref": "#/components/schemas/Coordinate"},

    maxLength: int | None = Field(default=None, ge=0)
    minLength: int | None = Field(default=None, ge=0)
    pattern: str | None = None
    maxItems: int | None = Field(default=None, ge=0)
    minItems: int | None = Field(default=None, ge=0)
    uniqueItems: bool | None = None
    maxContains: int | None = Field(default=None, ge=0)
    minContains: int | None = Field(default=None, ge=0)

 * Currently this pool holds up to 5 idle connections which will be evicted after 5 minutes of
 * inactivity.
 */
class ConnectionPool internal constructor(
  internal val delegate: RealConnectionPool,
) {
  internal constructor(
    maxIdleConnections: Int = 5,
    keepAliveDuration: Long = 5,
    timeUnit: TimeUnit = TimeUnit.MINUTES,
    taskRunner: TaskRunner = TaskRunner.INSTANCE,

  public void testSchedule() {
    MockExecutor mock = new MockExecutor();
    TestExecutor testExecutor = new TestExecutor(mock);

    Future<?> unused1 = testExecutor.schedule(() -> {}, 10, MINUTES);
    mock.assertLastMethodCalled("scheduleRunnable", 10, MINUTES);

    Future<?> unused2 = testExecutor.schedule(() -> null, 5, SECONDS);
    mock.assertLastMethodCalled("scheduleCallable", 5, SECONDS);
  }

  public void testSchedule_repeating() {

	minutes := time.Now().Unix() / 60
	l.forwardTo(minutes)
	winIdx := minutes % 60
	l.Totals[winIdx].merge(AccElem{Total: minutes, Size: sz, N: 1})
	l.LastMin = minutes
}

// Merge all recorded counts of last hour into one
func (l *ReplicationLastHour) getTotal() AccElem {
	var res AccElem
	minutes := time.Now().Unix() / 60
	l.forwardTo(minutes)
	for _, elem := range l.Totals[:] {

        long minutes = duration.toMinutesPart();
        long seconds = duration.toSecondsPart();
        long millis = duration.toMillisPart();

        if (days > 0) {
            return String.format("%d d %02d:%02d h", days, hours, minutes);
        } else if (hours > 0) {
            return String.format("%02d:%02d h", hours, minutes);
        } else if (minutes > 0) {

    CacheBuilderSpec spec = parse("expireAfterWrite=10m");
    assertThat(spec.writeExpirationTimeUnit).isEqualTo(MINUTES);
    assertThat(spec.writeExpirationDuration).isEqualTo(10L);
    assertCacheBuilderEquivalence(
        CacheBuilder.newBuilder().expireAfterWrite(10L, MINUTES), CacheBuilder.from(spec));
  }

  public void testParse_writeExpirationSeconds() {

      description: "MinIO instance {{ $labels.server }} of job {{ $labels.job }} has lost quorum on pool {{ $labels.pool }} on set {{ $labels.set }} for more than 5 minutes."
```

## Verify the configuration and alerts
To verify the above sample alert follow below steps

1. Start a distributed MinIO instance (4 nodes setup)
2. Start Prometheus server and AlertManager

		return FromInt(int64(duration / (24 * time.Hour))), nil
	case timePartHour:
		hours := duration / time.Hour
		return FromInt(int64(hours)), nil
	case timePartMinute:
		minutes := duration / time.Minute
		return FromInt(int64(minutes)), nil
	case timePartSecond:
		seconds := duration / time.Second
		return FromInt(int64(seconds)), nil
	default:
	}
	return nil, errNotImplemented

         * @param minutes the minute of the hour (0-59)
         * @param day the day of the week (1=Sunday, 7=Saturday)
         * @return true if this rule applies, false otherwise
         */
        public boolean isTarget(final int hours, final int minutes, final int day) {
            if (!reverse) {