## Importe `Cookie` { #import-cookie }

Primeiro importe `Cookie`:

{* ../../docs_src/cookie_params/tutorial001_an_py310.py hl[3] *}

## Declare parâmetros de `Cookie` { #declare-cookie-parameters }

Então declare os parâmetros de cookie usando a mesma estrutura que em `Path` e `Query`.

Você pode definir o valor padrão, assim como todas as validações extras ou parâmetros de anotação:

```JSON
{"item_id":"foo"}
```

## Parámetros de path con tipos { #path-parameters-with-types }

Puedes declarar el tipo de un parámetro de path en la función, usando anotaciones de tipos estándar de Python:

{* ../../docs_src/path_params/tutorial002_py39.py hl[7] *}

En este caso, `item_id` se declara como un `int`.

/// check | Revisa

Each "scope" is just a string (without spaces).

They are normally used to declare specific security permissions, for example:

* `users:read` or `users:write` are common examples.
* `instagram_basic` is used by Facebook / Instagram.
* `https://www.googleapis.com/auth/drive` is used by Google.

/// info

In OAuth2 a "scope" is just a string that declares a specific permission required.

///

/// note

This is supported since FastAPI version `0.113.0`. 🤓

///

## Pydantic Models for Forms { #pydantic-models-for-forms }

You just need to declare a **Pydantic model** with the fields you want to receive as **form fields**, and then declare the parameter as `Form`:

{* ../../docs_src/request_form_models/tutorial001_an_py39.py hl[9:11,15] *}

Because each SQLModel model is also a Pydantic model, you can use it in the same **type annotations** that you could use Pydantic models.

For example, if you declare a parameter of type `Hero`, it will be read from the **JSON body**.

The same way, you can declare it as the function's **return type**, and then the shape of the data will show up in the automatic API docs UI.

## Liste de paramètres / valeurs multiples via Query

Quand on définit un paramètre de requête explicitement avec `Query` on peut aussi déclarer qu'il reçoit une liste de valeur, ou des "valeurs multiples".

Par exemple, pour déclarer un paramètre de requête `q` qui peut apparaître plusieurs fois dans une URL, on écrit :

{* ../../docs_src/query_params_str_validations/tutorial011.py hl[9] *}

Podemos fazer melhor...

## O que caracteriza uma dependência { #what-makes-a-dependency }

Até agora você apenas viu dependências declaradas como funções.

Mas essa não é a única forma de declarar dependências (mesmo que provavelmente seja a mais comum).

O fator principal para uma dependência é que ela deve ser "chamável"

Um objeto "chamável" em Python é qualquer coisa que o Python possa "chamar" como uma função

  private final ImmutableList<Annotation> annotations;

  /**
   * An {@code AnnotatedType} instance, or {@code null} under Android VMs (possible only when using
   * the Android flavor of Guava). The field is declared with a type of {@code Object} to avoid
   * compatibility problems on Android VMs. The corresponding accessor method, however, can have the

Si tienes chequeos estrictos de tipos en tu editor, mypy, etc., puedes declarar el tipo de retorno de la función como `Any`.

De esa manera le dices al editor que intencionalmente estás devolviendo cualquier cosa. Pero FastAPI todavía hará la documentación de datos, validación, filtrado, etc. con `response_model`.

///

### Prioridad del `response_model` { #response-model-priority }

```JSON
{
    "name": "Foo",
    "price": 45.2
}
```

## Declare it as a parameter { #declare-it-as-a-parameter }

To add it to your *path operation*, declare it the same way you declared path and query parameters:

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

...and declare its type as the model you created, `Item`.

## Results { #results }

With just that Python type declaration, **FastAPI** will: