FOREIGN MODULE javax_crypto;

IMPORT
    java_lang := "java.lang",
    java_security := "java.security",
    java_io := "java.io",
    java_util := "java.util",
    sun_security_util := "sun.security.util",
    java_security_spec := "java.security.spec",
    java_security_cert := "java.security.cert",
    java_nio := "java.nio",
    sun_security_x509 := "sun.security.x509",
    sun_security_validator := "sun.security.validator",
    java_net := "java.net",
    sun_security_jca := "sun.security.jca",
    java_util_jar := "java.util.jar";

TYPE

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

  Cipher* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)    (* Typebound Procedures *)
            STATIC
              DECRYPT_MODE*               = 2;
              ENCRYPT_MODE*               = 1;
              PRIVATE_KEY*                = 2;
              PUBLIC_KEY*                 = 1;
              SECRET_KEY*                 = 3;
              UNWRAP_MODE*                = 4;
              WRAP_MODE*                  = 3;
              PROCEDURE getInstance*(p0 : java_lang.String;
                                     p1 : java_lang.String) : Cipher;
              PROCEDURE getInstance*(p0 : java_lang.String;
                                     p1 : java_security.Provider) : Cipher;
              PROCEDURE getInstance*(p0 : java_lang.String) : Cipher;
              PROCEDURE getMaxAllowedKeyLength*(p0 : java_lang.String) : INTEGER;
              PROCEDURE getMaxAllowedParameterSpec*(p0 : java_lang.String) : java_security_spec.AlgorithmParameterSpec;
              PROCEDURE Init!(p0 : CipherSpi;
                              p1 : java_security.Provider;
                              p2 : java_lang.String) : Cipher,CONSTRUCTOR;
            END;

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

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

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

  EncryptedPrivateKeyInfo* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)    (* Typebound Procedures *)
                             STATIC
                               PROCEDURE Init*(    p0 : java_security.AlgorithmParameters;
                                               IN  p1 : ARRAY OF BYTE) : EncryptedPrivateKeyInfo,CONSTRUCTOR;
                               PROCEDURE Init*(    p0 : java_lang.String;
                                               IN  p1 : ARRAY OF BYTE) : EncryptedPrivateKeyInfo,CONSTRUCTOR;
                               PROCEDURE Init*(IN  p0 : ARRAY OF BYTE) : EncryptedPrivateKeyInfo,CONSTRUCTOR;
                             END;

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

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

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

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

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

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

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

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

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

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

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

  NullCipher* = POINTER TO EXTENSIBLE RECORD (Cipher)
                STATIC
                  PROCEDURE Init*() : NullCipher,CONSTRUCTOR;
                END;

  SealedObject* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + java_io.Serializable)    (* Typebound Procedures *)
                    encodedParams! : POINTER TO ARRAY OF BYTE;
                  STATIC
                    PROCEDURE Init!(p0 : SealedObject) : SealedObject,CONSTRUCTOR;
                    PROCEDURE Init*(p0 : java_io.Serializable;
                                    p1 : Cipher) : SealedObject,CONSTRUCTOR;
                  END;

  SecretKey* = POINTER TO INTERFACE RECORD (java_lang.Object + java_security.Key)
               STATIC
                 serialVersionUID* = -4795878709595146952;
               END;

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

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

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




PROCEDURE (self:Cipher) doFinal*(IN  p0 : ARRAY OF BYTE;
                                     p1 : INTEGER;
                                     p2 : INTEGER;
                                 IN  p3 : ARRAY OF BYTE) : INTEGER,NEW;

PROCEDURE (self:Cipher) doFinal*(IN  p0 : ARRAY OF BYTE;
                                     p1 : INTEGER;
                                     p2 : INTEGER) : POINTER TO ARRAY OF BYTE,NEW;

PROCEDURE (self:Cipher) doFinal*(IN  p0 : ARRAY OF BYTE;
                                     p1 : INTEGER;
                                     p2 : INTEGER;
                                 IN  p3 : ARRAY OF BYTE;
                                     p4 : INTEGER) : INTEGER,NEW;

PROCEDURE (self:Cipher) doFinal*(p0 : java_nio.ByteBuffer;
                                 p1 : java_nio.ByteBuffer) : INTEGER,NEW;

PROCEDURE (self:Cipher) doFinal*(IN  p0 : ARRAY OF BYTE) : POINTER TO ARRAY OF BYTE,NEW;

PROCEDURE (self:Cipher) doFinal*() : POINTER TO ARRAY OF BYTE,NEW;

PROCEDURE (self:Cipher) doFinal*(IN  p0 : ARRAY OF BYTE;
                                     p1 : INTEGER) : INTEGER,NEW;

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

PROCEDURE (self:Cipher) getBlockSize*() : INTEGER,NEW;

PROCEDURE (self:Cipher) getExemptionMechanism*() : ExemptionMechanism,NEW;

PROCEDURE (self:Cipher) getIV*() : POINTER TO ARRAY OF BYTE,NEW;

PROCEDURE (self:Cipher) getOutputSize*(p0 : INTEGER) : INTEGER,NEW;

PROCEDURE (self:Cipher) getParameters*() : java_security.AlgorithmParameters,NEW;

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

PROCEDURE (self:Cipher) init*(p0 : INTEGER;
                              p1 : java_security_cert.Certificate;
                              p2 : java_security.SecureRandom),NEW;

PROCEDURE (self:Cipher) init*(p0 : INTEGER;
                              p1 : java_security.Key;
                              p2 : java_security_spec.AlgorithmParameterSpec;
                              p3 : java_security.SecureRandom),NEW;

PROCEDURE (self:Cipher) init*(p0 : INTEGER;
                              p1 : java_security.Key;
                              p2 : java_security.AlgorithmParameters),NEW;

PROCEDURE (self:Cipher) init*(p0 : INTEGER;
                              p1 : java_security.Key;
                              p2 : java_security.AlgorithmParameters;
                              p3 : java_security.SecureRandom),NEW;

PROCEDURE (self:Cipher) init*(p0 : INTEGER;
                              p1 : java_security.Key),NEW;

PROCEDURE (self:Cipher) init*(p0 : INTEGER;
                              p1 : java_security.Key;
                              p2 : java_security.SecureRandom),NEW;

PROCEDURE (self:Cipher) init*(p0 : INTEGER;
                              p1 : java_security.Key;
                              p2 : java_security_spec.AlgorithmParameterSpec),NEW;

PROCEDURE (self:Cipher) init*(p0 : INTEGER;
                              p1 : java_security_cert.Certificate),NEW;

PROCEDURE (self:Cipher) unwrap*(IN  p0 : ARRAY OF BYTE;
                                    p1 : java_lang.String;
                                    p2 : INTEGER) : java_security.Key,NEW;

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

PROCEDURE (self:Cipher) update*(IN  p0 : ARRAY OF BYTE) : POINTER TO ARRAY OF BYTE,NEW;

PROCEDURE (self:Cipher) update*(p0 : java_nio.ByteBuffer;
                                p1 : java_nio.ByteBuffer) : INTEGER,NEW;

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

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

PROCEDURE (self:Cipher) wrap*(p0 : java_security.Key) : POINTER TO ARRAY OF BYTE,NEW;

PROCEDURE (self:CipherInputStream) available*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:CipherInputStream) close*(),EXTENSIBLE;

PROCEDURE (self:CipherInputStream) markSupported*() : BOOLEAN,EXTENSIBLE;

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

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

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

PROCEDURE (self:CipherInputStream) skip*(p0 : LONGINT) : LONGINT,EXTENSIBLE;

PROCEDURE (self:CipherOutputStream) close*(),EXTENSIBLE;

PROCEDURE (self:CipherOutputStream) flush*(),EXTENSIBLE;

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

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

PROCEDURE (self:CipherOutputStream) write*(IN  p0 : ARRAY OF BYTE),EXTENSIBLE;

PROCEDURE (self:CipherSpi) engineDoFinal!(IN  p0 : ARRAY OF BYTE;
                                              p1 : INTEGER;
                                              p2 : INTEGER) : POINTER TO ARRAY OF BYTE,NEW,ABSTRACT;

PROCEDURE (self:CipherSpi) engineDoFinal!(p0 : java_nio.ByteBuffer;
                                          p1 : java_nio.ByteBuffer) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:CipherSpi) engineDoFinal!(IN  p0 : ARRAY OF BYTE;
                                              p1 : INTEGER;
                                              p2 : INTEGER;
                                          IN  p3 : ARRAY OF BYTE;
                                              p4 : INTEGER) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:CipherSpi) engineGetBlockSize!() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:CipherSpi) engineGetIV!() : POINTER TO ARRAY OF BYTE,NEW,ABSTRACT;

PROCEDURE (self:CipherSpi) engineGetKeySize!(p0 : java_security.Key) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:CipherSpi) engineGetOutputSize!(p0 : INTEGER) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:CipherSpi) engineGetParameters!() : java_security.AlgorithmParameters,NEW,ABSTRACT;

PROCEDURE (self:CipherSpi) engineInit!(p0 : INTEGER;
                                       p1 : java_security.Key;
                                       p2 : java_security.AlgorithmParameters;
                                       p3 : java_security.SecureRandom),NEW,ABSTRACT;

PROCEDURE (self:CipherSpi) engineInit!(p0 : INTEGER;
                                       p1 : java_security.Key;
                                       p2 : java_security_spec.AlgorithmParameterSpec;
                                       p3 : java_security.SecureRandom),NEW,ABSTRACT;

PROCEDURE (self:CipherSpi) engineInit!(p0 : INTEGER;
                                       p1 : java_security.Key;
                                       p2 : java_security.SecureRandom),NEW,ABSTRACT;

PROCEDURE (self:CipherSpi) engineSetMode!(p0 : java_lang.String),NEW,ABSTRACT;

PROCEDURE (self:CipherSpi) engineSetPadding!(p0 : java_lang.String),NEW,ABSTRACT;

PROCEDURE (self:CipherSpi) engineUnwrap!(IN  p0 : ARRAY OF BYTE;
                                             p1 : java_lang.String;
                                             p2 : INTEGER) : java_security.Key,NEW,EXTENSIBLE;

PROCEDURE (self:CipherSpi) engineUpdate!(p0 : java_nio.ByteBuffer;
                                         p1 : java_nio.ByteBuffer) : INTEGER,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:CipherSpi) engineWrap!(p0 : java_security.Key) : POINTER TO ARRAY OF BYTE,NEW,EXTENSIBLE;

PROCEDURE (self:EncryptedPrivateKeyInfo) getAlgName*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:EncryptedPrivateKeyInfo) getAlgParameters*() : java_security.AlgorithmParameters,NEW,EXTENSIBLE;

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

PROCEDURE (self:EncryptedPrivateKeyInfo) getEncryptedData*() : POINTER TO ARRAY OF BYTE,NEW,EXTENSIBLE;

PROCEDURE (self:EncryptedPrivateKeyInfo) getKeySpec*(p0 : java_security.Key;
                                                     p1 : java_security.Provider) : java_security_spec.PKCS8EncodedKeySpec,NEW,EXTENSIBLE;

PROCEDURE (self:EncryptedPrivateKeyInfo) getKeySpec*(p0 : java_security.Key;
                                                     p1 : java_lang.String) : java_security_spec.PKCS8EncodedKeySpec,NEW,EXTENSIBLE;

PROCEDURE (self:EncryptedPrivateKeyInfo) getKeySpec*(p0 : Cipher) : java_security_spec.PKCS8EncodedKeySpec,NEW,EXTENSIBLE;

PROCEDURE (self:EncryptedPrivateKeyInfo) getKeySpec*(p0 : java_security.Key) : java_security_spec.PKCS8EncodedKeySpec,NEW,EXTENSIBLE;

PROCEDURE (self:ExemptionMechanism) finalize!(),EXTENSIBLE;

PROCEDURE (self:ExemptionMechanism) genExemptionBlob*(IN  p0 : ARRAY OF BYTE) : INTEGER,NEW;

PROCEDURE (self:ExemptionMechanism) genExemptionBlob*(IN  p0 : ARRAY OF BYTE;
                                                          p1 : INTEGER) : INTEGER,NEW;

PROCEDURE (self:ExemptionMechanism) genExemptionBlob*() : POINTER TO ARRAY OF BYTE,NEW;

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

PROCEDURE (self:ExemptionMechanism) getOutputSize*(p0 : INTEGER) : INTEGER,NEW;

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

PROCEDURE (self:ExemptionMechanism) init*(p0 : java_security.Key),NEW;

PROCEDURE (self:ExemptionMechanism) init*(p0 : java_security.Key;
                                          p1 : java_security_spec.AlgorithmParameterSpec),NEW;

PROCEDURE (self:ExemptionMechanism) init*(p0 : java_security.Key;
                                          p1 : java_security.AlgorithmParameters),NEW;

PROCEDURE (self:ExemptionMechanism) isCryptoAllowed*(p0 : java_security.Key) : BOOLEAN,NEW;

PROCEDURE (self:ExemptionMechanismSpi) engineGenExemptionBlob!() : POINTER TO ARRAY OF BYTE,NEW,ABSTRACT;

PROCEDURE (self:ExemptionMechanismSpi) engineGenExemptionBlob!(IN  p0 : ARRAY OF BYTE;
                                                                   p1 : INTEGER) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:ExemptionMechanismSpi) engineGetOutputSize!(p0 : INTEGER) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:ExemptionMechanismSpi) engineInit!(p0 : java_security.Key;
                                                   p1 : java_security.AlgorithmParameters),NEW,ABSTRACT;

PROCEDURE (self:ExemptionMechanismSpi) engineInit!(p0 : java_security.Key),NEW,ABSTRACT;

PROCEDURE (self:ExemptionMechanismSpi) engineInit!(p0 : java_security.Key;
                                                   p1 : java_security_spec.AlgorithmParameterSpec),NEW,ABSTRACT;

PROCEDURE (self:KeyAgreement) doPhase*(p0 : java_security.Key;
                                       p1 : BOOLEAN) : java_security.Key,NEW;

PROCEDURE (self:KeyAgreement) generateSecret*(IN  p0 : ARRAY OF BYTE;
                                                  p1 : INTEGER) : INTEGER,NEW;

PROCEDURE (self:KeyAgreement) generateSecret*() : POINTER TO ARRAY OF BYTE,NEW;

PROCEDURE (self:KeyAgreement) generateSecret*(p0 : java_lang.String) : SecretKey,NEW;

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

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

PROCEDURE (self:KeyAgreement) init*(p0 : java_security.Key;
                                    p1 : java_security.SecureRandom),NEW;

PROCEDURE (self:KeyAgreement) init*(p0 : java_security.Key),NEW;

PROCEDURE (self:KeyAgreement) init*(p0 : java_security.Key;
                                    p1 : java_security_spec.AlgorithmParameterSpec;
                                    p2 : java_security.SecureRandom),NEW;

PROCEDURE (self:KeyAgreement) init*(p0 : java_security.Key;
                                    p1 : java_security_spec.AlgorithmParameterSpec),NEW;

PROCEDURE (self:KeyAgreementSpi) engineDoPhase!(p0 : java_security.Key;
                                                p1 : BOOLEAN) : java_security.Key,NEW,ABSTRACT;

PROCEDURE (self:KeyAgreementSpi) engineGenerateSecret!(IN  p0 : ARRAY OF BYTE;
                                                           p1 : INTEGER) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:KeyAgreementSpi) engineGenerateSecret!(p0 : java_lang.String) : SecretKey,NEW,ABSTRACT;

PROCEDURE (self:KeyAgreementSpi) engineGenerateSecret!() : POINTER TO ARRAY OF BYTE,NEW,ABSTRACT;

PROCEDURE (self:KeyAgreementSpi) engineInit!(p0 : java_security.Key;
                                             p1 : java_security_spec.AlgorithmParameterSpec;
                                             p2 : java_security.SecureRandom),NEW,ABSTRACT;

PROCEDURE (self:KeyAgreementSpi) engineInit!(p0 : java_security.Key;
                                             p1 : java_security.SecureRandom),NEW,ABSTRACT;

PROCEDURE (self:KeyGenerator) generateKey*() : SecretKey,NEW;

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

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

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

PROCEDURE (self:KeyGenerator) init*(p0 : INTEGER;
                                    p1 : java_security.SecureRandom),NEW;

PROCEDURE (self:KeyGenerator) init*(p0 : java_security.SecureRandom),NEW;

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

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

PROCEDURE (self:KeyGeneratorSpi) engineGenerateKey!() : SecretKey,NEW,ABSTRACT;

PROCEDURE (self:KeyGeneratorSpi) engineInit!(p0 : INTEGER;
                                             p1 : java_security.SecureRandom),NEW,ABSTRACT;

PROCEDURE (self:KeyGeneratorSpi) engineInit!(p0 : java_security.SecureRandom),NEW,ABSTRACT;

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

PROCEDURE (self:Mac) clone*() : java_lang.Object;

PROCEDURE (self:Mac) doFinal*(IN  p0 : ARRAY OF BYTE;
                                  p1 : INTEGER),NEW;

PROCEDURE (self:Mac) doFinal*(IN  p0 : ARRAY OF BYTE) : POINTER TO ARRAY OF BYTE,NEW;

PROCEDURE (self:Mac) doFinal*() : POINTER TO ARRAY OF BYTE,NEW;

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

PROCEDURE (self:Mac) getMacLength*() : INTEGER,NEW;

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

PROCEDURE (self:Mac) init*(p0 : java_security.Key),NEW;

PROCEDURE (self:Mac) init*(p0 : java_security.Key;
                           p1 : java_security_spec.AlgorithmParameterSpec),NEW;

PROCEDURE (self:Mac) reset*(),NEW;

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

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

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

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

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

PROCEDURE (self:MacSpi) engineDoFinal!() : POINTER TO ARRAY OF BYTE,NEW,ABSTRACT;

PROCEDURE (self:MacSpi) engineGetMacLength!() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:MacSpi) engineInit!(p0 : java_security.Key;
                                    p1 : java_security_spec.AlgorithmParameterSpec),NEW,ABSTRACT;

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

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

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

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

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

PROCEDURE (self:SealedObject) getObject*(p0 : java_security.Key;
                                         p1 : java_lang.String) : java_lang.Object,NEW;

PROCEDURE (self:SealedObject) getObject*(p0 : Cipher) : java_lang.Object,NEW;

PROCEDURE (self:SealedObject) getObject*(p0 : java_security.Key) : java_lang.Object,NEW;

PROCEDURE (self:SecretKeyFactory) generateSecret*(p0 : java_security_spec.KeySpec) : SecretKey,NEW;

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

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

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

PROCEDURE (self:SecretKeyFactory) translateKey*(p0 : SecretKey) : SecretKey,NEW;

PROCEDURE (self:SecretKeyFactorySpi) engineGenerateSecret!(p0 : java_security_spec.KeySpec) : SecretKey,NEW,ABSTRACT;

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

PROCEDURE (self:SecretKeyFactorySpi) engineTranslateKey!(p0 : SecretKey) : SecretKey,NEW,ABSTRACT;

END javax_crypto.