A própria *operação de rota* também declara o escopo, `"items"`, então ele também estará na lista de `security_scopes.scopes` passado para o `get_current_user`.

Aqui está como a hierarquia de dependências e escopos parecem:

                "Method com.example.Task.getIsFailOnError(): Is not annotated with @since 2.0. Reason for accepting this: Upgraded property" to listOf("Method added to public class"),
                "Method com.example.Task.isFailOnError(): Is not binary compatible. Reason for accepting this: Upgraded property" to listOf("Method has been removed"),

    }

    // Should not be pinned:
    certificatePinner.check("uk", listOf(certB1.certificate))
    certificatePinner.check("co.uk", listOf(certB1.certificate))
    certificatePinner.check("anotherexample.co.uk", listOf(certB1.certificate))
    certificatePinner.check("foo.anotherexample.co.uk", listOf(certB1.certificate))
  }

  @Test

                parameters = null,
              ),
            issuer =
              listOf(
                listOf(
                  AttributeTypeAndValue(
                    type = countryName,
                    value = "US",
                  ),
                ),
                listOf(
                  AttributeTypeAndValue(
                    type = organizationName,

    builder.interceptors().addAll(listOf(null) as List<Interceptor>)
    assertFailsWith<IllegalStateException> {
      builder.build()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Null interceptor: [null]")
    }
  }

  @Test fun nullNetworkInterceptorInList() {
    val builder = OkHttpClient.Builder()
    builder.networkInterceptors().addAll(listOf(null) as List<Interceptor>)

    enableProtocol(Protocol.HTTP_2)

    val request = Request(server1.url("/"))

    server1.enqueue(refusedStream)
    server2.enqueue(bodyResponse)

    dns[server1.hostName] = listOf(ipv6, ipv4)
    socketFactory[ipv6] = server1.socketAddress
    socketFactory[ipv4] = server2.socketAddress

    client =
      client
        .newBuilder()
        .fastFallback(false)
        .apply {

                docsTests =
                    listOf(
                        DocsTestCoverage(
                            Os.LINUX,
                            JvmCategory.MAX_VERSION,
                            listOf(CONFIG_CACHE_ENABLED, CONFIG_CACHE_DISABLED),
                        ),
                        DocsTestCoverage(Os.WINDOWS, JvmCategory.MAX_VERSION, listOf(CONFIG_CACHE_DISABLED)),
                    ),

              override fun get(
                uri: URI,
                requestHeaders: Map<String, List<String>>,
              ) = mapOf(
                "COOKIE" to listOf("Bar=bar"),
                "cooKIE2" to listOf("Baz=baz"),
              )
            },
          ),
        ).build()
    server.enqueue(MockResponse())
    get(server.url("/"))
    val request = server.takeRequest()

Você pode usar **anotações de tipo** da mesma forma que usaria para dados de entrada em **parâmetros** de função, você pode usar modelos Pydantic, listas, dicionários, valores escalares como inteiros, booleanos, etc.

{* ../../docs_src/response_model/tutorial001_01_py310.py hl[16,21] *}

O FastAPI usará este tipo de retorno para:

* **Validar** os dados retornados.

): List<PerformanceScenario> {
    val performanceTestTypes =
        if (performanceTestSpec.performanceTestType == PerformanceTestType.FLAKINESS_DETECTION) {
            listOf(PerformanceTestType.PER_COMMIT, PerformanceTestType.PER_DAY)
        } else {
            listOf(performanceTestSpec.performanceTestType)
        }
    return performanceTestConfigurations.flatMap { configuration ->
        configuration.groups