}
    }

    private List<String> filterChangesToReport(CtClass c, Map<String, CtClass> interfaces) {
        return interfaces.values().findAll { implementedDirectly(it, c) && addedInterfaceIsIncubatingOrInternal(it, c) }*.name.sort()
    }

    private boolean implementedDirectly(CtClass interf, CtClass c) {
        return c.interfaces.any { it.name == interf.name }
    }

    @Incubating
    interface IncubatingInterface {}

    interface InternalInterface {}

    interface StablePublicInterface {}

    CtClass oldBase
    CtClass newBase
    CtClass newSuper
    CtClass newIncubatingBase
    CtClass internalInterface
    CtClass incubatingInterface
    CtClass stablePublicInterface

    Map interfaces

    def setup() {

    interfaces.remove(AutoCloseable.class);
    @SuppressWarnings("unchecked") // super interface type of T
    Class<? super T> interfaceType = (Class<? super T>) Iterables.getOnlyElement(interfaces);
    new ForwardingWrapperTester()
        .testForwarding(
            interfaceType,
            new Function<Object, T>() {
              @Override
              public T apply(Object delegate) {

  /**
   * A set containing none of the optional features of the {@link Iterator} or {@link ListIterator}
   * interfaces.
   */
  public static final Set<IteratorFeature> UNMODIFIABLE = emptySet();

  /**
   * A set containing all of the optional features of the {@link Iterator} and {@link ListIterator}
   * interfaces.
   */
  public static final Set<IteratorFeature> MODIFIABLE =

    void addClassExtension(ClassExtensionDoc extensionDoc) {
        classExtensions.add(extensionDoc)
    }

    List<ClassDoc> getSuperTypes() {
        return superClass == null ? interfaces : [superClass] + interfaces
    }

    Element getClassSection() { return classSection }

    Element getPropertiesTable() { return propertiesTable }

    def getPropertiesSection() { return propertiesSection }

        try {
            List<NetworkInterface> interfaces = Collections.list(NetworkInterface.getNetworkInterfaces());
            interfaces.removeIf(ni -> {
                try {
                    return ni.isLoopback() || !ni.isUp() || ni.isVirtual();
                } catch (Exception e) {
                    return true;
                }
            });
            return interfaces;
        } catch (Exception e) {

  /**
   * A set containing none of the optional features of the {@link Iterator} or {@link ListIterator}
   * interfaces.
   */
  public static final Set<IteratorFeature> UNMODIFIABLE = emptySet();

  /**
   * A set containing all of the optional features of the {@link Iterator} and {@link ListIterator}
   * interfaces.
   */
  public static final Set<IteratorFeature> MODIFIABLE =

            return;
        }
        
        // Query network interfaces from server
        queryRemoteInterfaces();
        
        // Discover local interfaces
        discoverLocalInterfaces();
        
        // Enable multi-channel if we have multiple usable interfaces
        if (canEnableMultiChannel()) {
            multiChannelEnabled = true;

Se você quiser desativar completamente o esquema OpenAPI, pode definir `openapi_url=None`, o que também desativará as interfaces de documentação que o utilizam.

## URLs da Documentação { #docs-urls }

Você pode configurar as duas interfaces de documentação incluídas:

* **Swagger UI**: acessível em `/docs`.
    * Você pode definir sua URL com o parâmetro `docs_url`.

## Sobre seguridad, APIs y documentación { #about-security-apis-and-docs }

Ocultar las interfaces de usuario de la documentación en producción *no debería* ser la forma de proteger tu API.

Eso no añade ninguna seguridad extra a tu API, las *path operations* seguirán estando disponibles donde están.