Por exemplo, se o cliente tentar enviar um cookie `santa_tracker` com o valor de `good-list-please`, o cliente receberá uma resposta de **erro** informando que o `santa_tracker` <dfn title="O papai noel desaprova a falta de biscoitos. 🎅 Ok, chega de piadas com os cookies.">cookie não é permitido</dfn>:

```json
{
    "detail": [
        {

{* ../../docs_src/header_params/tutorial003_an_py310.py hl[9] *}

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

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

A resposta seria como:

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

## Recapitulando { #recap }

```JSON
{
  "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"
}
```

9. Esta *função de operação de rota* não está retornando dataclasses (embora pudesse), mas uma lista de dicionários com dados internos.

    O FastAPI usará o parâmetro `response_model` (que inclui dataclasses) para converter a resposta.

Você pode combinar `dataclasses` com outras anotações de tipo em muitas combinações diferentes para formar estruturas de dados complexas.

Confira as dicas de anotação no código acima para ver mais detalhes específicos.

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 { #other-data-types }

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

* `UUID`:

    val builder =
      Request
        .Builder()
        .url("https://square.com")
    val requestA = builder.tag(String::class.java, "a").build()
    val requestB = builder.tag(String::class.java, "b").build()
    val requestC = requestA.newBuilder().tag(String::class.java, "c").build()
    assertThat(requestA.tag(String::class.java)).isSameInstanceAs("a")
    assertThat(requestB.tag(String::class.java)).isSameInstanceAs("b")

///

/// 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`.

* `www_redirect` - Se definido como True, as requisições para versões sem www dos hosts permitidos serão redirecionadas para suas versões com www. O padrão é `True`.

Se uma requisição recebida não for validada corretamente, uma resposta `400` será enviada.

## `GZipMiddleware` { #gzipmiddleware }

Gerencia respostas GZip para qualquer requisição que inclua `"gzip"` no cabeçalho `Accept-Encoding`.

O middleware lidará com respostas padrão e de streaming.

* router (as in FastAPI's router): router (do not change if it's already translated to "roteador" or "roteadores")
* response (as in HTTP response): response (do not change if it's already translated to resposta)
* shutdown (of the app): encerramento
* shutdown event (of the app): evento de encerramento
* startup (as in the event of the app): inicialização
* startup event (as in the event of the app): evento de inicialização

Vamos começar com uma aplicação FastAPI simples:

{* ../../docs_src/generate_clients/tutorial001_py310.py hl[7:9,12:13,16:17,21] *}

Note que as *operações de rota* definem os modelos que usam para o corpo da requisição e o corpo da resposta, usando os modelos `Item` e `ResponseMessage`.

### Documentação da API { #api-docs }

Se você for para `/docs`, verá que ela tem os **schemas** para os dados a serem enviados nas requisições e recebidos nas respostas: