FOREIGN MODULE java_security;

IMPORT
    sun_misc := "sun.misc",
    java_lang := "java.lang",
    sun_security_util := "sun.security.util",
    java_io := "java.io",
    java_security_spec := "java.security.spec",
    java_util := "java.util",
    javax_security_auth := "javax.security.auth",
    javax_security_auth_callback := "javax.security.auth.callback",
    java_security_cert := "java.security.cert",
    java_net := "java.net",
    sun_security_jca := "sun.security.jca",
    javax_crypto := "javax.crypto",
    java_nio := "java.nio",
    java_lang_ref := "java.lang.ref",
    java_lang_reflect := "java.lang.reflect",
    java_util_concurrent_atomic := "java.util.concurrent.atomic",
    javax_security_auth_login := "javax.security.auth.login";

TYPE

  AccessControlContext* = POINTER TO RECORD (java_lang.Object)    (* Typebound Procedures *)
                          STATIC
                            PROCEDURE Init*(p0 : AccessControlContext;
                                            p1 : DomainCombiner) : AccessControlContext,CONSTRUCTOR;
                            PROCEDURE Init*(IN  p0 : ARRAY OF ProtectionDomain) : AccessControlContext,CONSTRUCTOR;
                          END;

  AccessControlException* = POINTER TO EXTENSIBLE RECORD (java_lang.SecurityException)    (* Typebound Procedures *)
                            STATIC
                              PROCEDURE Init*(p0 : java_lang.String;
                                              p1 : Permission) : AccessControlException,CONSTRUCTOR;
                              PROCEDURE Init*(p0 : java_lang.String) : AccessControlException,CONSTRUCTOR;
                            END;

  AccessController* = POINTER TO RECORD (java_lang.Object)
                      STATIC
                        PROCEDURE checkPermission*(p0 : Permission);
                        PROCEDURE doPrivileged*(p0 : PrivilegedExceptionAction) : java_lang.Object;
                        PROCEDURE doPrivileged*(p0 : PrivilegedExceptionAction;
                                                p1 : AccessControlContext) : java_lang.Object;
                        PROCEDURE doPrivileged*(p0 : PrivilegedAction) : java_lang.Object;
                        PROCEDURE doPrivileged*(p0 : PrivilegedAction;
                                                p1 : AccessControlContext) : java_lang.Object;
                        PROCEDURE doPrivilegedWithCombiner*(p0 : PrivilegedAction) : java_lang.Object;
                        PROCEDURE doPrivilegedWithCombiner*(p0 : PrivilegedExceptionAction) : java_lang.Object;
                        PROCEDURE getContext*() : AccessControlContext;
                      END;

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

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

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

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

  AllPermission* = POINTER TO RECORD (Permission)    (* Typebound Procedures *)
                   STATIC
                     PROCEDURE Init*(p0 : java_lang.String;
                                     p1 : java_lang.String) : AllPermission,CONSTRUCTOR;
                     PROCEDURE Init*() : AllPermission,CONSTRUCTOR;
                   END;

  AuthProvider* = POINTER TO ABSTRACT RECORD (Provider)    (* Typebound Procedures *)
                  STATIC
                    PROCEDURE Init!(p0 : java_lang.String;
                                    p1 : REAL;
                                    p2 : java_lang.String) : AuthProvider,CONSTRUCTOR;
                  END;

  BasicPermission* = POINTER TO ABSTRACT RECORD (Permission + java_io.Serializable)    (* Typebound Procedures *)
                     STATIC
                       PROCEDURE Init*(p0 : java_lang.String;
                                       p1 : java_lang.String) : BasicPermission,CONSTRUCTOR;
                       PROCEDURE Init*(p0 : java_lang.String) : BasicPermission,CONSTRUCTOR;
                     END;

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

  CodeSigner* = POINTER TO RECORD (java_lang.Object + java_io.Serializable)    (* Typebound Procedures *)
                STATIC
                  PROCEDURE Init*(p0 : java_security_cert.CertPath;
                                  p1 : Timestamp) : CodeSigner,CONSTRUCTOR;
                END;

  CodeSource* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + java_io.Serializable)    (* Typebound Procedures *)
                STATIC
                  PROCEDURE Init*(    p0 : java_net.URL;
                                  IN  p1 : ARRAY OF CodeSigner) : CodeSource,CONSTRUCTOR;
                  PROCEDURE Init*(    p0 : java_net.URL;
                                  IN  p1 : ARRAY OF java_security_cert.Certificate) : CodeSource,CONSTRUCTOR;
                END;

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

  DigestInputStream* = POINTER TO EXTENSIBLE RECORD (java_io.FilterInputStream)    (* Typebound Procedures *)
                         digest! : MessageDigest;
                       STATIC
                         PROCEDURE Init*(p0 : java_io.InputStream;
                                         p1 : MessageDigest) : DigestInputStream,CONSTRUCTOR;
                       END;

  DigestOutputStream* = POINTER TO EXTENSIBLE RECORD (java_io.FilterOutputStream)    (* Typebound Procedures *)
                          digest! : MessageDigest;
                        STATIC
                          PROCEDURE Init*(p0 : java_io.OutputStream;
                                          p1 : MessageDigest) : DigestOutputStream,CONSTRUCTOR;
                        END;

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

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

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

  GuardedObject* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + java_io.Serializable)    (* Typebound Procedures *)
                   STATIC
                     PROCEDURE Init*(p0 : java_lang.Object;
                                     p1 : Guard) : GuardedObject,CONSTRUCTOR;
                   END;

  Identity* = POINTER TO ABSTRACT RECORD (java_lang.Object + Principal + java_io.Serializable)    (* Typebound Procedures *)
              STATIC
                PROCEDURE Init*(p0 : java_lang.String) : Identity,CONSTRUCTOR;
                PROCEDURE Init*(p0 : java_lang.String;
                                p1 : IdentityScope) : Identity,CONSTRUCTOR;
                PROCEDURE Init!() : Identity,CONSTRUCTOR;
              END;

  IdentityScope* = POINTER TO ABSTRACT RECORD (Identity)    (* Typebound Procedures *)
                   STATIC
                     PROCEDURE getSystemScope*() : IdentityScope;
                     PROCEDURE Init*(p0 : java_lang.String;
                                     p1 : IdentityScope) : IdentityScope,CONSTRUCTOR;
                     PROCEDURE Init!() : IdentityScope,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : java_lang.String) : IdentityScope,CONSTRUCTOR;
                     PROCEDURE setSystemScope!(p0 : IdentityScope);
                   END;

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

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

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

  Key* = POINTER TO INTERFACE RECORD (java_lang.Object + java_io.Serializable)    (* Typebound Procedures *)
         STATIC
           serialVersionUID* = 6603384152749567654;
         END;

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

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

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

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

  KeyPair* = POINTER TO RECORD (java_lang.Object + java_io.Serializable)    (* Typebound Procedures *)
             STATIC
               PROCEDURE Init*(p0 : PublicKey;
                               p1 : PrivateKey) : KeyPair,CONSTRUCTOR;
             END;

  KeyPairGenerator* = POINTER TO ABSTRACT RECORD (KeyPairGeneratorSpi)    (* Typebound Procedures *)
                      STATIC
                        PROCEDURE getInstance*(p0 : java_lang.String;
                                               p1 : java_lang.String) : KeyPairGenerator;
                        PROCEDURE getInstance*(p0 : java_lang.String;
                                               p1 : Provider) : KeyPairGenerator;
                        PROCEDURE getInstance*(p0 : java_lang.String) : KeyPairGenerator;
                        PROCEDURE Init!(p0 : java_lang.String) : KeyPairGenerator,CONSTRUCTOR;
                      END;

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

  KeyRep* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + java_io.Serializable)    (* Typebound Procedures *)
            STATIC
              PROCEDURE Init*(    p0 : KeyRep$Type;
                                  p1 : java_lang.String;
                                  p2 : java_lang.String;
                              IN  p3 : ARRAY OF BYTE) : KeyRep,CONSTRUCTOR;
            END;

  KeyRep$Type* = POINTER TO RECORD (java_lang.Enum)
                 STATIC
                   PRIVATE* : KeyRep$Type;
                   PUBLIC*  : KeyRep$Type;
                   SECRET*  : KeyRep$Type;
                   PROCEDURE valueOf*(p0 : java_lang.String) : KeyRep$Type;
                   PROCEDURE values*() : POINTER TO ARRAY OF KeyRep$Type;
                 END;

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

  KeyStore$Builder* = POINTER TO ABSTRACT RECORD (java_lang.Object)    (* Typebound Procedures *)
                      STATIC
                        PROCEDURE Init!() : KeyStore$Builder,CONSTRUCTOR;
                        PROCEDURE newInstance*(p0 : java_lang.String;
                                               p1 : Provider;
                                               p2 : KeyStore$ProtectionParameter) : KeyStore$Builder;
                        PROCEDURE newInstance*(p0 : java_lang.String;
                                               p1 : Provider;
                                               p2 : java_io.File;
                                               p3 : KeyStore$ProtectionParameter) : KeyStore$Builder;
                        PROCEDURE newInstance*(p0 : KeyStore;
                                               p1 : KeyStore$ProtectionParameter) : KeyStore$Builder;
                      END;

  KeyStore$CallbackHandlerProtection* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + KeyStore$ProtectionParameter)    (* Typebound Procedures *)
                                        STATIC
                                          PROCEDURE Init*(p0 : javax_security_auth_callback.CallbackHandler) : KeyStore$CallbackHandlerProtection,CONSTRUCTOR;
                                        END;

  KeyStore$Entry* = POINTER TO INTERFACE RECORD (java_lang.Object)
                    END;

  KeyStore$LoadStoreParameter* = POINTER TO INTERFACE RECORD (java_lang.Object)    (* Typebound Procedures *)
                                 END;

  KeyStore$PasswordProtection* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + KeyStore$ProtectionParameter + javax_security_auth.Destroyable)    (* Typebound Procedures *)
                                 STATIC
                                   PROCEDURE Init*(IN  p0 : ARRAY OF CHAR) : KeyStore$PasswordProtection,CONSTRUCTOR;
                                 END;

  KeyStore$PrivateKeyEntry* = POINTER TO RECORD (java_lang.Object + KeyStore$Entry)    (* Typebound Procedures *)
                              STATIC
                                PROCEDURE Init*(    p0 : PrivateKey;
                                                IN  p1 : ARRAY OF java_security_cert.Certificate) : KeyStore$PrivateKeyEntry,CONSTRUCTOR;
                              END;

  KeyStore$ProtectionParameter* = POINTER TO INTERFACE RECORD (java_lang.Object)
                                  END;

  KeyStore$SecretKeyEntry* = POINTER TO RECORD (java_lang.Object + KeyStore$Entry)    (* Typebound Procedures *)
                             STATIC
                               PROCEDURE Init*(p0 : javax_crypto.SecretKey) : KeyStore$SecretKeyEntry,CONSTRUCTOR;
                             END;

  KeyStore$TrustedCertificateEntry* = POINTER TO RECORD (java_lang.Object + KeyStore$Entry)    (* Typebound Procedures *)
                                      STATIC
                                        PROCEDURE Init*(p0 : java_security_cert.Certificate) : KeyStore$TrustedCertificateEntry,CONSTRUCTOR;
                                      END;

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

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

  MessageDigest* = POINTER TO ABSTRACT RECORD (MessageDigestSpi)    (* Typebound Procedures *)
                   STATIC
                     PROCEDURE getInstance*(p0 : java_lang.String;
                                            p1 : java_lang.String) : MessageDigest;
                     PROCEDURE getInstance*(p0 : java_lang.String;
                                            p1 : Provider) : MessageDigest;
                     PROCEDURE getInstance*(p0 : java_lang.String) : MessageDigest;
                     PROCEDURE Init!(p0 : java_lang.String) : MessageDigest,CONSTRUCTOR;
                     PROCEDURE isEqual*(IN  p0 : ARRAY OF BYTE;
                                        IN  p1 : ARRAY OF BYTE) : BOOLEAN;
                   END;

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

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

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

  Permission* = POINTER TO ABSTRACT RECORD (java_lang.Object + Guard + java_io.Serializable)    (* Typebound Procedures *)
                STATIC
                  PROCEDURE Init*(p0 : java_lang.String) : Permission,CONSTRUCTOR;
                END;

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

  Permissions* = POINTER TO RECORD (PermissionCollection + java_io.Serializable)    (* Typebound Procedures *)
                 STATIC
                   PROCEDURE Init*() : Permissions,CONSTRUCTOR;
                 END;

  Policy* = POINTER TO ABSTRACT RECORD (java_lang.Object)    (* Typebound Procedures *)
            STATIC
              UNSUPPORTED_EMPTY_COLLECTION* : PermissionCollection;
              PROCEDURE getInstance*(p0 : java_lang.String;
                                     p1 : Policy$Parameters) : Policy;
              PROCEDURE getInstance*(p0 : java_lang.String;
                                     p1 : Policy$Parameters;
                                     p2 : java_lang.String) : Policy;
              PROCEDURE getInstance*(p0 : java_lang.String;
                                     p1 : Policy$Parameters;
                                     p2 : Provider) : Policy;
              PROCEDURE getPolicy*() : Policy;
              PROCEDURE Init*() : Policy,CONSTRUCTOR;
              PROCEDURE setPolicy*(p0 : Policy);
            END;

  Policy$Parameters* = POINTER TO INTERFACE RECORD (java_lang.Object)
                       END;

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

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

  PrivateKey* = POINTER TO INTERFACE RECORD (java_lang.Object + Key)
                STATIC
                  serialVersionUID* = 6034044314589513430;
                END;

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

  PrivilegedActionException* = POINTER TO EXTENSIBLE RECORD (java_lang.Exception)    (* Typebound Procedures *)
                               STATIC
                                 PROCEDURE Init*(p0 : java_lang.Exception) : PrivilegedActionException,CONSTRUCTOR;
                               END;

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

  ProtectionDomain* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)    (* Typebound Procedures *)
                      STATIC
                        PROCEDURE Init*(    p0 : CodeSource;
                                            p1 : PermissionCollection;
                                            p2 : java_lang.ClassLoader;
                                        IN  p3 : ARRAY OF Principal) : ProtectionDomain,CONSTRUCTOR;
                        PROCEDURE Init*(p0 : CodeSource;
                                        p1 : PermissionCollection) : ProtectionDomain,CONSTRUCTOR;
                      END;

  Provider* = POINTER TO ABSTRACT RECORD (java_util.Properties)    (* Typebound Procedures *)
              STATIC
                PROCEDURE Init!(p0 : java_lang.String;
                                p1 : REAL;
                                p2 : java_lang.String) : Provider,CONSTRUCTOR;
              END;

  Provider$Service* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)    (* Typebound Procedures *)
                      STATIC
                        PROCEDURE Init*(p0 : Provider;
                                        p1 : java_lang.String;
                                        p2 : java_lang.String;
                                        p3 : java_lang.String;
                                        p4 : java_util.List;
                                        p5 : java_util.Map) : Provider$Service,CONSTRUCTOR;
                      END;

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

  PublicKey* = POINTER TO INTERFACE RECORD (java_lang.Object + Key)
               STATIC
                 serialVersionUID* = 7187392471159151072;
               END;

  SecureClassLoader* = POINTER TO EXTENSIBLE RECORD (java_lang.ClassLoader)    (* Typebound Procedures *)
                       STATIC
                         PROCEDURE Init!() : SecureClassLoader,CONSTRUCTOR;
                         PROCEDURE Init!(p0 : java_lang.ClassLoader) : SecureClassLoader,CONSTRUCTOR;
                       END;

  SecureRandom* = POINTER TO EXTENSIBLE RECORD (java_util.Random)    (* Typebound Procedures *)
                  STATIC
                    PROCEDURE getInstance*(p0 : java_lang.String) : SecureRandom;
                    PROCEDURE getInstance*(p0 : java_lang.String;
                                           p1 : java_lang.String) : SecureRandom;
                    PROCEDURE getInstance*(p0 : java_lang.String;
                                           p1 : Provider) : SecureRandom;
                    PROCEDURE getSeed*(p0 : INTEGER) : POINTER TO ARRAY OF BYTE;
                    PROCEDURE Init*() : SecureRandom,CONSTRUCTOR;
                    PROCEDURE Init!(p0 : SecureRandomSpi;
                                    p1 : Provider) : SecureRandom,CONSTRUCTOR;
                    PROCEDURE Init*(IN  p0 : ARRAY OF BYTE) : SecureRandom,CONSTRUCTOR;
                  END;

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

  Security* = POINTER TO RECORD (java_lang.Object)
              STATIC
                PROCEDURE addProvider*(p0 : Provider) : INTEGER;
                PROCEDURE getAlgorithmProperty*(p0 : java_lang.String;
                                                p1 : java_lang.String) : java_lang.String;
                PROCEDURE getAlgorithms*(p0 : java_lang.String) : java_util.Set;
                PROCEDURE getProperty*(p0 : java_lang.String) : java_lang.String;
                PROCEDURE getProvider*(p0 : java_lang.String) : Provider;
                PROCEDURE getProviders*(p0 : java_util.Map) : POINTER TO ARRAY OF Provider;
                PROCEDURE getProviders*(p0 : java_lang.String) : POINTER TO ARRAY OF Provider;
                PROCEDURE getProviders*() : POINTER TO ARRAY OF Provider;
                PROCEDURE insertProviderAt*(p0 : Provider;
                                            p1 : INTEGER) : INTEGER;
                PROCEDURE removeProvider*(p0 : java_lang.String);
                PROCEDURE setProperty*(p0 : java_lang.String;
                                       p1 : java_lang.String);
              END;

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

  Signature* = POINTER TO ABSTRACT RECORD (SignatureSpi)    (* Typebound Procedures *)
                 state! : INTEGER;
               STATIC
                 SIGN!          = 2;
                 UNINITIALIZED! = 0;
                 VERIFY!        = 3;
                 PROCEDURE getInstance*(p0 : java_lang.String;
                                        p1 : java_lang.String) : Signature;
                 PROCEDURE getInstance*(p0 : java_lang.String;
                                        p1 : Provider) : Signature;
                 PROCEDURE getInstance*(p0 : java_lang.String) : Signature;
                 PROCEDURE Init!(p0 : java_lang.String) : Signature,CONSTRUCTOR;
               END;

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

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

  SignedObject* = POINTER TO RECORD (java_lang.Object + java_io.Serializable)    (* Typebound Procedures *)
                  STATIC
                    PROCEDURE Init*(p0 : java_io.Serializable;
                                    p1 : PrivateKey;
                                    p2 : Signature) : SignedObject,CONSTRUCTOR;
                  END;

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

  Timestamp* = POINTER TO RECORD (java_lang.Object + java_io.Serializable)    (* Typebound Procedures *)
               STATIC
                 PROCEDURE Init*(p0 : java_util.Date;
                                 p1 : java_security_cert.CertPath) : Timestamp,CONSTRUCTOR;
               END;

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

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

  UnresolvedPermission* = POINTER TO RECORD (Permission + java_io.Serializable)    (* Typebound Procedures *)
                          STATIC
                            PROCEDURE Init*(    p0 : java_lang.String;
                                                p1 : java_lang.String;
                                                p2 : java_lang.String;
                                            IN  p3 : ARRAY OF java_security_cert.Certificate) : UnresolvedPermission,CONSTRUCTOR;
                          END;

  URIParameter* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + Policy$Parameters + javax_security_auth_login.Configuration$Parameters)    (* Typebound Procedures *)
                  STATIC
                    PROCEDURE Init*(p0 : java_net.URI) : URIParameter,CONSTRUCTOR;
                  END;




PROCEDURE (self:AccessControlContext) checkPermission*(p0 : Permission),NEW,EXTENSIBLE;

PROCEDURE (self:AccessControlContext) equals*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:AccessControlContext) getDomainCombiner*() : DomainCombiner,NEW,EXTENSIBLE;

PROCEDURE (self:AccessControlContext) hashCode*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:AccessControlException) getPermission*() : Permission,NEW,EXTENSIBLE;

PROCEDURE (self:AlgorithmParameterGenerator) generateParameters*() : AlgorithmParameters,NEW;

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

PROCEDURE (self:AlgorithmParameterGenerator) getProvider*() : Provider,NEW;

PROCEDURE (self:AlgorithmParameterGenerator) init*(p0 : java_security_spec.AlgorithmParameterSpec;
                                                   p1 : SecureRandom),NEW;

PROCEDURE (self:AlgorithmParameterGenerator) init*(p0 : java_security_spec.AlgorithmParameterSpec),NEW;

PROCEDURE (self:AlgorithmParameterGenerator) init*(p0 : INTEGER),NEW;

PROCEDURE (self:AlgorithmParameterGenerator) init*(p0 : INTEGER;
                                                   p1 : SecureRandom),NEW;

PROCEDURE (self:AlgorithmParameterGeneratorSpi) engineGenerateParameters!() : AlgorithmParameters,NEW,ABSTRACT;

PROCEDURE (self:AlgorithmParameterGeneratorSpi) engineInit!(p0 : java_security_spec.AlgorithmParameterSpec;
                                                            p1 : SecureRandom),NEW,ABSTRACT;

PROCEDURE (self:AlgorithmParameterGeneratorSpi) engineInit!(p0 : INTEGER;
                                                            p1 : SecureRandom),NEW,ABSTRACT;

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

PROCEDURE (self:AlgorithmParameters) getEncoded*() : POINTER TO ARRAY OF BYTE,NEW;

PROCEDURE (self:AlgorithmParameters) getEncoded*(p0 : java_lang.String) : POINTER TO ARRAY OF BYTE,NEW;

PROCEDURE (self:AlgorithmParameters) getParameterSpec*(p0 : java_lang.Class) : java_security_spec.AlgorithmParameterSpec,NEW;

PROCEDURE (self:AlgorithmParameters) getProvider*() : Provider,NEW;

PROCEDURE (self:AlgorithmParameters) init*(p0 : java_security_spec.AlgorithmParameterSpec),NEW;

PROCEDURE (self:AlgorithmParameters) init*(IN  p0 : ARRAY OF BYTE),NEW;

PROCEDURE (self:AlgorithmParameters) init*(IN  p0 : ARRAY OF BYTE;
                                               p1 : java_lang.String),NEW;

PROCEDURE (self:AlgorithmParameters) toString*() : java_lang.String;

PROCEDURE (self:AlgorithmParametersSpi) engineGetEncoded!() : POINTER TO ARRAY OF BYTE,NEW,ABSTRACT;

PROCEDURE (self:AlgorithmParametersSpi) engineGetEncoded!(p0 : java_lang.String) : POINTER TO ARRAY OF BYTE,NEW,ABSTRACT;

PROCEDURE (self:AlgorithmParametersSpi) engineGetParameterSpec!(p0 : java_lang.Class) : java_security_spec.AlgorithmParameterSpec,NEW,ABSTRACT;

PROCEDURE (self:AlgorithmParametersSpi) engineInit!(p0 : java_security_spec.AlgorithmParameterSpec),NEW,ABSTRACT;

PROCEDURE (self:AlgorithmParametersSpi) engineInit!(IN  p0 : ARRAY OF BYTE),NEW,ABSTRACT;

PROCEDURE (self:AlgorithmParametersSpi) engineInit!(IN  p0 : ARRAY OF BYTE;
                                                        p1 : java_lang.String),NEW,ABSTRACT;

PROCEDURE (self:AlgorithmParametersSpi) engineToString!() : java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:AllPermission) equals*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:AllPermission) getActions*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:AllPermission) hashCode*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:AllPermission) implies*(p0 : Permission) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:AllPermission) newPermissionCollection*() : PermissionCollection,EXTENSIBLE;

PROCEDURE (self:AuthProvider) login*(p0 : javax_security_auth.Subject;
                                     p1 : javax_security_auth_callback.CallbackHandler),NEW,ABSTRACT;

PROCEDURE (self:AuthProvider) logout*(),NEW,ABSTRACT;

PROCEDURE (self:AuthProvider) setCallbackHandler*(p0 : javax_security_auth_callback.CallbackHandler),NEW,ABSTRACT;

PROCEDURE (self:BasicPermission) equals*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:BasicPermission) getActions*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:BasicPermission) hashCode*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:BasicPermission) implies*(p0 : Permission) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:BasicPermission) newPermissionCollection*() : PermissionCollection,EXTENSIBLE;

PROCEDURE (self:Certificate) decode*(p0 : java_io.InputStream),NEW,ABSTRACT;

PROCEDURE (self:Certificate) encode*(p0 : java_io.OutputStream),NEW,ABSTRACT;

PROCEDURE (self:Certificate) getFormat*() : java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:Certificate) getGuarantor*() : Principal,NEW,ABSTRACT;

PROCEDURE (self:Certificate) getPrincipal*() : Principal,NEW,ABSTRACT;

PROCEDURE (self:Certificate) getPublicKey*() : PublicKey,NEW,ABSTRACT;

PROCEDURE (self:Certificate) toString*(p0 : BOOLEAN) : java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:CodeSigner) equals*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:CodeSigner) getSignerCertPath*() : java_security_cert.CertPath,NEW,EXTENSIBLE;

PROCEDURE (self:CodeSigner) getTimestamp*() : Timestamp,NEW,EXTENSIBLE;

PROCEDURE (self:CodeSigner) hashCode*() : INTEGER,EXTENSIBLE;

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

PROCEDURE (self:CodeSource) equals*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:CodeSource) getCertificates*() : POINTER TO ARRAY OF java_security_cert.Certificate,NEW;

PROCEDURE (self:CodeSource) getCodeSigners*() : POINTER TO ARRAY OF CodeSigner,NEW;

PROCEDURE (self:CodeSource) getLocation*() : java_net.URL,NEW;

PROCEDURE (self:CodeSource) hashCode*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:CodeSource) implies*(p0 : CodeSource) : BOOLEAN,NEW,EXTENSIBLE;

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

PROCEDURE (self:DigestInputStream) getMessageDigest*() : MessageDigest,NEW,EXTENSIBLE;

PROCEDURE (self:DigestInputStream) on*(p0 : BOOLEAN),NEW,EXTENSIBLE;

PROCEDURE (self:DigestInputStream) read*(IN  p0 : ARRAY OF BYTE;
                                             p1 : INTEGER;
                                             p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:DigestInputStream) read*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:DigestInputStream) setMessageDigest*(p0 : MessageDigest),NEW,EXTENSIBLE;

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

PROCEDURE (self:DigestOutputStream) getMessageDigest*() : MessageDigest,NEW,EXTENSIBLE;

PROCEDURE (self:DigestOutputStream) on*(p0 : BOOLEAN),NEW,EXTENSIBLE;

PROCEDURE (self:DigestOutputStream) setMessageDigest*(p0 : MessageDigest),NEW,EXTENSIBLE;

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

PROCEDURE (self:DigestOutputStream) write*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:DigestOutputStream) write*(IN  p0 : ARRAY OF BYTE;
                                               p1 : INTEGER;
                                               p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:DomainCombiner) combine*(IN  p0 : ARRAY OF ProtectionDomain;
                                         IN  p1 : ARRAY OF ProtectionDomain) : POINTER TO ARRAY OF ProtectionDomain,NEW,ABSTRACT;

PROCEDURE (self:Guard) checkGuard*(p0 : java_lang.Object),NEW,ABSTRACT;

PROCEDURE (self:GuardedObject) getObject*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:Identity) addCertificate*(p0 : Certificate),NEW,EXTENSIBLE;

PROCEDURE (self:Identity) certificates*() : POINTER TO ARRAY OF Certificate,NEW,EXTENSIBLE;

PROCEDURE (self:Identity) equals*(p0 : java_lang.Object) : BOOLEAN;

PROCEDURE (self:Identity) getInfo*() : java_lang.String,NEW,EXTENSIBLE;

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

PROCEDURE (self:Identity) getPublicKey*() : PublicKey,NEW,EXTENSIBLE;

PROCEDURE (self:Identity) getScope*() : IdentityScope,NEW;

PROCEDURE (self:Identity) hashCode*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:Identity) identityEquals!(p0 : Identity) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Identity) removeCertificate*(p0 : Certificate),NEW,EXTENSIBLE;

PROCEDURE (self:Identity) setInfo*(p0 : java_lang.String),NEW,EXTENSIBLE;

PROCEDURE (self:Identity) setPublicKey*(p0 : PublicKey),NEW,EXTENSIBLE;

PROCEDURE (self:Identity) toString*(p0 : BOOLEAN) : java_lang.String,NEW,EXTENSIBLE;

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

PROCEDURE (self:IdentityScope) addIdentity*(p0 : Identity),NEW,ABSTRACT;

PROCEDURE (self:IdentityScope) getIdentity*(p0 : PublicKey) : Identity,NEW,ABSTRACT;

PROCEDURE (self:IdentityScope) getIdentity*(p0 : Principal) : Identity,NEW,EXTENSIBLE;

PROCEDURE (self:IdentityScope) getIdentity*(p0 : java_lang.String) : Identity,NEW,ABSTRACT;

PROCEDURE (self:IdentityScope) identities*() : java_util.Enumeration,NEW,ABSTRACT;

PROCEDURE (self:IdentityScope) removeIdentity*(p0 : Identity),NEW,ABSTRACT;

PROCEDURE (self:IdentityScope) size*() : INTEGER,NEW,ABSTRACT;

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

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

PROCEDURE (self:Key) getEncoded*() : POINTER TO ARRAY OF BYTE,NEW,ABSTRACT;

PROCEDURE (self:Key) getFormat*() : java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:KeyFactory) generatePrivate*(p0 : java_security_spec.KeySpec) : PrivateKey,NEW;

PROCEDURE (self:KeyFactory) generatePublic*(p0 : java_security_spec.KeySpec) : PublicKey,NEW;

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

PROCEDURE (self:KeyFactory) getKeySpec*(p0 : Key;
                                        p1 : java_lang.Class) : java_security_spec.KeySpec,NEW;

PROCEDURE (self:KeyFactory) getProvider*() : Provider,NEW;

PROCEDURE (self:KeyFactory) translateKey*(p0 : Key) : Key,NEW;

PROCEDURE (self:KeyFactorySpi) engineGeneratePrivate!(p0 : java_security_spec.KeySpec) : PrivateKey,NEW,ABSTRACT;

PROCEDURE (self:KeyFactorySpi) engineGeneratePublic!(p0 : java_security_spec.KeySpec) : PublicKey,NEW,ABSTRACT;

PROCEDURE (self:KeyFactorySpi) engineGetKeySpec!(p0 : Key;
                                                 p1 : java_lang.Class) : java_security_spec.KeySpec,NEW,ABSTRACT;

PROCEDURE (self:KeyFactorySpi) engineTranslateKey!(p0 : Key) : Key,NEW,ABSTRACT;

PROCEDURE (self:KeyPair) getPrivate*() : PrivateKey,NEW,EXTENSIBLE;

PROCEDURE (self:KeyPair) getPublic*() : PublicKey,NEW,EXTENSIBLE;

PROCEDURE (self:KeyPairGenerator) generateKeyPair*() : KeyPair,EXTENSIBLE;

PROCEDURE (self:KeyPairGenerator) genKeyPair*() : KeyPair,NEW;

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

PROCEDURE (self:KeyPairGenerator) getProvider*() : Provider,NEW;

PROCEDURE (self:KeyPairGenerator) initialize*(p0 : java_security_spec.AlgorithmParameterSpec;
                                              p1 : SecureRandom),EXTENSIBLE;

PROCEDURE (self:KeyPairGenerator) initialize*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:KeyPairGenerator) initialize*(p0 : INTEGER;
                                              p1 : SecureRandom),EXTENSIBLE;

PROCEDURE (self:KeyPairGenerator) initialize*(p0 : java_security_spec.AlgorithmParameterSpec),NEW,EXTENSIBLE;

PROCEDURE (self:KeyPairGeneratorSpi) generateKeyPair*() : KeyPair,NEW,ABSTRACT;

PROCEDURE (self:KeyPairGeneratorSpi) initialize*(p0 : java_security_spec.AlgorithmParameterSpec;
                                                 p1 : SecureRandom),NEW,EXTENSIBLE;

PROCEDURE (self:KeyPairGeneratorSpi) initialize*(p0 : INTEGER;
                                                 p1 : SecureRandom),NEW,ABSTRACT;

PROCEDURE (self:KeyRep) readResolve!() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:KeyStore) aliases*() : java_util.Enumeration,NEW;

PROCEDURE (self:KeyStore) containsAlias*(p0 : java_lang.String) : BOOLEAN,NEW;

PROCEDURE (self:KeyStore) deleteEntry*(p0 : java_lang.String),NEW;

PROCEDURE (self:KeyStore) entryInstanceOf*(p0 : java_lang.String;
                                           p1 : java_lang.Class) : BOOLEAN,NEW;

PROCEDURE (self:KeyStore) getCertificate*(p0 : java_lang.String) : java_security_cert.Certificate,NEW;

PROCEDURE (self:KeyStore) getCertificateAlias*(p0 : java_security_cert.Certificate) : java_lang.String,NEW;

PROCEDURE (self:KeyStore) getCertificateChain*(p0 : java_lang.String) : POINTER TO ARRAY OF java_security_cert.Certificate,NEW;

PROCEDURE (self:KeyStore) getCreationDate*(p0 : java_lang.String) : java_util.Date,NEW;

PROCEDURE (self:KeyStore) getEntry*(p0 : java_lang.String;
                                    p1 : KeyStore$ProtectionParameter) : KeyStore$Entry,NEW;

PROCEDURE (self:KeyStore) getKey*(    p0 : java_lang.String;
                                  IN  p1 : ARRAY OF CHAR) : Key,NEW;

PROCEDURE (self:KeyStore) getProvider*() : Provider,NEW;

PROCEDURE (self:KeyStore) getType*() : java_lang.String,NEW;

PROCEDURE (self:KeyStore) isCertificateEntry*(p0 : java_lang.String) : BOOLEAN,NEW;

PROCEDURE (self:KeyStore) isKeyEntry*(p0 : java_lang.String) : BOOLEAN,NEW;

PROCEDURE (self:KeyStore) load*(    p0 : java_io.InputStream;
                                IN  p1 : ARRAY OF CHAR),NEW;

PROCEDURE (self:KeyStore) load*(p0 : KeyStore$LoadStoreParameter),NEW;

PROCEDURE (self:KeyStore) setCertificateEntry*(p0 : java_lang.String;
                                               p1 : java_security_cert.Certificate),NEW;

PROCEDURE (self:KeyStore) setEntry*(p0 : java_lang.String;
                                    p1 : KeyStore$Entry;
                                    p2 : KeyStore$ProtectionParameter),NEW;

PROCEDURE (self:KeyStore) setKeyEntry*(    p0 : java_lang.String;
                                       IN  p1 : ARRAY OF BYTE;
                                       IN  p2 : ARRAY OF java_security_cert.Certificate),NEW;

PROCEDURE (self:KeyStore) setKeyEntry*(    p0 : java_lang.String;
                                           p1 : Key;
                                       IN  p2 : ARRAY OF CHAR;
                                       IN  p3 : ARRAY OF java_security_cert.Certificate),NEW;

PROCEDURE (self:KeyStore) size*() : INTEGER,NEW;

PROCEDURE (self:KeyStore) store*(    p0 : java_io.OutputStream;
                                 IN  p1 : ARRAY OF CHAR),NEW;

PROCEDURE (self:KeyStore) store*(p0 : KeyStore$LoadStoreParameter),NEW;

PROCEDURE (self:KeyStore$Builder) getKeyStore*() : KeyStore,NEW,ABSTRACT;

PROCEDURE (self:KeyStore$Builder) getProtectionParameter*(p0 : java_lang.String) : KeyStore$ProtectionParameter,NEW,ABSTRACT;

PROCEDURE (self:KeyStore$CallbackHandlerProtection) getCallbackHandler*() : javax_security_auth_callback.CallbackHandler,NEW,EXTENSIBLE;

PROCEDURE (self:KeyStore$LoadStoreParameter) getProtectionParameter*() : KeyStore$ProtectionParameter,NEW,ABSTRACT;

PROCEDURE (self:KeyStore$PasswordProtection) destroy*(),NEW,EXTENSIBLE;

PROCEDURE (self:KeyStore$PasswordProtection) getPassword*() : POINTER TO ARRAY OF CHAR,NEW,EXTENSIBLE;

PROCEDURE (self:KeyStore$PasswordProtection) isDestroyed*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:KeyStore$PrivateKeyEntry) getCertificate*() : java_security_cert.Certificate,NEW,EXTENSIBLE;

PROCEDURE (self:KeyStore$PrivateKeyEntry) getCertificateChain*() : POINTER TO ARRAY OF java_security_cert.Certificate,NEW,EXTENSIBLE;

PROCEDURE (self:KeyStore$PrivateKeyEntry) getPrivateKey*() : PrivateKey,NEW,EXTENSIBLE;

PROCEDURE (self:KeyStore$PrivateKeyEntry) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:KeyStore$SecretKeyEntry) getSecretKey*() : javax_crypto.SecretKey,NEW,EXTENSIBLE;

PROCEDURE (self:KeyStore$SecretKeyEntry) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:KeyStore$TrustedCertificateEntry) getTrustedCertificate*() : java_security_cert.Certificate,NEW,EXTENSIBLE;

PROCEDURE (self:KeyStore$TrustedCertificateEntry) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:KeyStoreSpi) engineAliases*() : java_util.Enumeration,NEW,ABSTRACT;

PROCEDURE (self:KeyStoreSpi) engineContainsAlias*(p0 : java_lang.String) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:KeyStoreSpi) engineDeleteEntry*(p0 : java_lang.String),NEW,ABSTRACT;

PROCEDURE (self:KeyStoreSpi) engineEntryInstanceOf*(p0 : java_lang.String;
                                                    p1 : java_lang.Class) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:KeyStoreSpi) engineGetCertificate*(p0 : java_lang.String) : java_security_cert.Certificate,NEW,ABSTRACT;

PROCEDURE (self:KeyStoreSpi) engineGetCertificateAlias*(p0 : java_security_cert.Certificate) : java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:KeyStoreSpi) engineGetCertificateChain*(p0 : java_lang.String) : POINTER TO ARRAY OF java_security_cert.Certificate,NEW,ABSTRACT;

PROCEDURE (self:KeyStoreSpi) engineGetCreationDate*(p0 : java_lang.String) : java_util.Date,NEW,ABSTRACT;

PROCEDURE (self:KeyStoreSpi) engineGetEntry*(p0 : java_lang.String;
                                             p1 : KeyStore$ProtectionParameter) : KeyStore$Entry,NEW,EXTENSIBLE;

PROCEDURE (self:KeyStoreSpi) engineGetKey*(    p0 : java_lang.String;
                                           IN  p1 : ARRAY OF CHAR) : Key,NEW,ABSTRACT;

PROCEDURE (self:KeyStoreSpi) engineIsCertificateEntry*(p0 : java_lang.String) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:KeyStoreSpi) engineIsKeyEntry*(p0 : java_lang.String) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:KeyStoreSpi) engineLoad*(    p0 : java_io.InputStream;
                                         IN  p1 : ARRAY OF CHAR),NEW,ABSTRACT;

PROCEDURE (self:KeyStoreSpi) engineLoad*(p0 : KeyStore$LoadStoreParameter),NEW,EXTENSIBLE;

PROCEDURE (self:KeyStoreSpi) engineSetCertificateEntry*(p0 : java_lang.String;
                                                        p1 : java_security_cert.Certificate),NEW,ABSTRACT;

PROCEDURE (self:KeyStoreSpi) engineSetEntry*(p0 : java_lang.String;
                                             p1 : KeyStore$Entry;
                                             p2 : KeyStore$ProtectionParameter),NEW,EXTENSIBLE;

PROCEDURE (self:KeyStoreSpi) engineSetKeyEntry*(    p0 : java_lang.String;
                                                    p1 : Key;
                                                IN  p2 : ARRAY OF CHAR;
                                                IN  p3 : ARRAY OF java_security_cert.Certificate),NEW,ABSTRACT;

PROCEDURE (self:KeyStoreSpi) engineSetKeyEntry*(    p0 : java_lang.String;
                                                IN  p1 : ARRAY OF BYTE;
                                                IN  p2 : ARRAY OF java_security_cert.Certificate),NEW,ABSTRACT;

PROCEDURE (self:KeyStoreSpi) engineSize*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:KeyStoreSpi) engineStore*(    p0 : java_io.OutputStream;
                                          IN  p1 : ARRAY OF CHAR),NEW,ABSTRACT;

PROCEDURE (self:KeyStoreSpi) engineStore*(p0 : KeyStore$LoadStoreParameter),NEW,EXTENSIBLE;

PROCEDURE (self:MessageDigest) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:MessageDigest) digest*() : POINTER TO ARRAY OF BYTE,NEW,EXTENSIBLE;

PROCEDURE (self:MessageDigest) digest*(IN  p0 : ARRAY OF BYTE;
                                           p1 : INTEGER;
                                           p2 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:MessageDigest) digest*(IN  p0 : ARRAY OF BYTE) : POINTER TO ARRAY OF BYTE,NEW,EXTENSIBLE;

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

PROCEDURE (self:MessageDigest) getDigestLength*() : INTEGER,NEW;

PROCEDURE (self:MessageDigest) getProvider*() : Provider,NEW;

PROCEDURE (self:MessageDigest) reset*(),NEW,EXTENSIBLE;

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

PROCEDURE (self:MessageDigest) update*(IN  p0 : ARRAY OF BYTE),NEW,EXTENSIBLE;

PROCEDURE (self:MessageDigest) update*(p0 : java_nio.ByteBuffer),NEW;

PROCEDURE (self:MessageDigest) update*(p0 : BYTE),NEW,EXTENSIBLE;

PROCEDURE (self:MessageDigest) update*(IN  p0 : ARRAY OF BYTE;
                                           p1 : INTEGER;
                                           p2 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:MessageDigestSpi) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:MessageDigestSpi) engineDigest!(IN  p0 : ARRAY OF BYTE;
                                                    p1 : INTEGER;
                                                    p2 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:MessageDigestSpi) engineDigest!() : POINTER TO ARRAY OF BYTE,NEW,ABSTRACT;

PROCEDURE (self:MessageDigestSpi) engineGetDigestLength!() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:MessageDigestSpi) engineReset!(),NEW,ABSTRACT;

PROCEDURE (self:MessageDigestSpi) engineUpdate!(p0 : BYTE),NEW,ABSTRACT;

PROCEDURE (self:MessageDigestSpi) engineUpdate!(IN  p0 : ARRAY OF BYTE;
                                                    p1 : INTEGER;
                                                    p2 : INTEGER),NEW,ABSTRACT;

PROCEDURE (self:MessageDigestSpi) engineUpdate!(p0 : java_nio.ByteBuffer),NEW,EXTENSIBLE;

PROCEDURE (self:Permission) checkGuard*(p0 : java_lang.Object),NEW,EXTENSIBLE;

PROCEDURE (self:Permission) equals*(p0 : java_lang.Object) : BOOLEAN,ABSTRACT;

PROCEDURE (self:Permission) getActions*() : java_lang.String,NEW,ABSTRACT;

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

PROCEDURE (self:Permission) hashCode*() : INTEGER,ABSTRACT;

PROCEDURE (self:Permission) implies*(p0 : Permission) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Permission) newPermissionCollection*() : PermissionCollection,NEW,EXTENSIBLE;

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

PROCEDURE (self:PermissionCollection) add*(p0 : Permission),NEW,ABSTRACT;

PROCEDURE (self:PermissionCollection) elements*() : java_util.Enumeration,NEW,ABSTRACT;

PROCEDURE (self:PermissionCollection) implies*(p0 : Permission) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:PermissionCollection) isReadOnly*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:PermissionCollection) setReadOnly*(),NEW,EXTENSIBLE;

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

PROCEDURE (self:Permissions) add*(p0 : Permission),EXTENSIBLE;

PROCEDURE (self:Permissions) elements*() : java_util.Enumeration,EXTENSIBLE;

PROCEDURE (self:Permissions) implies*(p0 : Permission) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Policy) getParameters*() : Policy$Parameters,NEW,EXTENSIBLE;

PROCEDURE (self:Policy) getPermissions*(p0 : CodeSource) : PermissionCollection,NEW,EXTENSIBLE;

PROCEDURE (self:Policy) getPermissions*(p0 : ProtectionDomain) : PermissionCollection,NEW,EXTENSIBLE;

PROCEDURE (self:Policy) getProvider*() : Provider,NEW,EXTENSIBLE;

PROCEDURE (self:Policy) getType*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Policy) implies*(p0 : ProtectionDomain;
                                 p1 : Permission) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Policy) refresh*(),NEW,EXTENSIBLE;

PROCEDURE (self:PolicySpi) engineGetPermissions!(p0 : CodeSource) : PermissionCollection,NEW,EXTENSIBLE;

PROCEDURE (self:PolicySpi) engineGetPermissions!(p0 : ProtectionDomain) : PermissionCollection,NEW,EXTENSIBLE;

PROCEDURE (self:PolicySpi) engineImplies!(p0 : ProtectionDomain;
                                          p1 : Permission) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:PolicySpi) engineRefresh!(),NEW,EXTENSIBLE;

PROCEDURE (self:Principal) equals*(p0 : java_lang.Object) : BOOLEAN,ABSTRACT;

PROCEDURE (self:Principal) getName*() : java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:Principal) hashCode*() : INTEGER,ABSTRACT;

PROCEDURE (self:Principal) toString*() : java_lang.String,ABSTRACT;

PROCEDURE (self:PrivilegedAction) run*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:PrivilegedActionException) getCause*() : java_lang.Throwable,EXTENSIBLE;

PROCEDURE (self:PrivilegedActionException) getException*() : java_lang.Exception,NEW,EXTENSIBLE;

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

PROCEDURE (self:PrivilegedExceptionAction) run*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:ProtectionDomain) getClassLoader*() : java_lang.ClassLoader,NEW;

PROCEDURE (self:ProtectionDomain) getCodeSource*() : CodeSource,NEW;

PROCEDURE (self:ProtectionDomain) getPermissions*() : PermissionCollection,NEW;

PROCEDURE (self:ProtectionDomain) getPrincipals*() : POINTER TO ARRAY OF Principal,NEW;

PROCEDURE (self:ProtectionDomain) implies*(p0 : Permission) : BOOLEAN,NEW,EXTENSIBLE;

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

PROCEDURE (self:Provider) clear*(),EXTENSIBLE;

PROCEDURE (self:Provider) elements*() : java_util.Enumeration,EXTENSIBLE;

PROCEDURE (self:Provider) entrySet*() : java_util.Set,EXTENSIBLE;

PROCEDURE (self:Provider) get*(p0 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:Provider) getInfo*() : java_lang.String,NEW,EXTENSIBLE;

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

PROCEDURE (self:Provider) getProperty*(p0 : java_lang.String) : java_lang.String,EXTENSIBLE;

PROCEDURE (self:Provider) getService*(p0 : java_lang.String;
                                      p1 : java_lang.String) : Provider$Service,NEW,EXTENSIBLE;

PROCEDURE (self:Provider) getServices*() : java_util.Set,NEW,EXTENSIBLE;

PROCEDURE (self:Provider) getVersion*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:Provider) keys*() : java_util.Enumeration,EXTENSIBLE;

PROCEDURE (self:Provider) keySet*() : java_util.Set,EXTENSIBLE;

PROCEDURE (self:Provider) load*(p0 : java_io.InputStream),EXTENSIBLE;

PROCEDURE (self:Provider) put*(p0 : java_lang.Object;
                               p1 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:Provider) putAll*(p0 : java_util.Map),EXTENSIBLE;

PROCEDURE (self:Provider) putService!(p0 : Provider$Service),NEW,EXTENSIBLE;

PROCEDURE (self:Provider) remove*(p0 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:Provider) removeService!(p0 : Provider$Service),NEW,EXTENSIBLE;

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

PROCEDURE (self:Provider) values*() : java_util.Collection,EXTENSIBLE;

PROCEDURE (self:Provider$Service) getAlgorithm*() : java_lang.String,NEW;

PROCEDURE (self:Provider$Service) getAttribute*(p0 : java_lang.String) : java_lang.String,NEW;

PROCEDURE (self:Provider$Service) getClassName*() : java_lang.String,NEW;

PROCEDURE (self:Provider$Service) getProvider*() : Provider,NEW;

PROCEDURE (self:Provider$Service) getType*() : java_lang.String,NEW;

PROCEDURE (self:Provider$Service) newInstance*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:Provider$Service) supportsParameter*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Provider$Service) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:SecureClassLoader) defineClass!(p0 : java_lang.String;
                                                p1 : java_nio.ByteBuffer;
                                                p2 : CodeSource) : java_lang.Class,NEW;

PROCEDURE (self:SecureClassLoader) defineClass!(    p0 : java_lang.String;
                                                IN  p1 : ARRAY OF BYTE;
                                                    p2 : INTEGER;
                                                    p3 : INTEGER;
                                                    p4 : CodeSource) : java_lang.Class,NEW;

PROCEDURE (self:SecureClassLoader) getPermissions!(p0 : CodeSource) : PermissionCollection,NEW,EXTENSIBLE;

PROCEDURE (self:SecureRandom) generateSeed*(p0 : INTEGER) : POINTER TO ARRAY OF BYTE,NEW,EXTENSIBLE;

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

PROCEDURE (self:SecureRandom) getProvider*() : Provider,NEW;

PROCEDURE (self:SecureRandom) next!(p0 : INTEGER) : INTEGER;

PROCEDURE (self:SecureRandom) nextBytes*(IN  p0 : ARRAY OF BYTE),EXTENSIBLE;

PROCEDURE (self:SecureRandom) setSeed*(IN  p0 : ARRAY OF BYTE),NEW,EXTENSIBLE;

PROCEDURE (self:SecureRandom) setSeed*(p0 : LONGINT),EXTENSIBLE;

PROCEDURE (self:SecureRandomSpi) engineGenerateSeed!(p0 : INTEGER) : POINTER TO ARRAY OF BYTE,NEW,ABSTRACT;

PROCEDURE (self:SecureRandomSpi) engineNextBytes!(IN  p0 : ARRAY OF BYTE),NEW,ABSTRACT;

PROCEDURE (self:SecureRandomSpi) engineSetSeed!(IN  p0 : ARRAY OF BYTE),NEW,ABSTRACT;

PROCEDURE (self:Signature) clone*() : java_lang.Object,EXTENSIBLE;

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

PROCEDURE (self:Signature) getParameter*(p0 : java_lang.String) : java_lang.Object,NEW;

PROCEDURE (self:Signature) getParameters*() : AlgorithmParameters,NEW;

PROCEDURE (self:Signature) getProvider*() : Provider,NEW;

PROCEDURE (self:Signature) initSign*(p0 : PrivateKey),NEW;

PROCEDURE (self:Signature) initSign*(p0 : PrivateKey;
                                     p1 : SecureRandom),NEW;

PROCEDURE (self:Signature) initVerify*(p0 : java_security_cert.Certificate),NEW;

PROCEDURE (self:Signature) initVerify*(p0 : PublicKey),NEW;

PROCEDURE (self:Signature) setParameter*(p0 : java_security_spec.AlgorithmParameterSpec),NEW;

PROCEDURE (self:Signature) setParameter*(p0 : java_lang.String;
                                         p1 : java_lang.Object),NEW;

PROCEDURE (self:Signature) sign*() : POINTER TO ARRAY OF BYTE,NEW;

PROCEDURE (self:Signature) sign*(IN  p0 : ARRAY OF BYTE;
                                     p1 : INTEGER;
                                     p2 : INTEGER) : INTEGER,NEW;

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

PROCEDURE (self:Signature) update*(IN  p0 : ARRAY OF BYTE),NEW;

PROCEDURE (self:Signature) update*(p0 : BYTE),NEW;

PROCEDURE (self:Signature) update*(p0 : java_nio.ByteBuffer),NEW;

PROCEDURE (self:Signature) update*(IN  p0 : ARRAY OF BYTE;
                                       p1 : INTEGER;
                                       p2 : INTEGER),NEW;

PROCEDURE (self:Signature) verify*(IN  p0 : ARRAY OF BYTE) : BOOLEAN,NEW;

PROCEDURE (self:Signature) verify*(IN  p0 : ARRAY OF BYTE;
                                       p1 : INTEGER;
                                       p2 : INTEGER) : BOOLEAN,NEW;

PROCEDURE (self:SignatureSpi) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:SignatureSpi) engineGetParameter!(p0 : java_lang.String) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:SignatureSpi) engineGetParameters!() : AlgorithmParameters,NEW,EXTENSIBLE;

PROCEDURE (self:SignatureSpi) engineInitSign!(p0 : PrivateKey),NEW,ABSTRACT;

PROCEDURE (self:SignatureSpi) engineInitSign!(p0 : PrivateKey;
                                              p1 : SecureRandom),NEW,EXTENSIBLE;

PROCEDURE (self:SignatureSpi) engineInitVerify!(p0 : PublicKey),NEW,ABSTRACT;

PROCEDURE (self:SignatureSpi) engineSetParameter!(p0 : java_lang.String;
                                                  p1 : java_lang.Object),NEW,ABSTRACT;

PROCEDURE (self:SignatureSpi) engineSetParameter!(p0 : java_security_spec.AlgorithmParameterSpec),NEW,EXTENSIBLE;

PROCEDURE (self:SignatureSpi) engineSign!(IN  p0 : ARRAY OF BYTE;
                                              p1 : INTEGER;
                                              p2 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:SignatureSpi) engineSign!() : POINTER TO ARRAY OF BYTE,NEW,ABSTRACT;

PROCEDURE (self:SignatureSpi) engineUpdate!(IN  p0 : ARRAY OF BYTE;
                                                p1 : INTEGER;
                                                p2 : INTEGER),NEW,ABSTRACT;

PROCEDURE (self:SignatureSpi) engineUpdate!(p0 : BYTE),NEW,ABSTRACT;

PROCEDURE (self:SignatureSpi) engineUpdate!(p0 : java_nio.ByteBuffer),NEW,EXTENSIBLE;

PROCEDURE (self:SignatureSpi) engineVerify!(IN  p0 : ARRAY OF BYTE;
                                                p1 : INTEGER;
                                                p2 : INTEGER) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:SignatureSpi) engineVerify!(IN  p0 : ARRAY OF BYTE) : BOOLEAN,NEW,ABSTRACT;

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

PROCEDURE (self:SignedObject) getObject*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:SignedObject) getSignature*() : POINTER TO ARRAY OF BYTE,NEW,EXTENSIBLE;

PROCEDURE (self:SignedObject) verify*(p0 : PublicKey;
                                      p1 : Signature) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Signer) getPrivateKey*() : PrivateKey,NEW,EXTENSIBLE;

PROCEDURE (self:Signer) setKeyPair*(p0 : KeyPair),NEW;

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

PROCEDURE (self:Timestamp) equals*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Timestamp) getSignerCertPath*() : java_security_cert.CertPath,NEW,EXTENSIBLE;

PROCEDURE (self:Timestamp) getTimestamp*() : java_util.Date,NEW,EXTENSIBLE;

PROCEDURE (self:Timestamp) hashCode*() : INTEGER,EXTENSIBLE;

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

PROCEDURE (self:UnresolvedPermission) equals*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:UnresolvedPermission) getActions*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:UnresolvedPermission) getUnresolvedActions*() : java_lang.String,NEW,EXTENSIBLE;

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

PROCEDURE (self:UnresolvedPermission) getUnresolvedName*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:UnresolvedPermission) getUnresolvedType*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:UnresolvedPermission) hashCode*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:UnresolvedPermission) implies*(p0 : Permission) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:UnresolvedPermission) newPermissionCollection*() : PermissionCollection,EXTENSIBLE;

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

PROCEDURE (self:URIParameter) getURI*() : java_net.URI,NEW,EXTENSIBLE;

END java_security.