* @param <Res> the type of the response
 */
public abstract class RequestBuilder<Req extends Request<Res>, Res extends Response> {
    /** The OpenSearch client. */
    protected Client client;
    /** The request being built. */
    protected Req request;

    /**
     * Constructor for RequestBuilder.
     * @param client The OpenSearch client.
     * @param request The request instance.
     */

        requestBuilder.header("Content-Length", contentLength.toString())
        requestBuilder.removeHeader("Transfer-Encoding")
      } else {
        requestBuilder.header("Transfer-Encoding", "chunked")
        requestBuilder.removeHeader("Content-Length")
      }
    }

    if (userRequest.header("Host") == null) {
      requestBuilder.header("Host", userRequest.url.toHostHeader())
    }

        requestBuilder.method("GET", null)
      } else {
        val requestBody = if (maintainBody) userResponse.request.body else null
        requestBuilder.method(method, requestBody)
      }
      if (!maintainBody) {
        requestBuilder.removeHeader("Transfer-Encoding")
        requestBuilder.removeHeader("Content-Length")
        requestBuilder.removeHeader("Content-Type")
      }
    }

import org.codelibs.fess.suggest.request.RequestBuilder;
import org.opensearch.transport.client.Client;

/**
 * Builder for creating a {@link PopularWordsRequest} to fetch popular words.
 * This builder provides methods to set various parameters for the request.
 */
public class PopularWordsRequestBuilder extends RequestBuilder<PopularWordsRequest, PopularWordsResponse> {
    /**

import org.codelibs.fess.suggest.normalizer.Normalizer;
import org.codelibs.fess.suggest.request.RequestBuilder;
import org.opensearch.transport.client.Client;

/**
 * Builder class for constructing {@link SuggestRequest} instances.
 * This builder provides methods to set various parameters for the suggest request.
 */
public class SuggestRequestBuilder extends RequestBuilder<SuggestRequest, SuggestResponse> {
    /**

            searchEngineClient.scrollSearch(fessConfig.getIndexDocumentUpdateIndex(), requestBuilder -> {
                requestBuilder.setQuery(queryBuilder).setSize((int) numFound);
                if (fields != null) {
                    requestBuilder.setFetchSource(fields, null);
                }
                return true;
            }, entity -> {

        final GetRequestBuilder requestBuilder = client.prepareGet(index, id);
        if (condition.build(requestBuilder)) {
            response = requestBuilder.execute().actionGet(ComponentUtil.getFessConfig().getIndexSearchTimeout());
        }
        final long execTime = systemHelper.getCurrentTimeAsLong() - startTime;

    Request(
      url = "".toHttpUrl(),
      headers = headersOf(),
      method = "",
      body = "".toRequestBody(null),
    )
  }

  @Test
  fun requestBuilder() {
    val requestBody = "".toRequestBody(null)
    var builder = Request.Builder()
    builder = builder.url("".toHttpUrl())
    builder = builder.url("")
    builder = builder.url(URL(""))

    server.enqueue(MockResponse(body = "Page 2"))
    val requestBuilder =
      Request
        .Builder()
        .url(server.url("/page1"))
    if (method == "POST") {
      requestBuilder.post("ABCD".toRequestBody(null))
    } else {
      requestBuilder.method(method, null)
    }
    val response = getResponse(requestBuilder.build())

  }

  @Test
  fun invalidScheme() {
    val requestBuilder = Request.Builder()
    assertFailsWith<IllegalArgumentException> {
      requestBuilder.url("ftp://hostname/path")
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Expected URL scheme 'http' or 'https' but was 'ftp'")
    }
  }

  @Test
  fun invalidPort() {
    val requestBuilder = Request.Builder()