this.numberOfSuggestDocs = numberOfSuggestDocs;
        this.numberOfInputDocs = numberOfInputDocs;
        this.took = took;
        if (errors == null || errors.isEmpty()) {
            hasError = false;
        } else {
            hasError = true;
            errors.forEach(this.errors::add);
        }
    }

    /**
     * Returns the number of suggest documents.
     * @return The number of suggest documents.
     */

        SuggestDeleteResponse response1 = new SuggestDeleteResponse(null, 100);
        assertFalse(response1.hasError());

        List<Throwable> errors = new ArrayList<>();
        errors.add(new Exception("Test error"));
        SuggestDeleteResponse response2 = new SuggestDeleteResponse(errors, 100);
        assertTrue(response2.hasError());
    }

    @Test
    public void test_getErrors() throws Exception {

        SuggestIndexResponse response1 = new SuggestIndexResponse(10, 5, null, 100);
        assertFalse(response1.hasError());

        List<Throwable> errors = new ArrayList<>();
        errors.add(new Exception("Test error"));
        SuggestIndexResponse response2 = new SuggestIndexResponse(10, 5, errors, 100);
        assertTrue(response2.hasError());
    }

    @Test
    public void test_getErrors() throws Exception {

        final AtomicBoolean hasError = new AtomicBoolean(false);

        Thread[] threads = new Thread[threadCount];

        for (int i = 0; i < threadCount; i++) {
            threads[i] = new Thread(() -> {
                try {
                    curtainFinallyHook.hook(assistantDirector);
                } catch (Exception e) {
                    hasError.set(true);
                }
            });

            this.errors.addAll(errors);
        }
    }

    /**
     * Checks if the response has any errors.
     * @return True if there are errors, false otherwise.
     */
    public boolean hasError() {
        return !errors.isEmpty();
    }

    /**
     * Returns the list of errors.
     * @return The list of errors.
     */
    public List<Throwable> getErrors() {
        return errors;
    }

            boolQuery.mustNot(QueryBuilders.matchPhraseQuery(FieldNames.KINDS, kind.toString()));
        }

        final SuggestDeleteResponse deleteResponse = deleteByQuery(index, boolQuery);
        if (deleteResponse.hasError()) {
            throw new SuggestIndexException(deleteResponse.getErrors().get(0));
        }

        final List<SuggestItem> updateItems = new ArrayList<>();

  val onException: (IOException) -> Unit,
) : ForwardingSink(delegate) {
  private var hasErrors = false

  override fun write(
    source: Buffer,
    byteCount: Long,
  ) {
    if (hasErrors) {
      source.skip(byteCount)
      return
    }
    try {
      super.write(source, byteCount)
    } catch (e: IOException) {
      hasErrors = true
      onException(e)
    }
  }

  override fun flush() {

                problemsList.add(modelProblem);
            }

            if (result.hasErrors()) {
                hasErrors = true;
            }
        }
        return new Result<>(hasErrors, modelsList, problemsList);
    }

    // helper to determine if problems contain error
    private static boolean hasErrors(Iterable<? extends ModelProblem> problems) {
        for (ModelProblem input : problems) {

        toolchainsMerger.merge(userToolchains, globalToolchains, TrackableBase.GLOBAL_LEVEL);

        problems.setSource("");

        userToolchains = interpolate(userToolchains, problems);

        if (hasErrors(problems.getProblems())) {
            throw new ToolchainsBuildingException(problems.getProblems());
        }

        return new DefaultToolchainsBuildingResult(userToolchains, problems.getProblems());
    }

 *
 */
public interface ModelProblemCollector {

    ProblemCollector<ModelProblem> getProblemCollector();

    default boolean hasErrors() {
        return getProblemCollector().hasErrorProblems();
    }

    default boolean hasFatalErrors() {
        return getProblemCollector().hasFatalProblems();
    }