FOREIGN MODULE java_security;

IMPORT
    sun_security_util,
    java_lang,
    java_io,
    java_security_spec,
    java_util,
    java_net,
    java_security_cert,
    sun_misc;

TYPE

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

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

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

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

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

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

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

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

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

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

  CodeSource* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + java_io.Serializable)
                STATIC
                  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*() : DigestException,CONSTRUCTOR;
                       PROCEDURE Init*(p0 : java_lang.String) : DigestException,CONSTRUCTOR;
                     END;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  PermissionCollection* = POINTER TO ABSTRACT RECORD (java_lang.Object + java_awt.Insets)
                          STATIC
                            PROCEDURE Init*() : PermissionCollection,CONSTRUCTOR;
                          END;

  Permissions* = POINTER TO RECORD (PermissionCollection + java_awt.Insets)
                 STATIC
                   PROCEDURE Init*() : Permissions,CONSTRUCTOR;
                 END;

  Policy* = POINTER TO ABSTRACT RECORD (java_lang.Object)
            STATIC
              PROCEDURE Init*() : Policy,CONSTRUCTOR;
              PROCEDURE getPolicy*() : Policy;
              PROCEDURE setPolicy*(p0 : Policy);
            END;

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

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

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

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

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

  ProtectionDomain* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)
                      STATIC
                        PROCEDURE Init*(p0 : CodeSource;
                                        p1 : PermissionCollection) : ProtectionDomain,CONSTRUCTOR;
                      END;

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

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

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

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

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

  SecureRandomSpi* = POINTER TO ABSTRACT RECORD (java_lang.Object + java_awt.Insets)
                     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 getProperty*(p0 : java_lang.String) : java_lang.String;
                PROCEDURE getProvider*(p0 : java_lang.String) : 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) : SecurityPermission,CONSTRUCTOR;
                          PROCEDURE Init*(p0 : java_lang.String;
                                          p1 : java_lang.String) : SecurityPermission,CONSTRUCTOR;
                        END;

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

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

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

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

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

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

  UnresolvedPermission* = POINTER TO RECORD (Permission + java_awt.Insets)
                          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;




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

PROCEDURE (self:AccessControlContext) equals*(p0 : java_lang.Object) : BOOLEAN,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 : INTEGER),NEW;

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

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

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

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

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

PROCEDURE (self:AlgorithmParameterGeneratorSpi) engineInit!(p0 : java_security_spec.AlgorithmParameterSpec;
                                                            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: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:CodeSource) equals*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:CodeSource) getCertificates*() : POINTER TO ARRAY OF java_security_cert.Certificate,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*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:DigestInputStream) read*(IN  p0 : ARRAY OF BYTE;
                                             p1 : INTEGER;
                                             p2 : INTEGER) : 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: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*() : java_lang.String,EXTENSIBLE;

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

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

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

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

PROCEDURE (self:IdentityScope) getIdentity*(p0 : PublicKey) : 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) genKeyPair*() : KeyPair,NEW;

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

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

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:KeyPairGenerator) initialize*(p0 : java_security_spec.AlgorithmParameterSpec;
                                              p1 : SecureRandom),EXTENSIBLE;

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

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

PROCEDURE (self:KeyPairGeneratorSpi) initialize*(p0 : java_security_spec.AlgorithmParameterSpec;
                                                 p1 : SecureRandom),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) 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) 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) setCertificateEntry*(p0 : java_lang.String;
                                               p1 : 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) setKeyEntry*(    p0 : java_lang.String;
                                       IN  p1 : ARRAY OF BYTE;
                                       IN  p2 : 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: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) 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) 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) engineSetCertificateEntry*(p0 : java_lang.String;
                                                        p1 : java_security_cert.Certificate),NEW,ABSTRACT;

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: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) : 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) 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*(p0 : BYTE),NEW,EXTENSIBLE;

PROCEDURE (self:MessageDigest) update*(IN  p0 : ARRAY OF 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!() : POINTER TO ARRAY OF BYTE,NEW,ABSTRACT;

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

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: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) getPermissions*(p0 : CodeSource) : PermissionCollection,NEW,ABSTRACT;

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

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) getException*() : java_lang.Exception,NEW,EXTENSIBLE;

PROCEDURE (self:PrivilegedActionException) printStackTrace*(),EXTENSIBLE;

PROCEDURE (self:PrivilegedActionException) printStackTrace*(p0 : java_io.PrintStream),EXTENSIBLE;

PROCEDURE (self:PrivilegedActionException) printStackTrace*(p0 : java_io.PrintWriter),EXTENSIBLE;

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

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

PROCEDURE (self:ProtectionDomain) getPermissions*() : PermissionCollection,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) entrySet*() : java_util.Set,EXTENSIBLE;

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

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

PROCEDURE (self:Provider) getVersion*() : REAL,NEW,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) remove*(p0 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

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

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

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) getProvider*() : Provider,NEW;

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

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

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

PROCEDURE (self:SecureRandom) setSeed*(IN  p0 : ARRAY OF BYTE),NEW,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) getProvider*() : Provider,NEW;

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

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

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

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

PROCEDURE (self:Signature) setParameter*(p0 : java_security_spec.AlgorithmParameterSpec),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*(p0 : BYTE),NEW;

PROCEDURE (self:Signature) update*(IN  p0 : ARRAY OF BYTE),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:SignatureSpi) clone*() : java_lang.Object,EXTENSIBLE;

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

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!() : POINTER TO ARRAY OF BYTE,NEW,ABSTRACT;

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

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

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

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:UnresolvedPermission) equals*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:UnresolvedPermission) getActions*() : java_lang.String,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;

END java_security.