*
 * <p>Like any other {@code Map<Class, Object>}, this map may contain entries for primitive types,
 * and a primitive type and its corresponding wrapper type may map to different values.
 *
 * @param <B> the common supertype that all entries must share; often this is simply {@link Object}
 * @author Ben Yu
 * @since 13.0
 */
@DoNotMock("Use ImmutableTypeToInstanceMap or MutableTypeToInstanceMap")

## About Starlette { #about-starlette }

You shouldn't pin the version of `starlette`.

Different versions of **FastAPI** will use a specific newer version of Starlette.

So, you can just let **FastAPI** use the correct Starlette version.

## About Pydantic { #about-pydantic }

## List of Amazon S3 APIs not supported on MinIO

We found the following APIs to be redundant or less useful outside of AWS S3. If you have a different view on any of the APIs we missed, please consider opening a [GitHub issue](https://github.com/minio/minio/issues) with relevant details on why MinIO must implement them.

### List of Amazon S3 Bucket APIs not supported on MinIO

    List<E> iteratorElements = new ArrayList<>();
    for (E element : collection) { // uses iterator()
      iteratorElements.add(element);
    }
    List<E> expected = copyToList(getOrderedElements());
    assertEquals("Different ordered iteration", expected, iteratorElements);
  }

  @CollectionFeature.Require(ALLOWS_NULL_VALUES)
  @CollectionSize.Require(absent = ZERO)
  public void testIterator_nullElement() {

    }

    /**
     * The logic used here used to be a copy of the logic used in the DefaultArtifactCollector, and this method was
     * called right before the actual version/artifactScope changes were done. However, a different set of conditionals
     * (and more information) is needed to be able to determine when and if the version and/or artifactScope changes.
     * See the two added methods, manageArtifactVersion and manageArtifactScope.
     */

 * cyclic buffer or ring buffer).
 *
 * <p>An evicting queue must be configured with a maximum size. Each time an element is added to a
 * full queue, the queue automatically removes its head element. This is different from conventional
 * bounded queues, which either block or reject new elements when full.
 *
 * <p>This class is not thread-safe, and does not accept null elements.
 *
 * @author Kurt Alfred Kluever
 * @since 15.0

		HTTPStatusCode: http.StatusBadRequest,
	},
	ErrSTSInvalidClientCertificate: {
		Code:           "InvalidClientCertificate",
		Description:    "The provided client certificate is invalid. Retry with a different certificate.",
		HTTPStatusCode: http.StatusBadRequest,
	},
	ErrSTSTooManyIntermediateCAs: {
		Code:           "TooManyIntermediateCAs",

- Provides a set of APIs and services for use from outside the module.
- Has a private implementation.
- Is owned by a single team. A team may own multiple architecture modules.

The modules are arranged into several different "Gradle platforms".
A Gradle platform is a logical distribution that provides support for a specific kind of automation.

Prefer either:
  * Provide only non-nullable version and move the `null` check to the call site (if the number of nullable callsites is low).
  * Provide two overloads with a different names (as Java doesn't support overloading on nullability). See 

 *       safe for the next task to start.</i>
 * </ul>
 *
 * <p>This class is similar to {@link MoreExecutors#newSequentialExecutor}. This class is different
 * in a few ways:
 *
 * <ul>
 *   <li>Each task may be associated with a different executor.
 *   <li>Tasks may be of type {@code AsyncCallable}.
 *   <li>Running tasks <i>cannot</i> be interrupted. (Note that {@code newSequentialExecutor} does