In the previous example, because the classes were different, we had to use the `response_model` parameter. But that also means that we don't get the support from the editor and tools checking the function return type.

But in most of the cases where we need to do something like this, we want the model just to **filter/remove** some of the data as in this example.

No exemplo anterior, como as classes eram diferentes, tivemos que usar o parâmetro `response_model`. Mas isso também significa que não temos suporte do editor e das ferramentas verificando o tipo de retorno da função.

Mas na maioria dos casos em que precisamos fazer algo assim, queremos que o modelo apenas **filtre/remova** alguns dados como neste exemplo.

  }

  /** Test that giving a null 'safeChars' string causes a {@link NullPointerException}. */
  public void testBadArguments_null() {
    assertThrows(NullPointerException.class, () -> new PercentEscaper(null, false));
  }

  /**
   * Tests that specifying any alphanumeric characters as 'safe' causes an {@link
   * IllegalArgumentException}.
   */
  public void testBadArguments_badchars() {

# Requisições Personalizadas e Classes da APIRoute

Em algum casos, você pode querer sobreescrever a lógica usada pelas classes `Request`e `APIRoute`.

Em particular, isso pode ser uma boa alternativa para uma lógica em um middleware

Por exemplo, se você quiser ler ou manipular o corpo da requisição antes que ele seja processado pela sua aplicação.

/// danger | Perigo

Isso é um recurso "avançado".

     *       then the test dependency will be placed on the Java {@code --patch-module} option instead of the
     *       class path.</li>
     * </ul>
     */
    CLASSES(StandardLocation.CLASS_PATH, "--class-path"),

    /**
     * The path identified by the Java {@code --module-path} option.
     * Used for compilation, execution and Javadoc among others.

/**
 * Marker interface to indicate services that can be provided by plugins and extensions.
 * <p>
 * This interface serves as the base for all Service Provider Interface (SPI) components in Maven.
 * Classes implementing this interface can be discovered and loaded by Maven through the
 * Java ServiceLoader mechanism, allowing plugins and extensions to contribute functionality
 * to the Maven build process.
 * <p>

    ListenableFuture -- but is also available in a second "version" that
    contains com.google.common.util.concurrent.ListenableFuture class, without
    any other Guava classes. The idea is:

    - If users want only ListenableFuture, they depend on listenablefuture-1.0.

    - If users want all of Guava, they depend on guava, which, as of Guava
    27.0, depends on

import org.apache.maven.api.plugin.descriptor.PluginDescriptor;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;

/**
 * Verifies that subclasses from generated model classes are possible.
 */
class ExtendedPluginDescriptorTest {

    /**
     * A subclass of the generated class {@link PluginDescriptor} that adds an additional field.
     */

@file:Suppress(
  "CANNOT_OVERRIDE_INVISIBLE_MEMBER",
  "INVISIBLE_MEMBER",
  "INVISIBLE_REFERENCE",
)

package okhttp3

import java.io.IOException
import okhttp3.internal.SuppressSignatureCheck

/** Data classes that correspond to each of the methods of [ConnectionListener]. */
@SuppressSignatureCheck
sealed class ConnectionEvent {
  abstract val timestampNs: Long
  open val connection: Connection?
    get() = null

    ]]></description>

  <defaults>
    <default>
      <key>package</key>
      <value>org.apache.maven.toolchain.model</value>
    </default>
  </defaults>

  <classes>
    <class java.clone="deep">
      <name>TrackableBase</name>
      <version>1.1.0+</version>
      <description>
        Common base class that contains code to track the source for this instance.
      </description>