* to the build path.
 *
 * @since 4.0.0
 */
@Experimental
@Immutable
public interface Type extends ExtensibleEnum {
    /**
     * Artifact type name for a POM file.
     */
    String POM = "pom";

    /**
     * Artifact type name for a BOM file.
     */
    String BOM = "bom";

    /**
     * Artifact type name for a JAR file that can be placed either on the class-path or on the module-path.

import types
from enum import Enum
from typing import Any, Callable, Dict, Set, Type, TypeVar, Union

from pydantic import BaseModel

DecoratedCallable = TypeVar("DecoratedCallable", bound=Callable[..., Any])
UnionType = getattr(types, "UnionType", Union)
ModelNameMap = Dict[Union[Type[BaseModel], Type[Enum]], str]

Todo **FastAPI** está basado en estos type hints, lo que le da muchas ventajas y beneficios.

Pero, así nunca uses **FastAPI** te beneficiarás de aprender un poco sobre los type hints.

!!! note "Nota"
    Si eres un experto en Python y ya lo sabes todo sobre los type hints, salta al siguiente capítulo.

<img src="/img/python-types/image02.png">

Com isso, você pode rolar, vendo as opções, até encontrar o que "toca uma campainha":

<img src="/img/python-types/image03.png">

## Mais motivação

Marque esta função, ela já possui type hints:

```Python hl_lines="1"
{!../../../docs_src/python_types/tutorial003.py!}
```

// Error implements Error interface
func (b BatchJobYamlErr) Error() string {
	return fmt.Sprintf("%s\n Hint: error near line: %d, col: %d", b.msg, b.line, b.col)
}

// BatchJobKV is a key-value data type which supports wildcard matching
type BatchJobKV struct {
	line, col int
	Key       string `yaml:"key" json:"key"`
	Value     string `yaml:"value" json:"value"`
}

var _ yaml.Unmarshaler = &BatchJobKV{}

import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

@Target({FIELD, METHOD, TYPE})
@Retention(RUNTIME)
@Documented
public @interface Typed {
    Class<?>[] value() default {};

          "type": "object"
        },
        "labels": {
          "type": "object"
        },
        "name": {
          "type": "string"
        },
        "nodeSelector": {
          "type": "object"
        },
        "podAnnotations": {
          "type": "object",
          "properties": {
            "inject.istio.io/templates": {
              "type": "string"
            },

            KtTypeMappingMode.RETURN_TYPE_BOXED -> TypeMappingMode.RETURN_TYPE_BOXED
            KtTypeMappingMode.RETURN_TYPE ->
                typeMapper.typeContext.getOptimalModeForReturnType(type.fe10Type, isAnnotationMethod)
            KtTypeMappingMode.VALUE_PARAMETER ->
                typeMapper.typeContext.getOptimalModeForValueParameter(type.fe10Type)
        }.let { typeMappingMode ->

    /**
     * Performs a collection lookup for given typed components.
     *
     * @param type The component type.
     * @return The map of components. The map may be empty if no components found.
     * @param <T> The component type.
     * @throws LookupException if there is some provisioning related issue.
     */
    @Nonnull
    <T> Map<String, T> lookupMap(Class<T> type);

                            "type": "array",
                            "items": {
                                "anyOf": [{"type": "string"}, {"type": "integer"}]
                            },
                        },
                        "msg": {"title": "Message", "type": "string"},
                        "type": {"title": "Error Type", "type": "string"},
                    },
                },