private final ImmutableList<Annotation> annotations;

  /**
   * An {@code AnnotatedType} instance, or {@code null} under Android VMs (possible only when using
   * the Android flavor of Guava). The field is declared with a type of {@code Object} to avoid
   * compatibility problems on Android VMs. The corresponding accessor method, however, can have the

 * finding the annotated elements. Subclasses only need to provide the processing logic given those elements.
 *
 * The declared type of the processor can be overwritten to test various error cases, e.g. a processor that
 * declares itself as incremental, but doesn't honor that contract.
 */
@CompileStatic
class AnnotationProcessorFixture {
    protected final String annotationName

        return new AbstractTypeMetadataWalker.InstanceTypeMetadataWalker(typeMetadataStore, nestedAnnotation);
    }

    /**
     * A factory method for a walker that can visit property hierarchy declared by a type.
     *
     * Type walker can detect a nested property cycle and stop walking the path with a cycle, no exception is thrown.
     */

[[sec:strict-version]]
`strictly`::
Any version not matched by this version notation will be excluded.
This is the strongest version declaration.
On a declared dependency, a `strictly` can downgrade a version.
When on a transitive dependency, it will cause dependency resolution to fail if no version acceptable by this clause can be selected.

    /**
     * Configures the variants of this configuration.
     */
    void variants(Action<? super NamedDomainObjectContainer<ConfigurationVariant>> configureAction);

    /**
     * Declares a capability for this configuration.
     *
     * @param notation the notation
     *
     * Valid notations are a <i>group:name:version</i> string (e.g: <i>org.test:capability:1.0</i>, or a map

  private final ImmutableList<Annotation> annotations;

  /**
   * An {@code AnnotatedType} instance, or {@code null} under Android VMs (possible only when using
   * the Android flavor of Guava). The field is declared with a type of {@code Object} to avoid
   * compatibility problems on Android VMs. The corresponding accessor method, however, can have the

        child.displayName == displayName
        child.attributes == ImmutableAttributes.EMPTY
        child.artifacts == allArtifacts
    }

    def "converts to OutgoingVariant when artifacts declared"() {
        def artifact = Stub(PublishArtifact)

        given:
        publications.artifacts.add(artifact)

        expect:
        def variants = getOutgoingVariants(publications)

                    d.name == "scaladoc_3" &&
                    d.version == "3.0.1"
            }
        }
    }

    def "inference fails if 'scalaTools' configuration is empty and no repository declared"() {
        when:
        def scalaClasspath = project.scalaRuntime.inferScalaClasspath([new File("other.jar"), new File("scala-library-2.10.1.jar")])
        scalaClasspath.files

        then:

                        }
                    }
                }
            }
        }
    }

    public final static Closure<Void> VIRTUAL_PLATFORM = {
        // If the platform is declared as virtual, we won't fetch metadata
    }

    void expectAlignment(@DelegatesTo(value = AlignmentSpec, strategy = Closure.DELEGATE_FIRST) Closure<?> spec) {
        def align = new AlignmentSpec()

    ```Python hl_lines="31"
    {!> ../../../docs_src/security/tutorial002.py!}
    ```

Notice that we declare the type of `current_user` as the Pydantic model `User`.

This will help us inside of the function with all the completion and type checks.

!!! tip
    You might remember that request bodies are also declared with Pydantic models.

    Here **FastAPI** won't get confused because you are using `Depends`.

!!! check