try {
                transport.disconnect(true);
                transport.connect(getConfig().getConnTimeout()); // Reconnect
                log.info("Successfully reconnected after witness notification");
            } catch (Exception e) {
                log.error("Failed to reconnect after witness notification", e);
            }
        });
    }

    /**

 }


 stanConnection, _ = stan.Connect("test-cluster", "test-client", stan.NatsURL("nats://yourusername:yoursecret@0.0.0.0:4222"), stan.SetConnectionLostHandler(func(c stan.Conn, _ error) {
  go func() {
   for {
    // Reconnect if the connection is lost.
    if stanConnection == nil || stanConnection.NatsConn() == nil ||  !stanConnection.NatsConn().IsConnected() {

        }
    }

    /**
     * Connect the transport
     *
     * @throws SmbException
     */
    @Override
    public boolean ensureConnected() throws SmbException {
        try {
            return super.connect(this.transportContext.getConfig().getResponseTimeout());
        } catch (final TransportException te) {
            throw new SmbException("Failed to connect: " + this.address, te);
        }

  ): Http2Connection {
    peer.setClient(client)
    peer.sendFrame().settings(settings!!)
    peer.acceptFrame() // ACK
    peer.play()
    return connect(peer)
  }

  /** Builds a new connection to `peer` with settings acked.  */
  private fun connect(
    peer: MockHttp2Peer,
    pushObserver: PushObserver = IGNORE,
    listener: Http2Connection.Listener = Http2Connection.Listener.REFUSE_INCOMING_STREAMS,

   * there is for the connect, write, and read actions within a call.
   *
   * For WebSockets and duplex calls the timeout only applies to the initial setup.
   */
  @get:JvmName("callTimeoutMillis")
  val callTimeoutMillis: Int = builder.callTimeout

  /** Default connect timeout (in milliseconds). The default is 10 seconds. */
  @get:JvmName("connectTimeoutMillis")

import com.nimbusds.jwt.JWTParser;
import com.nimbusds.oauth2.sdk.AuthorizationCode;
import com.nimbusds.openid.connect.sdk.AuthenticationErrorResponse;
import com.nimbusds.openid.connect.sdk.AuthenticationResponse;
import com.nimbusds.openid.connect.sdk.AuthenticationResponseParser;
import com.nimbusds.openid.connect.sdk.AuthenticationSuccessResponse;

import jakarta.annotation.PostConstruct;
import jakarta.servlet.http.HttpServletRequest;

    val call1Connect = server.takeRequest()
    assertThat(call1Connect.method).isEqualTo("CONNECT")
    assertThat(call1Connect.exchangeIndex).isEqualTo(0)
    val call2Connect = server.takeRequest()
    assertThat(call2Connect.method).isEqualTo("CONNECT")
    assertThat(call2Connect.exchangeIndex).isEqualTo(0)
    val call2Get = server.takeRequest()

 *  **Proxy authenticators are now asked for preemptive authentication.** OkHttp will now request
    authentication credentials before creating TLS tunnels through HTTP proxies (HTTP `CONNECT`).
    Authenticators should identify preemptive authentications by the presence of a challenge whose
    scheme is "OkHttp-Preemptive".

                            || e.getMessage().contains("Failed to connect") || e.getMessage().contains("localhost/0:0:0:0:0:0:0:1"))) {
                        // Network connectivity issue in CI - skip test
                        assumeTrue(false, "Cannot connect to SMB server in CI environment - skipping test: " + e.getMessage());
                    }
                }
            }

                                            <la:option value="none">None</la:option>
                                            <la:option value="oic">OpenID Connect</la:option>
                                            <la:option value="saml">SAML</la:option>
                                            <la:option value="spnego">SPNEGO</la:option>