this.activeExternalProfiles.addAll(result.getActiveExternalProfiles());
        this.effectiveModel = result.getEffectiveModel();
        this.fileModel = result.getFileModel();
        this.problems.addAll(result.getProblems());

        for (String modelId : result.getModelIds()) {
            this.modelIds.add(modelId);
            this.rawModels.put(modelId, result.getRawModel(modelId));

 */
public interface GradleEnterprisePluginEndOfBuildListener {

    interface BuildResult {
        @Nullable
        Throwable getFailure();

        Collection<Problem> getProblems();

        Collection<Problem> getProblemsFor(Throwable failure);
    }

    void buildFinished(BuildResult buildResult);

    @Nullable
    InternalDocumentationLink getDocumentationLink();

    InternalSeverity getSeverity();

    List<InternalProblemContextDetails> getProblems();

    InternalLabel getLabel();

    InternalProblemCategory getCategory();

                @Inject
                public abstract Problems getProblems();

                @Override
                public void execute() {
                    Exception wrappedException = new Exception("Wrapped cause");
                    // Create and report a problem
                    // This needs to be Java 6 compatible, as we are in a worker
                     getProblems().forNamespace("org.example.plugin").reporting(problem -> problem

            );
        }

        if (!typeValidationContext.getProblems().isEmpty()) {
            throw new DefaultMultiCauseException(
                String.format(typeValidationContext.getProblems().size() == 1
                        ? "A problem was found with the %s plugin."
                        : "Some problems were found with the %s plugin.",

@NonNullApi
public interface InternalProblemAggregationDetailsVersion3 extends InternalProblemDetailsVersion2 {

    InternalProblemDefinition getDefinition();

    List<InternalProblemContextDetails> getProblems();

            if (!result.getProblems().isEmpty() && LOGGER.isWarnEnabled()) {
                LOGGER.warn("");
                LOGGER.warn(
                        "Some problems were encountered while building the effective model for '{}'",
                        result.getProject().getId());

                for (ModelProblem problem : result.getProblems()) {

        this.problems = problems;
    }

    @Override
    public InternalProblemDefinition getDefinition() {
        return definition;
    }

    @Override
    public List<InternalProblemContextDetails> getProblems() {
        return problems;
    }

                            new DefaultProjectBuildingResult(e.getModelId(), pomFile, convert(e.getProblems())));
                }
                // validation error, continue project building and delay failing to help IDEs
                // result.getProblems().addAll(e.getProblems()) ?
            }

            Model model = result.getActivatedFileModel();

                }

                @Nonnull
                @Override
                public Collection<BuilderProblem> getProblems() {
                    return new MappedCollection<>(res.getProblems(), this::toProblem);
                }

                private BuilderProblem toProblem(ModelProblem problem) {
                    return new BuilderProblem() {