* <p>
     * If <code>type</code> is not an array of parameterized types, <code>null</code> is returned.
     * </p>
     *
     * @param type
     *            the type to analyze
     * @return the element type of the array, or null if not an array of parameterized types
     */
    public static Type getElementTypeOfArray(final Type type) {
        if (!(type instanceof GenericArrayType)) {
            return null;

import jakarta.validation.constraints.Size;

/**
 * Form class for editing label types in the admin interface.
 * This form extends CreateForm to include fields necessary for updating existing label type entries,
 * including tracking information for optimistic locking and audit trails.
 * Label types are used to categorize and filter documents in search results.
 *
 */
public class EditForm extends CreateForm {

@app.command()
def make_pr(
    *,
    language: Annotated[str | None, typer.Option(envvar="LANGUAGE")] = None,
    command: Annotated[str | None, typer.Option(envvar="COMMAND")] = None,
    github_token: Annotated[str, typer.Option(envvar="GITHUB_TOKEN")],
    github_repository: Annotated[str, typer.Option(envvar="GITHUB_REPOSITORY")],
    commit_in_place: Annotated[
        bool, typer.Option(envvar="COMMIT_IN_PLACE", show_default=True)
    ] = False,

  }

  @CanIgnoreReturnValue
  Type[] resolveTypesInPlace(Type[] types) {
    for (int i = 0; i < types.length; i++) {
      types[i] = resolveType(types[i]);
    }
    return types;
  }

  private Type[] resolveTypes(Type[] types) {
    Type[] result = new Type[types.length];
    for (int i = 0; i < types.length; i++) {
      result[i] = resolveType(types[i]);
    }
    return result;
  }

    // Packet Types (ptype)
    /**
     * Request packet type
     */
    int RPC_PT_REQUEST = 0x00;
    /**
     * Ping packet type
     */
    int RPC_PT_PING = 0x01;
    /**
     * Response packet type
     */
    int RPC_PT_RESPONSE = 0x02;
    /**
     * Fault packet type - indicates an error
     */
    int RPC_PT_FAULT = 0x03;
    /**

		return errors.New("value is not valid utf-8")
	}
	// Fallback to string
	v.setString(asString)
	return err
}

// When numeric types are compared, type promotions could happen. If
// values do not have types (e.g. when reading from CSV), for
// comparison operations, automatic type conversion happens by trying
// to check if the value is a number (first an integer, then a float),
// and falling back to string.

import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * A type implemented by, or extended by maven itself.
 * Maven provides implementations of those types and may inject them in plugins.
 * <p>
 * A type can be marked {@link Consumer} or {@link Provider} but not both. A type is assumed to be
 * {@link Consumer} if it is not marked either {@link Consumer} or {@link Provider}.
 * <p>

    assertNotPrimitive(type);
    assertEquals(TypeToken.of(Primitives.unwrap((Class<?>) type.getType())), type.unwrap());
  }

  private static void assertNotWrapper(TypeToken<?> type) {
    assertThat(type.unwrap()).isEqualTo(type);
  }

  private static void assertNotPrimitiveNorWrapper(TypeToken<?> type) {
    assertNotPrimitive(type);
    assertNotWrapper(type);
  }

}

// CurrentStats returns the current statistics.
func CurrentStats() map[string]types.TargetStats {
	sys := SystemTargets()
	audit := AuditTargets()
	res := make(map[string]types.TargetStats, len(sys)+len(audit))
	cnt := make(map[string]int, len(sys)+len(audit))

	// Add system and audit.
	for _, t := range sys {
		key := strings.ToLower(t.Type().String())
		n := cnt[key]
		cnt[key]++

{* ../../docs_src/body/tutorial001_py310.py hl[16] *}

... et déclarez que son type est le modèle que vous avez créé : `Item`.

## Résultats { #results }

En utilisant uniquement les déclarations de type Python, **FastAPI** réussit à :

* Lire le contenu de la requête en tant que JSON.
* Convertir les types correspondants (si nécessaire).
* Valider la donnée.