func buildAdminRequest(queryVal url.Values, method, path string,
	contentLength int64, bodySeeker io.ReadSeeker) (*http.Request, error,
) {
	req, err := newTestRequest(method,
		adminPathPrefix+adminAPIVersionPrefix+path+"?"+queryVal.Encode(),
		contentLength, bodySeeker)
	if err != nil {
		return nil, err
	}

	cred := globalActiveCred

    AccessResultData<IDTYPE> getAccessResultData();

    void setAccessResultData(AccessResultData<IDTYPE> accessResultData);

    Long getContentLength();

    void setContentLength(Long contentLength);

    Long getLastModified();

    void setLastModified(Long lastModified);

	objAPI, cred := validateAdminReq(ctx, w, r, policy.SetTierAction)
	if objAPI == nil {
		return
	}

	password := cred.SecretKey
	reqBytes, err := madmin.DecryptData(password, io.LimitReader(r.Body, r.ContentLength))
	if err != nil {
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErrWithErr(ErrAdminConfigBadJSON, err), r.URL)
		return
	}

	var cfg madmin.TierConfig
	json := jsoniter.ConfigCompatibleWithStandardLibrary

            callback.accept(builder);
            builder.setFetchSource(new String[] { "parentUrl", "method", "mimeType", "sessionId", "url", "executionTime", "createTime",
                    "contentLength", "lastModified", "ruleId", "httpStatusCode", "status" }, null);
            return builder.execute();
        });
        final OpenSearchResultList<OpenSearchAccessResult> targetList = new OpenSearchResultList<>();

	"http://dbflute.org/meta/lastadi10.dtd">
<components namespace="fessCrawler">
	<include path="crawler/container.xml" />
	<include path="crawler/robotstxt.xml" />
	<include path="crawler/contentlength.xml" />
	<include path="crawler/mimetype.xml" />

	<component name="internalHttpClient" class="org.codelibs.fess.crawler.client.http.HcHttpClient"
		instance="prototype">
		<property name="connectionTimeout">15000</property>

        throw IOException("response: " + response.code + " " + response.message)
      }

      val body = response.body

      if (body.contentLength() > MAX_RESPONSE_SIZE) {
        throw IOException(
          "response size exceeds limit ($MAX_RESPONSE_SIZE bytes): ${body.contentLength()} bytes",
        )
      }

      val responseBytes = body.source().readByteString()

      Protocol.H2_PRIOR_KNOWLEDGE
    } else {
      Protocol.HTTP_2
    }

  @Volatile
  private var canceled = false

  override fun createRequestBody(
    request: Request,
    contentLength: Long,
  ): Sink {
    return stream!!.getSink()
  }

  override fun writeRequestHeaders(request: Request) {
    if (stream != null) return

    val hasRequestBody = request.body != null

    return object : RequestBody() {
      override fun contentType(): MediaType? {
        return original!!.contentType()
      }

      override fun contentLength(): Long {
        return original!!.contentLength()
      }

      override fun writeTo(sink: BufferedSink) {
        val uppercase = uppercase(sink)
        val bufferedSink = uppercase.buffer()

        }

        final long contentLength;
        final File tempFile;
        final boolean isByteStream = inputStream instanceof ByteArrayInputStream;
        if (isByteStream) {
            inputStream.mark(0);
            tempFile = null;
            contentLength = ((ByteArrayInputStream) inputStream).available();
        } else {
            try {

        }

        this.resumeKey = new byte[24];
        System.arraycopy(buffer, bufferIndex, this.resumeKey, 0, 24);
        bufferIndex += 24;

        SMBUtil.readInt4(buffer, bufferIndex); // contextLength - reserved
        bufferIndex += 4;

        return bufferIndex - start;
    }