}

    /**
     * Sets the default timeout for complete calls. A value of 0 means no timeout, otherwise values
     * must be between 1 and [Integer.MAX_VALUE] when converted to milliseconds.
     *
     * The call timeout spans the entire call: resolving DNS, connecting, writing the request body,
     * server processing, and reading the response body. If the call requires redirects or retries

    private final JavadocConverter javadocConverter;
    private final GenerationListener listener;

    public ClassDocMethodsBuilder(JavadocConverter converter, GenerationListener listener) {
        this.javadocConverter = converter;
        this.listener = listener;
    }

    /**
     * Builds the methods and script blocks of the given class. Assumes properties have already been built.
     */

     * @param clazz the class type to convert the value to
     * @param defaultValue the default value to return if the key is not found or conversion fails
     * @return the converted value or the default value if not found
     */
    public static <T> T getValue(final Map<String, Object> doc, final String key, final Class<T> clazz, final T defaultValue) {
        final T value = getValue(doc, key, clazz);

 * possible readings.
 * </p>
 *
 * <p>
 * The class also utilizes ICU4J's {@link com.ibm.icu.text.Transliterator} to convert full-width characters
 * to half-width and to convert any characters to lowercase, ensuring consistency in the output.
 * </p>
 *
 * <p>
 * Example:
 * For the input "キャ", the converter might return a list containing "kya".

                    final String converted = URLEncoder.encode(target, Constants.UTF_8);
                    if (target.equals(converted)) {
                        encodedBuf.append(Base64.getUrlEncoder().encodeToString(target.getBytes(Constants.CHARSET_UTF_8)));
                    } else {
                        encodedBuf.append(converted);
                    }

    this.min = min;
    this.max = max;
  }

  /**
   * Returns statistics over a dataset containing the given values.
   *
   * @param values a series of values, which will be converted to {@code double} values (this may
   *     cause loss of precision)
   */
  public static Stats of(Iterable<? extends Number> values) {
    StatsAccumulator accumulator = new StatsAccumulator();

a `response_class` with a JSON media type (`application/json`), like is the case with the `JSONResponse`, the data you return will be automatically converted (and filtered) with any Pydantic `response_model` that you declared in the *path operation decorator*. But the data won't be serialized to JSON bytes with Pydantic, instead it will be converted with the `jsonable_encoder` and then passed to the `JSONResponse` class, which will serialize it to bytes using the standard JSON library in Python....

import java.util.Map;

import org.codelibs.fess.suggest.Suggester;
import org.codelibs.fess.suggest.analysis.SuggestAnalyzer;
import org.codelibs.fess.suggest.converter.KatakanaToAlphabetConverter;
import org.codelibs.fess.suggest.converter.ReadingConverter;
import org.codelibs.fess.suggest.converter.ReadingConverterChain;
import org.codelibs.fess.suggest.entity.SuggestItem;
import org.codelibs.fess.suggest.index.contents.querylog.QueryLog;

 * ListenableFuture} directly.
 *
 * <p>For interoperability between {@code ListenableFuture} and <b>{@code CompletableFuture}</b>,
 * consider <a href="https://github.com/lukas-krecan/future-converter">Future Converter</a>.
 *
 * @author Sven Mawson
 * @since 10.0 (replacing {@code Futures.makeListenable}, which existed in 1.0)
 */
@J2ktIncompatible
@GwtIncompatible
public final class JdkFutureAdapters {
  /**

You couldn't get this kind of editor support if you were working directly with `dict` instead of Pydantic models.

But you don't have to worry about them either, incoming dicts are converted automatically and your output is converted automatically to JSON too.

## Bodies of arbitrary `dict`s { #bodies-of-arbitrary-dicts }

You can also declare a body as a `dict` with keys of some type and values of some other type.