public interface TypeMetadata {
    void visitValidationFailures(@Nullable String ownerPropertyPath, TypeValidationContext validationContext);

    /**
     * Returns the set of relevant properties, that is, those properties annotated with a relevant annotation.
     */
    Set<PropertyMetadata> getPropertiesMetadata();

    boolean hasAnnotatedProperties();

    PropertyAnnotationHandler getAnnotationHandlerFor(PropertyMetadata propertyMetadata);

=== "Python 3.8+"

    ```Python hl_lines="16"
    {!> ../../../docs_src/dependencies/tutorial012_an.py!}
    ```

=== "Python 3.8 nicht annotiert"

    !!! tip "Tipp"
        Bevorzugen Sie die `Annotated`-Version, falls möglich.

    ```Python hl_lines="15"
    {!> ../../../docs_src/dependencies/tutorial012.py!}
    ```

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Indicates that there is an internal complementary protocol to the public type that is annotated with this.
 *
 * This should only be used on a type that is always assumed to also implement the internal protocol by Gradle internals.
 *

            }

            apply plugin: CustomPlugin
        """

        expect:
        succeeds()
        outputContains("got it")
    }

    def "fails when plugin constructor is not annotated with @Inject"() {
        buildFile """
            class CustomPlugin implements Plugin<Project> {
                CustomPlugin(WorkerExecutor executor) {
                }

                void apply(Project p) {

 */

package org.gradle.internal.service;

import org.gradle.api.NonNullApi;
import org.gradle.internal.service.scopes.Scope;

/**
 * A registry validating that all registered services are annotated with a corresponding {@link Scope}.
 */
@NonNullApi
public class ScopedServiceRegistry extends DefaultServiceRegistry {

    public ScopedServiceRegistry(
        Class<? extends Scope> scope,

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * Indicates that annotated component should be instantiated before session execution starts
 * and discarded after session execution completes.
 *
 * @since 4.0.0
 */
@Scope
@Documented
@Retention(RUNTIME)
@Target({TYPE, METHOD})

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * Indicates that the annotated bean has a lifespan limited to a given mojo execution,
 * which means each mojo execution will result in a different instance being injected.
 *
 * @since 4.0.0
 */
@Scope
@Documented
@Retention(RUNTIME)

            annotationType, unpackValueTypesOf(propertyMetadata),
            propertyMetadata, validationContext,
            ResolvedArtifactResult.class,
            "Extract artifact metadata and annotate with @Input",
            "Extract artifact files and annotate with @InputFiles"
        );
    }

    private static final String UNSUPPORTED_VALUE_TYPE = "UNSUPPORTED_VALUE_TYPE";

    private static void validateUnsupportedPropertyValueType(

                .id("invalid-use-of-type-annotation", "Incorrect use of type annotation", GradleCoreProblemGroup.validation().type())
                .contextualLabel("is incorrectly annotated with @" + annotationType.getSimpleName())
                .documentedAt(Documentation.userManual("validation_problems", "invalid_use_of_cacheable_annotation"))
                .severity(Severity.ERROR)

=== "Python 3.10+ nicht annotiert"

    !!! tip "Tipp"
        Bevorzugen Sie die `Annotated`-Version, falls möglich.

    ```Python hl_lines="66-67  79"
    {!> ../../../docs_src/websockets/tutorial002_py310.py!}
    ```

=== "Python 3.8+ nicht annotiert"

    !!! tip "Tipp"
        Bevorzugen Sie die `Annotated`-Version, falls möglich.

    ```Python hl_lines="68-69  81"