Mas se você usar o mesmo modelo como saída, como aqui:

{* ../../docs_src/separate_openapi_schemas/tutorial001_py310.py hl[19] *}

... então, como `description` tem um valor padrão, se você **não retornar nada** para esse campo, ele ainda terá o **valor padrão**.

### Modelo para Dados de Resposta de Saída { #model-for-output-response-data }

Nesse caso, você poderia querer documentar como essa API externa *deveria* ser. Que *operação de rota* ela deveria ter, que corpo ela deveria esperar, que resposta ela deveria retornar, etc.

## Um aplicativo com callbacks { #an-app-with-callbacks }

Vamos ver tudo isso com um exemplo.

Imagine que você desenvolve um aplicativo que permite criar faturas.

* la expresión
* el statement

* el frontend
* el backend

* la discusión de GitHub
* el issue de GitHub

* el rendimiento
* la optimización de rendimiento

* el tipo de retorno
* el valor de retorno

* la seguridad
* el esquema de seguridad

* la tarea
* la tarea en segundo plano
* la función de tarea

* la plantilla
* el motor de plantillas

* la anotación de tipos

`Header` es una clase "hermana" de `Path`, `Query` y `Cookie`. También hereda de la misma clase común `Param`.

Pero recuerda que cuando importas `Query`, `Path`, `Header`, y otros de `fastapi`, en realidad son funciones que retornan clases especiales.

///

/// info | Información

Para declarar headers, necesitas usar `Header`, porque de otra forma los parámetros serían interpretados como parámetros de query.

///

* Importe `Jinja2Templates`.
* Crie um objeto `templates` que você possa reutilizar posteriormente.
* Declare um parâmetro `Request` no *path operation* que retornará um template.
* Use o `templates` que você criou para renderizar e retornar uma `TemplateResponse`, passe o nome do template, o objeto `request` e um dicionário "context" com pares chave-valor a serem usados dentro do template do Jinja2.

{* ../../docs_src/templates/tutorial001_py39.py hl[4,11,15:18] *}

Você pode criar uma primeira dependência ("dependable") dessa forma:

{* ../../docs_src/dependencies/tutorial005_an_py310.py hl[8:9] *}

Esse código declara um parâmetro de consulta opcional, `q`, com o tipo `str`, e então retorna esse parâmetro.

Isso é bastante simples (e não muito útil), mas irá nos ajudar a focar em como as subdependências funcionam.

## Segunda dependência, "dependable" e "dependente" { #second-dependency-dependable-and-dependant }

Apenas com essa declaração de tipos do Python, o **FastAPI** irá:

* Ler o corpo da requisição como um JSON.
* Converter os tipos correspondentes (se necessário).
* Validar os dados.
    * Se algum dado for inválido, irá retornar um erro bem claro, indicando exatamente onde e o que estava incorreto.
* Entregar a você a informação recebida no parâmetro `item`.

/// info | Informação

`File` é uma classe que herda diretamente de `Form`.

Mas lembre-se que quando você importa `Query`, `Path`, `File` e outros de `fastapi`, eles são, na verdade, funções que retornam classes especiais.

///

/// tip | Dica

Para declarar corpos de arquivos, você precisa usar `File`, caso contrário, os parâmetros seriam interpretados como parâmetros de consulta ou parâmetros de corpo (JSON).

    * Isso é comparável ao uso do método `.model_dump()`, mas garante (e converte) os valores para tipos de dados que possam ser convertidos em JSON, por exemplo, `datetime` para `str`.
* Salvar os dados no seu banco de dados.
* Retornar o modelo atualizado.

{* ../../docs_src/body_updates/tutorial002_py310.py hl[28:35] *}

/// tip | Dica

Você pode realmente usar essa mesma técnica com uma operação HTTP `PUT`.

Há algum tempo, <a href="https://github.com/fastapi/fastapi/issues/3#issuecomment-454956920" class="external-link" target="_blank">um usuário **FastAPI** perguntou</a>:

> Qual é a história desse projeto? Parece que surgiu do nada e se tornou incrível em poucas semanas [...]

Aqui está um pouco dessa história.

## Alternativas { #alternatives }