) : okhttp3.Authenticator {
  @Throws(IOException::class)
  override fun authenticate(
    route: Route?,
    response: Response,
  ): Request? {
    val challenges = response.challenges()
    val request = response.request
    val url = request.url
    val proxyAuthorization = response.code == 407
    val proxy = route?.proxy ?: Proxy.NO_PROXY

    for (challenge in challenges) {

    Request request = new Request.Builder()
        .url("https://google.com/robots.txt")
        .build();
    try (Response response = client.newCall(request).execute()) {
      assertEquals(200, response.code());
      assertEquals(Protocol.HTTP_2, response.protocol());
    }
  }

    end
```

/// info | Información

Solo **un response** será enviado al cliente. Podría ser uno de los responses de error o será el response de la *path operation*.

Después de que se envíe uno de esos responses, no se podrá enviar ningún otro response.

///

/// tip | Consejo

     */
    @Override
    public T getResponse() {
        return this.response;
    }

    /**
     * Create the response object for this request
     *
     * @param tc the CIFS context
     * @param req the request object
     * @return the response object
     */
    protected abstract T createResponse(CIFSContext tc, ServerMessageBlock2Request<T> req);

    /**

    replaceWith =
      ReplaceWith(
        expression = "response.processEventSource(listener)",
        imports = ["okhttp3.sse.EventSource.Companion.processEventSource"],
      ),
    level = DeprecationLevel.WARNING,
  )
  @JvmStatic
  fun processResponse(
    response: Response,
    listener: EventSourceListener,
  ): Unit = response.processEventSource(listener)

| token          | string     | Token from the AssumeRoleWithCustomToken call for external verification |

### Response

If the token is valid and access is approved, the plugin must return a `200` (OK) HTTP status code.

A `200 OK` Response should have `application/json` content-type and body with the following structure:

```json
{
    "user": <string>,
    "maxValiditySeconds": <integer>,

    val request = Request(server.url("/"))

    val response = client.newCall(request).execute()

    response.use {
      assertEquals(200, response.code)
      assertEquals(TlsVersion.TLS_1_3, response.handshake?.tlsVersion)
      assertEquals(Protocol.HTTP_2, response.protocol)

      assertThat(response.exchangeAccessor!!.connectionAccessor.socket())
        .isInstanceOf<SSLSocketImpl>()
    }

        // Mock successful but empty response
        when(treeHandle.send(any(), any(), (RequestParam[]) any())).thenAnswer(invocation -> {
            // The response is the second argument
            Object response = invocation.getArgument(1);
            // Return it unchanged (which will have default values = empty results)
            return response;
        });

        // When: Create iterator

	public static fun process (Lokhttp3/Response;Lokhttp3/sse/EventSourceListener;)V
	public abstract fun request ()Lokhttp3/Request;
}

public final class okhttp3/sse/EventSource$Companion {
	public final fun enqueue (Lokhttp3/Call;Lokhttp3/sse/EventSourceListener;)Lokhttp3/sse/EventSource;
	public final fun process (Lokhttp3/Response;Lokhttp3/sse/EventSourceListener;)V
}

        response.getServerData().securityMode = 1;
        response.getServerData().encryptedPasswords = true;
        response.getServerData().smaxMpxCount = 50;
        response.getServerData().maxNumberVcs = 1;
        response.getServerData().maxBufferSize = 16384;
        response.getServerData().maxRawSize = 4096;
        response.getServerData().sessKey = 0x12345678;
        response.getServerData().scapabilities = SmbConstants.CAP_UNICODE;