return method.isVarArgs();
    }
  }

  static class ConstructorInvokable<T> extends Invokable<T, T> {

    final Constructor<?> constructor;

    ConstructorInvokable(Constructor<?> constructor) {
      super(constructor);
      this.constructor = constructor;
    }

    @Override
    final Object invokeInternal(@Nullable Object receiver, @Nullable Object[] args)

        value =
          listOf(
            Adapters.ANY_VALUE to
              AnyValue(
                tagClass = DerHeader.TAG_CLASS_CONTEXT_SPECIFIC,
                tag = 1L,
                constructed = false,
                length = 16,
                bytes = "******@****.***".encodeUtf8(),
              ),
          ),
      ),
    )
  }

 * OpenSearch queries with appropriate filters and scoring mechanisms.
 */
public class QueryHelper {

    /**
     * Default constructor.
     */
    public QueryHelper() {
        // Default constructor
    }

    /** Logger for this class */
    private static final Logger logger = LogManager.getLogger(QueryHelper.class);

 *
 * <p>This class supports an optional fairness policy for ordering waiting producer and consumer
 * threads. By default, this ordering is not guaranteed. However, a queue constructed with fairness
 * set to {@code true} grants threads access in FIFO order. Fairness generally decreases throughput
 * but reduces variability and avoids starvation.
 *

   *
   * <ul>
   *   <li>The non-private constructor or non-private static factory method with the most parameters
   *       is used to construct the sample instances. In case of tie, the candidate constructors or
   *       factories are tried one after another until one can be used to construct sample
   *       instances.
   *   <li>For the constructor or static factory method used to construct instances, it's checked

    protected Set<String> availableSearcherNameSet;

    /**
     * Default constructor for RankFusionProcessor.
     * Initializes the processor with default values. The actual initialization
     * is performed by the init() method which is called after construction.
     */
    public RankFusionProcessor() {
        // Default constructor - initialization is done in init() method
    }

    /**

    Builder(int expectedKeys) {
      if (expectedKeys > 0) {
        builderMap = Platform.preservesInsertionOrderOnPutsMapWithExpectedSize(expectedKeys);
      }
      // otherwise, leave it null to be constructed lazily
    }

    Map<K, ImmutableCollection.Builder<V>> ensureBuilderMapNonNull() {
      Map<K, ImmutableCollection.Builder<V>> result = builderMap;
      if (result == null) {

  /**
   * Returns {@code true} if this range is of the form {@code [v..v)} or {@code (v..v]}. (This does
   * not encompass ranges of the form {@code (v..v)}, because such ranges are <i>invalid</i> and
   * can't be constructed at all.)
   *
   * <p>Note that certain discrete ranges such as the integer range {@code (3..4)} are <b>not</b>
   * considered empty, even though they contain no actual values. In these cases, it may be helpful

    Builder(int expectedKeys) {
      if (expectedKeys > 0) {
        builderMap = Platform.preservesInsertionOrderOnPutsMapWithExpectedSize(expectedKeys);
      }
      // otherwise, leave it null to be constructed lazily
    }

    Map<K, ImmutableCollection.Builder<V>> ensureBuilderMapNonNull() {
      Map<K, ImmutableCollection.Builder<V>> result = builderMap;
      if (result == null) {

// on the client side, meaning the request is recycled/pooled when a request is sent.
// CAREFUL: This should only be used when there are no pointers, slices that aren't freshly constructed.
func (h *SingleHandler[Req, Resp]) AllowCallRequestPool(b bool) *SingleHandler[Req, Resp] {
	h.callReuseReq = b
	return h
}

// IgnoreNilConn will ignore nil connections when calling.