"price": 35.4,
                        "tax": 3.2,
                    },
                },
                "converted": {
                    "summary": "An example with converted data",
                    "description": "FastAPI can convert price `strings` to actual `numbers` automatically",
                    "value": {
                        "name": "Bar",

     */
    public void setSuggestDetail(final boolean suggestDetail) {
        this.suggestDetail = suggestDetail;
    }

    /**
     * Sets the reading converter.
     * @param readingConverter The reading converter.
     */
    public void setReadingConverter(final ReadingConverter readingConverter) {
        this.readingConverter = readingConverter;
    }

    /**

## Converter qualquer dado para compatível com JSON { #convert-any-data-to-json-compatible }

Para converter qualquer dado para um formato compatível com JSON, leia a documentação de [Tutorial - Codificador Compatível com JSON](../tutorial/encoder.md).

        assertEquals(0, results.length);
        assertNull(response.getLastName());
    }

    @Test
    @DisplayName("Test readDataWireFormat with converter offset")
    void testReadDataWireFormatWithConverter() throws Exception {
        // Set converter to test offset calculation
        int converterValue = 100;
        setConverter(response, converterValue);
        setNumEntries(response, 1);

# Codificador Compatível com JSON { #json-compatible-encoder }

Existem alguns casos em que você pode precisar converter um tipo de dados (como um modelo Pydantic) para algo compatível com JSON (como um `dict`, `list`, etc).

Por exemplo, se você precisar armazená-lo em um banco de dados.

Para isso, **FastAPI** fornece uma função `jsonable_encoder()`.

## Usando a função `jsonable_encoder` { #using-the-jsonable-encoder }

Mas se o dado não existir, você quer criá-lo e retornar um código de status HTTP de "CREATED" `201`.

Mas você ainda quer ser capaz de filtrar e converter o dado que você retornará com um `response_model`.

Para estes casos, você pode utilizar um parâmetro `Response`.

## Use um parâmetro `Response` { #use-a-response-parameter }

      T defaultType = (T) getFirstTypeParameter(type.getType());
      return defaultType;
    }
    if (type.getRawType() == Converter.class) {
      TypeToken<?> convertFromType = type.resolveType(Converter.class.getTypeParameters()[0]);
      TypeToken<?> convertToType = type.resolveType(Converter.class.getTypeParameters()[1]);
      @SuppressWarnings("unchecked") // returns default for both F and T

    }

    /**
     * Convert property using appropriate converter.
     */
    private Object convertProperty(
            Class<?> beanType, Class<?> rawPropertyType, Type genericPropertyType, PlexusConfiguration configuration)
            throws ComponentConfigurationException {

        ConfigurationConverter converter = lookup.lookupConverterForType(rawPropertyType);

     */
    protected BooleanConversionUtil() {
    }

    /**
     * Converts to {@link Boolean}.
     *
     * @param o
     *            The object to convert
     * @return The converted {@link Boolean}
     */
    public static Boolean toBoolean(final Object o) {
        return switch (o) {
        case null -> null;
        case Boolean b -> b;
        case Number n -> n.intValue() != 0;

  }

  /**
   * Returns a serializable {@code Converter} that converts strings from this format to {@code
   * targetFormat}.
   *
   * @since 16.0
   */
  public Converter<String, String> converterTo(CaseFormat targetFormat) {
    return new StringConverter(this, targetFormat);
  }

  private static final class StringConverter extends Converter<String, String>
      implements Serializable {