boolQueryBuilder.mustNot(QueryBuilders.termQuery(FieldNames.KINDS, SuggestItem.Kind.USER.toString()));

        SuggestUtil.deleteByQuery(ComponentUtil.getSearchEngineClient(), suggester.settings(), suggester.getIndex(), boolQueryBuilder);
    }

    public void purgeSearchlogSuggest(final LocalDateTime time) {
        final BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder

        final PropertyDesc idProp = beanDesc.getPropertyDesc(ID);
        idProp.setValue(target, id);
    }

    public String getIndex() {
        return index;
    }

    public void setIndex(final String index) {
        this.index = index;
    }

    public int getScrollTimeout() {
        return scrollTimeout;
    }

        final List<SuggestItem> firstItems = new ArrayList<>();
        final List<SuggestItem> secondItems = new ArrayList<>();

        final String index;
        if (hits.length > 0) {
            index = hits[0].getIndex();
        } else {
            index = SuggestConstants.EMPTY_STRING;
        }

        final boolean singleWordQuery = isSingleWordQuery(query);
        final boolean hiraganaQuery = isHiraganaQuery(query);

        }
    }

    public SuggestRequestBuilder suggest() {
        return new SuggestRequestBuilder(client, readingConverter, normalizer).setIndex(getSearchAlias(index));
    }

    public PopularWordsRequestBuilder popularWords() {
        return new PopularWordsRequestBuilder(client).setIndex(getSearchAlias(index));
    }

    public RefreshResponse refresh() {

        int count = 0;
        for (String index : getIndexResponse.getIndices()) {
            if (index.startsWith(suggester.getIndex())) {
                count++;
            }
        }
        assertEquals(2, count);

        suggester.removeDisableIndices();

                        SearchEngineUtil.scroll(alias, hit -> {
                            try {
                                writer.write("{\"index\":{\"_index\":\"" + hit.getIndex() + "\",\"_id\":\""
                                        + StringEscapeUtils.escapeJson(hit.getId()) + "\"}}\n");
                                writer.write(hit.getSourceAsString());

                    final BulkRequestBuilder bulkRequest = client.prepareBulk();
                    for (final SearchHit hit : hits) {
                        bulkRequest.add(client.prepareDelete().setIndex(hit.getIndex()).setId(hit.getId()));
                    }
                    return bulkRequest.execute();
                });
                if (bulkResponse.hasFailures()) {

        final ParsePosition pos = new ParsePosition(0);
        final Date date = format.parse(str, pos);
        if (date == null) {
            return null;
        }
        final int index = pos.getIndex();
        if (index == 0) {
            return null;
        }
        if (index < str.length()) {
            return null;
        }
        return date;
    }

    /**

    assertTrue(interfaces.hasMoreElements());
    while (interfaces.hasMoreElements()) {
      NetworkInterface i = interfaces.nextElement();
      builder.add(i.getName()).add(String.valueOf(i.getIndex()));
    }
    return builder.build();
  }

  /** Checks that the IP converts to the big integer and the big integer converts to the IP. */

				return
			}
		case "PoolIndex":
			z.PoolIndex, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "PoolIndex")
				return
			}
		case "SetIndex":
			z.SetIndex, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "SetIndex")
				return
			}
		case "DiskIndex":
			z.DiskIndex, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "DiskIndex")
				return
			}