* value.
   */
  @SuppressWarnings("Immutable")
  @LazyInit
  private int registrySuffixIndexCache = SUFFIX_NOT_INITIALIZED;

  /** Constructor used to implement {@link #from(String)}, and from subclasses. */
  InternetDomainName(String name) {
    // Normalize:
    // * ASCII characters to lowercase
    // * All dot-like characters to '.'
    // * Strip trailing '.'

     *
     * @return the context class loader
     */
    public static ClassLoader getClassLoader() {
        return Thread.currentThread().getContextClassLoader();
    }

    /**
     * Returns the resource from the context class loader.
     *
     * @param path
     *            The resource path. Must not be {@literal null} or empty string.
     * @return The resource {@link URL}
     * @see #getResource(String, String)
     */

1a) Send encrypted data key and master key ID to KMS.
1b) Receive decrypted data key.
2)  Decrypt encrypted object key with the KEK derived from the data key.
3a) Receive new plain data key from the KMS using the master key ID of the server config.
3b) Receive encrypted form of the data key from the KMS.
4)  Derive a new KEK from the new data key and re-encrypt the OEK with it.
5)  Store the encrypted OEK encrypted data key and master key ID in object metadata.

```

/// note | Technical Details

You could also use `from starlette.requests import Request` and `from starlette.responses import JSONResponse`.

**FastAPI** provides the same `starlette.responses` as `fastapi.responses` just as a convenience for you, the developer. But most of the available responses come directly from Starlette. The same with `Request`.

///

 * @author koichik
 */
public abstract class SchemaUtil {

    /**
     * Do not instantiate.
     */
    protected SchemaUtil() {
    }

    /**
     * Generates a {@link Schema} for W3C XML Schema from a file.
     *
     * @param schema
     *            W3C XML Schema file. Must not be {@literal null}.
     * @return {@link Schema}
     */
    public static Schema newW3cXmlSchema(final File schema) {

        return total;
      }
    },
    NEW {
      @Override
      long copy(Readable from, Appendable to) throws IOException {
        return CharStreams.copy(from, to);
      }
    };

    abstract long copy(Readable from, Appendable to) throws IOException;
  }

  enum TargetSupplier {
    STRING_WRITER {
      @Override
      Appendable get(int sz) {
        return new StringWriter(sz);
      }
    },

     *            The {@link Reader} to read strings from. Must not be {@literal null}.
     */
    public LineIterator(final Reader reader) {
        assertArgumentNotNull("reader", reader);
        this.reader = new BufferedReader(reader);
    }

    /**
     * Constructs an instance.
     *
     * @param reader
     *            The {@link BufferedReader} to read strings from. Must not be {@literal null}.
     */

There are several custom response classes you can use to create an instance and return them directly from your *path operations*.

Read more about it in the [FastAPI docs for Custom Response - HTML, Stream, File, others](https://fastapi.tiangolo.com/advanced/custom-response/).

You can import them directly from `fastapi.responses`:

```python
from fastapi.responses import (
    FileResponse,
    HTMLResponse,
    JSONResponse,

# -*- coding: utf-8 -*-
import json
# standard.
import os

import certifi
# Dependencies
import urllib3
from botocore.credentials import CredentialProvider, RefreshableCredentials
from botocore.exceptions import CredentialRetrievalError
from dateutil.parser import parse

from .sts_element import STSElement


class ClientGrantsCredentialProvider(CredentialProvider):
    """

 *       bytes of the source as they are read from it. A source that provides such streams will not
 *       be reusable, and operations that read from the stream (including {@link #size()}, in some
 *       implementations) will prevent further operations from completing as expected.
 * </ul>
 *
 * @since 14.0
 * @author Colin Decker
 */
@J2ktIncompatible