}

    public boolean deleteQueryWords() {
        final SuggestDeleteResponse response = suggester.indexer().deleteQueryWords();
        if (response.hasError()) {
            logger.warn("Failed to delete query words.", response.getErrors().get(0));
            return false;
        }
        refresh();
        return true;
    }

    public void storeAllElevateWords(final boolean apply) {

    @Execute
    public JsonResponse<ApiResult> delete$query(final SearchBody body) {
        validateApi(body, messages -> {});

        if (StringUtil.isBlank(body.q)) {
            throwValidationErrorApi(messages -> messages.addErrorsInvalidQueryUnknown(GLOBAL));
        }
        try {
            final long count = searchHelper.deleteByQuery(request, body);

    }

    public SuggestDeleteResponse deleteByQuery(final String queryString) {
        return deleteByQuery(QueryBuilders.queryStringQuery(queryString).defaultOperator(Operator.AND));
    }

    public SuggestDeleteResponse deleteByQuery(final QueryBuilder queryBuilder) {
        final long start = System.currentTimeMillis();
        final SuggestWriterResult result = suggestWriter.deleteByQuery(client, settings, index, queryBuilder);

                return oldDocList;
            }

            @Override
            public long deleteByQuery(final String index, final QueryBuilder queryBuilder) {
                if (queryBuilder instanceof final TermsQueryBuilder termsQueryBuilder) {

    }

    protected long deleteDocumentByQuery(final SearchEngineClient searchEngineClient, final String index, final QueryBuilder queryBuilder) {
        return searchEngineClient.deleteByQuery(index, queryBuilder);
    }

    public Map<String, Object> getDocument(final SearchEngineClient searchEngineClient, final String id, final String[] fields) {

        final String docId = form.docId;
        try {
            final QueryBuilder query = QueryBuilders.termQuery(fessConfig.getIndexFieldDocId(), docId);
            searchEngineClient.deleteByQuery(fessConfig.getIndexDocumentUpdateIndex(), query);
            saveInfo(messages -> messages.addSuccessDeleteDocFromIndex(GLOBAL));
        } catch (final Exception e) {

                    docMap.put(fessConfig.getIndexFieldPrimaryTerm(), hit.getPrimaryTerm());
                    return docMap;
                }, cursor);
    }

    public long deleteByQuery(final HttpServletRequest request, final SearchRequestParams params) {
        final String query = ComponentUtil.getQueryStringBuilder().params(params).build();

            return (List<String>) value;
        }
        throw new IllegalArgumentException("The value should be String or List, but " + value.getClass());
    }

    public static boolean deleteByQuery(final Client client, final SuggestSettings settings, final String index,
            final QueryBuilder queryBuilder) {
        try {

    protected void deleteKeyFromArray(final String index, final String type, final String key) {
        final String actualIndex = index + "." + type.toLowerCase(Locale.ENGLISH);
        try {
            SuggestUtil.deleteByQuery(client, settings, actualIndex, QueryBuilders.termQuery(FieldNames.ARRAY_KEY, key));
        } catch (final Exception e) {
            throw new SuggestSettingsException("Failed to delete all from array.", e);
        }

    }

    @Override
    public Client filterWithHeader(final Map<String, String> headers) {
        client.filterWithHeader(headers);
        return this;
    }

    public int deleteByQuery(final String index, final String type, final QueryBuilder queryBuilder) {
        SearchResponse response =