if (list.size() == 1) {
                return list.get(0);
            }
            if (list.size() > 1) {
                final BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
                list.forEach(boolQuery::should);
                return boolQuery;
            }
            return null;
        }).filter(q -> q != null).toArray(n -> new QueryBuilder[n]);

        if (queryBuilders.length == 1) {

        assertObjectNotNull("filterList", filterList);
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        mustList.forEach(query -> {
            boolQuery.must(query);
        });
        shouldList.forEach(query -> {
            boolQuery.should(query);
        });
        mustNotList.forEach(query -> {
            boolQuery.mustNot(query);
        });
        filterList.forEach(query -> {

        assertObjectNotNull("filterList", filterList);
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        mustList.forEach(query -> {
            boolQuery.must(query);
        });
        shouldList.forEach(query -> {
            boolQuery.should(query);
        });
        mustNotList.forEach(query -> {
            boolQuery.mustNot(query);
        });
        filterList.forEach(query -> {

                    boolQuery.should(queryBuilder);
                    break;
                case MUST_NOT:
                    boolQuery.mustNot(queryBuilder);
                    break;
                default:
                    break;
                }
            }
        }
        if (boolQuery.hasClauses()) {
            return boolQuery;
        }
        return null;
    }

        return ComponentUtil.getSearchEngineClient().getDocument(fessConfig.getIndexDocumentSearchIndex(), builder -> {
            final BoolQueryBuilder boolQuery =
                    QueryBuilders.boolQuery().must(QueryBuilders.termQuery(fessConfig.getIndexFieldDocId(), docId));
            final Set<String> roleSet = ComponentUtil.getRoleQueryHelper().build(SearchRequestType.JSON); // TODO SearchRequestType?

                }).forEach(docId -> {
                    boolQuery.should(QueryBuilders.termQuery(fessConfig.getIndexFieldDocId(), docId));
                });

                if (boolQuery.hasClauses()) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Loaded KeyMatch Boost Query: {}", boolQuery);
                    }

                queryContext.addQuery(boolQuery -> buildRoleQuery(roleSet, boolQuery));
            }
        }
    }

    /**
     * Builds role-based query filters using the provided role set.
     * This method adds should clauses for allowed roles and must-not clauses for denied roles.
     *
     * @param roleSet the set of roles to use for filtering
     * @param boolQuery the boolean query builder to add role filters to

        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        for (QueryBuilder query : queries) {
            boolQuery.must(query);
        }
        return boolQuery;
    }

    private QueryBuilder orQuery(QueryBuilder... queries) {
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        for (QueryBuilder query : queries) {

     * @param boolQuery Consumer that configures the boolean query.
     */
    public void addQuery(final Consumer<BoolQueryBuilder> boolQuery) {
        BoolQueryBuilder builder;
        if (queryBuilder instanceof MatchAllQueryBuilder) {
            builder = QueryBuilders.boolQuery();
        } else {
            builder = QueryBuilders.boolQuery().must(queryBuilder);
        }

        }

        final BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        final String minimumShouldMatch = fessConfig.getQueryBoolMinimumShouldMatch();
        if (StringUtil.isNotBlank(minimumShouldMatch)) {
            boolQuery.minimumShouldMatch(minimumShouldMatch);
        }
        return new DefaultQueryBuilder(boolQuery);
    }

    /**