"properties" : {
          "authRealm" : {
            "type" : "keyword"
          },
          "createdBy" : {
            "type" : "keyword"
          },
          "createdTime" : {
            "type" : "long"
          },
          "hostname" : {
            "type" : "keyword"
          },
          "parameters" : {
            "type" : "keyword"
          },
          "password" : {
            "type" : "keyword"

    private void cleanupOldRateLimitCounters(long currentWindow) {
        // Clean up counters from previous windows to prevent memory leaks
        rateLimitCounters.entrySet().removeIf(entry -> {
            String key = entry.getKey();
            int lastUnderscore = key.lastIndexOf('_');
            if (lastUnderscore > 0) {
                try {
                    long window = Long.parseLong(key.substring(lastUnderscore + 1));

        assertTrue(file.canRead(), "Should be readable");
        assertTrue(file.canWrite(), "Should be writable");

        // Test timestamps
        long createTime = file.createTime();
        long lastModified = file.lastModified();
        long lastAccess = file.lastAccess();

        assertTrue(createTime > 0, "Create time should be set");
        assertTrue(lastModified > 0, "Last modified time should be set");

final class OverflowAvoidingLockSupport {
  // Represents the max nanoseconds representable on a linux timespec with a 32 bit tv_sec
  static final long MAX_NANOSECONDS_THRESHOLD = (1L + Integer.MAX_VALUE) * 1_000_000_000L - 1L;

  private OverflowAvoidingLockSupport() {}

  static void parkNanos(@Nullable Object blocker, long nanos) {
    // Even in the extremely unlikely event that a thread unblocks itself early after only 68 years,

          },
          "crawler" : {
            "type" : "boolean"
          },
          "createdBy" : {
            "type" : "keyword"
          },
          "createdTime" : {
            "type" : "long"
          },
          "cronExpression" : {
            "type" : "keyword"
          },
          "jobLogging" : {
            "type" : "boolean"
          },
          "name" : {

    private static final long serialVersionUID = 1L;

    private Map<String, Object> fields;

    @Override
    public String getId() {
        return asDocMeta().id();
    }

    public void setId(final String id) {
        asDocMeta().id(id);
    }

    @Override
    public Long getVersionNo() {
        return asDocMeta().version();
    }

java.util.concurrent.ThreadPoolExecutor#<init>(int, int, long, java.util.concurrent.TimeUnit, java.util.concurrent.BlockingQueue)
java.util.concurrent.ThreadPoolExecutor#<init>(int, int, long, java.util.concurrent.TimeUnit, java.util.concurrent.BlockingQueue, java.util.concurrent.ThreadFactory)

        return val;
    }

    /**
     * Encodes a long integer (4 bytes) in NDR format.
     *
     * @param l the long integer value to encode
     */
    public void enc_ndr_long(final int l) {
        align(4);
        Encdec.enc_uint32le(l, buf, index);
        advance(4);
    }

    /**
     * Decodes a long integer (4 bytes) from NDR format.
     *

            false, "keyword", 0, 0, null, null, false, null, null, null, null, null, false);
    protected final ColumnInfo _columnCreatedTime = cci("createdTime", "createdTime", null, null, Long.class, "createdTime", null, false,
            false, false, "Long", 0, 0, null, null, false, null, null, null, null, null, false);
    protected final ColumnInfo _columnPermissions = cci("permissions", "permissions", null, null, String[].class, "permissions", null,

      }
      return builder.buildOrThrow();
    }

    private double singleQuantileFromSorted(int index, int scale, double[] dataset) {
      long numerator = (long) index * (dataset.length - 1);
      int positionFloor = (int) LongMath.divide(numerator, scale, RoundingMode.DOWN);
      int remainder = (int) (numerator - positionFloor * scale);
      if (remainder == 0) {