if (queryBuilder != null) {
                builder.setQuery(queryBuilder);
            }
            _conditionQuery.getFieldSortBuilderList().forEach(sort -> {
                builder.addSort(sort);
            });
        }

        if (_conditionAggregation != null) {
            _conditionAggregation.getAggregationBuilderList().forEach(builder::addAggregation);
        }

            if (queryBuilder != null) {
                builder.setQuery(queryBuilder);
            }
            _conditionQuery.getFieldSortBuilderList().forEach(sort -> {
                builder.addSort(sort);
            });
        }

        if (_conditionAggregation != null) {
            _conditionAggregation.getAggregationBuilderList().forEach(builder::addAggregation);
        }

            if (queryBuilder != null) {
                builder.setQuery(queryBuilder);
            }
            _conditionQuery.getFieldSortBuilderList().forEach(sort -> {
                builder.addSort(sort);
            });
        }

        if (_conditionAggregation != null) {
            _conditionAggregation.getAggregationBuilderList().forEach(builder::addAggregation);
        }

         */
        protected void buildSort(final QueryContext queryContext, final QueryFieldConfig queryFieldConfig, final FessConfig fessConfig) {
            queryContext.sortBuilders().forEach(sortBuilder -> searchRequestBuilder.addSort(sortBuilder));
        }

        /**
         * Builds the rescorer configuration.
         *
         * @param queryHelper the query helper

                final int maxDocumentCacheSize = fessConfig.getIndexerWebfsMaxDocumentCacheSizeAsInteger();
                builder.setSize(maxDocumentCacheSize <= 0 ? 1 : maxDocumentCacheSize);
                builder.addSort(OpenSearchAccessResult.CREATE_TIME, SortOrder.ASC);
            };

            final DocList docList = new DocList();
            final List<OpenSearchAccessResult> accessResultList = new ArrayList<>();

    }

    // Test addSorts
    @Test
    public void test_addSorts() {
        queryContext = new QueryContext("test", false);
        assertFalse(queryContext.hasSorts());

        SortBuilder<?> sort1 = SortBuilders.fieldSort("field1");
        SortBuilder<?> sort2 = SortBuilders.fieldSort("field2");

        queryContext.addSorts(sort1, sort2);

            if (endIndex > 0) {
                val packageName = zipEntry.name.substring(0, endIndex)
                if (shouldInclude(packageName, excludes, includes)) {
                    builder.addWord(packageName)
                }
            }
        }

        private
        fun shouldInclude(packageName: String, excludes: List<String>, includes: List<String>): Boolean {

                            "Invalid sort order: " + termQuery);
                }
            } else {
                sortOrder = SortOrder.ASC;
            }
            context.addSorts(createFieldSortBuilder(sortField, sortOrder));
        }));
        return null;
    }

    /**
     * Converts a term query for the default field with fuzzy matching support.
     *

        this.queryBuilder = queryBuilder;
    }

    /**
     * Adds sort builders to the query context.
     * @param sortBuilders Variable number of sort builders to add.
     */
    public void addSorts(final SortBuilder<?>... sortBuilders) {
        stream(sortBuilders).of(stream -> stream.forEach(sortBuilder -> sortBuilderList.add(sortBuilder)));
    }

    /**

        buildRoleQuery(queryContext, searchRequestType);
        buildVirtualHostQuery(queryContext, searchRequestType);

        if (!queryContext.hasSorts() && defaultSortBuilders != null) {
            queryContext.addSorts(defaultSortBuilders);
        }
        return queryContext;
    }

    /**
     * Builds virtual host query filters to restrict search results to the current virtual host.