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.
     */

        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;
    }

     * @return true if the operation was successful, false otherwise.
     */
    public boolean deleteAllWords() {
        final SuggestDeleteResponse response = suggester.indexer().deleteAll();
        if (response.hasError()) {
            logger.warn("Failed to delete all words.", response.getErrors().get(0));
            return false;
        }
        refresh();
        return true;
    }

    /**

                .mustNot(QueryBuilders.matchPhraseQuery(FieldNames.KINDS, SuggestItem.Kind.USER.toString())));
        if (deleteResponse.hasError()) {
            throw new SuggestIndexException(deleteResponse.getErrors().get(0));
        }

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

    private static class MockBadWordSettings {
        public void deleteAll() {
            // Mock implementation
        }
    }

    private static class MockSuggestDeleteResponse {
        public boolean hasError() {
            return false;
        }

        public List<Throwable> getErrors() {
            return new ArrayList<>();
        }
    }

        suggester.refresh();

        SuggestItem[] items2 = getItemSet1();
        SuggestIndexResponse response = suggester.indexer().index(items2);

        assertFalse(response.hasError());

        suggester.refresh();

        SuggestResponse response2 = suggester.suggest().setSuggestDetail(true).execute().getResponse();
        assertEquals(2, response2.getNum());
    }

    @Test

  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() {

 *
 */
public interface ModelProblemCollector {

    ProblemCollector<ModelProblem> getProblemCollector();

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

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