<code>
            <![CDATA[
    /**
     * Computes a hash value based on {@link #getType()} and {@link #getProvides()} values.
     */
    public int hashCode() {
        return java.util.Objects.hash(getType(), getProvides());
    } //-- int hashCode()

    /**
     * Checks equality based on {@link #getType()} and {@link #getProvides()} values.
     */
    public boolean equals(Object other) {

/// note

FastAPI will know that the value of `q` is not required because of the default value `= None`.

The `str | None` is not used by FastAPI to determine that the value is not required, it will know it's not required because it has a default value of `= None`.

But adding the type annotations will allow your editor to give you better support and detect errors.

  public NavigableMap<K, V> tailMap(K fromKey, boolean inclusive) {
    return new SafeTreeMap<>(delegate.tailMap(checkValid(fromKey), inclusive));
  }

  @Override
  public Collection<V> values() {
    return delegate.values();
  }

  @CanIgnoreReturnValue
  private <T> T checkValid(T t) {
    // a ClassCastException is what's supposed to happen!
    @SuppressWarnings("unchecked")
    K k = (K) t;

    return generateListMultimap(key, value);
  }

  @Generates
  static <K, V> ImmutableMultimap<K, V> generateImmutableMultimap(K key, V value) {
    return ImmutableMultimap.of(key, value);
  }

  @Generates
  static <K, V> ListMultimap<K, V> generateListMultimap(@Nullable K key, @Nullable V value) {
    return generateArrayListMultimap(key, value);
  }

  @Generates

      ImmutableMap.Builder<Integer, UnhashableObject> builder = ImmutableMap.builder();
      int key = 1;
      for (UnhashableObject value : elements) {
        builder.put(key++, value);
      }
      return builder.buildOrThrow().values();
    }
  }

  public static class ImmutableMapKeyListGenerator extends TestStringListGenerator {
    @Override
    public List<String> create(String[] elements) {

    val reportOnly: Provider<Boolean>
)

private class ConcurrentMultiMap<K, V> {
    private val map = ConcurrentHashMap<K, MutableSet<V>>()

    fun add(key: K, value: V) =
        map.computeIfAbsent(key, { _ -> ConcurrentHashMap.newKeySet() }).add(value)

    fun getOrEmpty(key: K): Set<V> = map[key] ?: emptySet()
}

abstract class TestFilesCleanupService @Inject constructor(

     *
     * @param value the integer value to convert
     * @param length the desired length of the hex string
     * @return the hexadecimal string representation
     */
    public static String bin_to_hex(int value, final int length) {
        final char[] arr = new char[length];
        int ai = arr.length;
        while (ai-- > 0) {
            arr[ai] = HEXCHARS[value & 0xF];
            value >>>= 4;
        }

        // Decode
        smbInfoAllocation.decode(buffer, 0, buffer.length);

        // The implementation reads values as signed integers and stores them as long
        // Negative values remain negative when stored in long fields
        // The calculations will result in negative values
        long expectedCapacity = (long) alloc * sectPerAlloc * bytesPerSect;

 * way of "cutting" a "number line" (actually of instances of type {@code C}, not necessarily
 * "numbers") into two sections; this can be done below a certain value, above a certain value,
 * below all values or above all values. With this object defined in this way, an interval can
 * always be represented by a pair of {@code Cut} instances.
 *
 * @author Kevin Bourrillion
 */

     */
    @Required
    @Min(value = 1)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer numOfThread;

    /**
     * The interval time between requests in milliseconds.
     */
    @Required
    @Min(value = 0)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer intervalTime;

    /**
     * The boost value for documents from this web configuration.