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

package com.chilkatsoft;

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

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

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

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

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

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

  public CkCrypt2() {
    this(chilkatJNI.new_CkCrypt2(), true);
  }

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

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

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

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

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

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

  public int get_BCryptWorkFactor() {
    return chilkatJNI.CkCrypt2_get_BCryptWorkFactor(swigCPtr, this);
  }

  public void put_BCryptWorkFactor(int newVal) {
    chilkatJNI.CkCrypt2_put_BCryptWorkFactor(swigCPtr, this, newVal);
  }

  public int get_BlockSize() {
    return chilkatJNI.CkCrypt2_get_BlockSize(swigCPtr, this);
  }

  public boolean get_CadesEnabled() {
    return chilkatJNI.CkCrypt2_get_CadesEnabled(swigCPtr, this);
  }

  public void put_CadesEnabled(boolean newVal) {
    chilkatJNI.CkCrypt2_put_CadesEnabled(swigCPtr, this, newVal);
  }

  public void get_CadesSigPolicyHash(CkString str) {
    chilkatJNI.CkCrypt2_get_CadesSigPolicyHash(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String cadesSigPolicyHash() {
    return chilkatJNI.CkCrypt2_cadesSigPolicyHash(swigCPtr, this);
  }

  public void put_CadesSigPolicyHash(String newVal) {
    chilkatJNI.CkCrypt2_put_CadesSigPolicyHash(swigCPtr, this, newVal);
  }

  public void get_CadesSigPolicyId(CkString str) {
    chilkatJNI.CkCrypt2_get_CadesSigPolicyId(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String cadesSigPolicyId() {
    return chilkatJNI.CkCrypt2_cadesSigPolicyId(swigCPtr, this);
  }

  public void put_CadesSigPolicyId(String newVal) {
    chilkatJNI.CkCrypt2_put_CadesSigPolicyId(swigCPtr, this, newVal);
  }

  public void get_CadesSigPolicyUri(CkString str) {
    chilkatJNI.CkCrypt2_get_CadesSigPolicyUri(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String cadesSigPolicyUri() {
    return chilkatJNI.CkCrypt2_cadesSigPolicyUri(swigCPtr, this);
  }

  public void put_CadesSigPolicyUri(String newVal) {
    chilkatJNI.CkCrypt2_put_CadesSigPolicyUri(swigCPtr, this, newVal);
  }

  public void get_Charset(CkString str) {
    chilkatJNI.CkCrypt2_get_Charset(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String charset() {
    return chilkatJNI.CkCrypt2_charset(swigCPtr, this);
  }

  public void put_Charset(String newVal) {
    chilkatJNI.CkCrypt2_put_Charset(swigCPtr, this, newVal);
  }

  public void get_CipherMode(CkString str) {
    chilkatJNI.CkCrypt2_get_CipherMode(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String cipherMode() {
    return chilkatJNI.CkCrypt2_cipherMode(swigCPtr, this);
  }

  public void put_CipherMode(String newVal) {
    chilkatJNI.CkCrypt2_put_CipherMode(swigCPtr, this, newVal);
  }

  public void get_CmsOptions(CkString str) {
    chilkatJNI.CkCrypt2_get_CmsOptions(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String cmsOptions() {
    return chilkatJNI.CkCrypt2_cmsOptions(swigCPtr, this);
  }

  public void put_CmsOptions(String newVal) {
    chilkatJNI.CkCrypt2_put_CmsOptions(swigCPtr, this, newVal);
  }

  public void get_CryptAlgorithm(CkString str) {
    chilkatJNI.CkCrypt2_get_CryptAlgorithm(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String cryptAlgorithm() {
    return chilkatJNI.CkCrypt2_cryptAlgorithm(swigCPtr, this);
  }

  public void put_CryptAlgorithm(String newVal) {
    chilkatJNI.CkCrypt2_put_CryptAlgorithm(swigCPtr, this, newVal);
  }

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

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

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

  public void get_EncodingMode(CkString str) {
    chilkatJNI.CkCrypt2_get_EncodingMode(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String encodingMode() {
    return chilkatJNI.CkCrypt2_encodingMode(swigCPtr, this);
  }

  public void put_EncodingMode(String newVal) {
    chilkatJNI.CkCrypt2_put_EncodingMode(swigCPtr, this, newVal);
  }

  public boolean get_FirstChunk() {
    return chilkatJNI.CkCrypt2_get_FirstChunk(swigCPtr, this);
  }

  public void put_FirstChunk(boolean newVal) {
    chilkatJNI.CkCrypt2_put_FirstChunk(swigCPtr, this, newVal);
  }

  public void get_HashAlgorithm(CkString str) {
    chilkatJNI.CkCrypt2_get_HashAlgorithm(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String hashAlgorithm() {
    return chilkatJNI.CkCrypt2_hashAlgorithm(swigCPtr, this);
  }

  public void put_HashAlgorithm(String newVal) {
    chilkatJNI.CkCrypt2_put_HashAlgorithm(swigCPtr, this, newVal);
  }

  public int get_HavalRounds() {
    return chilkatJNI.CkCrypt2_get_HavalRounds(swigCPtr, this);
  }

  public void put_HavalRounds(int newVal) {
    chilkatJNI.CkCrypt2_put_HavalRounds(swigCPtr, this, newVal);
  }

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

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

  public boolean get_IncludeCertChain() {
    return chilkatJNI.CkCrypt2_get_IncludeCertChain(swigCPtr, this);
  }

  public void put_IncludeCertChain(boolean newVal) {
    chilkatJNI.CkCrypt2_put_IncludeCertChain(swigCPtr, this, newVal);
  }

  public int get_InitialCount() {
    return chilkatJNI.CkCrypt2_get_InitialCount(swigCPtr, this);
  }

  public void put_InitialCount(int newVal) {
    chilkatJNI.CkCrypt2_put_InitialCount(swigCPtr, this, newVal);
  }

  public int get_IterationCount() {
    return chilkatJNI.CkCrypt2_get_IterationCount(swigCPtr, this);
  }

  public void put_IterationCount(int newVal) {
    chilkatJNI.CkCrypt2_put_IterationCount(swigCPtr, this, newVal);
  }

  public int get_KeyLength() {
    return chilkatJNI.CkCrypt2_get_KeyLength(swigCPtr, this);
  }

  public void put_KeyLength(int newVal) {
    chilkatJNI.CkCrypt2_put_KeyLength(swigCPtr, this, newVal);
  }

  public boolean get_LastChunk() {
    return chilkatJNI.CkCrypt2_get_LastChunk(swigCPtr, this);
  }

  public void put_LastChunk(boolean newVal) {
    chilkatJNI.CkCrypt2_put_LastChunk(swigCPtr, this, newVal);
  }

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

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

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

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

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

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

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

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

  public void get_MacAlgorithm(CkString str) {
    chilkatJNI.CkCrypt2_get_MacAlgorithm(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String macAlgorithm() {
    return chilkatJNI.CkCrypt2_macAlgorithm(swigCPtr, this);
  }

  public void put_MacAlgorithm(String newVal) {
    chilkatJNI.CkCrypt2_put_MacAlgorithm(swigCPtr, this, newVal);
  }

  public int get_NumSignerCerts() {
    return chilkatJNI.CkCrypt2_get_NumSignerCerts(swigCPtr, this);
  }

  public void get_OaepHash(CkString str) {
    chilkatJNI.CkCrypt2_get_OaepHash(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String oaepHash() {
    return chilkatJNI.CkCrypt2_oaepHash(swigCPtr, this);
  }

  public void put_OaepHash(String newVal) {
    chilkatJNI.CkCrypt2_put_OaepHash(swigCPtr, this, newVal);
  }

  public void get_OaepMgfHash(CkString str) {
    chilkatJNI.CkCrypt2_get_OaepMgfHash(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String oaepMgfHash() {
    return chilkatJNI.CkCrypt2_oaepMgfHash(swigCPtr, this);
  }

  public void put_OaepMgfHash(String newVal) {
    chilkatJNI.CkCrypt2_put_OaepMgfHash(swigCPtr, this, newVal);
  }

  public boolean get_OaepPadding() {
    return chilkatJNI.CkCrypt2_get_OaepPadding(swigCPtr, this);
  }

  public void put_OaepPadding(boolean newVal) {
    chilkatJNI.CkCrypt2_put_OaepPadding(swigCPtr, this, newVal);
  }

  public int get_PaddingScheme() {
    return chilkatJNI.CkCrypt2_get_PaddingScheme(swigCPtr, this);
  }

  public void put_PaddingScheme(int newVal) {
    chilkatJNI.CkCrypt2_put_PaddingScheme(swigCPtr, this, newVal);
  }

  public void get_PbesAlgorithm(CkString str) {
    chilkatJNI.CkCrypt2_get_PbesAlgorithm(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String pbesAlgorithm() {
    return chilkatJNI.CkCrypt2_pbesAlgorithm(swigCPtr, this);
  }

  public void put_PbesAlgorithm(String newVal) {
    chilkatJNI.CkCrypt2_put_PbesAlgorithm(swigCPtr, this, newVal);
  }

  public void get_PbesPassword(CkString str) {
    chilkatJNI.CkCrypt2_get_PbesPassword(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String pbesPassword() {
    return chilkatJNI.CkCrypt2_pbesPassword(swigCPtr, this);
  }

  public void put_PbesPassword(String newVal) {
    chilkatJNI.CkCrypt2_put_PbesPassword(swigCPtr, this, newVal);
  }

  public void get_Pkcs7CryptAlg(CkString str) {
    chilkatJNI.CkCrypt2_get_Pkcs7CryptAlg(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String pkcs7CryptAlg() {
    return chilkatJNI.CkCrypt2_pkcs7CryptAlg(swigCPtr, this);
  }

  public void put_Pkcs7CryptAlg(String newVal) {
    chilkatJNI.CkCrypt2_put_Pkcs7CryptAlg(swigCPtr, this, newVal);
  }

  public int get_Rc2EffectiveKeyLength() {
    return chilkatJNI.CkCrypt2_get_Rc2EffectiveKeyLength(swigCPtr, this);
  }

  public void put_Rc2EffectiveKeyLength(int newVal) {
    chilkatJNI.CkCrypt2_put_Rc2EffectiveKeyLength(swigCPtr, this, newVal);
  }

  public void get_SigningAlg(CkString str) {
    chilkatJNI.CkCrypt2_get_SigningAlg(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String signingAlg() {
    return chilkatJNI.CkCrypt2_signingAlg(swigCPtr, this);
  }

  public void put_SigningAlg(String newVal) {
    chilkatJNI.CkCrypt2_put_SigningAlg(swigCPtr, this, newVal);
  }

  public void get_SigningAttributes(CkString str) {
    chilkatJNI.CkCrypt2_get_SigningAttributes(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String signingAttributes() {
    return chilkatJNI.CkCrypt2_signingAttributes(swigCPtr, this);
  }

  public void put_SigningAttributes(String newVal) {
    chilkatJNI.CkCrypt2_put_SigningAttributes(swigCPtr, this, newVal);
  }

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

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

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

  public void get_UuFilename(CkString str) {
    chilkatJNI.CkCrypt2_get_UuFilename(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String uuFilename() {
    return chilkatJNI.CkCrypt2_uuFilename(swigCPtr, this);
  }

  public void put_UuFilename(String newVal) {
    chilkatJNI.CkCrypt2_put_UuFilename(swigCPtr, this, newVal);
  }

  public void get_UuMode(CkString str) {
    chilkatJNI.CkCrypt2_get_UuMode(swigCPtr, this, CkString.getCPtr(str), str);
  }

  public String uuMode() {
    return chilkatJNI.CkCrypt2_uuMode(swigCPtr, this);
  }

  public void put_UuMode(String newVal) {
    chilkatJNI.CkCrypt2_put_UuMode(swigCPtr, this, newVal);
  }

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

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

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

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

  public void AddEncryptCert(CkCert cert) {
    chilkatJNI.CkCrypt2_AddEncryptCert(swigCPtr, this, CkCert.getCPtr(cert), cert);
  }

  public boolean AddPfxSourceBd(CkBinData bd, String password) {
    return chilkatJNI.CkCrypt2_AddPfxSourceBd(swigCPtr, this, CkBinData.getCPtr(bd), bd, password);
  }

  public boolean AddPfxSourceData(CkByteData pfxBytes, String pfxPassword) {
    return chilkatJNI.CkCrypt2_AddPfxSourceData(swigCPtr, this, CkByteData.getCPtr(pfxBytes), pfxBytes, pfxPassword);
  }

  public boolean AddPfxSourceFile(String pfxFilePath, String pfxPassword) {
    return chilkatJNI.CkCrypt2_AddPfxSourceFile(swigCPtr, this, pfxFilePath, pfxPassword);
  }

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

  public boolean AesKeyUnwrap(String kek, String wrappedKeyData, String encoding, CkString outStr) {
    return chilkatJNI.CkCrypt2_AesKeyUnwrap(swigCPtr, this, kek, wrappedKeyData, encoding, CkString.getCPtr(outStr), outStr);
  }

  public String aesKeyUnwrap(String kek, String wrappedKeyData, String encoding) {
    return chilkatJNI.CkCrypt2_aesKeyUnwrap(swigCPtr, this, kek, wrappedKeyData, encoding);
  }

  public boolean AesKeyUnwrapWithPadding(String kek, String wrappedKeyData, String encoding, CkString outStr) {
    return chilkatJNI.CkCrypt2_AesKeyUnwrapWithPadding(swigCPtr, this, kek, wrappedKeyData, encoding, CkString.getCPtr(outStr), outStr);
  }

  public String aesKeyUnwrapWithPadding(String kek, String wrappedKeyData, String encoding) {
    return chilkatJNI.CkCrypt2_aesKeyUnwrapWithPadding(swigCPtr, this, kek, wrappedKeyData, encoding);
  }

  public boolean AesKeyWrap(String kek, String keyData, String encoding, CkString outStr) {
    return chilkatJNI.CkCrypt2_AesKeyWrap(swigCPtr, this, kek, keyData, encoding, CkString.getCPtr(outStr), outStr);
  }

  public String aesKeyWrap(String kek, String keyData, String encoding) {
    return chilkatJNI.CkCrypt2_aesKeyWrap(swigCPtr, this, kek, keyData, encoding);
  }

  public boolean AesKeyWrapWithPadding(String kek, String keyData, String encoding, CkString outStr) {
    return chilkatJNI.CkCrypt2_AesKeyWrapWithPadding(swigCPtr, this, kek, keyData, encoding, CkString.getCPtr(outStr), outStr);
  }

  public String aesKeyWrapWithPadding(String kek, String keyData, String encoding) {
    return chilkatJNI.CkCrypt2_aesKeyWrapWithPadding(swigCPtr, this, kek, keyData, encoding);
  }

  public boolean BCryptHash(String password, CkString outStr) {
    return chilkatJNI.CkCrypt2_BCryptHash(swigCPtr, this, password, CkString.getCPtr(outStr), outStr);
  }

  public String bCryptHash(String password) {
    return chilkatJNI.CkCrypt2_bCryptHash(swigCPtr, this, password);
  }

  public boolean BCryptVerify(String password, String bcryptHash) {
    return chilkatJNI.CkCrypt2_BCryptVerify(swigCPtr, this, password, bcryptHash);
  }

  public boolean CkDecryptFile(String srcFile, String destFile) {
    return chilkatJNI.CkCrypt2_CkDecryptFile(swigCPtr, this, srcFile, destFile);
  }

  public CkTask CkDecryptFileAsync(String srcFile, String destFile) {
    long cPtr = chilkatJNI.CkCrypt2_CkDecryptFileAsync(swigCPtr, this, srcFile, destFile);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean CkEncryptFile(String srcFile, String destFile) {
    return chilkatJNI.CkCrypt2_CkEncryptFile(swigCPtr, this, srcFile, destFile);
  }

  public CkTask CkEncryptFileAsync(String srcFile, String destFile) {
    long cPtr = chilkatJNI.CkCrypt2_CkEncryptFileAsync(swigCPtr, this, srcFile, destFile);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public void ClearEncryptCerts() {
    chilkatJNI.CkCrypt2_ClearEncryptCerts(swigCPtr, this);
  }

  public void ClearSigningCerts() {
    chilkatJNI.CkCrypt2_ClearSigningCerts(swigCPtr, this);
  }

  public boolean CoSign(CkBinData bdIn, CkCert cert, CkBinData bdOut) {
    return chilkatJNI.CkCrypt2_CoSign(swigCPtr, this, CkBinData.getCPtr(bdIn), bdIn, CkCert.getCPtr(cert), cert, CkBinData.getCPtr(bdOut), bdOut);
  }

  public long CrcBd(String crcAlg, CkBinData bd) {
    return chilkatJNI.CkCrypt2_CrcBd(swigCPtr, this, crcAlg, CkBinData.getCPtr(bd), bd);
  }

  public long CrcBytes(String crcAlg, CkByteData byteData) {
    return chilkatJNI.CkCrypt2_CrcBytes(swigCPtr, this, crcAlg, CkByteData.getCPtr(byteData), byteData);
  }

  public long CrcFile(String crcAlg, String path) {
    return chilkatJNI.CkCrypt2_CrcFile(swigCPtr, this, crcAlg, path);
  }

  public CkTask CrcFileAsync(String crcAlg, String path) {
    long cPtr = chilkatJNI.CkCrypt2_CrcFileAsync(swigCPtr, this, crcAlg, path);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean CreateDetachedSignature(String inFilePath, String sigFilePath) {
    return chilkatJNI.CkCrypt2_CreateDetachedSignature(swigCPtr, this, inFilePath, sigFilePath);
  }

  public boolean CreateP7M(String inFilename, String p7mPath) {
    return chilkatJNI.CkCrypt2_CreateP7M(swigCPtr, this, inFilename, p7mPath);
  }

  public CkTask CreateP7MAsync(String inFilename, String p7mPath) {
    long cPtr = chilkatJNI.CkCrypt2_CreateP7MAsync(swigCPtr, this, inFilename, p7mPath);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean CreateP7S(String inFilename, String p7sPath) {
    return chilkatJNI.CkCrypt2_CreateP7S(swigCPtr, this, inFilename, p7sPath);
  }

  public CkTask CreateP7SAsync(String inFilename, String p7sPath) {
    long cPtr = chilkatJNI.CkCrypt2_CreateP7SAsync(swigCPtr, this, inFilename, p7sPath);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean Decode(String str, String encoding, CkByteData outData) {
    return chilkatJNI.CkCrypt2_Decode(swigCPtr, this, str, encoding, CkByteData.getCPtr(outData), outData);
  }

  public boolean DecodeString(String inStr, String charset, String encoding, CkString outStr) {
    return chilkatJNI.CkCrypt2_DecodeString(swigCPtr, this, inStr, charset, encoding, CkString.getCPtr(outStr), outStr);
  }

  public String decodeString(String inStr, String charset, String encoding) {
    return chilkatJNI.CkCrypt2_decodeString(swigCPtr, this, inStr, charset, encoding);
  }

  public boolean DecryptBd(CkBinData bd) {
    return chilkatJNI.CkCrypt2_DecryptBd(swigCPtr, this, CkBinData.getCPtr(bd), bd);
  }

  public boolean DecryptBytes(CkByteData data, CkByteData outData) {
    return chilkatJNI.CkCrypt2_DecryptBytes(swigCPtr, this, CkByteData.getCPtr(data), data, CkByteData.getCPtr(outData), outData);
  }

  public boolean DecryptBytesENC(String str, CkByteData outData) {
    return chilkatJNI.CkCrypt2_DecryptBytesENC(swigCPtr, this, str, CkByteData.getCPtr(outData), outData);
  }

  public boolean DecryptEncoded(String encodedEncryptedData, CkString outStr) {
    return chilkatJNI.CkCrypt2_DecryptEncoded(swigCPtr, this, encodedEncryptedData, CkString.getCPtr(outStr), outStr);
  }

  public String decryptEncoded(String encodedEncryptedData) {
    return chilkatJNI.CkCrypt2_decryptEncoded(swigCPtr, this, encodedEncryptedData);
  }

  public boolean DecryptSb(CkBinData bdIn, CkStringBuilder sbOut) {
    return chilkatJNI.CkCrypt2_DecryptSb(swigCPtr, this, CkBinData.getCPtr(bdIn), bdIn, CkStringBuilder.getCPtr(sbOut), sbOut);
  }

  public boolean DecryptSecureENC(String cipherText, CkSecureString secureStr) {
    return chilkatJNI.CkCrypt2_DecryptSecureENC(swigCPtr, this, cipherText, CkSecureString.getCPtr(secureStr), secureStr);
  }

  public boolean DecryptStream(CkStream strm) {
    return chilkatJNI.CkCrypt2_DecryptStream(swigCPtr, this, CkStream.getCPtr(strm), strm);
  }

  public CkTask DecryptStreamAsync(CkStream strm) {
    long cPtr = chilkatJNI.CkCrypt2_DecryptStreamAsync(swigCPtr, this, CkStream.getCPtr(strm), strm);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean DecryptString(CkByteData data, CkString outStr) {
    return chilkatJNI.CkCrypt2_DecryptString(swigCPtr, this, CkByteData.getCPtr(data), data, CkString.getCPtr(outStr), outStr);
  }

  public String decryptString(CkByteData data) {
    return chilkatJNI.CkCrypt2_decryptString(swigCPtr, this, CkByteData.getCPtr(data), data);
  }

  public boolean DecryptStringENC(String str, CkString outStr) {
    return chilkatJNI.CkCrypt2_DecryptStringENC(swigCPtr, this, str, CkString.getCPtr(outStr), outStr);
  }

  public String decryptStringENC(String str) {
    return chilkatJNI.CkCrypt2_decryptStringENC(swigCPtr, this, str);
  }

  public boolean Encode(CkByteData byteData, String encoding, CkString outStr) {
    return chilkatJNI.CkCrypt2_Encode(swigCPtr, this, CkByteData.getCPtr(byteData), byteData, encoding, CkString.getCPtr(outStr), outStr);
  }

  public String encode(CkByteData byteData, String encoding) {
    return chilkatJNI.CkCrypt2_encode(swigCPtr, this, CkByteData.getCPtr(byteData), byteData, encoding);
  }

  public boolean EncodeInt(int value, int numBytes, boolean littleEndian, String encoding, CkString outStr) {
    return chilkatJNI.CkCrypt2_EncodeInt(swigCPtr, this, value, numBytes, littleEndian, encoding, CkString.getCPtr(outStr), outStr);
  }

  public String encodeInt(int value, int numBytes, boolean littleEndian, String encoding) {
    return chilkatJNI.CkCrypt2_encodeInt(swigCPtr, this, value, numBytes, littleEndian, encoding);
  }

  public boolean EncodeString(String strToEncode, String charsetName, String toEncodingName, CkString outStr) {
    return chilkatJNI.CkCrypt2_EncodeString(swigCPtr, this, strToEncode, charsetName, toEncodingName, CkString.getCPtr(outStr), outStr);
  }

  public String encodeString(String strToEncode, String charsetName, String toEncodingName) {
    return chilkatJNI.CkCrypt2_encodeString(swigCPtr, this, strToEncode, charsetName, toEncodingName);
  }

  public boolean EncryptBd(CkBinData bd) {
    return chilkatJNI.CkCrypt2_EncryptBd(swigCPtr, this, CkBinData.getCPtr(bd), bd);
  }

  public boolean EncryptBytes(CkByteData data, CkByteData outData) {
    return chilkatJNI.CkCrypt2_EncryptBytes(swigCPtr, this, CkByteData.getCPtr(data), data, CkByteData.getCPtr(outData), outData);
  }

  public boolean EncryptBytesENC(CkByteData data, CkString outStr) {
    return chilkatJNI.CkCrypt2_EncryptBytesENC(swigCPtr, this, CkByteData.getCPtr(data), data, CkString.getCPtr(outStr), outStr);
  }

  public String encryptBytesENC(CkByteData data) {
    return chilkatJNI.CkCrypt2_encryptBytesENC(swigCPtr, this, CkByteData.getCPtr(data), data);
  }

  public boolean EncryptEncoded(String str, CkString outStr) {
    return chilkatJNI.CkCrypt2_EncryptEncoded(swigCPtr, this, str, CkString.getCPtr(outStr), outStr);
  }

  public String encryptEncoded(String str) {
    return chilkatJNI.CkCrypt2_encryptEncoded(swigCPtr, this, str);
  }

  public boolean EncryptSb(CkStringBuilder sbIn, CkBinData bdOut) {
    return chilkatJNI.CkCrypt2_EncryptSb(swigCPtr, this, CkStringBuilder.getCPtr(sbIn), sbIn, CkBinData.getCPtr(bdOut), bdOut);
  }

  public boolean EncryptSecureENC(CkSecureString secureStr, CkString outStr) {
    return chilkatJNI.CkCrypt2_EncryptSecureENC(swigCPtr, this, CkSecureString.getCPtr(secureStr), secureStr, CkString.getCPtr(outStr), outStr);
  }

  public String encryptSecureENC(CkSecureString secureStr) {
    return chilkatJNI.CkCrypt2_encryptSecureENC(swigCPtr, this, CkSecureString.getCPtr(secureStr), secureStr);
  }

  public boolean EncryptStream(CkStream strm) {
    return chilkatJNI.CkCrypt2_EncryptStream(swigCPtr, this, CkStream.getCPtr(strm), strm);
  }

  public CkTask EncryptStreamAsync(CkStream strm) {
    long cPtr = chilkatJNI.CkCrypt2_EncryptStreamAsync(swigCPtr, this, CkStream.getCPtr(strm), strm);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean EncryptString(String str, CkByteData outData) {
    return chilkatJNI.CkCrypt2_EncryptString(swigCPtr, this, str, CkByteData.getCPtr(outData), outData);
  }

  public boolean EncryptStringENC(String str, CkString outStr) {
    return chilkatJNI.CkCrypt2_EncryptStringENC(swigCPtr, this, str, CkString.getCPtr(outStr), outStr);
  }

  public String encryptStringENC(String str) {
    return chilkatJNI.CkCrypt2_encryptStringENC(swigCPtr, this, str);
  }

  public boolean GenEncodedSecretKey(String password, String encoding, CkString outStr) {
    return chilkatJNI.CkCrypt2_GenEncodedSecretKey(swigCPtr, this, password, encoding, CkString.getCPtr(outStr), outStr);
  }

  public String genEncodedSecretKey(String password, String encoding) {
    return chilkatJNI.CkCrypt2_genEncodedSecretKey(swigCPtr, this, password, encoding);
  }

  public boolean GenerateSecretKey(String password, CkByteData outData) {
    return chilkatJNI.CkCrypt2_GenerateSecretKey(swigCPtr, this, password, CkByteData.getCPtr(outData), outData);
  }

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

  public String generateUuid() {
    return chilkatJNI.CkCrypt2_generateUuid(swigCPtr, this);
  }

  public boolean GenRandomBytesENC(int numBytes, CkString outStr) {
    return chilkatJNI.CkCrypt2_GenRandomBytesENC(swigCPtr, this, numBytes, CkString.getCPtr(outStr), outStr);
  }

  public String genRandomBytesENC(int numBytes) {
    return chilkatJNI.CkCrypt2_genRandomBytesENC(swigCPtr, this, numBytes);
  }

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

  public boolean GetEncodedAad(String encoding, CkString outStr) {
    return chilkatJNI.CkCrypt2_GetEncodedAad(swigCPtr, this, encoding, CkString.getCPtr(outStr), outStr);
  }

  public String getEncodedAad(String encoding) {
    return chilkatJNI.CkCrypt2_getEncodedAad(swigCPtr, this, encoding);
  }

  public String encodedAad(String encoding) {
    return chilkatJNI.CkCrypt2_encodedAad(swigCPtr, this, encoding);
  }

  public boolean GetEncodedAuthTag(String encoding, CkString outStr) {
    return chilkatJNI.CkCrypt2_GetEncodedAuthTag(swigCPtr, this, encoding, CkString.getCPtr(outStr), outStr);
  }

  public String getEncodedAuthTag(String encoding) {
    return chilkatJNI.CkCrypt2_getEncodedAuthTag(swigCPtr, this, encoding);
  }

  public String encodedAuthTag(String encoding) {
    return chilkatJNI.CkCrypt2_encodedAuthTag(swigCPtr, this, encoding);
  }

  public boolean GetEncodedIV(String encoding, CkString outIV) {
    return chilkatJNI.CkCrypt2_GetEncodedIV(swigCPtr, this, encoding, CkString.getCPtr(outIV), outIV);
  }

  public String getEncodedIV(String encoding) {
    return chilkatJNI.CkCrypt2_getEncodedIV(swigCPtr, this, encoding);
  }

  public String encodedIV(String encoding) {
    return chilkatJNI.CkCrypt2_encodedIV(swigCPtr, this, encoding);
  }

  public boolean GetEncodedKey(String encoding, CkString outKey) {
    return chilkatJNI.CkCrypt2_GetEncodedKey(swigCPtr, this, encoding, CkString.getCPtr(outKey), outKey);
  }

  public String getEncodedKey(String encoding) {
    return chilkatJNI.CkCrypt2_getEncodedKey(swigCPtr, this, encoding);
  }

  public String encodedKey(String encoding) {
    return chilkatJNI.CkCrypt2_encodedKey(swigCPtr, this, encoding);
  }

  public boolean GetEncodedSalt(String encoding, CkString outStr) {
    return chilkatJNI.CkCrypt2_GetEncodedSalt(swigCPtr, this, encoding, CkString.getCPtr(outStr), outStr);
  }

  public String getEncodedSalt(String encoding) {
    return chilkatJNI.CkCrypt2_getEncodedSalt(swigCPtr, this, encoding);
  }

  public String encodedSalt(String encoding) {
    return chilkatJNI.CkCrypt2_encodedSalt(swigCPtr, this, encoding);
  }

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

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

  public String getSignatureSigningTimeStr(int index) {
    return chilkatJNI.CkCrypt2_getSignatureSigningTimeStr(swigCPtr, this, index);
  }

  public String signatureSigningTimeStr(int index) {
    return chilkatJNI.CkCrypt2_signatureSigningTimeStr(swigCPtr, this, index);
  }

  public boolean GetSignedAttributes(int signerIndex, CkBinData pkcs7Der, CkStringBuilder sbJson) {
    return chilkatJNI.CkCrypt2_GetSignedAttributes(swigCPtr, this, signerIndex, CkBinData.getCPtr(pkcs7Der), pkcs7Der, CkStringBuilder.getCPtr(sbJson), sbJson);
  }

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

  public CkCertChain GetSignerCertChain(int index) {
    long cPtr = chilkatJNI.CkCrypt2_GetSignerCertChain(swigCPtr, this, index);
    return (cPtr == 0) ? null : new CkCertChain(cPtr, true);
  }

  public boolean HashBdENC(CkBinData bd, CkString outStr) {
    return chilkatJNI.CkCrypt2_HashBdENC(swigCPtr, this, CkBinData.getCPtr(bd), bd, CkString.getCPtr(outStr), outStr);
  }

  public String hashBdENC(CkBinData bd) {
    return chilkatJNI.CkCrypt2_hashBdENC(swigCPtr, this, CkBinData.getCPtr(bd), bd);
  }

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

  public boolean HashBeginString(String strData) {
    return chilkatJNI.CkCrypt2_HashBeginString(swigCPtr, this, strData);
  }

  public boolean HashBytes(CkByteData data, CkByteData outData) {
    return chilkatJNI.CkCrypt2_HashBytes(swigCPtr, this, CkByteData.getCPtr(data), data, CkByteData.getCPtr(outData), outData);
  }

  public boolean HashBytesENC(CkByteData data, CkString outStr) {
    return chilkatJNI.CkCrypt2_HashBytesENC(swigCPtr, this, CkByteData.getCPtr(data), data, CkString.getCPtr(outStr), outStr);
  }

  public String hashBytesENC(CkByteData data) {
    return chilkatJNI.CkCrypt2_hashBytesENC(swigCPtr, this, CkByteData.getCPtr(data), data);
  }

  public boolean HashChunkBd(boolean firstChunk, CkBinData bd) {
    return chilkatJNI.CkCrypt2_HashChunkBd(swigCPtr, this, firstChunk, CkBinData.getCPtr(bd), bd);
  }

  public boolean HashFile(String path, CkByteData outBytes) {
    return chilkatJNI.CkCrypt2_HashFile(swigCPtr, this, path, CkByteData.getCPtr(outBytes), outBytes);
  }

  public CkTask HashFileAsync(String path) {
    long cPtr = chilkatJNI.CkCrypt2_HashFileAsync(swigCPtr, this, path);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean HashFileENC(String path, CkString outStr) {
    return chilkatJNI.CkCrypt2_HashFileENC(swigCPtr, this, path, CkString.getCPtr(outStr), outStr);
  }

  public String hashFileENC(String path) {
    return chilkatJNI.CkCrypt2_hashFileENC(swigCPtr, this, path);
  }

  public CkTask HashFileENCAsync(String path) {
    long cPtr = chilkatJNI.CkCrypt2_HashFileENCAsync(swigCPtr, this, path);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean HashFinal(CkByteData outBytes) {
    return chilkatJNI.CkCrypt2_HashFinal(swigCPtr, this, CkByteData.getCPtr(outBytes), outBytes);
  }

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

  public String hashFinalENC() {
    return chilkatJNI.CkCrypt2_hashFinalENC(swigCPtr, this);
  }

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

  public boolean HashMoreString(String strData) {
    return chilkatJNI.CkCrypt2_HashMoreString(swigCPtr, this, strData);
  }

  public boolean HashString(String str, CkByteData outData) {
    return chilkatJNI.CkCrypt2_HashString(swigCPtr, this, str, CkByteData.getCPtr(outData), outData);
  }

  public boolean HashStringENC(String str, CkString outStr) {
    return chilkatJNI.CkCrypt2_HashStringENC(swigCPtr, this, str, CkString.getCPtr(outStr), outStr);
  }

  public String hashStringENC(String str) {
    return chilkatJNI.CkCrypt2_hashStringENC(swigCPtr, this, str);
  }

  public boolean HasSignatureSigningTime(int index) {
    return chilkatJNI.CkCrypt2_HasSignatureSigningTime(swigCPtr, this, index);
  }

  public boolean Hotp(String secret, String secretEnc, String counterHex, int numDigits, int truncOffset, String hashAlg, CkString outStr) {
    return chilkatJNI.CkCrypt2_Hotp(swigCPtr, this, secret, secretEnc, counterHex, numDigits, truncOffset, hashAlg, CkString.getCPtr(outStr), outStr);
  }

  public String hotp(String secret, String secretEnc, String counterHex, int numDigits, int truncOffset, String hashAlg) {
    return chilkatJNI.CkCrypt2_hotp(swigCPtr, this, secret, secretEnc, counterHex, numDigits, truncOffset, hashAlg);
  }

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

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

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

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

  public boolean MacBdENC(CkBinData bd, CkString outStr) {
    return chilkatJNI.CkCrypt2_MacBdENC(swigCPtr, this, CkBinData.getCPtr(bd), bd, CkString.getCPtr(outStr), outStr);
  }

  public String macBdENC(CkBinData bd) {
    return chilkatJNI.CkCrypt2_macBdENC(swigCPtr, this, CkBinData.getCPtr(bd), bd);
  }

  public boolean MacBytes(CkByteData inBytes, CkByteData outBytes) {
    return chilkatJNI.CkCrypt2_MacBytes(swigCPtr, this, CkByteData.getCPtr(inBytes), inBytes, CkByteData.getCPtr(outBytes), outBytes);
  }

  public boolean MacBytesENC(CkByteData inBytes, CkString outStr) {
    return chilkatJNI.CkCrypt2_MacBytesENC(swigCPtr, this, CkByteData.getCPtr(inBytes), inBytes, CkString.getCPtr(outStr), outStr);
  }

  public String macBytesENC(CkByteData inBytes) {
    return chilkatJNI.CkCrypt2_macBytesENC(swigCPtr, this, CkByteData.getCPtr(inBytes), inBytes);
  }

  public boolean MacString(String inText, CkByteData outBytes) {
    return chilkatJNI.CkCrypt2_MacString(swigCPtr, this, inText, CkByteData.getCPtr(outBytes), outBytes);
  }

  public boolean MacStringENC(String inText, CkString outStr) {
    return chilkatJNI.CkCrypt2_MacStringENC(swigCPtr, this, inText, CkString.getCPtr(outStr), outStr);
  }

  public String macStringENC(String inText) {
    return chilkatJNI.CkCrypt2_macStringENC(swigCPtr, this, inText);
  }

  public boolean MySqlAesDecrypt(String strEncryptedHex, String strPassword, CkString outStr) {
    return chilkatJNI.CkCrypt2_MySqlAesDecrypt(swigCPtr, this, strEncryptedHex, strPassword, CkString.getCPtr(outStr), outStr);
  }

  public String mySqlAesDecrypt(String strEncryptedHex, String strPassword) {
    return chilkatJNI.CkCrypt2_mySqlAesDecrypt(swigCPtr, this, strEncryptedHex, strPassword);
  }

  public boolean MySqlAesEncrypt(String strData, String strPassword, CkString outStr) {
    return chilkatJNI.CkCrypt2_MySqlAesEncrypt(swigCPtr, this, strData, strPassword, CkString.getCPtr(outStr), outStr);
  }

  public String mySqlAesEncrypt(String strData, String strPassword) {
    return chilkatJNI.CkCrypt2_mySqlAesEncrypt(swigCPtr, this, strData, strPassword);
  }

  public boolean OpaqueSignBd(CkBinData bd) {
    return chilkatJNI.CkCrypt2_OpaqueSignBd(swigCPtr, this, CkBinData.getCPtr(bd), bd);
  }

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

  public boolean OpaqueSignBytes(CkByteData data, CkByteData outData) {
    return chilkatJNI.CkCrypt2_OpaqueSignBytes(swigCPtr, this, CkByteData.getCPtr(data), data, CkByteData.getCPtr(outData), outData);
  }

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

  public boolean OpaqueSignBytesENC(CkByteData data, CkString outStr) {
    return chilkatJNI.CkCrypt2_OpaqueSignBytesENC(swigCPtr, this, CkByteData.getCPtr(data), data, CkString.getCPtr(outStr), outStr);
  }

  public String opaqueSignBytesENC(CkByteData data) {
    return chilkatJNI.CkCrypt2_opaqueSignBytesENC(swigCPtr, this, CkByteData.getCPtr(data), data);
  }

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

  public boolean OpaqueSignString(String str, CkByteData outData) {
    return chilkatJNI.CkCrypt2_OpaqueSignString(swigCPtr, this, str, CkByteData.getCPtr(outData), outData);
  }

  public CkTask OpaqueSignStringAsync(String str) {
    long cPtr = chilkatJNI.CkCrypt2_OpaqueSignStringAsync(swigCPtr, this, str);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean OpaqueSignStringENC(String str, CkString outStr) {
    return chilkatJNI.CkCrypt2_OpaqueSignStringENC(swigCPtr, this, str, CkString.getCPtr(outStr), outStr);
  }

  public String opaqueSignStringENC(String str) {
    return chilkatJNI.CkCrypt2_opaqueSignStringENC(swigCPtr, this, str);
  }

  public CkTask OpaqueSignStringENCAsync(String str) {
    long cPtr = chilkatJNI.CkCrypt2_OpaqueSignStringENCAsync(swigCPtr, this, str);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean OpaqueVerifyBd(CkBinData bd) {
    return chilkatJNI.CkCrypt2_OpaqueVerifyBd(swigCPtr, this, CkBinData.getCPtr(bd), bd);
  }

  public boolean OpaqueVerifyBytes(CkByteData p7m, CkByteData outOriginal) {
    return chilkatJNI.CkCrypt2_OpaqueVerifyBytes(swigCPtr, this, CkByteData.getCPtr(p7m), p7m, CkByteData.getCPtr(outOriginal), outOriginal);
  }

  public boolean OpaqueVerifyBytesENC(String p7m, CkByteData outOriginal) {
    return chilkatJNI.CkCrypt2_OpaqueVerifyBytesENC(swigCPtr, this, p7m, CkByteData.getCPtr(outOriginal), outOriginal);
  }

  public boolean OpaqueVerifyString(CkByteData p7m, CkString outOriginal) {
    return chilkatJNI.CkCrypt2_OpaqueVerifyString(swigCPtr, this, CkByteData.getCPtr(p7m), p7m, CkString.getCPtr(outOriginal), outOriginal);
  }

  public String opaqueVerifyString(CkByteData p7m) {
    return chilkatJNI.CkCrypt2_opaqueVerifyString(swigCPtr, this, CkByteData.getCPtr(p7m), p7m);
  }

  public boolean OpaqueVerifyStringENC(String p7m, CkString outOriginal) {
    return chilkatJNI.CkCrypt2_OpaqueVerifyStringENC(swigCPtr, this, p7m, CkString.getCPtr(outOriginal), outOriginal);
  }

  public String opaqueVerifyStringENC(String p7m) {
    return chilkatJNI.CkCrypt2_opaqueVerifyStringENC(swigCPtr, this, p7m);
  }

  public boolean Pbkdf1(String password, String charset, String hashAlg, String salt, int iterationCount, int outputKeyBitLen, String encoding, CkString outStr) {
    return chilkatJNI.CkCrypt2_Pbkdf1(swigCPtr, this, password, charset, hashAlg, salt, iterationCount, outputKeyBitLen, encoding, CkString.getCPtr(outStr), outStr);
  }

  public String pbkdf1(String password, String charset, String hashAlg, String salt, int iterationCount, int outputKeyBitLen, String encoding) {
    return chilkatJNI.CkCrypt2_pbkdf1(swigCPtr, this, password, charset, hashAlg, salt, iterationCount, outputKeyBitLen, encoding);
  }

  public boolean Pbkdf2(String password, String charset, String hashAlg, String salt, int iterationCount, int outputKeyBitLen, String encoding, CkString outStr) {
    return chilkatJNI.CkCrypt2_Pbkdf2(swigCPtr, this, password, charset, hashAlg, salt, iterationCount, outputKeyBitLen, encoding, CkString.getCPtr(outStr), outStr);
  }

  public String pbkdf2(String password, String charset, String hashAlg, String salt, int iterationCount, int outputKeyBitLen, String encoding) {
    return chilkatJNI.CkCrypt2_pbkdf2(swigCPtr, this, password, charset, hashAlg, salt, iterationCount, outputKeyBitLen, encoding);
  }

  public void RandomizeIV() {
    chilkatJNI.CkCrypt2_RandomizeIV(swigCPtr, this);
  }

  public void RandomizeKey() {
    chilkatJNI.CkCrypt2_RandomizeKey(swigCPtr, this);
  }

  public boolean ReEncode(String encodedData, String fromEncoding, String toEncoding, CkString outStr) {
    return chilkatJNI.CkCrypt2_ReEncode(swigCPtr, this, encodedData, fromEncoding, toEncoding, CkString.getCPtr(outStr), outStr);
  }

  public String reEncode(String encodedData, String fromEncoding, String toEncoding) {
    return chilkatJNI.CkCrypt2_reEncode(swigCPtr, this, encodedData, fromEncoding, toEncoding);
  }

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

  public boolean SetDecryptCert2(CkCert cert, CkPrivateKey key) {
    return chilkatJNI.CkCrypt2_SetDecryptCert2(swigCPtr, this, CkCert.getCPtr(cert), cert, CkPrivateKey.getCPtr(key), key);
  }

  public boolean SetEncodedAad(String aadStr, String encoding) {
    return chilkatJNI.CkCrypt2_SetEncodedAad(swigCPtr, this, aadStr, encoding);
  }

  public boolean SetEncodedAuthTag(String authTagStr, String encoding) {
    return chilkatJNI.CkCrypt2_SetEncodedAuthTag(swigCPtr, this, authTagStr, encoding);
  }

  public void SetEncodedIV(String ivStr, String encoding) {
    chilkatJNI.CkCrypt2_SetEncodedIV(swigCPtr, this, ivStr, encoding);
  }

  public void SetEncodedKey(String keyStr, String encoding) {
    chilkatJNI.CkCrypt2_SetEncodedKey(swigCPtr, this, keyStr, encoding);
  }

  public void SetEncodedSalt(String saltStr, String encoding) {
    chilkatJNI.CkCrypt2_SetEncodedSalt(swigCPtr, this, saltStr, encoding);
  }

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

  public boolean SetMacKeyBytes(CkByteData keyBytes) {
    return chilkatJNI.CkCrypt2_SetMacKeyBytes(swigCPtr, this, CkByteData.getCPtr(keyBytes), keyBytes);
  }

  public boolean SetMacKeyEncoded(String key, String encoding) {
    return chilkatJNI.CkCrypt2_SetMacKeyEncoded(swigCPtr, this, key, encoding);
  }

  public boolean SetMacKeyString(String key) {
    return chilkatJNI.CkCrypt2_SetMacKeyString(swigCPtr, this, key);
  }

  public void SetSecretKeyViaPassword(String password) {
    chilkatJNI.CkCrypt2_SetSecretKeyViaPassword(swigCPtr, this, password);
  }

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

  public boolean SetSigningCert2(CkCert cert, CkPrivateKey privateKey) {
    return chilkatJNI.CkCrypt2_SetSigningCert2(swigCPtr, this, CkCert.getCPtr(cert), cert, CkPrivateKey.getCPtr(privateKey), privateKey);
  }

  public void SetTsaHttpObj(CkHttp http) {
    chilkatJNI.CkCrypt2_SetTsaHttpObj(swigCPtr, this, CkHttp.getCPtr(http), http);
  }

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

  public boolean SignBdENC(CkBinData dataToSign, CkString outStr) {
    return chilkatJNI.CkCrypt2_SignBdENC(swigCPtr, this, CkBinData.getCPtr(dataToSign), dataToSign, CkString.getCPtr(outStr), outStr);
  }

  public String signBdENC(CkBinData dataToSign) {
    return chilkatJNI.CkCrypt2_signBdENC(swigCPtr, this, CkBinData.getCPtr(dataToSign), dataToSign);
  }

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

  public boolean SignBytes(CkByteData data, CkByteData outData) {
    return chilkatJNI.CkCrypt2_SignBytes(swigCPtr, this, CkByteData.getCPtr(data), data, CkByteData.getCPtr(outData), outData);
  }

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

  public boolean SignBytesENC(CkByteData data, CkString outStr) {
    return chilkatJNI.CkCrypt2_SignBytesENC(swigCPtr, this, CkByteData.getCPtr(data), data, CkString.getCPtr(outStr), outStr);
  }

  public String signBytesENC(CkByteData data) {
    return chilkatJNI.CkCrypt2_signBytesENC(swigCPtr, this, CkByteData.getCPtr(data), data);
  }

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

  public boolean SignHashENC(String encodedHash, String hashAlg, String hashEncoding, CkString outStr) {
    return chilkatJNI.CkCrypt2_SignHashENC(swigCPtr, this, encodedHash, hashAlg, hashEncoding, CkString.getCPtr(outStr), outStr);
  }

  public String signHashENC(String encodedHash, String hashAlg, String hashEncoding) {
    return chilkatJNI.CkCrypt2_signHashENC(swigCPtr, this, encodedHash, hashAlg, hashEncoding);
  }

  public CkTask SignHashENCAsync(String encodedHash, String hashAlg, String hashEncoding) {
    long cPtr = chilkatJNI.CkCrypt2_SignHashENCAsync(swigCPtr, this, encodedHash, hashAlg, hashEncoding);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean SignSbENC(CkStringBuilder sb, CkString outStr) {
    return chilkatJNI.CkCrypt2_SignSbENC(swigCPtr, this, CkStringBuilder.getCPtr(sb), sb, CkString.getCPtr(outStr), outStr);
  }

  public String signSbENC(CkStringBuilder sb) {
    return chilkatJNI.CkCrypt2_signSbENC(swigCPtr, this, CkStringBuilder.getCPtr(sb), sb);
  }

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

  public boolean SignString(String str, CkByteData outData) {
    return chilkatJNI.CkCrypt2_SignString(swigCPtr, this, str, CkByteData.getCPtr(outData), outData);
  }

  public CkTask SignStringAsync(String str) {
    long cPtr = chilkatJNI.CkCrypt2_SignStringAsync(swigCPtr, this, str);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean SignStringENC(String str, CkString outStr) {
    return chilkatJNI.CkCrypt2_SignStringENC(swigCPtr, this, str, CkString.getCPtr(outStr), outStr);
  }

  public String signStringENC(String str) {
    return chilkatJNI.CkCrypt2_signStringENC(swigCPtr, this, str);
  }

  public CkTask SignStringENCAsync(String str) {
    long cPtr = chilkatJNI.CkCrypt2_SignStringENCAsync(swigCPtr, this, str);
    return (cPtr == 0) ? null : new CkTask(cPtr, true);
  }

  public boolean Totp(String secret, String secretEnc, String t0, String tNow, int tStep, int numDigits, int truncOffset, String hashAlg, CkString outStr) {
    return chilkatJNI.CkCrypt2_Totp(swigCPtr, this, secret, secretEnc, t0, tNow, tStep, numDigits, truncOffset, hashAlg, CkString.getCPtr(outStr), outStr);
  }

  public String totp(String secret, String secretEnc, String t0, String tNow, int tStep, int numDigits, int truncOffset, String hashAlg) {
    return chilkatJNI.CkCrypt2_totp(swigCPtr, this, secret, secretEnc, t0, tNow, tStep, numDigits, truncOffset, hashAlg);
  }

  public boolean UseCertVault(CkXmlCertVault vault) {
    return chilkatJNI.CkCrypt2_UseCertVault(swigCPtr, this, CkXmlCertVault.getCPtr(vault), vault);
  }

  public boolean VerifyBdENC(CkBinData data, String encodedSig) {
    return chilkatJNI.CkCrypt2_VerifyBdENC(swigCPtr, this, CkBinData.getCPtr(data), data, encodedSig);
  }

  public boolean VerifyBytes(CkByteData data, CkByteData sig) {
    return chilkatJNI.CkCrypt2_VerifyBytes(swigCPtr, this, CkByteData.getCPtr(data), data, CkByteData.getCPtr(sig), sig);
  }

  public boolean VerifyBytesENC(CkByteData data, String encodedSig) {
    return chilkatJNI.CkCrypt2_VerifyBytesENC(swigCPtr, this, CkByteData.getCPtr(data), data, encodedSig);
  }

  public boolean VerifyDetachedSignature(String inFilename, String p7sFilename) {
    return chilkatJNI.CkCrypt2_VerifyDetachedSignature(swigCPtr, this, inFilename, p7sFilename);
  }

  public boolean VerifyP7M(String p7mPath, String destPath) {
    return chilkatJNI.CkCrypt2_VerifyP7M(swigCPtr, this, p7mPath, destPath);
  }

  public boolean VerifyP7S(String originalDataPath, String p7sPath) {
    return chilkatJNI.CkCrypt2_VerifyP7S(swigCPtr, this, originalDataPath, p7sPath);
  }

  public boolean VerifySbENC(CkStringBuilder sb, String encodedSig) {
    return chilkatJNI.CkCrypt2_VerifySbENC(swigCPtr, this, CkStringBuilder.getCPtr(sb), sb, encodedSig);
  }

  public boolean VerifyString(String str, CkByteData sig) {
    return chilkatJNI.CkCrypt2_VerifyString(swigCPtr, this, str, CkByteData.getCPtr(sig), sig);
  }

  public boolean VerifyStringENC(String str, String encodedSig) {
    return chilkatJNI.CkCrypt2_VerifyStringENC(swigCPtr, this, str, encodedSig);
  }

  public void XtsSetDataUnitNumber(long loUint32, long hiUint32) {
    chilkatJNI.CkCrypt2_XtsSetDataUnitNumber(swigCPtr, this, loUint32, hiUint32);
  }

  public void XtsSetEncodedTweakKey(String key, String encoding) {
    chilkatJNI.CkCrypt2_XtsSetEncodedTweakKey(swigCPtr, this, key, encoding);
  }

  public void XtsSetEncodedTweakValue(String tweak, String encoding) {
    chilkatJNI.CkCrypt2_XtsSetEncodedTweakValue(swigCPtr, this, tweak, encoding);
  }

}
