It will always have the security scopes declared in the current `Security` dependencies and all the dependants for **that specific** *path operation* and **that specific** dependency tree.

Because the `SecurityScopes` will have all the scopes declared by dependants, you can use it to verify that a token has the required scopes in a central dependency function, and then declare different scope requirements in different *path operations*.

/**
 * A component which can declare additional variants corresponding to
 * features. When published to Maven POMs, the dependencies of those variants
 * are exposed as optional dependencies. When published to Gradle metadata, the
 * variants are published as is.
 *
 * @since 5.3
 */
public interface AdhocComponentWithVariants extends SoftwareComponent {

    /**

```Python hl_lines="2"
{!../../../docs_src/python_types/tutorial004.py!}
```

## Déclarer des types

Vous venez de voir là où les types sont généralement déclarés : dans les paramètres de fonctions.

C'est aussi ici que vous les utiliseriez avec **FastAPI**.

### Types simples

Vous pouvez déclarer tous les types  de Python, pas seulement `str`.

Comme par exemple :

* `int`
* `float`

[[included_build_substitution_requirements]]
=== Cases where included build substitutions must be declared

Many builds will function automatically as an included build, without declared substitutions.
Here are some common cases where declared substitutions are required:

* When the `archivesBaseName` property is used to set the name of the published artifact.

        then:
        failure.assertHasCause("Mutation of repositories declared in settings is only allowed during settings evaluation")
    }

    /**
     * the `buildSrc` directory behaves like an included build. As such, it may have its own settings,
     * so repositories declared in the main build shouldn't be visible to buildSrc.
     */
    def "repositories declared in settings shouldn't be used to resolve dependencies in buildSrc"() {

	ls.errh(Error{pos, fmt.Sprintf(format, args...)})
}

// declare declares the label introduced by s in block b and returns
// the new label. If the label was already declared, declare reports
// and error and the existing label is returned instead.
func (ls *labelScope) declare(b *block, s *LabeledStmt) *label {
	name := s.Label.Value
	labels := ls.labels
	if labels == nil {

The `api` configuration should be used to declare constraints and dependencies which should be used when compiling against the platform, whereas the `runtime` configuration should be used to declare constraints or dependencies which are visible at runtime.

.Declaring API and runtime constraints
====

|===
|Mode |Description |Default? |Use-Case

|`PREFER_PROJECT`
|Any repository declared on a project will cause the project to use the repositories declared by the project, ignoring those declared in settings.
|Yes
|Useful when teams need to use different repositories not common among subprojects.

|`PREFER_SETTINGS`
|Any repository declared directly in a project, either directly or via a plugin, will be ignored.
|No

.Configurations are used to declare dependencies
====
include::sample[dir="snippets/dependencyManagement/attributeMatching/kotlin",files="build.gradle.kts[tags=declare-configuration]"]
include::sample[dir="snippets/dependencyManagement/attributeMatching/groovy",files="build.gradle[tags=declare-configuration]"]
====

    /**
     * Declares a new attribute in the schema and configures it with the default strategy.
     * If the attribute was already declared it will simply return the existing strategy.
     *
     * @param attribute the attribute to declare in the schema
     * @param <T> the concrete type of the attribute
     *