Request(
        url = "https://api.github.com/markdown/raw".toHttpUrl(),
        body = requestBody,
      )

    client.newCall(request).execute().use { response ->
      if (!response.isSuccessful) throw IOException("Unexpected code $response")

      println(response.body.string())
    }
  }

  companion object {
    val MEDIA_TYPE_MARKDOWN = "text/x-markdown; charset=utf-8".toMediaType()
  }
}

fun main() {

     *
     * @return HTML response for the suggest management page
     */
    @Execute
    @Secured({ ROLE, ROLE + VIEW })
    public HtmlResponse index() {
        saveToken();
        return asHtml(path_AdminSuggest_AdminSuggestJsp).useForm(SuggestForm.class);
    }

    /**
     * Deletes all suggest words from the suggest index.
     *
     * @return HTML response redirecting to the index page
     */

        .build();

    Call call = client.newCall(new Request.Builder()
        .url(server.url("/"))
        .build());
    Response response = call.execute();
    System.out.println(response.handshake().tlsVersion());
  }

  public static void main(String... args) throws Exception {
    new HttpsServer().run();
  }

import jcifs.Configuration;
import jcifs.internal.SmbBasicFileInfo;
import jcifs.internal.smb1.ServerMessageBlock;
import jcifs.internal.util.SMBUtil;
import jcifs.util.Hexdump;

/**
 * Response for SMB1 COM_QUERY_INFORMATION command.
 *
 * This response contains file attributes, size, and timestamps
 * for the requested file or directory.
 */
public class SmbComQueryInformationResponse extends ServerMessageBlock implements SmbBasicFileInfo {

import org.codelibs.fess.util.RenderDataUtil;
import org.dbflute.optional.OptionalEntity;
import org.dbflute.optional.OptionalThing;
import org.lastaflute.web.Execute;
import org.lastaflute.web.response.HtmlResponse;
import org.lastaflute.web.response.render.RenderData;
import org.lastaflute.web.ruts.process.ActionRuntime;
import org.lastaflute.web.validation.VaErrorHook;
import org.lastaflute.web.validation.VaMessenger;

import org.opensearch.transport.client.Client;

/**
 * Abstract class representing a request that can be executed to produce a response.
 *
 * @param <T> the type of response produced by this request
 */
public abstract class Request<T extends Response> {
    /**
     * Constructs a new request.
     */
    public Request() {
        // nothing
    }

    /**
     * Executes the request.

 */
package jcifs.internal.dfs;

import java.util.Arrays;

import jcifs.Decodable;
import jcifs.internal.util.SMBUtil;

/**
 * DFS (Distributed File System) referral response buffer parser.
 * Decodes server responses to DFS referral requests, extracting information about
 * available DFS targets, path consumption details, and referral flags.
 *
 * @author mbechler
 */

            throw new SmbException("Response buffer is null");
        }

        if (buffer.length < expectedSize) {
            failedValidations.incrementAndGet();
            bufferOverflowsPrevented.incrementAndGet();
            log.warn("Response buffer too small: {} < {}", buffer.length, expectedSize);
            throw new SmbException("Response buffer too small: " + buffer.length + " < " + expectedSize);
        }

import jcifs.Configuration;
import jcifs.internal.smb1.ServerMessageBlock;

/**
 * SMB1 blank response message.
 *
 * This is a generic response message for SMB commands that don't
 * return specific data in their response.
 */
public class SmbComBlankResponse extends ServerMessageBlock {

    /**
     * Creates a new blank SMB1 response.
     *
     * @param config the CIFS configuration
     */

        final Map<String, Object> searchBody = new HashMap<>();
        String response = checkGetMethod(searchBody, getListEndpointSuffix()).asString();
        final int total = JsonPath.from(response).getInt("response.total");
        final List<Map<String, String>> items = JsonPath.from(response).getList("response.settings");
        final int status = JsonPath.from(response).getInt("response.status");
        assertEquals(total, items.size());