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

    /**
     * Stores all elevate words in the suggest index.
     *

 * <li>{@link #delete(String)} - Delete a suggest item by ID.
 * <li>{@link #deleteByQuery(String)} - Delete suggest items by query string.
 * <li>{@link #deleteByQuery(QueryBuilder)} - Delete suggest items by query builder.
 * <li>{@link #deleteAll()} - Delete all suggest items.
 * <li>{@link #deleteDocumentWords()} - Delete document words.
 * <li>{@link #deleteQueryWords()} - Delete query words.

        }
        return result;
    }

    @Override
    public SuggestWriterResult deleteByQuery(final Client client, final SuggestSettings settings, final String index,
            final QueryBuilder queryBuilder) {
        final SuggestWriterResult result = new SuggestWriterResult();
        try {
            SuggestUtil.deleteByQuery(client, settings, index, queryBuilder);
        } catch (final Exception e) {

     * @throws OpenSearchAccessException if the deletion fails.
     * @deprecated Use {@link #deleteByQuery(String, QueryBuilder)} instead. The type parameter is no longer used.
     */
    @Deprecated
    public int deleteByQuery(final String index, final String type, final QueryBuilder queryBuilder) {
        return deleteByQuery(index, queryBuilder);
    }

    /**

        }).when(mockClearScrollBuilder).execute(any(ActionListener.class));

        final int deleted = fesenClient.deleteByQuery("test-index", QueryBuilders.matchAllQuery());

        assertEquals(1, deleted);
        verify(mockClearScrollBuilder, times(1)).addScrollId("scroll1");
    }

    /**
     * Test: deleteByQuery deprecated method delegates to new method
     * Verifies backward compatibility
     */
    @Test

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

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

    /**
     * Retrieves a document from the search index by its ID.
     *
     * @param searchEngineClient the search engine client to use for retrieval

        boolean result = SuggestUtil.deleteByQuery(client, settings, TEST_INDEX, QueryBuilders.termQuery("nonexistent", "value"));
        assertTrue(result); // Should still return true even with no matches
    }

    @Test(expected = SuggesterException.class)
    public void testDeleteByQueryWithInvalidIndex() {
        // Test delete with non-existent index

        runner.refresh();

        assertEquals(3, suggester.getAllWordsNum());

        SuggestWriterResult result = writer.deleteByQuery(runner.client(), suggester.settings(), suggester.getIndex(),
                QueryBuilders.matchQuery(FieldNames.TEXT, "テスト0"));

        assertNotNull(result);
        assertFalse(result.hasFailure());

        suggester.indexer().index(item);
        suggester.refresh();

        SuggestDeleteResponse deleteResponse = suggester.indexer().deleteByQuery(FieldNames.TEXT + ":テスト");

        assertNotNull(deleteResponse);
        assertFalse(deleteResponse.hasError());
    }

    @Test
    public void test_deleteByQueryBuilder() throws Exception {