Map.ofEntries(
    Map.entry(boolean.class, Boolean.class),
    Map.entry(byte.class, Byte.class),
    Map.entry(char.class, Character.class),
    Map.entry(double.class, Double.class),
    Map.entry(float.class, Float.class),
    Map.entry(int.class, Integer.class),
    Map.entry(long.class, Long.class),
    Map.entry(short.class, Short.class),
    Map.entry(void.class, Void.class));

@Override
public Set<String> getSectionNames() {
  return Set.copyOf(raw.keySet());
}

@Override
public Set<String> getOptions(String section) {
  Require.nonNull("Section name to get options for", section);

  Map<String, Object> values = raw.getOrDefault(section, Map.of());
  return Collections.unmodifiableSortedSet(new TreeSet<>(values.keySet()));
}

private HttpResponse httpResponse(boolean ready, String message) {
  return new HttpResponse()
      .addHeader("Content-Type", JSON_UTF_8)
      .setContent(
          asJson(
              Map.of(
                  "value",
                  Map.of(
                      "ready", ready,
                      "message", message))));
}

          "events", Map.of("implementation", "org.openqa.selenium.events.local.GuavaEventBus"),
          "sessions",
              Map.of(
                  "implementation",
                  "org.openqa.selenium.grid.sessionmap.local.LocalSessionMap")));
}

  Require.nonNull("Underlying map", raw);

  Map<String, Map<String, Object>> validated = new HashMap<>();

  for (Map.Entry<String, Object> entry : raw.entrySet()) {
    if (!(entry.getValue() instanceof Map)) {
      continue;
    }

    Map<String, Object> values =
        ((Map<?, ?>) entry.getValue())
            .entrySet().stream()
                .filter(e -> e.getKey() instanceof String)
                .collect(
                    Collectors.toUnmodifiableMap(
                        e -> String.valueOf(e.getKey()), Map.Entry::getValue));

    validated.put(entry.getKey(), values);
  }

  this.raw = Collections.unmodifiableMap(validated);
}

  Objects.requireNonNull(roles);

  Set<Role> minimized = Set.copyOf(roles);

  return StreamSupport.stream(ServiceLoader.load(HasRoles.class).spliterator(), false)
      .filter(hasRoles -> !Collections.disjoint(hasRoles.getRoles(), minimized))
      .flatMap(DescribedOption::getAllFields)
      .collect(
          Collectors.collectingAndThen(
              Collectors.toCollection(TreeSet::new), Collections::unmodifiableSortedSet));
}