}

  /**
   * Revoke this exchange's access to streams. This is necessary when a follow-up request is
   * required but the preceding exchange hasn't completed yet.
   */
  fun detachWithViolence() {
    codec.cancel()
    call.messageDone(
      exchange = this,
      requestDone = true,
      responseDone = true,
      socketSinkDone = true,
      socketSourceDone = true,
      e = null,
    )

 */
class RealInterceptorChain(
  internal val call: RealCall,
  private val interceptors: List<Interceptor>,
  private val index: Int,
  internal val exchange: Exchange?,
  internal val request: Request,
  internal val connectTimeoutMillis: Int,
  internal val readTimeoutMillis: Int,
  internal val writeTimeoutMillis: Int,
  override val authenticator: Authenticator,
  override val cache: Cache?,

    exchange: Exchange,
    requestDone: Boolean = false,
    responseDone: Boolean = false,
    socketSourceDone: Boolean = false,
    socketSinkDone: Boolean = false,
    e: IOException?,
  ): IOException? {
    if (exchange != this.exchange) return e // This exchange was detached violently!

    var allStreamsDone = false
    var callDone = false
    withLock {
      if (
        requestDone && requestBodyOpen ||

            .request(request)
            .priorResponse(priorResponse?.stripBody())
            .build()

        val exchange = call.interceptorScopedExchange
        val followUp = followUpRequest(response, exchange, chain)

        if (followUp == null) {
          if (exchange != null && exchange.isDuplex) {
            call.timeoutEarlyExit()
          }
          closeActiveExchange = false

    open fun receivedResponseAtMillis(receivedResponseAtMillis: Long) =
      apply {
        this.receivedResponseAtMillis = receivedResponseAtMillis
      }

    internal fun initExchange(exchange: Exchange) {
      this.exchange = exchange
    }

    open fun build(): Response {
      check(code >= 0) { "code < 0: $code" }
      return Response(
        checkNotNull(request) { "request == null" },

	"github.com/rabbitmq/amqp091-go"
)

// AMQPArgs - AMQP target arguments.
type AMQPArgs struct {
	Enable            bool        `json:"enable"`
	URL               amqp091.URI `json:"url"`
	Exchange          string      `json:"exchange"`
	RoutingKey        string      `json:"routingKey"`
	ExchangeType      string      `json:"exchangeType"`
	DeliveryMode      uint8       `json:"deliveryMode"`
	Mandatory         bool        `json:"mandatory"`

  val carrier: Carrier

  /** Returns true if the response body and (possibly empty) trailers have been received. */
  val isResponseComplete: Boolean

  /** The socket that carries this exchange. */
  val socket: Socket

  /** Returns an output stream where the request body can be streamed. */
  @Throws(IOException::class)
  fun createRequestBody(
    request: Request,
    contentLength: Long,
  ): Sink

    return connect
  }

  /**
   * Returns the connection already attached to the call if it's eligible for a new exchange.
   *
   * If the call's connection exists and is eligible for another exchange, it is returned. If it
   * exists but cannot be used for another exchange, it is closed and this returns null.
   */
  private fun planReuseCallConnection(): ReusePlan? {

        if ("100-continue".equals(request.header("Expect"), ignoreCase = true)) {
          exchange.flushRequest()
          responseBuilder = exchange.readResponseHeaders(expectContinue = true)
          exchange.responseHeadersStart()
          invokeStartEvent = false
        }
        if (responseBuilder == null) {
          if (requestBody.isDuplex()) {

 * OAuth, SPNEGO, or other authentication mechanisms. Each authenticator is responsible
 * for obtaining login credentials, resolving user information, and managing SSO
 * lifecycle operations like logout and metadata exchange.
 */
public interface SsoAuthenticator {

    /**
     * Gets the login credential for SSO authentication.
     * @return The login credential.
     */
    LoginCredential getLoginCredential();

    /**