*
   * @param formalType is {@code Foo<formalType>} a supertype of {@code Foo<T>}?
   * @param declaration The type variable in the context of a parameterized type. Used to infer type
   *     bound when {@code formalType} is a wildcard with implicit upper bound.
   */
  private boolean is(Type formalType, TypeVariable<?> declaration) {
    if (runtimeType.equals(formalType)) {
      return true;
    }

  }

  @GwtIncompatible
  @J2ktIncompatible
  /*
   * The mainline copy of ImmutableMapValues doesn't produce this serialized form anymore, though
   * the backport does. For now, we're keeping the class declaration in *both* flavors so that both
   * flavors can read old data or data from the other flavor. However, we strongly discourage
   * relying on this, as we have made incompatible changes to serialized forms in the past and

    }
  }

  /**
   * Returns a new {@link TypeVariable} that belongs to {@code declaration} with {@code name} and
   * {@code bounds}.
   */
  static <D extends GenericDeclaration> TypeVariable<D> newArtificialTypeVariable(
      D declaration, String name, Type... bounds) {
    return newTypeVariableImpl(
        declaration, name, (bounds.length == 0) ? new Type[] {Object.class} : bounds);
  }

///

## Duplicate headers { #duplicate-headers }

It is possible to receive duplicate headers. That means, the same header with multiple values.

You can define those cases using a list in the type declaration.

You will receive all the values from the duplicate header as a Python `list`.

For example, to declare a header of `X-Token` that can appear more than once, you can write:

To create the callback *path operation* use the same `APIRouter` you created above.

It should look just like a normal FastAPI *path operation*:

* It should probably have a declaration of the body it should receive, e.g. `body: InvoiceEvent`.
* And it could also have a declaration of the response it should return, e.g. `response_model=InvoiceEventReceived`.

{* ../../docs_src/openapi_callbacks/tutorial001_py310.py hl[14:16,19:20,26:30] *}

  }

  @GwtIncompatible
  @J2ktIncompatible
  /*
   * The mainline copy of ImmutableMapValues doesn't produce this serialized form anymore, though
   * the backport does. For now, we're keeping the class declaration in *both* flavors so that both
   * flavors can read old data or data from the other flavor. However, we strongly discourage
   * relying on this, as we have made incompatible changes to serialized forms in the past and

  <suppress files="server[/\\]src[/\\]test[/\\]java[/\\]org[/\\]elasticsearch[/\\]plugins[/\\]PluginsServiceTests.java" checks="RedundantModifier" />

  <!-- Intentionally doesn't have a package declaration to test logging
    configuration of classes that aren't in packages. -->
  <suppress files="test[/\\]framework[/\\]src[/\\]test[/\\]java[/\\]Dummy.java" checks="PackageDeclaration" />

   * explicit {@code @NullableDecl} annotation (see <a
   * href="https://github.com/google/guava/issues/1819">#1819</a>).
   *
   * <p>It is not necessary to consider visibility, return type, or type parameter declarations. The
   * declaration of a method with the same name and formal parameters as {@link Object#equals} that
   * is not public and boolean-returning, or that declares any type parameters, would be rejected at
   * compile-time.
   */

      example, this does not allow interface methods to be declared public
      because they are *always* public. -->
    <module name="RedundantModifier" />
    <!-- Checks that all java files have a package declaration and that it
      lines up with the directory structure. -->
    <module name="PackageDeclaration" />

    <!-- Checks that a local variable or a parameter does not shadow a field that is defined in the same class. -->

    return accessibleObject.getDeclaredAnnotations();
  }

  // We ought to be able to implement GenericDeclaration instead its parent AnnotatedElement.
  // That would give us this method declaration. But for some reason, implementing
  // GenericDeclaration leads to weird errors in Android tests:
  // IncompatibleClassChangeError: interface not implemented