{!> ../../../docs_src/header_params/tutorial003.py!}
    ```

Se você se comunicar com essa *operação de caminho* enviando dois cabeçalhos HTTP como:

```
X-Token: foo
X-Token: bar
```

A resposta seria como:

```JSON
{
    "X-Token values": [
        "bar",
        "foo"
    ]
}
```

## Recapitulando

E você ainda terá os mesmos recursos que viu até agora:

* Ótimo suporte do editor.
* Conversão de dados das requisições recebidas.
* Conversão de dados para os dados da resposta.
* Validação de dados.
* Anotação e documentação automáticas.

## Outros tipos de dados

Aqui estão alguns dos tipos de dados adicionais que você pode usar:

* `UUID`:

```

você receberá os múltiplos *parâmetros de consulta* `q` com os valores (`foo` e `bar`) em uma lista (`list`) Python dentro da *função de operação de rota*, no *parâmetro da função* `q`.

Assim, a resposta para essa URL seria:

```JSON
{
  "q": [
    "foo",
    "bar"
  ]
}
```

!!! tip "Dica"

!!! tip "Dica"
    Ao declarar `response_class=HTMLResponse`, a documentação entenderá que a resposta será HTML.


!!! note "Detalhes Técnicos"
    Você também poderia usar `from starlette.templating import Jinja2Templates`.

```
{
  "item": "The Foo Wrestlers"
}
```

Mas se o cliente faz uma requisição para `http://example.com/items/bar` (ou seja, um não existente `item_id "bar"`), esse cliente receberá um HTTP status code 404 (o erro "não encontrado" — *not found error*), e uma resposta JSON:

```JSON
{
  "detail": "Item not found"
}
```

{!../../../docs_src/body_nested_models/tutorial003.py!}
```

Com isso, mesmo que você receba uma requisição contendo dados duplicados, ela será convertida em um conjunto de itens exclusivos.

E sempre que você enviar esses dados como resposta, mesmo se a fonte tiver duplicatas, eles serão gerados como um conjunto de itens exclusivos.

E também teremos anotações/documentação em conformidade.

## Modelos aninhados

    dispatcher.maxRequests = 1
    client =
      client.newBuilder()
        .dispatcher(dispatcher)
        .build()
    val requestA = Request(server.url("/a"))
    val requestB = Request(server.url("/b"))
    val callA = client.newCall(requestA)
    val callB = client.newCall(requestB)
    server.dispatcher =
      object : mockwebserver3.Dispatcher() {
        var nextResponse = 'A'

```Python hl_lines="15-23"
{!../../../docs_src/schema_extra_example/tutorial001.py!}
```

Essas informações extras serão adicionadas como se encontram no **JSON Schema** de resposta desse modelo e serão usadas na documentação da API.

!!! tip "Dica"
    Você pode usar a mesma técnica para estender o JSON Schema e adicionar suas próprias informações extras de forma personalizada.

        assertThat(j).isEqualTo(0)
        assertThat(transferKind).isIn(TransferKind.CHUNKED, TransferKind.FIXED_LENGTH)
      }
    }
    val requestA = server.takeRequest()
    assertThat(requestA.path).isEqualTo("/a")
    val requestB = server.takeRequest()
    assertThat(requestB.path).isEqualTo("/b")
    assertThat(requestB.body.readUtf8()).isEqualTo(requestBody)
  }

Este es el caso de la mayoría de las aplicaciones web.

Muchos, muchos usuarios, pero el servidor está esperando 🕙 el envío de las peticiones ya que su conexión no es buena.

Y luego esperando 🕙 nuevamente a que las respuestas retornen.

Esta "espera" 🕙 se mide en microsegundos, pero aun así, sumando todo, al final es mucha espera.

Es por eso que tiene mucho sentido usar código asíncrono ⏸🔀⏯ para las API web.