labels.reset_dictionaries=Reset Dictionaries
labels.reindex_start_button=Start
labels.targetVersion=Target Version
labels.target_version=Target Version
labels.sereq_configuration=Request to OpenSearch
labels.sereq_request_file=Request File
labels.requestFile=Request File
labels.sereq_button_upload=Send
labels.facet_is_not_found=Not found
labels.doc_score=Score:

            try {
                relatedQueryService.store(entity);
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));
            }
            return entity;
        }).orElseGet(() -> {

    val client =
      clientTestRule
        .newClientBuilder()
        .addInterceptor(empty)
        .addInterceptor { chain ->
          assertThat(chain.request().header("Accept-Encoding")).isNull()
          Response
            .Builder()
            .request(chain.request())
            .protocol(Protocol.HTTP_1_1)
            .code(200)
            .message("OK")
            .body("Hello".toResponseBody())

import okhttp3.OkHttpClient
import okhttp3.Protocol
import okhttp3.Request

object ExternalHttp2Example {
  @JvmStatic
  fun main(args: Array<String>) {
    val client =
      OkHttpClient
        .Builder()
        .protocols(listOf(Protocol.HTTP_2, Protocol.HTTP_1_1))
        .build()
    val call =
      client.newCall(
        Request
          .Builder()
          .url("https://www.google.ca/")

 *
 * <p>This interface is intended for internal use.</p>
 */
public enum RequestParam {

    /**
     * No special request parameters.
     */
    NONE,

    /**
     * Wait indefinitely for a response
     */
    NO_TIMEOUT,

    /**
     * Do not retry request on failure
     */
    NO_RETRY,

    /**
     * Save the raw payload for further inspection
     */
    RETAIN_PAYLOAD

        try {
            pathMappingService.store(entity);
            saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
        } catch (final Exception e) {
            logger.warn("Failed to process a request.", e);
            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));
        }

            try {
                relatedContentService.store(entity);
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));
            }
            return entity;
        }).orElseGet(() -> {

	pluginAuthnServiceLastFailSecondsMD      = NewCounterMD(pluginAuthnServiceLastFailSeconds, "When plugin authentication is configured, returns time (in seconds) since the last failed request to the service")

import java.io.IOException
import okhttp3.Call
import okhttp3.Callback
import okhttp3.Request
import okhttp3.Response
import okhttp3.ResponseBody
import okhttp3.internal.stripBody
import okhttp3.sse.EventSource
import okhttp3.sse.EventSourceListener

internal class RealEventSource private constructor(
  private val call: Call?,
  private val request: Request,
  private val listener: EventSourceListener,
) : EventSource,

    }

    @Override
    public ResolutionGroup retrieve(MetadataResolutionRequest request) throws ArtifactMetadataRetrievalException {
        return retrieve(request.getArtifact(), request.getLocalRepository(), request.getRemoteRepositories());
    }

    @Override
    public List<ArtifactVersion> retrieveAvailableVersions(MetadataResolutionRequest request)
            throws ArtifactMetadataRetrievalException {