```

!!! info "Informação"
    `Body` também possui todas as validações adicionais e metadados de parâmetros como em `Query`,`Path` e outras que você verá depois.

## Declare um único parâmetro de corpo indicando sua chave

Suponha que você tem um único parâmetro de corpo `item`, a partir de um modelo Pydantic `Item`.

Por padrão, o **FastAPI** esperará que seu conteúdo venha no corpo diretamente.

        when:
        run 'tasks', '-refresh-dependencies'

        then:
        "should fail in a consistent way as with '--refresh-dependencies'"
    }

    def "cannot declare option for task dependency of another task"() {
        given:
        buildFile << """
            apply plugin: 'java'
        """

        when:
        runAndFail 'check', '--tests', 'abc'

[[custom_dependencies_blocks]]
== Using a custom `dependencies` block

NOTE: Custom `dependencies` blocks are based on incubating APIs.

A plugin can provide dependency declarations in custom blocks that allow users to declare dependencies in a type-safe and context-aware way.

class RepositoriesDeclaredInSettingsIntegrationTest extends AbstractModuleDependencyResolveTest implements PluginDslSupport {
    boolean isDeclareRepositoriesInSettings() {
        true
    }

    def "can declare dependency in settings for a single-project build"() {
        repository {
            'org:module:1.0'()
        }

        buildFile << """
            dependencies {
                conf 'org:module:1.0'

        return new IvyDependencyDescriptor(selector, "12", false, true, false, ImmutableListMultimap.of(), artifacts, [])
    }

    def "returns empty set of artifacts when dependency descriptor does not declare any artifacts"() {
        def metadata = createWithArtifacts(requested, [])
        def fromConfiguration = Stub(ConfigurationMetadata)

        expect:
        metadata.getConfigurationArtifacts(fromConfiguration).empty

* Any keyword arguments that should be passed to the task function (`message="some notification"`).

## Dependency Injection

Using `BackgroundTasks` also works with the dependency injection system, you can declare a parameter of type `BackgroundTasks` at multiple levels: in a *path operation function*, in a dependency (dependable), in a sub-dependency, etc.

//
// (6) Conversion of a [reflect.SliceHeader] or [reflect.StringHeader] Data field to or from Pointer.
//
// As in the previous case, the reflect data structures SliceHeader and StringHeader
// declare the field Data as a uintptr to keep callers from changing the result to
// an arbitrary type without first importing "unsafe". However, this means that
// SliceHeader and StringHeader are only valid when interpreting the content

        explicit.displayName.displayName == '<config> variant child'
        explicit.attributes == AttributeTestUtil.attributes(["thing": "value2"])
        explicit.artifacts == variantDef.artifacts
    }

    def "can declare outgoing artifacts using lazy provider for configuration"() {
        given:
        artifactNotationParser.parseNotation(_ as DefaultFileSystemLocation) >> { args ->

our code is calling Couchbase and we are not using the <a href="https://docs.couchbase.com/python-sdk/2.5/async-programming.html#asyncio-python-3-5" class="external-link" target="_blank">experimental Python <code>await</code> support</a>, we should declare our function with normal `def` instead of `async def`.

Also, Couchbase recommends not using a single `Bucket` object in multiple "<abbr title="A sequence of code being executed by the program, while at the same time, or at intervals, there...

	"k8s.io/client-go/tools/cache"
	"k8s.io/client-go/util/workqueue"
	v1 "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1"
)

// AutoAPIServiceRegistration is an interface which callers can re-declare locally and properly cast to for
// adding and removing APIServices
type AutoAPIServiceRegistration interface {
	// AddAPIServiceToSync adds an API service to auto-register.
	AddAPIServiceToSync(in *v1.APIService)