this.locations = locations;
        this.solutions = solutions;
        this.additionalData = additionalData;
        this.failure = failure;
    }

    @Override
    public ProblemDefinition getDefinition() {
        return problemDefinition;
    }

    @Override
    public ContextualLabel getContextualLabel() {
        return contextualLabel;
    }

    @Override
    public Details getDetails() {

        formatter.endChildren();
        throw new InvalidUserDataException(formatter.toString());
    }

    public static String getProblemString(Problem problem) {
        ProblemDefinition definition = problem.getDefinition();
        String contextualLabel = problem.getContextualLabel();
        String renderedLabel = contextualLabel == null ? definition.getId().getDisplayName() : contextualLabel;

            .map(TypeValidationProblemRenderer::renderMinimalInformationAbout)
            .collect(toImmutableSet());
    }

    private static boolean isWarning(Problem problem) {
        return problem.getDefinition().getSeverity().equals(Severity.WARNING);
    }

from fastapi import routing
from fastapi._compat import (
    GenerateJsonSchema,
    JsonSchemaValue,
    ModelField,
    Undefined,
    get_compat_model_name_map,
    get_definitions,
    get_schema_from_model_field,
    lenient_issubclass,
)
from fastapi.datastructures import DefaultPlaceholder
from fastapi.dependencies.models import Dependant

        DocLink docLink = warning.getDefinition().getDocumentationLink();
        if (docLink != null) {
            return withDeprecationTimeline
                .withDocumentation(warning.getDefinition().getDocumentationLink());
        }
        return withDeprecationTimeline.undocumented();
    }

        if (problems.isEmpty()) {
            getLogger().info("Plugin validation finished without warnings.");
        } else {
            if (getFailOnWarning().get() || problems.stream().anyMatch(problem -> problem.getDefinition().getSeverity() == ERROR)) {
                if (getIgnoreFailures().get()) {
                    getLogger().warn("Plugin validation finished with errors. {} {}",
                        annotateTaskPropertiesDoc(),

            reporter.report(problem);
        }

        Map<Severity, ImmutableList<Problem>> problemsMap = problems.stream()
            .collect(
                groupingBy(p -> p.getDefinition().getSeverity(),
                    mapping(identity(), toImmutableList())));
        List<Problem> warnings = problemsMap.getOrDefault(WARNING, ImmutableList.of());

            )
        return json_schema

    def get_compat_model_name_map(fields: List[ModelField]) -> ModelNameMap:
        return {}

    def get_definitions(
        *,
        fields: List[ModelField],
        schema_generator: GenerateJsonSchema,
        model_name_map: ModelNameMap,
        separate_input_output_schemas: bool = True,
    ) -> Tuple[

        return new DefaultProblemEvent(
            createDefaultProblemDescriptor(buildOperationId),
            new DefaultProblemDetails(
                toInternalDefinition(problem.getDefinition()),
                toInternalDetails(problem.getDetails()),
                toInternalContextualLabel(problem.getContextualLabel()),
                toInternalLocations(problem.getLocations()),

        def locations = getLocations()
        assert locations.size() == 1
        assert type.isInstance(locations[0])
        locations[0] as T
    }

    @Override
    ReceivedProblemDefinition getDefinition() {
        definition
    }

    Severity getSeverity() {
        definition.severity
    }