/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (https://www.swig.org).
 * Version 4.3.0
 *
 * Do not make changes to this file unless you know what you are doing - modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */

package com.chilkatsoft;

public class CkSocket {
  private transient long swigCPtr;
  protected transient boolean swigCMemOwn;

  protected CkSocket(long cPtr, boolean cMemoryOwn) {
    swigCMemOwn = cMemoryOwn;
    swigCPtr = cPtr;
  }

  protected static long getCPtr(CkSocket obj) {
    return (obj == null) ? 0 : obj.swigCPtr;
  }

  protected static long swigRelease(CkSocket obj) {
    long ptr = 0;
    if (obj != null) {
      if (!obj.swigCMemOwn)
        throw new RuntimeException("Cannot release ownership as memory is not owned");
      ptr = obj.swigCPtr;
      obj.swigCMemOwn = false;
      obj.delete();
    }
    return ptr;
  }

  @SuppressWarnings({"deprecation", "removal"})
  protected void finalize() {
    delete();
  }

  public synchronized void delete() {
    if (swigCPtr != 0) {
      if (swigCMemOwn) {
        swigCMemOwn = false;
        chilkatJNI.delete_CkSocket(swigCPtr);
      }
      swigCPtr = 0;
    }
  }

  public CkSocket() {
    this(chilkatJNI.new_CkSocket(), true);
  }

  public void LastErrorXml(CkString str) {
    chilkatJNI.CkSocket_LastErrorXml(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public void LastErrorHtml(CkString str) {
    chilkatJNI.CkSocket_LastErrorHtml(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public void LastErrorText(CkString str) {
    chilkatJNI.CkSocket_LastErrorText(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public void put_EventCallbackObject(CkBaseProgress progress) {
    chilkatJNI.CkSocket_put_EventCallbackObject(swigCPtr, this, CkBaseProgress.getCPtr(progress), progress);
  }

  public boolean get_AbortCurrent() {
    return chilkatJNI.CkSocket_get_AbortCurrent(swigCPtr, this);
  }

  public void put_AbortCurrent(boolean newVal) {
    chilkatJNI.CkSocket_put_AbortCurrent(swigCPtr, this, newVal);
  }

  public int get_AcceptFailReason() {
    return chilkatJNI.CkSocket_get_AcceptFailReason(swigCPtr, this);
  }

  public void get_AlpnProtocol(CkString str) {
    chilkatJNI.CkSocket_get_AlpnProtocol(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String alpnProtocol() {
    return chilkatJNI.CkSocket_alpnProtocol(swigCPtr, this);
  }

  public void put_AlpnProtocol(String newVal) {
    chilkatJNI.CkSocket_put_AlpnProtocol(swigCPtr, this, newVal);
  }

  public int get_BandwidthThrottleDown() {
    return chilkatJNI.CkSocket_get_BandwidthThrottleDown(swigCPtr, this);
  }

  public void put_BandwidthThrottleDown(int newVal) {
    chilkatJNI.CkSocket_put_BandwidthThrottleDown(swigCPtr, this, newVal);
  }

  public int get_BandwidthThrottleUp() {
    return chilkatJNI.CkSocket_get_BandwidthThrottleUp(swigCPtr, this);
  }

  public void put_BandwidthThrottleUp(int newVal) {
    chilkatJNI.CkSocket_put_BandwidthThrottleUp(swigCPtr, this, newVal);
  }

  public boolean get_BigEndian() {
    return chilkatJNI.CkSocket_get_BigEndian(swigCPtr, this);
  }

  public void put_BigEndian(boolean newVal) {
    chilkatJNI.CkSocket_put_BigEndian(swigCPtr, this, newVal);
  }

  public void get_ClientIpAddress(CkString str) {
    chilkatJNI.CkSocket_get_ClientIpAddress(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String clientIpAddress() {
    return chilkatJNI.CkSocket_clientIpAddress(swigCPtr, this);
  }

  public void put_ClientIpAddress(String newVal) {
    chilkatJNI.CkSocket_put_ClientIpAddress(swigCPtr, this, newVal);
  }

  public int get_ClientPort() {
    return chilkatJNI.CkSocket_get_ClientPort(swigCPtr, this);
  }

  public void put_ClientPort(int newVal) {
    chilkatJNI.CkSocket_put_ClientPort(swigCPtr, this, newVal);
  }

  public int get_ConnectFailReason() {
    return chilkatJNI.CkSocket_get_ConnectFailReason(swigCPtr, this);
  }

  public void get_DebugLogFilePath(CkString str) {
    chilkatJNI.CkSocket_get_DebugLogFilePath(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String debugLogFilePath() {
    return chilkatJNI.CkSocket_debugLogFilePath(swigCPtr, this);
  }

  public void put_DebugLogFilePath(String newVal) {
    chilkatJNI.CkSocket_put_DebugLogFilePath(swigCPtr, this, newVal);
  }

  public int get_ElapsedSeconds() {
    return chilkatJNI.CkSocket_get_ElapsedSeconds(swigCPtr, this);
  }

  public int get_HeartbeatMs() {
    return chilkatJNI.CkSocket_get_HeartbeatMs(swigCPtr, this);
  }

  public void put_HeartbeatMs(int newVal) {
    chilkatJNI.CkSocket_put_HeartbeatMs(swigCPtr, this, newVal);
  }

  public void get_HttpProxyAuthMethod(CkString str) {
    chilkatJNI.CkSocket_get_HttpProxyAuthMethod(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String httpProxyAuthMethod() {
    return chilkatJNI.CkSocket_httpProxyAuthMethod(swigCPtr, this);
  }

  public void put_HttpProxyAuthMethod(String newVal) {
    chilkatJNI.CkSocket_put_HttpProxyAuthMethod(swigCPtr, this, newVal);
  }

  public void get_HttpProxyDomain(CkString str) {
    chilkatJNI.CkSocket_get_HttpProxyDomain(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String httpProxyDomain() {
    return chilkatJNI.CkSocket_httpProxyDomain(swigCPtr, this);
  }

  public void put_HttpProxyDomain(String newVal) {
    chilkatJNI.CkSocket_put_HttpProxyDomain(swigCPtr, this, newVal);
  }

  public boolean get_HttpProxyForHttp() {
    return chilkatJNI.CkSocket_get_HttpProxyForHttp(swigCPtr, this);
  }

  public void put_HttpProxyForHttp(boolean newVal) {
    chilkatJNI.CkSocket_put_HttpProxyForHttp(swigCPtr, this, newVal);
  }

  public void get_HttpProxyHostname(CkString str) {
    chilkatJNI.CkSocket_get_HttpProxyHostname(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String httpProxyHostname() {
    return chilkatJNI.CkSocket_httpProxyHostname(swigCPtr, this);
  }

  public void put_HttpProxyHostname(String newVal) {
    chilkatJNI.CkSocket_put_HttpProxyHostname(swigCPtr, this, newVal);
  }

  public void get_HttpProxyPassword(CkString str) {
    chilkatJNI.CkSocket_get_HttpProxyPassword(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String httpProxyPassword() {
    return chilkatJNI.CkSocket_httpProxyPassword(swigCPtr, this);
  }

  public void put_HttpProxyPassword(String newVal) {
    chilkatJNI.CkSocket_put_HttpProxyPassword(swigCPtr, this, newVal);
  }

  public int get_HttpProxyPort() {
    return chilkatJNI.CkSocket_get_HttpProxyPort(swigCPtr, this);
  }

  public void put_HttpProxyPort(int newVal) {
    chilkatJNI.CkSocket_put_HttpProxyPort(swigCPtr, this, newVal);
  }

  public void get_HttpProxyUsername(CkString str) {
    chilkatJNI.CkSocket_get_HttpProxyUsername(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String httpProxyUsername() {
    return chilkatJNI.CkSocket_httpProxyUsername(swigCPtr, this);
  }

  public void put_HttpProxyUsername(String newVal) {
    chilkatJNI.CkSocket_put_HttpProxyUsername(swigCPtr, this, newVal);
  }

  public boolean get_IsConnected() {
    return chilkatJNI.CkSocket_get_IsConnected(swigCPtr, this);
  }

  public boolean get_KeepAlive() {
    return chilkatJNI.CkSocket_get_KeepAlive(swigCPtr, this);
  }

  public void put_KeepAlive(boolean newVal) {
    chilkatJNI.CkSocket_put_KeepAlive(swigCPtr, this, newVal);
  }

  public boolean get_KeepSessionLog() {
    return chilkatJNI.CkSocket_get_KeepSessionLog(swigCPtr, this);
  }

  public void put_KeepSessionLog(boolean newVal) {
    chilkatJNI.CkSocket_put_KeepSessionLog(swigCPtr, this, newVal);
  }

  public void get_LastErrorHtml(CkString str) {
    chilkatJNI.CkSocket_get_LastErrorHtml(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String lastErrorHtml() {
    return chilkatJNI.CkSocket_lastErrorHtml(swigCPtr, this);
  }

  public void get_LastErrorText(CkString str) {
    chilkatJNI.CkSocket_get_LastErrorText(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String lastErrorText() {
    return chilkatJNI.CkSocket_lastErrorText(swigCPtr, this);
  }

  public void get_LastErrorXml(CkString str) {
    chilkatJNI.CkSocket_get_LastErrorXml(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String lastErrorXml() {
    return chilkatJNI.CkSocket_lastErrorXml(swigCPtr, this);
  }

  public boolean get_LastMethodFailed() {
    return chilkatJNI.CkSocket_get_LastMethodFailed(swigCPtr, this);
  }

  public boolean get_LastMethodSuccess() {
    return chilkatJNI.CkSocket_get_LastMethodSuccess(swigCPtr, this);
  }

  public void put_LastMethodSuccess(boolean newVal) {
    chilkatJNI.CkSocket_put_LastMethodSuccess(swigCPtr, this, newVal);
  }

  public boolean get_ListenIpv6() {
    return chilkatJNI.CkSocket_get_ListenIpv6(swigCPtr, this);
  }

  public void put_ListenIpv6(boolean newVal) {
    chilkatJNI.CkSocket_put_ListenIpv6(swigCPtr, this, newVal);
  }

  public int get_ListenPort() {
    return chilkatJNI.CkSocket_get_ListenPort(swigCPtr, this);
  }

  public void get_LocalIpAddress(CkString str) {
    chilkatJNI.CkSocket_get_LocalIpAddress(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String localIpAddress() {
    return chilkatJNI.CkSocket_localIpAddress(swigCPtr, this);
  }

  public int get_LocalPort() {
    return chilkatJNI.CkSocket_get_LocalPort(swigCPtr, this);
  }

  public int get_MaxReadIdleMs() {
    return chilkatJNI.CkSocket_get_MaxReadIdleMs(swigCPtr, this);
  }

  public void put_MaxReadIdleMs(int newVal) {
    chilkatJNI.CkSocket_put_MaxReadIdleMs(swigCPtr, this, newVal);
  }

  public int get_MaxSendIdleMs() {
    return chilkatJNI.CkSocket_get_MaxSendIdleMs(swigCPtr, this);
  }

  public void put_MaxSendIdleMs(int newVal) {
    chilkatJNI.CkSocket_put_MaxSendIdleMs(swigCPtr, this, newVal);
  }

  public void get_MyIpAddress(CkString str) {
    chilkatJNI.CkSocket_get_MyIpAddress(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String myIpAddress() {
    return chilkatJNI.CkSocket_myIpAddress(swigCPtr, this);
  }

  public int get_NumBytesAvailable() {
    return chilkatJNI.CkSocket_get_NumBytesAvailable(swigCPtr, this);
  }

  public int get_NumReceivedClientCerts() {
    return chilkatJNI.CkSocket_get_NumReceivedClientCerts(swigCPtr, this);
  }

  public int get_NumSocketsInSet() {
    return chilkatJNI.CkSocket_get_NumSocketsInSet(swigCPtr, this);
  }

  public int get_NumSslAcceptableClientCAs() {
    return chilkatJNI.CkSocket_get_NumSslAcceptableClientCAs(swigCPtr, this);
  }

  public int get_ObjectId() {
    return chilkatJNI.CkSocket_get_ObjectId(swigCPtr, this);
  }

  public int get_PercentDoneScale() {
    return chilkatJNI.CkSocket_get_PercentDoneScale(swigCPtr, this);
  }

  public void put_PercentDoneScale(int newVal) {
    chilkatJNI.CkSocket_put_PercentDoneScale(swigCPtr, this, newVal);
  }

  public boolean get_PreferIpv6() {
    return chilkatJNI.CkSocket_get_PreferIpv6(swigCPtr, this);
  }

  public void put_PreferIpv6(boolean newVal) {
    chilkatJNI.CkSocket_put_PreferIpv6(swigCPtr, this, newVal);
  }

  public int get_RcvBytesPerSec() {
    return chilkatJNI.CkSocket_get_RcvBytesPerSec(swigCPtr, this);
  }

  public int get_ReceivedCount() {
    return chilkatJNI.CkSocket_get_ReceivedCount(swigCPtr, this);
  }

  public void put_ReceivedCount(int newVal) {
    chilkatJNI.CkSocket_put_ReceivedCount(swigCPtr, this, newVal);
  }

  public int get_ReceivedInt() {
    return chilkatJNI.CkSocket_get_ReceivedInt(swigCPtr, this);
  }

  public void put_ReceivedInt(int newVal) {
    chilkatJNI.CkSocket_put_ReceivedInt(swigCPtr, this, newVal);
  }

  public int get_ReceiveFailReason() {
    return chilkatJNI.CkSocket_get_ReceiveFailReason(swigCPtr, this);
  }

  public int get_ReceivePacketSize() {
    return chilkatJNI.CkSocket_get_ReceivePacketSize(swigCPtr, this);
  }

  public void put_ReceivePacketSize(int newVal) {
    chilkatJNI.CkSocket_put_ReceivePacketSize(swigCPtr, this, newVal);
  }

  public void get_RemoteIpAddress(CkString str) {
    chilkatJNI.CkSocket_get_RemoteIpAddress(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String remoteIpAddress() {
    return chilkatJNI.CkSocket_remoteIpAddress(swigCPtr, this);
  }

  public int get_RemotePort() {
    return chilkatJNI.CkSocket_get_RemotePort(swigCPtr, this);
  }

  public boolean get_RequireSslCertVerify() {
    return chilkatJNI.CkSocket_get_RequireSslCertVerify(swigCPtr, this);
  }

  public void put_RequireSslCertVerify(boolean newVal) {
    chilkatJNI.CkSocket_put_RequireSslCertVerify(swigCPtr, this, newVal);
  }

  public int get_SelectorIndex() {
    return chilkatJNI.CkSocket_get_SelectorIndex(swigCPtr, this);
  }

  public void put_SelectorIndex(int newVal) {
    chilkatJNI.CkSocket_put_SelectorIndex(swigCPtr, this, newVal);
  }

  public int get_SelectorReadIndex() {
    return chilkatJNI.CkSocket_get_SelectorReadIndex(swigCPtr, this);
  }

  public void put_SelectorReadIndex(int newVal) {
    chilkatJNI.CkSocket_put_SelectorReadIndex(swigCPtr, this, newVal);
  }

  public int get_SelectorWriteIndex() {
    return chilkatJNI.CkSocket_get_SelectorWriteIndex(swigCPtr, this);
  }

  public void put_SelectorWriteIndex(int newVal) {
    chilkatJNI.CkSocket_put_SelectorWriteIndex(swigCPtr, this, newVal);
  }

  public int get_SendBytesPerSec() {
    return chilkatJNI.CkSocket_get_SendBytesPerSec(swigCPtr, this);
  }

  public int get_SendFailReason() {
    return chilkatJNI.CkSocket_get_SendFailReason(swigCPtr, this);
  }

  public int get_SendPacketSize() {
    return chilkatJNI.CkSocket_get_SendPacketSize(swigCPtr, this);
  }

  public void put_SendPacketSize(int newVal) {
    chilkatJNI.CkSocket_put_SendPacketSize(swigCPtr, this, newVal);
  }

  public void get_SessionLog(CkString str) {
    chilkatJNI.CkSocket_get_SessionLog(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String sessionLog() {
    return chilkatJNI.CkSocket_sessionLog(swigCPtr, this);
  }

  public void get_SessionLogEncoding(CkString str) {
    chilkatJNI.CkSocket_get_SessionLogEncoding(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String sessionLogEncoding() {
    return chilkatJNI.CkSocket_sessionLogEncoding(swigCPtr, this);
  }

  public void put_SessionLogEncoding(String newVal) {
    chilkatJNI.CkSocket_put_SessionLogEncoding(swigCPtr, this, newVal);
  }

  public void get_SniHostname(CkString str) {
    chilkatJNI.CkSocket_get_SniHostname(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String sniHostname() {
    return chilkatJNI.CkSocket_sniHostname(swigCPtr, this);
  }

  public void put_SniHostname(String newVal) {
    chilkatJNI.CkSocket_put_SniHostname(swigCPtr, this, newVal);
  }

  public void get_SocksHostname(CkString str) {
    chilkatJNI.CkSocket_get_SocksHostname(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String socksHostname() {
    return chilkatJNI.CkSocket_socksHostname(swigCPtr, this);
  }

  public void put_SocksHostname(String newVal) {
    chilkatJNI.CkSocket_put_SocksHostname(swigCPtr, this, newVal);
  }

  public void get_SocksPassword(CkString str) {
    chilkatJNI.CkSocket_get_SocksPassword(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String socksPassword() {
    return chilkatJNI.CkSocket_socksPassword(swigCPtr, this);
  }

  public void put_SocksPassword(String newVal) {
    chilkatJNI.CkSocket_put_SocksPassword(swigCPtr, this, newVal);
  }

  public int get_SocksPort() {
    return chilkatJNI.CkSocket_get_SocksPort(swigCPtr, this);
  }

  public void put_SocksPort(int newVal) {
    chilkatJNI.CkSocket_put_SocksPort(swigCPtr, this, newVal);
  }

  public void get_SocksUsername(CkString str) {
    chilkatJNI.CkSocket_get_SocksUsername(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String socksUsername() {
    return chilkatJNI.CkSocket_socksUsername(swigCPtr, this);
  }

  public void put_SocksUsername(String newVal) {
    chilkatJNI.CkSocket_put_SocksUsername(swigCPtr, this, newVal);
  }

  public int get_SocksVersion() {
    return chilkatJNI.CkSocket_get_SocksVersion(swigCPtr, this);
  }

  public void put_SocksVersion(int newVal) {
    chilkatJNI.CkSocket_put_SocksVersion(swigCPtr, this, newVal);
  }

  public int get_SoRcvBuf() {
    return chilkatJNI.CkSocket_get_SoRcvBuf(swigCPtr, this);
  }

  public void put_SoRcvBuf(int newVal) {
    chilkatJNI.CkSocket_put_SoRcvBuf(swigCPtr, this, newVal);
  }

  public boolean get_SoReuseAddr() {
    return chilkatJNI.CkSocket_get_SoReuseAddr(swigCPtr, this);
  }

  public void put_SoReuseAddr(boolean newVal) {
    chilkatJNI.CkSocket_put_SoReuseAddr(swigCPtr, this, newVal);
  }

  public int get_SoSndBuf() {
    return chilkatJNI.CkSocket_get_SoSndBuf(swigCPtr, this);
  }

  public void put_SoSndBuf(int newVal) {
    chilkatJNI.CkSocket_put_SoSndBuf(swigCPtr, this, newVal);
  }

  public boolean get_Ssl() {
    return chilkatJNI.CkSocket_get_Ssl(swigCPtr, this);
  }

  public void put_Ssl(boolean newVal) {
    chilkatJNI.CkSocket_put_Ssl(swigCPtr, this, newVal);
  }

  public void get_SslAllowedCiphers(CkString str) {
    chilkatJNI.CkSocket_get_SslAllowedCiphers(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String sslAllowedCiphers() {
    return chilkatJNI.CkSocket_sslAllowedCiphers(swigCPtr, this);
  }

  public void put_SslAllowedCiphers(String newVal) {
    chilkatJNI.CkSocket_put_SslAllowedCiphers(swigCPtr, this, newVal);
  }

  public void get_SslProtocol(CkString str) {
    chilkatJNI.CkSocket_get_SslProtocol(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String sslProtocol() {
    return chilkatJNI.CkSocket_sslProtocol(swigCPtr, this);
  }

  public void put_SslProtocol(String newVal) {
    chilkatJNI.CkSocket_put_SslProtocol(swigCPtr, this, newVal);
  }

  public void get_StringCharset(CkString str) {
    chilkatJNI.CkSocket_get_StringCharset(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String stringCharset() {
    return chilkatJNI.CkSocket_stringCharset(swigCPtr, this);
  }

  public void put_StringCharset(String newVal) {
    chilkatJNI.CkSocket_put_StringCharset(swigCPtr, this, newVal);
  }

  public boolean get_TcpNoDelay() {
    return chilkatJNI.CkSocket_get_TcpNoDelay(swigCPtr, this);
  }

  public void put_TcpNoDelay(boolean newVal) {
    chilkatJNI.CkSocket_put_TcpNoDelay(swigCPtr, this, newVal);
  }

  public void get_TlsCipherSuite(CkString str) {
    chilkatJNI.CkSocket_get_TlsCipherSuite(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String tlsCipherSuite() {
    return chilkatJNI.CkSocket_tlsCipherSuite(swigCPtr, this);
  }

  public void get_TlsPinSet(CkString str) {
    chilkatJNI.CkSocket_get_TlsPinSet(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String tlsPinSet() {
    return chilkatJNI.CkSocket_tlsPinSet(swigCPtr, this);
  }

  public void put_TlsPinSet(String newVal) {
    chilkatJNI.CkSocket_put_TlsPinSet(swigCPtr, this, newVal);
  }

  public void get_TlsVersion(CkString str) {
    chilkatJNI.CkSocket_get_TlsVersion(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String tlsVersion() {
    return chilkatJNI.CkSocket_tlsVersion(swigCPtr, this);
  }

  public void get_UncommonOptions(CkString str) {
    chilkatJNI.CkSocket_get_UncommonOptions(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String uncommonOptions() {
    return chilkatJNI.CkSocket_uncommonOptions(swigCPtr, this);
  }

  public void put_UncommonOptions(String newVal) {
    chilkatJNI.CkSocket_put_UncommonOptions(swigCPtr, this, newVal);
  }

  public void get_UserData(CkString str) {
    chilkatJNI.CkSocket_get_UserData(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String userData() {
    return chilkatJNI.CkSocket_userData(swigCPtr, this);
  }

  public void put_UserData(String newVal) {
    chilkatJNI.CkSocket_put_UserData(swigCPtr, this, newVal);
  }

  public boolean get_VerboseLogging() {
    return chilkatJNI.CkSocket_get_VerboseLogging(swigCPtr, this);
  }

  public void put_VerboseLogging(boolean newVal) {
    chilkatJNI.CkSocket_put_VerboseLogging(swigCPtr, this, newVal);
  }

  public void get_Version(CkString str) {
    chilkatJNI.CkSocket_get_Version(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String version() {
    return chilkatJNI.CkSocket_version(swigCPtr, this);
  }

  public boolean AcceptNext(int maxWaitMs, CkSocket socket) {
    return chilkatJNI.CkSocket_AcceptNext(swigCPtr, this, maxWaitMs, CkSocket.getCPtr(socket), socket);
  }

  public CkTask AcceptNextAsync(int maxWaitMs, CkSocket socket) {
    long cPtr = chilkatJNI.CkSocket_AcceptNextAsync(swigCPtr, this, maxWaitMs, CkSocket.getCPtr(socket), socket);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public CkSocket AcceptNextConnection(int maxWaitMs) {
    long cPtr = chilkatJNI.CkSocket_AcceptNextConnection(swigCPtr, this, maxWaitMs);
    return (cPtr == 0) ? null : new CkSocket(cPtr, true);
  }

  public CkTask AcceptNextConnectionAsync(int maxWaitMs) {
    long cPtr = chilkatJNI.CkSocket_AcceptNextConnectionAsync(swigCPtr, this, maxWaitMs);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean AddSslAcceptableClientCaDn(String certAuthDN) {
    return chilkatJNI.CkSocket_AddSslAcceptableClientCaDn(swigCPtr, this, certAuthDN);
  }

  public boolean BindAndListen(int port, int backLog) {
    return chilkatJNI.CkSocket_BindAndListen(swigCPtr, this, port, backLog);
  }

  public CkTask BindAndListenAsync(int port, int backLog) {
    long cPtr = chilkatJNI.CkSocket_BindAndListenAsync(swigCPtr, this, port, backLog);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public int BindAndListenPortRange(int beginPort, int endPort, int backLog) {
    return chilkatJNI.CkSocket_BindAndListenPortRange(swigCPtr, this, beginPort, endPort, backLog);
  }

  public CkTask BindAndListenPortRangeAsync(int beginPort, int endPort, int backLog) {
    long cPtr = chilkatJNI.CkSocket_BindAndListenPortRangeAsync(swigCPtr, this, beginPort, endPort, backLog);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean BuildHttpGetRequest(String url, CkString outStr) {
    return chilkatJNI.CkSocket_BuildHttpGetRequest(swigCPtr, this, url, CkString.getCPtr(outStr), outStr);
  }

  public String buildHttpGetRequest(String url) {
    return chilkatJNI.CkSocket_buildHttpGetRequest(swigCPtr, this, url);
  }

  public int CheckWriteable(int maxWaitMs) {
    return chilkatJNI.CkSocket_CheckWriteable(swigCPtr, this, maxWaitMs);
  }

  public CkTask CheckWriteableAsync(int maxWaitMs) {
    long cPtr = chilkatJNI.CkSocket_CheckWriteableAsync(swigCPtr, this, maxWaitMs);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public void ClearSessionLog() {
    chilkatJNI.CkSocket_ClearSessionLog(swigCPtr, this);
  }

  public CkSocket CloneSocket() {
    long cPtr = chilkatJNI.CkSocket_CloneSocket(swigCPtr, this);
    return (cPtr == 0) ? null : new CkSocket(cPtr, true);
  }

  public boolean Close(int maxWaitMs) {
    return chilkatJNI.CkSocket_Close(swigCPtr, this, maxWaitMs);
  }

  public CkTask CloseAsync(int maxWaitMs) {
    long cPtr = chilkatJNI.CkSocket_CloseAsync(swigCPtr, this, maxWaitMs);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean Connect(String hostname, int port, boolean ssl, int maxWaitMs) {
    return chilkatJNI.CkSocket_Connect(swigCPtr, this, hostname, port, ssl, maxWaitMs);
  }

  public CkTask ConnectAsync(String hostname, int port, boolean ssl, int maxWaitMs) {
    long cPtr = chilkatJNI.CkSocket_ConnectAsync(swigCPtr, this, hostname, port, ssl, maxWaitMs);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean ConvertFromSsl() {
    return chilkatJNI.CkSocket_ConvertFromSsl(swigCPtr, this);
  }

  public CkTask ConvertFromSslAsync() {
    long cPtr = chilkatJNI.CkSocket_ConvertFromSslAsync(swigCPtr, this);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean ConvertToSsl() {
    return chilkatJNI.CkSocket_ConvertToSsl(swigCPtr, this);
  }

  public CkTask ConvertToSslAsync() {
    long cPtr = chilkatJNI.CkSocket_ConvertToSslAsync(swigCPtr, this);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public void DnsCacheClear() {
    chilkatJNI.CkSocket_DnsCacheClear(swigCPtr, this);
  }

  public boolean DnsLookup(String hostname, int maxWaitMs, CkString outStr) {
    return chilkatJNI.CkSocket_DnsLookup(swigCPtr, this, hostname, maxWaitMs, CkString.getCPtr(outStr), outStr);
  }

  public String dnsLookup(String hostname, int maxWaitMs) {
    return chilkatJNI.CkSocket_dnsLookup(swigCPtr, this, hostname, maxWaitMs);
  }

  public CkTask DnsLookupAsync(String hostname, int maxWaitMs) {
    long cPtr = chilkatJNI.CkSocket_DnsLookupAsync(swigCPtr, this, hostname, maxWaitMs);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean DupSocket(CkSocket dest) {
    return chilkatJNI.CkSocket_DupSocket(swigCPtr, this, CkSocket.getCPtr(dest), dest);
  }

  public boolean GetAdaptersAddresses(CkJsonObject json) {
    return chilkatJNI.CkSocket_GetAdaptersAddresses(swigCPtr, this, CkJsonObject.getCPtr(json), json);
  }

  public void GetLastJsonData(CkJsonObject json) {
    chilkatJNI.CkSocket_GetLastJsonData(swigCPtr, this, CkJsonObject.getCPtr(json), json);
  }

  public CkCert GetMyCert() {
    long cPtr = chilkatJNI.CkSocket_GetMyCert(swigCPtr, this);
    return (cPtr == 0) ? null : new CkCert(cPtr, true);
  }

  public boolean GetMyServerCert(CkCert cert) {
    return chilkatJNI.CkSocket_GetMyServerCert(swigCPtr, this, CkCert.getCPtr(cert), cert);
  }

  public boolean GetRcvdClientCert(int index, CkCert cert) {
    return chilkatJNI.CkSocket_GetRcvdClientCert(swigCPtr, this, index, CkCert.getCPtr(cert), cert);
  }

  public CkCert GetReceivedClientCert(int index) {
    long cPtr = chilkatJNI.CkSocket_GetReceivedClientCert(swigCPtr, this, index);
    return (cPtr == 0) ? null : new CkCert(cPtr, true);
  }

  public boolean GetServerCert(CkCert cert) {
    return chilkatJNI.CkSocket_GetServerCert(swigCPtr, this, CkCert.getCPtr(cert), cert);
  }

  public boolean GetSslAcceptableClientCaDn(int index, CkString outStr) {
    return chilkatJNI.CkSocket_GetSslAcceptableClientCaDn(swigCPtr, this, index, CkString.getCPtr(outStr), outStr);
  }

  public String getSslAcceptableClientCaDn(int index) {
    return chilkatJNI.CkSocket_getSslAcceptableClientCaDn(swigCPtr, this, index);
  }

  public String sslAcceptableClientCaDn(int index) {
    return chilkatJNI.CkSocket_sslAcceptableClientCaDn(swigCPtr, this, index);
  }

  public CkCert GetSslServerCert() {
    long cPtr = chilkatJNI.CkSocket_GetSslServerCert(swigCPtr, this);
    return (cPtr == 0) ? null : new CkCert(cPtr, true);
  }

  public boolean InitSslServer(CkCert cert) {
    return chilkatJNI.CkSocket_InitSslServer(swigCPtr, this, CkCert.getCPtr(cert), cert);
  }

  public CkJsonObject LastJsonData() {
    long cPtr = chilkatJNI.CkSocket_LastJsonData(swigCPtr, this);
    return (cPtr == 0) ? null : new CkJsonObject(cPtr, true);
  }

  public boolean LoadTaskCaller(CkTask task) {
    return chilkatJNI.CkSocket_LoadTaskCaller(swigCPtr, this, CkTask.getCPtr(task), task);
  }

  public boolean LoadTaskResult(CkTask task) {
    return chilkatJNI.CkSocket_LoadTaskResult(swigCPtr, this, CkTask.getCPtr(task), task);
  }

  public boolean PollDataAvailable() {
    return chilkatJNI.CkSocket_PollDataAvailable(swigCPtr, this);
  }

  public CkTask PollDataAvailableAsync() {
    long cPtr = chilkatJNI.CkSocket_PollDataAvailableAsync(swigCPtr, this);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean ReceiveBd(CkBinData binData) {
    return chilkatJNI.CkSocket_ReceiveBd(swigCPtr, this, CkBinData.getCPtr(binData), binData);
  }

  public CkTask ReceiveBdAsync(CkBinData binData) {
    long cPtr = chilkatJNI.CkSocket_ReceiveBdAsync(swigCPtr, this, CkBinData.getCPtr(binData), binData);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean ReceiveBdN(long numBytes, CkBinData binData) {
    return chilkatJNI.CkSocket_ReceiveBdN(swigCPtr, this, numBytes, CkBinData.getCPtr(binData), binData);
  }

  public CkTask ReceiveBdNAsync(long numBytes, CkBinData binData) {
    long cPtr = chilkatJNI.CkSocket_ReceiveBdNAsync(swigCPtr, this, numBytes, CkBinData.getCPtr(binData), binData);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean ReceiveByte(boolean bUnsigned) {
    return chilkatJNI.CkSocket_ReceiveByte(swigCPtr, this, bUnsigned);
  }

  public CkTask ReceiveByteAsync(boolean bUnsigned) {
    long cPtr = chilkatJNI.CkSocket_ReceiveByteAsync(swigCPtr, this, bUnsigned);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean ReceiveBytes(CkByteData outData) {
    return chilkatJNI.CkSocket_ReceiveBytes(swigCPtr, this, CkByteData.getCPtr(outData), outData);
  }

  public CkTask ReceiveBytesAsync() {
    long cPtr = chilkatJNI.CkSocket_ReceiveBytesAsync(swigCPtr, this);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean ReceiveBytesENC(String encodingAlg, CkString outStr) {
    return chilkatJNI.CkSocket_ReceiveBytesENC(swigCPtr, this, encodingAlg, CkString.getCPtr(outStr), outStr);
  }

  public String receiveBytesENC(String encodingAlg) {
    return chilkatJNI.CkSocket_receiveBytesENC(swigCPtr, this, encodingAlg);
  }

  public CkTask ReceiveBytesENCAsync(String encodingAlg) {
    long cPtr = chilkatJNI.CkSocket_ReceiveBytesENCAsync(swigCPtr, this, encodingAlg);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean ReceiveBytesN(long numBytes, CkByteData outData) {
    return chilkatJNI.CkSocket_ReceiveBytesN(swigCPtr, this, numBytes, CkByteData.getCPtr(outData), outData);
  }

  public CkTask ReceiveBytesNAsync(long numBytes) {
    long cPtr = chilkatJNI.CkSocket_ReceiveBytesNAsync(swigCPtr, this, numBytes);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean ReceiveBytesToFile(String appendFilename) {
    return chilkatJNI.CkSocket_ReceiveBytesToFile(swigCPtr, this, appendFilename);
  }

  public CkTask ReceiveBytesToFileAsync(String appendFilename) {
    long cPtr = chilkatJNI.CkSocket_ReceiveBytesToFileAsync(swigCPtr, this, appendFilename);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public int ReceiveCount() {
    return chilkatJNI.CkSocket_ReceiveCount(swigCPtr, this);
  }

  public CkTask ReceiveCountAsync() {
    long cPtr = chilkatJNI.CkSocket_ReceiveCountAsync(swigCPtr, this);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean ReceiveInt16(boolean bigEndian, boolean bUnsigned) {
    return chilkatJNI.CkSocket_ReceiveInt16(swigCPtr, this, bigEndian, bUnsigned);
  }

  public CkTask ReceiveInt16Async(boolean bigEndian, boolean bUnsigned) {
    long cPtr = chilkatJNI.CkSocket_ReceiveInt16Async(swigCPtr, this, bigEndian, bUnsigned);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean ReceiveInt32(boolean bigEndian) {
    return chilkatJNI.CkSocket_ReceiveInt32(swigCPtr, this, bigEndian);
  }

  public CkTask ReceiveInt32Async(boolean bigEndian) {
    long cPtr = chilkatJNI.CkSocket_ReceiveInt32Async(swigCPtr, this, bigEndian);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean ReceiveNBytesENC(long numBytes, String encodingAlg, CkString outStr) {
    return chilkatJNI.CkSocket_ReceiveNBytesENC(swigCPtr, this, numBytes, encodingAlg, CkString.getCPtr(outStr), outStr);
  }

  public String receiveNBytesENC(long numBytes, String encodingAlg) {
    return chilkatJNI.CkSocket_receiveNBytesENC(swigCPtr, this, numBytes, encodingAlg);
  }

  public CkTask ReceiveNBytesENCAsync(long numBytes, String encodingAlg) {
    long cPtr = chilkatJNI.CkSocket_ReceiveNBytesENCAsync(swigCPtr, this, numBytes, encodingAlg);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean ReceiveSb(CkStringBuilder sb) {
    return chilkatJNI.CkSocket_ReceiveSb(swigCPtr, this, CkStringBuilder.getCPtr(sb), sb);
  }

  public CkTask ReceiveSbAsync(CkStringBuilder sb) {
    long cPtr = chilkatJNI.CkSocket_ReceiveSbAsync(swigCPtr, this, CkStringBuilder.getCPtr(sb), sb);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean ReceiveString(CkString outStr) {
    return chilkatJNI.CkSocket_ReceiveString(swigCPtr, this, CkString.getCPtr(outStr), outStr);
  }

  public String receiveString() {
    return chilkatJNI.CkSocket_receiveString(swigCPtr, this);
  }

  public CkTask ReceiveStringAsync() {
    long cPtr = chilkatJNI.CkSocket_ReceiveStringAsync(swigCPtr, this);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean ReceiveStringMaxN(int maxByteCount, CkString outStr) {
    return chilkatJNI.CkSocket_ReceiveStringMaxN(swigCPtr, this, maxByteCount, CkString.getCPtr(outStr), outStr);
  }

  public String receiveStringMaxN(int maxByteCount) {
    return chilkatJNI.CkSocket_receiveStringMaxN(swigCPtr, this, maxByteCount);
  }

  public CkTask ReceiveStringMaxNAsync(int maxByteCount) {
    long cPtr = chilkatJNI.CkSocket_ReceiveStringMaxNAsync(swigCPtr, this, maxByteCount);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean ReceiveStringUntilByte(int lookForByte, CkString outStr) {
    return chilkatJNI.CkSocket_ReceiveStringUntilByte(swigCPtr, this, lookForByte, CkString.getCPtr(outStr), outStr);
  }

  public String receiveStringUntilByte(int lookForByte) {
    return chilkatJNI.CkSocket_receiveStringUntilByte(swigCPtr, this, lookForByte);
  }

  public CkTask ReceiveStringUntilByteAsync(int lookForByte) {
    long cPtr = chilkatJNI.CkSocket_ReceiveStringUntilByteAsync(swigCPtr, this, lookForByte);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean ReceiveToCRLF(CkString outStr) {
    return chilkatJNI.CkSocket_ReceiveToCRLF(swigCPtr, this, CkString.getCPtr(outStr), outStr);
  }

  public String receiveToCRLF() {
    return chilkatJNI.CkSocket_receiveToCRLF(swigCPtr, this);
  }

  public CkTask ReceiveToCRLFAsync() {
    long cPtr = chilkatJNI.CkSocket_ReceiveToCRLFAsync(swigCPtr, this);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean ReceiveUntilByte(int lookForByte, CkByteData outBytes) {
    return chilkatJNI.CkSocket_ReceiveUntilByte(swigCPtr, this, lookForByte, CkByteData.getCPtr(outBytes), outBytes);
  }

  public CkTask ReceiveUntilByteAsync(int lookForByte) {
    long cPtr = chilkatJNI.CkSocket_ReceiveUntilByteAsync(swigCPtr, this, lookForByte);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean ReceiveUntilByteBd(int lookForByte, CkBinData bd) {
    return chilkatJNI.CkSocket_ReceiveUntilByteBd(swigCPtr, this, lookForByte, CkBinData.getCPtr(bd), bd);
  }

  public CkTask ReceiveUntilByteBdAsync(int lookForByte, CkBinData bd) {
    long cPtr = chilkatJNI.CkSocket_ReceiveUntilByteBdAsync(swigCPtr, this, lookForByte, CkBinData.getCPtr(bd), bd);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean ReceiveUntilMatch(String matchStr, CkString outStr) {
    return chilkatJNI.CkSocket_ReceiveUntilMatch(swigCPtr, this, matchStr, CkString.getCPtr(outStr), outStr);
  }

  public String receiveUntilMatch(String matchStr) {
    return chilkatJNI.CkSocket_receiveUntilMatch(swigCPtr, this, matchStr);
  }

  public CkTask ReceiveUntilMatchAsync(String matchStr) {
    long cPtr = chilkatJNI.CkSocket_ReceiveUntilMatchAsync(swigCPtr, this, matchStr);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean ReceiveUntilMatchSb(String matchStr, CkStringBuilder sb) {
    return chilkatJNI.CkSocket_ReceiveUntilMatchSb(swigCPtr, this, matchStr, CkStringBuilder.getCPtr(sb), sb);
  }

  public CkTask ReceiveUntilMatchSbAsync(String matchStr, CkStringBuilder sb) {
    long cPtr = chilkatJNI.CkSocket_ReceiveUntilMatchSbAsync(swigCPtr, this, matchStr, CkStringBuilder.getCPtr(sb), sb);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public void ResetPerf(boolean rcvPerf) {
    chilkatJNI.CkSocket_ResetPerf(swigCPtr, this, rcvPerf);
  }

  public int SelectForReading(int timeoutMs) {
    return chilkatJNI.CkSocket_SelectForReading(swigCPtr, this, timeoutMs);
  }

  public CkTask SelectForReadingAsync(int timeoutMs) {
    long cPtr = chilkatJNI.CkSocket_SelectForReadingAsync(swigCPtr, this, timeoutMs);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public int SelectForWriting(int timeoutMs) {
    return chilkatJNI.CkSocket_SelectForWriting(swigCPtr, this, timeoutMs);
  }

  public CkTask SelectForWritingAsync(int timeoutMs) {
    long cPtr = chilkatJNI.CkSocket_SelectForWritingAsync(swigCPtr, this, timeoutMs);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean SendBd(CkBinData binData, long offset, long numBytes) {
    return chilkatJNI.CkSocket_SendBd(swigCPtr, this, CkBinData.getCPtr(binData), binData, offset, numBytes);
  }

  public CkTask SendBdAsync(CkBinData binData, long offset, long numBytes) {
    long cPtr = chilkatJNI.CkSocket_SendBdAsync(swigCPtr, this, CkBinData.getCPtr(binData), binData, offset, numBytes);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean SendByte(int value) {
    return chilkatJNI.CkSocket_SendByte(swigCPtr, this, value);
  }

  public CkTask SendByteAsync(int value) {
    long cPtr = chilkatJNI.CkSocket_SendByteAsync(swigCPtr, this, value);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean SendBytes(CkByteData data) {
    return chilkatJNI.CkSocket_SendBytes(swigCPtr, this, CkByteData.getCPtr(data), data);
  }

  public CkTask SendBytesAsync(CkByteData data) {
    long cPtr = chilkatJNI.CkSocket_SendBytesAsync(swigCPtr, this, CkByteData.getCPtr(data), data);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean SendBytesENC(String encodedBytes, String encodingAlg) {
    return chilkatJNI.CkSocket_SendBytesENC(swigCPtr, this, encodedBytes, encodingAlg);
  }

  public CkTask SendBytesENCAsync(String encodedBytes, String encodingAlg) {
    long cPtr = chilkatJNI.CkSocket_SendBytesENCAsync(swigCPtr, this, encodedBytes, encodingAlg);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean SendCount(int byteCount) {
    return chilkatJNI.CkSocket_SendCount(swigCPtr, this, byteCount);
  }

  public CkTask SendCountAsync(int byteCount) {
    long cPtr = chilkatJNI.CkSocket_SendCountAsync(swigCPtr, this, byteCount);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean SendInt16(int value, boolean bigEndian) {
    return chilkatJNI.CkSocket_SendInt16(swigCPtr, this, value, bigEndian);
  }

  public CkTask SendInt16Async(int value, boolean bigEndian) {
    long cPtr = chilkatJNI.CkSocket_SendInt16Async(swigCPtr, this, value, bigEndian);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean SendInt32(int value, boolean bigEndian) {
    return chilkatJNI.CkSocket_SendInt32(swigCPtr, this, value, bigEndian);
  }

  public CkTask SendInt32Async(int value, boolean bigEndian) {
    long cPtr = chilkatJNI.CkSocket_SendInt32Async(swigCPtr, this, value, bigEndian);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean SendSb(CkStringBuilder sb) {
    return chilkatJNI.CkSocket_SendSb(swigCPtr, this, CkStringBuilder.getCPtr(sb), sb);
  }

  public CkTask SendSbAsync(CkStringBuilder sb) {
    long cPtr = chilkatJNI.CkSocket_SendSbAsync(swigCPtr, this, CkStringBuilder.getCPtr(sb), sb);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean SendString(String stringToSend) {
    return chilkatJNI.CkSocket_SendString(swigCPtr, this, stringToSend);
  }

  public CkTask SendStringAsync(String stringToSend) {
    long cPtr = chilkatJNI.CkSocket_SendStringAsync(swigCPtr, this, stringToSend);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean SendWakeOnLan(String macAddress, int port, String ipBroadcastAddr) {
    return chilkatJNI.CkSocket_SendWakeOnLan(swigCPtr, this, macAddress, port, ipBroadcastAddr);
  }

  public boolean SendWakeOnLan2(String macAddress, int port, String ipBroadcastAddr, String password) {
    return chilkatJNI.CkSocket_SendWakeOnLan2(swigCPtr, this, macAddress, port, ipBroadcastAddr, password);
  }

  public boolean SetSslClientCert(CkCert cert) {
    return chilkatJNI.CkSocket_SetSslClientCert(swigCPtr, this, CkCert.getCPtr(cert), cert);
  }

  public boolean SetSslClientCertPem(String pemDataOrFilename, String pemPassword) {
    return chilkatJNI.CkSocket_SetSslClientCertPem(swigCPtr, this, pemDataOrFilename, pemPassword);
  }

  public boolean SetSslClientCertPfx(String pfxFilename, String pfxPassword) {
    return chilkatJNI.CkSocket_SetSslClientCertPfx(swigCPtr, this, pfxFilename, pfxPassword);
  }

  public void SleepMs(int millisec) {
    chilkatJNI.CkSocket_SleepMs(swigCPtr, this, millisec);
  }

  public boolean SshAuthenticatePk(String sshLogin, CkSshKey privateKey) {
    return chilkatJNI.CkSocket_SshAuthenticatePk(swigCPtr, this, sshLogin, CkSshKey.getCPtr(privateKey), privateKey);
  }

  public CkTask SshAuthenticatePkAsync(String sshLogin, CkSshKey privateKey) {
    long cPtr = chilkatJNI.CkSocket_SshAuthenticatePkAsync(swigCPtr, this, sshLogin, CkSshKey.getCPtr(privateKey), privateKey);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean SshAuthenticatePw(String sshLogin, String sshPassword) {
    return chilkatJNI.CkSocket_SshAuthenticatePw(swigCPtr, this, sshLogin, sshPassword);
  }

  public CkTask SshAuthenticatePwAsync(String sshLogin, String sshPassword) {
    long cPtr = chilkatJNI.CkSocket_SshAuthenticatePwAsync(swigCPtr, this, sshLogin, sshPassword);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean SshCloseTunnel() {
    return chilkatJNI.CkSocket_SshCloseTunnel(swigCPtr, this);
  }

  public CkTask SshCloseTunnelAsync() {
    long cPtr = chilkatJNI.CkSocket_SshCloseTunnelAsync(swigCPtr, this);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean SshNewChannel(String hostname, int port, boolean ssl, int maxWaitMs, CkSocket channel) {
    return chilkatJNI.CkSocket_SshNewChannel(swigCPtr, this, hostname, port, ssl, maxWaitMs, CkSocket.getCPtr(channel), channel);
  }

  public CkTask SshNewChannelAsync(String hostname, int port, boolean ssl, int maxWaitMs, CkSocket channel) {
    long cPtr = chilkatJNI.CkSocket_SshNewChannelAsync(swigCPtr, this, hostname, port, ssl, maxWaitMs, CkSocket.getCPtr(channel), channel);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public CkSocket SshOpenChannel(String hostname, int port, boolean ssl, int maxWaitMs) {
    long cPtr = chilkatJNI.CkSocket_SshOpenChannel(swigCPtr, this, hostname, port, ssl, maxWaitMs);
    return (cPtr == 0) ? null : new CkSocket(cPtr, true);
  }

  public CkTask SshOpenChannelAsync(String hostname, int port, boolean ssl, int maxWaitMs) {
    long cPtr = chilkatJNI.CkSocket_SshOpenChannelAsync(swigCPtr, this, hostname, port, ssl, maxWaitMs);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean SshOpenTunnel(String sshHostname, int sshPort) {
    return chilkatJNI.CkSocket_SshOpenTunnel(swigCPtr, this, sshHostname, sshPort);
  }

  public CkTask SshOpenTunnelAsync(String sshHostname, int sshPort) {
    long cPtr = chilkatJNI.CkSocket_SshOpenTunnelAsync(swigCPtr, this, sshHostname, sshPort);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public void StartTiming() {
    chilkatJNI.CkSocket_StartTiming(swigCPtr, this);
  }

  public boolean TakeConnection(CkSocket sock) {
    return chilkatJNI.CkSocket_TakeConnection(swigCPtr, this, CkSocket.getCPtr(sock), sock);
  }

  public boolean TakeSocket(CkSocket sock) {
    return chilkatJNI.CkSocket_TakeSocket(swigCPtr, this, CkSocket.getCPtr(sock), sock);
  }

  public boolean TlsRenegotiate() {
    return chilkatJNI.CkSocket_TlsRenegotiate(swigCPtr, this);
  }

  public CkTask TlsRenegotiateAsync() {
    long cPtr = chilkatJNI.CkSocket_TlsRenegotiateAsync(swigCPtr, this);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean UseSsh(CkSsh ssh) {
    return chilkatJNI.CkSocket_UseSsh(swigCPtr, this, CkSsh.getCPtr(ssh), ssh);
  }

}
