for additional_status_code, response in self.responses.items():
            assert isinstance(response, dict), "An additional response must be a dict"
            model = response.get("model")
            if model:
                assert is_body_allowed_for_status_code(
                    additional_status_code
                ), f"Status code {additional_status_code} must not have a response body"

        SuggestResponse response3 = suggester.suggest().setQuery("is").setSuggestDetail(true).execute().getResponse();
        assertEquals(0, response3.getNum());
        assertEquals(0, response3.getTotal());

        SuggestResponse response4 = suggester.suggest().setQuery("delicious").setSuggestDetail(true).execute().getResponse();
        assertEquals(1, response4.getNum());

from starlette.responses import FileResponse as FileResponse  # noqa
from starlette.responses import HTMLResponse as HTMLResponse  # noqa
from starlette.responses import JSONResponse as JSONResponse  # noqa
from starlette.responses import PlainTextResponse as PlainTextResponse  # noqa
from starlette.responses import RedirectResponse as RedirectResponse  # noqa
from starlette.responses import Response as Response  # noqa

package echo

import (
	"fmt"
)

// Responses is an ordered list of parsed response objects.
type Responses []Response

func (r Responses) IsEmpty() bool {
	return len(r) == 0
}

// Len returns the length of the parsed responses.
func (r Responses) Len() int {
	return len(r)
}

// Count occurrences of the given text within the bodies of all responses.
func (r Responses) Count(text string) int {
	count := 0

# Custom Response Classes - File, HTML, Redirect, Streaming, etc.

There are several custom response classes you can use to create an instance and return them directly from your *path operations*.

Read more about it in the [FastAPI docs for Custom Response - HTML, Stream, File, others](https://fastapi.tiangolo.com/advanced/custom-response/).

You can import them directly from `fastapi.responses`:

```python
from fastapi.responses import (
    FileResponse,

Lesen Sie mehr darüber in der [FastAPI-Dokumentation zu benutzerdefinierten Responses – HTML, Stream, Datei, andere](../advanced/custom-response.md).

Sie können diese direkt von `fastapi.responses` importieren:

```python
from fastapi.responses import (
    FileResponse,
    HTMLResponse,
    JSONResponse,
    ORJSONResponse,
    PlainTextResponse,
    RedirectResponse,
    Response,
    StreamingResponse,
    UJSONResponse,
)
```

	"Transfer-Encoding": true,
	"Trailer":           true,
}

// Response represents the response from an HTTP request.
//
// The [Client] and [Transport] return Responses from servers once
// the response headers have been received. The response body
// is streamed on demand as the Body field is read.
type Response struct {
	Status     string // e.g. "200 OK"
	StatusCode int    // e.g. 200

        .build()
    val response1 = client.newCall(request).execute()
    response1.body.close()
    assertThat(response1.header("X-Response-ID")).isEqualTo("1")
    val response2 = get(url)
    response2.body.close()
    if (expectCached) {
      assertThat(response2.header("X-Response-ID")).isEqualTo("1")
    } else {
      assertThat(response2.header("X-Response-ID")).isEqualTo("2")
    }
  }

## Zusätzliche Response mit `model`

Sie können Ihren *Pfadoperation-Dekoratoren* einen Parameter `responses` übergeben.

Der nimmt ein `dict` entgegen, die Schlüssel sind Statuscodes für jede Response, wie etwa `200`, und die Werte sind andere `dict`s mit den Informationen für jede Response.

# Additional Responses in OpenAPI

!!! warning
    This is a rather advanced topic.

    If you are starting with **FastAPI**, you might not need this.

You can declare additional responses, with additional status codes, media types, descriptions, etc.

Those additional responses will be included in the OpenAPI schema, so they will also appear in the API docs.