void execute(ComponentMetadataContext context) {
            ruleInvoked = true
            def descriptor = context.getDescriptor(IvyModuleDescriptor)
            assert descriptor.extraInfo.asMap() == [${declareNS('foo')}: "fooValue", ${declareNS('bar')}: "barValue"]
            assert descriptor.extraInfo.get('foo') == 'fooValue'
            assert descriptor.extraInfo.get('${ns('foo').namespace}', 'foo') == 'fooValue'

## Liste de paramètres / valeurs multiples via Query

Quand on définit un paramètre de requête explicitement avec `Query` on peut aussi déclarer qu'il reçoit une liste de valeur, ou des "valeurs multiples".

Par exemple, pour déclarer un paramètre de requête `q` qui peut apparaître plusieurs fois dans une URL, on écrit :

```Python hl_lines="9"
{!../../../docs_src/query_params_str_validations/tutorial011.py!}

The https://toml.io/[TOML] file consists of 4 major sections:

- the `[versions]` section is used to declare versions which can be referenced by dependencies
- the `[libraries]` section is used to declare the aliases to coordinates
- the `[bundles]` section is used to declare dependency bundles
- the `[plugins]` section is used to declare plugins

For example:

.The libs.versions.toml file
----

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*.

```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 {

|===
|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]"]
====