FOREIGN MODULE javax_net_ssl;

IMPORT
    java_security_cert := "java.security.cert",
    java_lang := "java.lang",
    java_io := "java.io",
    javax_security_cert := "javax.security.cert",
    java_security := "java.security",
    java_util := "java.util",
    java_net := "java.net",
    java_nio := "java.nio",
    java_nio_channels := "java.nio.channels",
    javax_net := "javax.net";

TYPE

  CertPathTrustManagerParameters* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + ManagerFactoryParameters)    (* Typebound Procedures *)
                                    STATIC
                                      PROCEDURE Init*(p0 : java_security_cert.CertPathParameters) : CertPathTrustManagerParameters,CONSTRUCTOR;
                                    END;

  HandshakeCompletedEvent* = POINTER TO EXTENSIBLE RECORD (java_util.EventObject + java_io.Serializable)    (* Typebound Procedures *)
                             STATIC
                               PROCEDURE Init*(p0 : SSLSocket;
                                               p1 : SSLSession) : HandshakeCompletedEvent,CONSTRUCTOR;
                             END;

  HandshakeCompletedListener* = POINTER TO INTERFACE RECORD (java_lang.Object + java_util.EventListener)    (* Typebound Procedures *)
                                END;

  HostnameVerifier* = POINTER TO INTERFACE RECORD (java_lang.Object)    (* Typebound Procedures *)
                      END;

  HttpsURLConnection* = POINTER TO ABSTRACT RECORD (java_net.HttpURLConnection)    (* Typebound Procedures *)
                          hostnameVerifier! : HostnameVerifier;
                        STATIC
                          PROCEDURE getDefaultHostnameVerifier*() : HostnameVerifier;
                          PROCEDURE getDefaultSSLSocketFactory*() : SSLSocketFactory;
                          PROCEDURE Init!(p0 : java_net.URL) : HttpsURLConnection,CONSTRUCTOR;
                          PROCEDURE setDefaultHostnameVerifier*(p0 : HostnameVerifier);
                          PROCEDURE setDefaultSSLSocketFactory*(p0 : SSLSocketFactory);
                        END;

  KeyManager* = POINTER TO INTERFACE RECORD (java_lang.Object)
                END;

  KeyManagerFactory* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)    (* Typebound Procedures *)
                       STATIC
                         PROCEDURE getDefaultAlgorithm*() : java_lang.String;
                         PROCEDURE getInstance*(p0 : java_lang.String;
                                                p1 : java_lang.String) : KeyManagerFactory;
                         PROCEDURE getInstance*(p0 : java_lang.String;
                                                p1 : java_security.Provider) : KeyManagerFactory;
                         PROCEDURE getInstance*(p0 : java_lang.String) : KeyManagerFactory;
                         PROCEDURE Init!(p0 : KeyManagerFactorySpi;
                                         p1 : java_security.Provider;
                                         p2 : java_lang.String) : KeyManagerFactory,CONSTRUCTOR;
                       END;

  KeyManagerFactorySpi* = POINTER TO ABSTRACT RECORD (java_lang.Object)    (* Typebound Procedures *)
                          STATIC
                            PROCEDURE Init*() : KeyManagerFactorySpi,CONSTRUCTOR;
                          END;

  KeyStoreBuilderParameters* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + ManagerFactoryParameters)    (* Typebound Procedures *)
                               STATIC
                                 PROCEDURE Init*(p0 : java_util.List) : KeyStoreBuilderParameters,CONSTRUCTOR;
                                 PROCEDURE Init*(p0 : java_security.KeyStore$Builder) : KeyStoreBuilderParameters,CONSTRUCTOR;
                               END;

  ManagerFactoryParameters* = POINTER TO INTERFACE RECORD (java_lang.Object)
                              END;

  SSLContext* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)    (* Typebound Procedures *)
                STATIC
                  PROCEDURE getInstance*(p0 : java_lang.String;
                                         p1 : java_lang.String) : SSLContext;
                  PROCEDURE getInstance*(p0 : java_lang.String;
                                         p1 : java_security.Provider) : SSLContext;
                  PROCEDURE getInstance*(p0 : java_lang.String) : SSLContext;
                  PROCEDURE Init!(p0 : SSLContextSpi;
                                  p1 : java_security.Provider;
                                  p2 : java_lang.String) : SSLContext,CONSTRUCTOR;
                END;

  SSLContextSpi* = POINTER TO ABSTRACT RECORD (java_lang.Object)    (* Typebound Procedures *)
                   STATIC
                     PROCEDURE Init*() : SSLContextSpi,CONSTRUCTOR;
                   END;

  SSLEngine* = POINTER TO ABSTRACT RECORD (java_lang.Object)    (* Typebound Procedures *)
               STATIC
                 PROCEDURE Init!(p0 : java_lang.String;
                                 p1 : INTEGER) : SSLEngine,CONSTRUCTOR;
                 PROCEDURE Init!() : SSLEngine,CONSTRUCTOR;
               END;

  SSLEngineResult* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)    (* Typebound Procedures *)
                     STATIC
                       PROCEDURE Init*(p0 : SSLEngineResult$Status;
                                       p1 : SSLEngineResult$HandshakeStatus;
                                       p2 : INTEGER;
                                       p3 : INTEGER) : SSLEngineResult,CONSTRUCTOR;
                     END;

  SSLEngineResult$HandshakeStatus* = POINTER TO RECORD (java_lang.Enum)
                                     STATIC
                                       FINISHED*        : SSLEngineResult$HandshakeStatus;
                                       NEED_TASK*       : SSLEngineResult$HandshakeStatus;
                                       NEED_UNWRAP*     : SSLEngineResult$HandshakeStatus;
                                       NEED_WRAP*       : SSLEngineResult$HandshakeStatus;
                                       NOT_HANDSHAKING* : SSLEngineResult$HandshakeStatus;
                                       PROCEDURE valueOf*(p0 : java_lang.String) : SSLEngineResult$HandshakeStatus;
                                       PROCEDURE values*() : POINTER TO ARRAY OF SSLEngineResult$HandshakeStatus;
                                     END;

  SSLEngineResult$Status* = POINTER TO RECORD (java_lang.Enum)
                            STATIC
                              BUFFER_OVERFLOW*  : SSLEngineResult$Status;
                              BUFFER_UNDERFLOW* : SSLEngineResult$Status;
                              CLOSED*           : SSLEngineResult$Status;
                              OK*               : SSLEngineResult$Status;
                              PROCEDURE valueOf*(p0 : java_lang.String) : SSLEngineResult$Status;
                              PROCEDURE values*() : POINTER TO ARRAY OF SSLEngineResult$Status;
                            END;

  SSLException* = POINTER TO EXTENSIBLE RECORD (java_io.IOException)
                  STATIC
                    PROCEDURE Init*(p0 : java_lang.Throwable) : SSLException,CONSTRUCTOR;
                    PROCEDURE Init*(p0 : java_lang.String;
                                    p1 : java_lang.Throwable) : SSLException,CONSTRUCTOR;
                    PROCEDURE Init*(p0 : java_lang.String) : SSLException,CONSTRUCTOR;
                  END;

  SSLHandshakeException* = POINTER TO EXTENSIBLE RECORD (SSLException)
                           STATIC
                             PROCEDURE Init*(p0 : java_lang.String) : SSLHandshakeException,CONSTRUCTOR;
                           END;

  SSLKeyException* = POINTER TO EXTENSIBLE RECORD (SSLException)
                     STATIC
                       PROCEDURE Init*(p0 : java_lang.String) : SSLKeyException,CONSTRUCTOR;
                     END;

  SSLPeerUnverifiedException* = POINTER TO EXTENSIBLE RECORD (SSLException)
                                STATIC
                                  PROCEDURE Init*(p0 : java_lang.String) : SSLPeerUnverifiedException,CONSTRUCTOR;
                                END;

  SSLPermission* = POINTER TO RECORD (java_security.BasicPermission)
                   STATIC
                     PROCEDURE Init*(p0 : java_lang.String;
                                     p1 : java_lang.String) : SSLPermission,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : java_lang.String) : SSLPermission,CONSTRUCTOR;
                   END;

  SSLProtocolException* = POINTER TO EXTENSIBLE RECORD (SSLException)
                          STATIC
                            PROCEDURE Init*(p0 : java_lang.String) : SSLProtocolException,CONSTRUCTOR;
                          END;

  SSLServerSocket* = POINTER TO ABSTRACT RECORD (java_net.ServerSocket)    (* Typebound Procedures *)
                     STATIC
                       PROCEDURE Init!(p0 : INTEGER;
                                       p1 : INTEGER) : SSLServerSocket,CONSTRUCTOR;
                       PROCEDURE Init!(p0 : INTEGER;
                                       p1 : INTEGER;
                                       p2 : java_net.InetAddress) : SSLServerSocket,CONSTRUCTOR;
                       PROCEDURE Init!() : SSLServerSocket,CONSTRUCTOR;
                       PROCEDURE Init!(p0 : INTEGER) : SSLServerSocket,CONSTRUCTOR;
                     END;

  SSLServerSocketFactory* = POINTER TO ABSTRACT RECORD (javax_net.ServerSocketFactory)    (* Typebound Procedures *)
                            STATIC
                              PROCEDURE getDefault*() : javax_net.ServerSocketFactory;
                              PROCEDURE Init!() : SSLServerSocketFactory,CONSTRUCTOR;
                            END;

  SSLSession* = POINTER TO INTERFACE RECORD (java_lang.Object)    (* Typebound Procedures *)
                END;

  SSLSessionBindingEvent* = POINTER TO EXTENSIBLE RECORD (java_util.EventObject + java_io.Serializable)    (* Typebound Procedures *)
                            STATIC
                              PROCEDURE Init*(p0 : SSLSession;
                                              p1 : java_lang.String) : SSLSessionBindingEvent,CONSTRUCTOR;
                            END;

  SSLSessionBindingListener* = POINTER TO INTERFACE RECORD (java_lang.Object + java_util.EventListener)    (* Typebound Procedures *)
                               END;

  SSLSessionContext* = POINTER TO INTERFACE RECORD (java_lang.Object)    (* Typebound Procedures *)
                       END;

  SSLSocket* = POINTER TO ABSTRACT RECORD (java_net.Socket)    (* Typebound Procedures *)
               STATIC
                 PROCEDURE Init!(p0 : java_lang.String;
                                 p1 : INTEGER;
                                 p2 : java_net.InetAddress;
                                 p3 : INTEGER) : SSLSocket,CONSTRUCTOR;
                 PROCEDURE Init!(p0 : java_net.InetAddress;
                                 p1 : INTEGER;
                                 p2 : java_net.InetAddress;
                                 p3 : INTEGER) : SSLSocket,CONSTRUCTOR;
                 PROCEDURE Init!(p0 : java_net.InetAddress;
                                 p1 : INTEGER) : SSLSocket,CONSTRUCTOR;
                 PROCEDURE Init!() : SSLSocket,CONSTRUCTOR;
                 PROCEDURE Init!(p0 : java_lang.String;
                                 p1 : INTEGER) : SSLSocket,CONSTRUCTOR;
               END;

  SSLSocketFactory* = POINTER TO ABSTRACT RECORD (javax_net.SocketFactory)    (* Typebound Procedures *)
                      STATIC
                        PROCEDURE getDefault*() : javax_net.SocketFactory;
                        PROCEDURE Init*() : SSLSocketFactory,CONSTRUCTOR;
                      END;

  TrustManager* = POINTER TO INTERFACE RECORD (java_lang.Object)
                  END;

  TrustManagerFactory* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)    (* Typebound Procedures *)
                         STATIC
                           PROCEDURE getDefaultAlgorithm*() : java_lang.String;
                           PROCEDURE getInstance*(p0 : java_lang.String;
                                                  p1 : java_lang.String) : TrustManagerFactory;
                           PROCEDURE getInstance*(p0 : java_lang.String;
                                                  p1 : java_security.Provider) : TrustManagerFactory;
                           PROCEDURE getInstance*(p0 : java_lang.String) : TrustManagerFactory;
                           PROCEDURE Init!(p0 : TrustManagerFactorySpi;
                                           p1 : java_security.Provider;
                                           p2 : java_lang.String) : TrustManagerFactory,CONSTRUCTOR;
                         END;

  TrustManagerFactorySpi* = POINTER TO ABSTRACT RECORD (java_lang.Object)    (* Typebound Procedures *)
                            STATIC
                              PROCEDURE Init*() : TrustManagerFactorySpi,CONSTRUCTOR;
                            END;

  X509ExtendedKeyManager* = POINTER TO ABSTRACT RECORD (java_lang.Object + X509KeyManager)    (* Typebound Procedures *)
                            STATIC
                              PROCEDURE Init!() : X509ExtendedKeyManager,CONSTRUCTOR;
                            END;

  X509KeyManager* = POINTER TO INTERFACE RECORD (java_lang.Object + KeyManager)    (* Typebound Procedures *)
                    END;

  X509TrustManager* = POINTER TO INTERFACE RECORD (java_lang.Object + TrustManager)    (* Typebound Procedures *)
                      END;




PROCEDURE (self:CertPathTrustManagerParameters) getParameters*() : java_security_cert.CertPathParameters,NEW,EXTENSIBLE;

PROCEDURE (self:HandshakeCompletedEvent) getCipherSuite*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:HandshakeCompletedEvent) getLocalCertificates*() : POINTER TO ARRAY OF java_security_cert.Certificate,NEW,EXTENSIBLE;

PROCEDURE (self:HandshakeCompletedEvent) getLocalPrincipal*() : java_security.Principal,NEW,EXTENSIBLE;

PROCEDURE (self:HandshakeCompletedEvent) getPeerCertificateChain*() : POINTER TO ARRAY OF javax_security_cert.X509Certificate,NEW,EXTENSIBLE;

PROCEDURE (self:HandshakeCompletedEvent) getPeerCertificates*() : POINTER TO ARRAY OF java_security_cert.Certificate,NEW,EXTENSIBLE;

PROCEDURE (self:HandshakeCompletedEvent) getPeerPrincipal*() : java_security.Principal,NEW,EXTENSIBLE;

PROCEDURE (self:HandshakeCompletedEvent) getSession*() : SSLSession,NEW,EXTENSIBLE;

PROCEDURE (self:HandshakeCompletedEvent) getSocket*() : SSLSocket,NEW,EXTENSIBLE;

PROCEDURE (self:HandshakeCompletedListener) handshakeCompleted*(p0 : HandshakeCompletedEvent),NEW,ABSTRACT;

PROCEDURE (self:HostnameVerifier) verify*(p0 : java_lang.String;
                                          p1 : SSLSession) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:HttpsURLConnection) getCipherSuite*() : java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:HttpsURLConnection) getHostnameVerifier*() : HostnameVerifier,NEW,EXTENSIBLE;

PROCEDURE (self:HttpsURLConnection) getLocalCertificates*() : POINTER TO ARRAY OF java_security_cert.Certificate,NEW,ABSTRACT;

PROCEDURE (self:HttpsURLConnection) getLocalPrincipal*() : java_security.Principal,NEW,EXTENSIBLE;

PROCEDURE (self:HttpsURLConnection) getPeerPrincipal*() : java_security.Principal,NEW,EXTENSIBLE;

PROCEDURE (self:HttpsURLConnection) getServerCertificates*() : POINTER TO ARRAY OF java_security_cert.Certificate,NEW,ABSTRACT;

PROCEDURE (self:HttpsURLConnection) getSSLSocketFactory*() : SSLSocketFactory,NEW,EXTENSIBLE;

PROCEDURE (self:HttpsURLConnection) setHostnameVerifier*(p0 : HostnameVerifier),NEW,EXTENSIBLE;

PROCEDURE (self:HttpsURLConnection) setSSLSocketFactory*(p0 : SSLSocketFactory),NEW,EXTENSIBLE;

PROCEDURE (self:KeyManagerFactory) getAlgorithm*() : java_lang.String,NEW;

PROCEDURE (self:KeyManagerFactory) getKeyManagers*() : POINTER TO ARRAY OF KeyManager,NEW;

PROCEDURE (self:KeyManagerFactory) getProvider*() : java_security.Provider,NEW;

PROCEDURE (self:KeyManagerFactory) init*(p0 : ManagerFactoryParameters),NEW;

PROCEDURE (self:KeyManagerFactory) init*(    p0 : java_security.KeyStore;
                                         IN  p1 : ARRAY OF CHAR),NEW;

PROCEDURE (self:KeyManagerFactorySpi) engineGetKeyManagers!() : POINTER TO ARRAY OF KeyManager,NEW,ABSTRACT;

PROCEDURE (self:KeyManagerFactorySpi) engineInit!(p0 : ManagerFactoryParameters),NEW,ABSTRACT;

PROCEDURE (self:KeyManagerFactorySpi) engineInit!(    p0 : java_security.KeyStore;
                                                  IN  p1 : ARRAY OF CHAR),NEW,ABSTRACT;

PROCEDURE (self:KeyStoreBuilderParameters) getParameters*() : java_util.List,NEW,EXTENSIBLE;

PROCEDURE (self:SSLContext) createSSLEngine*(p0 : java_lang.String;
                                             p1 : INTEGER) : SSLEngine,NEW;

PROCEDURE (self:SSLContext) createSSLEngine*() : SSLEngine,NEW;

PROCEDURE (self:SSLContext) getClientSessionContext*() : SSLSessionContext,NEW;

PROCEDURE (self:SSLContext) getProtocol*() : java_lang.String,NEW;

PROCEDURE (self:SSLContext) getProvider*() : java_security.Provider,NEW;

PROCEDURE (self:SSLContext) getServerSessionContext*() : SSLSessionContext,NEW;

PROCEDURE (self:SSLContext) getServerSocketFactory*() : SSLServerSocketFactory,NEW;

PROCEDURE (self:SSLContext) getSocketFactory*() : SSLSocketFactory,NEW;

PROCEDURE (self:SSLContext) init*(IN  p0 : ARRAY OF KeyManager;
                                  IN  p1 : ARRAY OF TrustManager;
                                      p2 : java_security.SecureRandom),NEW;

PROCEDURE (self:SSLContextSpi) engineCreateSSLEngine!(p0 : java_lang.String;
                                                      p1 : INTEGER) : SSLEngine,NEW,ABSTRACT;

PROCEDURE (self:SSLContextSpi) engineCreateSSLEngine!() : SSLEngine,NEW,ABSTRACT;

PROCEDURE (self:SSLContextSpi) engineGetClientSessionContext!() : SSLSessionContext,NEW,ABSTRACT;

PROCEDURE (self:SSLContextSpi) engineGetServerSessionContext!() : SSLSessionContext,NEW,ABSTRACT;

PROCEDURE (self:SSLContextSpi) engineGetServerSocketFactory!() : SSLServerSocketFactory,NEW,ABSTRACT;

PROCEDURE (self:SSLContextSpi) engineGetSocketFactory!() : SSLSocketFactory,NEW,ABSTRACT;

PROCEDURE (self:SSLContextSpi) engineInit!(IN  p0 : ARRAY OF KeyManager;
                                           IN  p1 : ARRAY OF TrustManager;
                                               p2 : java_security.SecureRandom),NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) beginHandshake*(),NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) closeInbound*(),NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) closeOutbound*(),NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) getDelegatedTask*() : java_lang.Runnable,NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) getEnabledCipherSuites*() : POINTER TO ARRAY OF java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) getEnabledProtocols*() : POINTER TO ARRAY OF java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) getEnableSessionCreation*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) getHandshakeStatus*() : SSLEngineResult$HandshakeStatus,NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) getNeedClientAuth*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) getPeerHost*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:SSLEngine) getPeerPort*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:SSLEngine) getSession*() : SSLSession,NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) getSupportedCipherSuites*() : POINTER TO ARRAY OF java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) getSupportedProtocols*() : POINTER TO ARRAY OF java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) getUseClientMode*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) getWantClientAuth*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) isInboundDone*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) isOutboundDone*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) setEnabledCipherSuites*(IN  p0 : ARRAY OF java_lang.String),NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) setEnabledProtocols*(IN  p0 : ARRAY OF java_lang.String),NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) setEnableSessionCreation*(p0 : BOOLEAN),NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) setNeedClientAuth*(p0 : BOOLEAN),NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) setUseClientMode*(p0 : BOOLEAN),NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) setWantClientAuth*(p0 : BOOLEAN),NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) unwrap*(p0 : java_nio.ByteBuffer;
                                   p1 : java_nio.ByteBuffer) : SSLEngineResult,NEW,EXTENSIBLE;

PROCEDURE (self:SSLEngine) unwrap*(    p0 : java_nio.ByteBuffer;
                                   IN  p1 : ARRAY OF java_nio.ByteBuffer) : SSLEngineResult,NEW,EXTENSIBLE;

PROCEDURE (self:SSLEngine) unwrap*(    p0 : java_nio.ByteBuffer;
                                   IN  p1 : ARRAY OF java_nio.ByteBuffer;
                                       p2 : INTEGER;
                                       p3 : INTEGER) : SSLEngineResult,NEW,ABSTRACT;

PROCEDURE (self:SSLEngine) wrap*(p0 : java_nio.ByteBuffer;
                                 p1 : java_nio.ByteBuffer) : SSLEngineResult,NEW,EXTENSIBLE;

PROCEDURE (self:SSLEngine) wrap*(IN  p0 : ARRAY OF java_nio.ByteBuffer;
                                     p1 : java_nio.ByteBuffer) : SSLEngineResult,NEW,EXTENSIBLE;

PROCEDURE (self:SSLEngine) wrap*(IN  p0 : ARRAY OF java_nio.ByteBuffer;
                                     p1 : INTEGER;
                                     p2 : INTEGER;
                                     p3 : java_nio.ByteBuffer) : SSLEngineResult,NEW,ABSTRACT;

PROCEDURE (self:SSLEngineResult) bytesConsumed*() : INTEGER,NEW;

PROCEDURE (self:SSLEngineResult) bytesProduced*() : INTEGER,NEW;

PROCEDURE (self:SSLEngineResult) getHandshakeStatus*() : SSLEngineResult$HandshakeStatus,NEW;

PROCEDURE (self:SSLEngineResult) getStatus*() : SSLEngineResult$Status,NEW;

PROCEDURE (self:SSLEngineResult) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:SSLServerSocket) getEnabledCipherSuites*() : POINTER TO ARRAY OF java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:SSLServerSocket) getEnabledProtocols*() : POINTER TO ARRAY OF java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:SSLServerSocket) getEnableSessionCreation*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SSLServerSocket) getNeedClientAuth*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SSLServerSocket) getSupportedCipherSuites*() : POINTER TO ARRAY OF java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:SSLServerSocket) getSupportedProtocols*() : POINTER TO ARRAY OF java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:SSLServerSocket) getUseClientMode*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SSLServerSocket) getWantClientAuth*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SSLServerSocket) setEnabledCipherSuites*(IN  p0 : ARRAY OF java_lang.String),NEW,ABSTRACT;

PROCEDURE (self:SSLServerSocket) setEnabledProtocols*(IN  p0 : ARRAY OF java_lang.String),NEW,ABSTRACT;

PROCEDURE (self:SSLServerSocket) setEnableSessionCreation*(p0 : BOOLEAN),NEW,ABSTRACT;

PROCEDURE (self:SSLServerSocket) setNeedClientAuth*(p0 : BOOLEAN),NEW,ABSTRACT;

PROCEDURE (self:SSLServerSocket) setUseClientMode*(p0 : BOOLEAN),NEW,ABSTRACT;

PROCEDURE (self:SSLServerSocket) setWantClientAuth*(p0 : BOOLEAN),NEW,ABSTRACT;

PROCEDURE (self:SSLServerSocketFactory) getDefaultCipherSuites*() : POINTER TO ARRAY OF java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:SSLServerSocketFactory) getSupportedCipherSuites*() : POINTER TO ARRAY OF java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:SSLSession) getApplicationBufferSize*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:SSLSession) getCipherSuite*() : java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:SSLSession) getCreationTime*() : LONGINT,NEW,ABSTRACT;

PROCEDURE (self:SSLSession) getId*() : POINTER TO ARRAY OF BYTE,NEW,ABSTRACT;

PROCEDURE (self:SSLSession) getLastAccessedTime*() : LONGINT,NEW,ABSTRACT;

PROCEDURE (self:SSLSession) getLocalCertificates*() : POINTER TO ARRAY OF java_security_cert.Certificate,NEW,ABSTRACT;

PROCEDURE (self:SSLSession) getLocalPrincipal*() : java_security.Principal,NEW,ABSTRACT;

PROCEDURE (self:SSLSession) getPacketBufferSize*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:SSLSession) getPeerCertificateChain*() : POINTER TO ARRAY OF javax_security_cert.X509Certificate,NEW,ABSTRACT;

PROCEDURE (self:SSLSession) getPeerCertificates*() : POINTER TO ARRAY OF java_security_cert.Certificate,NEW,ABSTRACT;

PROCEDURE (self:SSLSession) getPeerHost*() : java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:SSLSession) getPeerPort*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:SSLSession) getPeerPrincipal*() : java_security.Principal,NEW,ABSTRACT;

PROCEDURE (self:SSLSession) getProtocol*() : java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:SSLSession) getSessionContext*() : SSLSessionContext,NEW,ABSTRACT;

PROCEDURE (self:SSLSession) getValue*(p0 : java_lang.String) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:SSLSession) getValueNames*() : POINTER TO ARRAY OF java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:SSLSession) invalidate*(),NEW,ABSTRACT;

PROCEDURE (self:SSLSession) isValid*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SSLSession) putValue*(p0 : java_lang.String;
                                      p1 : java_lang.Object),NEW,ABSTRACT;

PROCEDURE (self:SSLSession) removeValue*(p0 : java_lang.String),NEW,ABSTRACT;

PROCEDURE (self:SSLSessionBindingEvent) getName*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:SSLSessionBindingEvent) getSession*() : SSLSession,NEW,EXTENSIBLE;

PROCEDURE (self:SSLSessionBindingListener) valueBound*(p0 : SSLSessionBindingEvent),NEW,ABSTRACT;

PROCEDURE (self:SSLSessionBindingListener) valueUnbound*(p0 : SSLSessionBindingEvent),NEW,ABSTRACT;

PROCEDURE (self:SSLSessionContext) getIds*() : java_util.Enumeration,NEW,ABSTRACT;

PROCEDURE (self:SSLSessionContext) getSession*(IN  p0 : ARRAY OF BYTE) : SSLSession,NEW,ABSTRACT;

PROCEDURE (self:SSLSessionContext) getSessionCacheSize*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:SSLSessionContext) getSessionTimeout*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:SSLSessionContext) setSessionCacheSize*(p0 : INTEGER),NEW,ABSTRACT;

PROCEDURE (self:SSLSessionContext) setSessionTimeout*(p0 : INTEGER),NEW,ABSTRACT;

PROCEDURE (self:SSLSocket) addHandshakeCompletedListener*(p0 : HandshakeCompletedListener),NEW,ABSTRACT;

PROCEDURE (self:SSLSocket) getEnabledCipherSuites*() : POINTER TO ARRAY OF java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:SSLSocket) getEnabledProtocols*() : POINTER TO ARRAY OF java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:SSLSocket) getEnableSessionCreation*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SSLSocket) getNeedClientAuth*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SSLSocket) getSession*() : SSLSession,NEW,ABSTRACT;

PROCEDURE (self:SSLSocket) getSupportedCipherSuites*() : POINTER TO ARRAY OF java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:SSLSocket) getSupportedProtocols*() : POINTER TO ARRAY OF java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:SSLSocket) getUseClientMode*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SSLSocket) getWantClientAuth*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:SSLSocket) removeHandshakeCompletedListener*(p0 : HandshakeCompletedListener),NEW,ABSTRACT;

PROCEDURE (self:SSLSocket) setEnabledCipherSuites*(IN  p0 : ARRAY OF java_lang.String),NEW,ABSTRACT;

PROCEDURE (self:SSLSocket) setEnabledProtocols*(IN  p0 : ARRAY OF java_lang.String),NEW,ABSTRACT;

PROCEDURE (self:SSLSocket) setEnableSessionCreation*(p0 : BOOLEAN),NEW,ABSTRACT;

PROCEDURE (self:SSLSocket) setNeedClientAuth*(p0 : BOOLEAN),NEW,ABSTRACT;

PROCEDURE (self:SSLSocket) setUseClientMode*(p0 : BOOLEAN),NEW,ABSTRACT;

PROCEDURE (self:SSLSocket) setWantClientAuth*(p0 : BOOLEAN),NEW,ABSTRACT;

PROCEDURE (self:SSLSocket) startHandshake*(),NEW,ABSTRACT;

PROCEDURE (self:SSLSocketFactory) createSocket*(p0 : java_net.Socket;
                                                p1 : java_lang.String;
                                                p2 : INTEGER;
                                                p3 : BOOLEAN) : java_net.Socket,NEW,ABSTRACT;

PROCEDURE (self:SSLSocketFactory) getDefaultCipherSuites*() : POINTER TO ARRAY OF java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:SSLSocketFactory) getSupportedCipherSuites*() : POINTER TO ARRAY OF java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:TrustManagerFactory) getAlgorithm*() : java_lang.String,NEW;

PROCEDURE (self:TrustManagerFactory) getProvider*() : java_security.Provider,NEW;

PROCEDURE (self:TrustManagerFactory) getTrustManagers*() : POINTER TO ARRAY OF TrustManager,NEW;

PROCEDURE (self:TrustManagerFactory) init*(p0 : ManagerFactoryParameters),NEW;

PROCEDURE (self:TrustManagerFactory) init*(p0 : java_security.KeyStore),NEW;

PROCEDURE (self:TrustManagerFactorySpi) engineGetTrustManagers!() : POINTER TO ARRAY OF TrustManager,NEW,ABSTRACT;

PROCEDURE (self:TrustManagerFactorySpi) engineInit!(p0 : ManagerFactoryParameters),NEW,ABSTRACT;

PROCEDURE (self:TrustManagerFactorySpi) engineInit!(p0 : java_security.KeyStore),NEW,ABSTRACT;

PROCEDURE (self:X509ExtendedKeyManager) chooseEngineClientAlias*(IN  p0 : ARRAY OF java_lang.String;
                                                                 IN  p1 : ARRAY OF java_security.Principal;
                                                                     p2 : SSLEngine) : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:X509ExtendedKeyManager) chooseEngineServerAlias*(    p0 : java_lang.String;
                                                                 IN  p1 : ARRAY OF java_security.Principal;
                                                                     p2 : SSLEngine) : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:X509KeyManager) chooseClientAlias*(IN  p0 : ARRAY OF java_lang.String;
                                                   IN  p1 : ARRAY OF java_security.Principal;
                                                       p2 : java_net.Socket) : java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:X509KeyManager) chooseServerAlias*(    p0 : java_lang.String;
                                                   IN  p1 : ARRAY OF java_security.Principal;
                                                       p2 : java_net.Socket) : java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:X509KeyManager) getCertificateChain*(p0 : java_lang.String) : POINTER TO ARRAY OF java_security_cert.X509Certificate,NEW,ABSTRACT;

PROCEDURE (self:X509KeyManager) getClientAliases*(    p0 : java_lang.String;
                                                  IN  p1 : ARRAY OF java_security.Principal) : POINTER TO ARRAY OF java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:X509KeyManager) getPrivateKey*(p0 : java_lang.String) : java_security.PrivateKey,NEW,ABSTRACT;

PROCEDURE (self:X509KeyManager) getServerAliases*(    p0 : java_lang.String;
                                                  IN  p1 : ARRAY OF java_security.Principal) : POINTER TO ARRAY OF java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:X509TrustManager) checkClientTrusted*(IN  p0 : ARRAY OF java_security_cert.X509Certificate;
                                                          p1 : java_lang.String),NEW,ABSTRACT;

PROCEDURE (self:X509TrustManager) checkServerTrusted*(IN  p0 : ARRAY OF java_security_cert.X509Certificate;
                                                          p1 : java_lang.String),NEW,ABSTRACT;

PROCEDURE (self:X509TrustManager) getAcceptedIssuers*() : POINTER TO ARRAY OF java_security_cert.X509Certificate,NEW,ABSTRACT;

END javax_net_ssl.