@chilkat/react-native 11.6.1

package/nitrogen/generated/shared/c++/HybridEccSpec.hpp

@@ -0,0 +1,96 @@
+///
+/// HybridEccSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridPrivateKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPrivateKeySpec; }
+// Forward declaration of `HybridPublicKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPublicKeySpec; }
+// Forward declaration of `HybridPrngSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPrngSpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridCertSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridCertSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridPrivateKeySpec.hpp"
+#include "HybridPublicKeySpec.hpp"
+#include "HybridPrngSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+#include "HybridCertSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Ecc`
+   * Inherit this class to create instances of `HybridEccSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridEcc: public HybridEccSpec {
+   * public:
+   *   HybridEcc(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridEccSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridEccSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridEccSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getLastErrorHtml() = 0;
+      virtual std::string getLastErrorText() = 0;
+      virtual std::string getLastErrorXml() = 0;
+      virtual std::string getVersion() = 0;
+      virtual std::string getDebugLogFilePath() = 0;
+      virtual void setDebugLogFilePath(const std::string& debugLogFilePath) = 0;
+      virtual bool getVerboseLogging() = 0;
+      virtual void setVerboseLogging(bool verboseLogging) = 0;
+      virtual bool getLastMethodSuccess() = 0;
+      virtual void setLastMethodSuccess(bool lastMethodSuccess) = 0;
+      virtual bool getAsnFormat() = 0;
+      virtual void setAsnFormat(bool asnFormat) = 0;
+
+    public:
+      // Methods
+      virtual std::string sharedSecretENC(const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridPublicKeySpec>& pubKey, const std::string& encoding) = 0;
+      virtual std::string signHashENC(const std::string& encodedHash, const std::string& encoding, const std::shared_ptr<HybridPrivateKeySpec>& privkey, const std::shared_ptr<HybridPrngSpec>& prng) = 0;
+      virtual double verifyHashENC(const std::string& encodedHash, const std::string& encodedSig, const std::string& encoding, const std::shared_ptr<HybridPublicKeySpec>& pubkey) = 0;
+      virtual std::string signBd(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlg, const std::string& encoding, const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridPrngSpec>& prng) = 0;
+      virtual double verifyBd(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlg, const std::string& encodedSig, const std::string& encoding, const std::shared_ptr<HybridPublicKeySpec>& pubkey) = 0;
+      virtual std::string signBdUsingCert(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlg, const std::string& encoding, const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual std::string signHashUsingCert(const std::string& encodedHash, const std::string& encoding, const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void genKey(const std::string& curveName, const std::shared_ptr<HybridPrngSpec>& prng, const std::shared_ptr<HybridPrivateKeySpec>& privKey) = 0;
+      virtual void genKey2(const std::string& curveName, const std::string& encodedK, const std::string& encoding, const std::shared_ptr<HybridPrivateKeySpec>& privKey) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Ecc";
+  };
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridEdDSASpec.cpp

@@ -0,0 +1,38 @@
+///
+/// HybridEdDSASpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridEdDSASpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridEdDSASpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridEdDSASpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridEdDSASpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridEdDSASpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridEdDSASpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridEdDSASpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridEdDSASpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridEdDSASpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridEdDSASpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridEdDSASpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridEdDSASpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("algorithm", &HybridEdDSASpec::getAlgorithm);
+      prototype.registerHybridSetter("algorithm", &HybridEdDSASpec::setAlgorithm);
+      prototype.registerHybridGetter("context", &HybridEdDSASpec::getContext);
+      prototype.registerHybridSetter("context", &HybridEdDSASpec::setContext);
+      prototype.registerHybridMethod("genEd25519Key", &HybridEdDSASpec::genEd25519Key);
+      prototype.registerHybridMethod("signBdENC", &HybridEdDSASpec::signBdENC);
+      prototype.registerHybridMethod("verifyBdENC", &HybridEdDSASpec::verifyBdENC);
+      prototype.registerHybridMethod("sharedSecretENC", &HybridEdDSASpec::sharedSecretENC);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridEdDSASpec.hpp

@@ -0,0 +1,90 @@
+///
+/// HybridEdDSASpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridPrngSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPrngSpec; }
+// Forward declaration of `HybridPrivateKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPrivateKeySpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridPublicKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPublicKeySpec; }
+
+#include <string>
+#include <memory>
+#include "HybridPrngSpec.hpp"
+#include "HybridPrivateKeySpec.hpp"
+#include "HybridBinDataSpec.hpp"
+#include "HybridPublicKeySpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `EdDSA`
+   * Inherit this class to create instances of `HybridEdDSASpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridEdDSA: public HybridEdDSASpec {
+   * public:
+   *   HybridEdDSA(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridEdDSASpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridEdDSASpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridEdDSASpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getLastErrorHtml() = 0;
+      virtual std::string getLastErrorText() = 0;
+      virtual std::string getLastErrorXml() = 0;
+      virtual std::string getVersion() = 0;
+      virtual std::string getDebugLogFilePath() = 0;
+      virtual void setDebugLogFilePath(const std::string& debugLogFilePath) = 0;
+      virtual bool getVerboseLogging() = 0;
+      virtual void setVerboseLogging(bool verboseLogging) = 0;
+      virtual bool getLastMethodSuccess() = 0;
+      virtual void setLastMethodSuccess(bool lastMethodSuccess) = 0;
+      virtual std::string getAlgorithm() = 0;
+      virtual void setAlgorithm(const std::string& algorithm) = 0;
+      virtual std::string getContext() = 0;
+      virtual void setContext(const std::string& context) = 0;
+
+    public:
+      // Methods
+      virtual void genEd25519Key(const std::shared_ptr<HybridPrngSpec>& prng, const std::shared_ptr<HybridPrivateKeySpec>& privKey) = 0;
+      virtual std::string signBdENC(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& encoding, const std::shared_ptr<HybridPrivateKeySpec>& privkey) = 0;
+      virtual void verifyBdENC(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& encodedSig, const std::string& enocding, const std::shared_ptr<HybridPublicKeySpec>& pubkey) = 0;
+      virtual std::string sharedSecretENC(const std::shared_ptr<HybridPrivateKeySpec>& privkey, const std::shared_ptr<HybridPublicKeySpec>& pubkey, const std::string& encoding) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "EdDSA";
+  };
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridEmailBundleSpec.cpp

@@ -0,0 +1,45 @@
+///
+/// HybridEmailBundleSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridEmailBundleSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridEmailBundleSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridEmailBundleSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridEmailBundleSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridEmailBundleSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridEmailBundleSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridEmailBundleSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridEmailBundleSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridEmailBundleSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridEmailBundleSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridEmailBundleSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridEmailBundleSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("messageCount", &HybridEmailBundleSpec::getMessageCount);
+      prototype.registerHybridMethod("addEmail", &HybridEmailBundleSpec::addEmail);
+      prototype.registerHybridMethod("getXml", &HybridEmailBundleSpec::getXml);
+      prototype.registerHybridMethod("loadXml", &HybridEmailBundleSpec::loadXml);
+      prototype.registerHybridMethod("loadXmlString", &HybridEmailBundleSpec::loadXmlString);
+      prototype.registerHybridMethod("removeEmail", &HybridEmailBundleSpec::removeEmail);
+      prototype.registerHybridMethod("removeEmailByIndex", &HybridEmailBundleSpec::removeEmailByIndex);
+      prototype.registerHybridMethod("saveXml", &HybridEmailBundleSpec::saveXml);
+      prototype.registerHybridMethod("sortByDate", &HybridEmailBundleSpec::sortByDate);
+      prototype.registerHybridMethod("sortByRecipient", &HybridEmailBundleSpec::sortByRecipient);
+      prototype.registerHybridMethod("sortBySender", &HybridEmailBundleSpec::sortBySender);
+      prototype.registerHybridMethod("sortBySubject", &HybridEmailBundleSpec::sortBySubject);
+      prototype.registerHybridMethod("findEmail", &HybridEmailBundleSpec::findEmail);
+      prototype.registerHybridMethod("emailAt", &HybridEmailBundleSpec::emailAt);
+      prototype.registerHybridMethod("clear", &HybridEmailBundleSpec::clear);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridEmailBundleSpec.hpp

@@ -0,0 +1,91 @@
+///
+/// HybridEmailBundleSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridEmailSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridEmailSpec; }
+// Forward declaration of `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridEmailSpec.hpp"
+#include "HybridJsonObjectSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `EmailBundle`
+   * Inherit this class to create instances of `HybridEmailBundleSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridEmailBundle: public HybridEmailBundleSpec {
+   * public:
+   *   HybridEmailBundle(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridEmailBundleSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridEmailBundleSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridEmailBundleSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getLastErrorHtml() = 0;
+      virtual std::string getLastErrorText() = 0;
+      virtual std::string getLastErrorXml() = 0;
+      virtual std::string getVersion() = 0;
+      virtual std::string getDebugLogFilePath() = 0;
+      virtual void setDebugLogFilePath(const std::string& debugLogFilePath) = 0;
+      virtual bool getVerboseLogging() = 0;
+      virtual void setVerboseLogging(bool verboseLogging) = 0;
+      virtual bool getLastMethodSuccess() = 0;
+      virtual void setLastMethodSuccess(bool lastMethodSuccess) = 0;
+      virtual double getMessageCount() = 0;
+
+    public:
+      // Methods
+      virtual void addEmail(const std::shared_ptr<HybridEmailSpec>& email) = 0;
+      virtual std::string getXml() = 0;
+      virtual void loadXml(const std::string& path) = 0;
+      virtual void loadXmlString(const std::string& xmlStr) = 0;
+      virtual void removeEmail(const std::shared_ptr<HybridEmailSpec>& email) = 0;
+      virtual void removeEmailByIndex(double index) = 0;
+      virtual void saveXml(const std::string& path) = 0;
+      virtual void sortByDate(bool ascending) = 0;
+      virtual void sortByRecipient(bool ascending) = 0;
+      virtual void sortBySender(bool ascending) = 0;
+      virtual void sortBySubject(bool ascending) = 0;
+      virtual void findEmail(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridEmailSpec>& email) = 0;
+      virtual void emailAt(double index, const std::shared_ptr<HybridEmailSpec>& email) = 0;
+      virtual void clear() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "EmailBundle";
+  };
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridEmailSpec.cpp

@@ -0,0 +1,259 @@
+///
+/// HybridEmailSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridEmailSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridEmailSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridEmailSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridEmailSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridEmailSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridEmailSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridEmailSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridEmailSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridEmailSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridEmailSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridEmailSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridEmailSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("body", &HybridEmailSpec::getBody);
+      prototype.registerHybridSetter("body", &HybridEmailSpec::setBody);
+      prototype.registerHybridGetter("charset", &HybridEmailSpec::getCharset);
+      prototype.registerHybridSetter("charset", &HybridEmailSpec::setCharset);
+      prototype.registerHybridGetter("decrypted", &HybridEmailSpec::getDecrypted);
+      prototype.registerHybridGetter("emailDateStr", &HybridEmailSpec::getEmailDateStr);
+      prototype.registerHybridSetter("emailDateStr", &HybridEmailSpec::setEmailDateStr);
+      prototype.registerHybridGetter("encryptedBy", &HybridEmailSpec::getEncryptedBy);
+      prototype.registerHybridGetter("fileDistList", &HybridEmailSpec::getFileDistList);
+      prototype.registerHybridSetter("fileDistList", &HybridEmailSpec::setFileDistList);
+      prototype.registerHybridGetter("from", &HybridEmailSpec::getFrom);
+      prototype.registerHybridSetter("from", &HybridEmailSpec::setFrom);
+      prototype.registerHybridGetter("fromAddress", &HybridEmailSpec::getFromAddress);
+      prototype.registerHybridSetter("fromAddress", &HybridEmailSpec::setFromAddress);
+      prototype.registerHybridGetter("fromName", &HybridEmailSpec::getFromName);
+      prototype.registerHybridSetter("fromName", &HybridEmailSpec::setFromName);
+      prototype.registerHybridGetter("header", &HybridEmailSpec::getHeader);
+      prototype.registerHybridGetter("language", &HybridEmailSpec::getLanguage);
+      prototype.registerHybridGetter("localDateStr", &HybridEmailSpec::getLocalDateStr);
+      prototype.registerHybridSetter("localDateStr", &HybridEmailSpec::setLocalDateStr);
+      prototype.registerHybridGetter("mailer", &HybridEmailSpec::getMailer);
+      prototype.registerHybridSetter("mailer", &HybridEmailSpec::setMailer);
+      prototype.registerHybridGetter("numAlternatives", &HybridEmailSpec::getNumAlternatives);
+      prototype.registerHybridGetter("numAttachedMessages", &HybridEmailSpec::getNumAttachedMessages);
+      prototype.registerHybridGetter("numAttachments", &HybridEmailSpec::getNumAttachments);
+      prototype.registerHybridGetter("numBcc", &HybridEmailSpec::getNumBcc);
+      prototype.registerHybridGetter("numCC", &HybridEmailSpec::getNumCC);
+      prototype.registerHybridGetter("numDaysOld", &HybridEmailSpec::getNumDaysOld);
+      prototype.registerHybridGetter("numHeaderFields", &HybridEmailSpec::getNumHeaderFields);
+      prototype.registerHybridGetter("numRelatedItems", &HybridEmailSpec::getNumRelatedItems);
+      prototype.registerHybridGetter("numReplacePatterns", &HybridEmailSpec::getNumReplacePatterns);
+      prototype.registerHybridGetter("numReports", &HybridEmailSpec::getNumReports);
+      prototype.registerHybridGetter("numTo", &HybridEmailSpec::getNumTo);
+      prototype.registerHybridGetter("overwriteExisting", &HybridEmailSpec::getOverwriteExisting);
+      prototype.registerHybridSetter("overwriteExisting", &HybridEmailSpec::setOverwriteExisting);
+      prototype.registerHybridGetter("pkcs7CryptAlg", &HybridEmailSpec::getPkcs7CryptAlg);
+      prototype.registerHybridSetter("pkcs7CryptAlg", &HybridEmailSpec::setPkcs7CryptAlg);
+      prototype.registerHybridGetter("pkcs7KeyLength", &HybridEmailSpec::getPkcs7KeyLength);
+      prototype.registerHybridSetter("pkcs7KeyLength", &HybridEmailSpec::setPkcs7KeyLength);
+      prototype.registerHybridGetter("preferredCharset", &HybridEmailSpec::getPreferredCharset);
+      prototype.registerHybridSetter("preferredCharset", &HybridEmailSpec::setPreferredCharset);
+      prototype.registerHybridGetter("prependHeaders", &HybridEmailSpec::getPrependHeaders);
+      prototype.registerHybridSetter("prependHeaders", &HybridEmailSpec::setPrependHeaders);
+      prototype.registerHybridGetter("receivedEncrypted", &HybridEmailSpec::getReceivedEncrypted);
+      prototype.registerHybridGetter("receivedSigned", &HybridEmailSpec::getReceivedSigned);
+      prototype.registerHybridGetter("replyTo", &HybridEmailSpec::getReplyTo);
+      prototype.registerHybridSetter("replyTo", &HybridEmailSpec::setReplyTo);
+      prototype.registerHybridGetter("returnReceipt", &HybridEmailSpec::getReturnReceipt);
+      prototype.registerHybridSetter("returnReceipt", &HybridEmailSpec::setReturnReceipt);
+      prototype.registerHybridGetter("sendEncrypted", &HybridEmailSpec::getSendEncrypted);
+      prototype.registerHybridSetter("sendEncrypted", &HybridEmailSpec::setSendEncrypted);
+      prototype.registerHybridGetter("sendSigned", &HybridEmailSpec::getSendSigned);
+      prototype.registerHybridSetter("sendSigned", &HybridEmailSpec::setSendSigned);
+      prototype.registerHybridGetter("signaturesValid", &HybridEmailSpec::getSignaturesValid);
+      prototype.registerHybridGetter("signedBy", &HybridEmailSpec::getSignedBy);
+      prototype.registerHybridGetter("signingHashAlg", &HybridEmailSpec::getSigningHashAlg);
+      prototype.registerHybridSetter("signingHashAlg", &HybridEmailSpec::setSigningHashAlg);
+      prototype.registerHybridGetter("size", &HybridEmailSpec::getSize);
+      prototype.registerHybridGetter("subject", &HybridEmailSpec::getSubject);
+      prototype.registerHybridSetter("subject", &HybridEmailSpec::setSubject);
+      prototype.registerHybridGetter("uidl", &HybridEmailSpec::getUidl);
+      prototype.registerHybridGetter("unpackUseRelPaths", &HybridEmailSpec::getUnpackUseRelPaths);
+      prototype.registerHybridSetter("unpackUseRelPaths", &HybridEmailSpec::setUnpackUseRelPaths);
+      prototype.registerHybridGetter("numDigests", &HybridEmailSpec::getNumDigests);
+      prototype.registerHybridGetter("signingAlg", &HybridEmailSpec::getSigningAlg);
+      prototype.registerHybridSetter("signingAlg", &HybridEmailSpec::setSigningAlg);
+      prototype.registerHybridGetter("oaepPadding", &HybridEmailSpec::getOaepPadding);
+      prototype.registerHybridSetter("oaepPadding", &HybridEmailSpec::setOaepPadding);
+      prototype.registerHybridGetter("oaepHash", &HybridEmailSpec::getOaepHash);
+      prototype.registerHybridSetter("oaepHash", &HybridEmailSpec::setOaepHash);
+      prototype.registerHybridGetter("oaepMgfHash", &HybridEmailSpec::getOaepMgfHash);
+      prototype.registerHybridSetter("oaepMgfHash", &HybridEmailSpec::setOaepMgfHash);
+      prototype.registerHybridGetter("uncommonOptions", &HybridEmailSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridEmailSpec::setUncommonOptions);
+      prototype.registerHybridMethod("addAttachmentHeader", &HybridEmailSpec::addAttachmentHeader);
+      prototype.registerHybridMethod("addBcc", &HybridEmailSpec::addBcc);
+      prototype.registerHybridMethod("addCC", &HybridEmailSpec::addCC);
+      prototype.registerHybridMethod("addEncryptCert", &HybridEmailSpec::addEncryptCert);
+      prototype.registerHybridMethod("addFileAttachment", &HybridEmailSpec::addFileAttachment);
+      prototype.registerHybridMethod("addFileAttachment2", &HybridEmailSpec::addFileAttachment2);
+      prototype.registerHybridMethod("addHeaderField", &HybridEmailSpec::addHeaderField);
+      prototype.registerHybridMethod("addHeaderField2", &HybridEmailSpec::addHeaderField2);
+      prototype.registerHybridMethod("addHtmlAlternativeBody", &HybridEmailSpec::addHtmlAlternativeBody);
+      prototype.registerHybridMethod("addMultipleBcc", &HybridEmailSpec::addMultipleBcc);
+      prototype.registerHybridMethod("addMultipleCC", &HybridEmailSpec::addMultipleCC);
+      prototype.registerHybridMethod("addMultipleTo", &HybridEmailSpec::addMultipleTo);
+      prototype.registerHybridMethod("addPfxSourceFile", &HybridEmailSpec::addPfxSourceFile);
+      prototype.registerHybridMethod("addPlainTextAlternativeBody", &HybridEmailSpec::addPlainTextAlternativeBody);
+      prototype.registerHybridMethod("addRelatedFile", &HybridEmailSpec::addRelatedFile);
+      prototype.registerHybridMethod("addRelatedFile2", &HybridEmailSpec::addRelatedFile2);
+      prototype.registerHybridMethod("addRelatedHeader", &HybridEmailSpec::addRelatedHeader);
+      prototype.registerHybridMethod("addRelatedString", &HybridEmailSpec::addRelatedString);
+      prototype.registerHybridMethod("addRelatedString2", &HybridEmailSpec::addRelatedString2);
+      prototype.registerHybridMethod("addStringAttachment", &HybridEmailSpec::addStringAttachment);
+      prototype.registerHybridMethod("addStringAttachment2", &HybridEmailSpec::addStringAttachment2);
+      prototype.registerHybridMethod("addTo", &HybridEmailSpec::addTo);
+      prototype.registerHybridMethod("addiCalendarAlternativeBody", &HybridEmailSpec::addiCalendarAlternativeBody);
+      prototype.registerHybridMethod("aesDecrypt", &HybridEmailSpec::aesDecrypt);
+      prototype.registerHybridMethod("aesEncrypt", &HybridEmailSpec::aesEncrypt);
+      prototype.registerHybridMethod("appendToBody", &HybridEmailSpec::appendToBody);
+      prototype.registerHybridMethod("aspUnpack", &HybridEmailSpec::aspUnpack);
+      prototype.registerHybridMethod("bEncodeString", &HybridEmailSpec::bEncodeString);
+      prototype.registerHybridMethod("clearBcc", &HybridEmailSpec::clearBcc);
+      prototype.registerHybridMethod("clearCC", &HybridEmailSpec::clearCC);
+      prototype.registerHybridMethod("clearEncryptCerts", &HybridEmailSpec::clearEncryptCerts);
+      prototype.registerHybridMethod("clearTo", &HybridEmailSpec::clearTo);
+      prototype.registerHybridMethod("createTempMht", &HybridEmailSpec::createTempMht);
+      prototype.registerHybridMethod("dropAttachments", &HybridEmailSpec::dropAttachments);
+      prototype.registerHybridMethod("dropRelatedItem", &HybridEmailSpec::dropRelatedItem);
+      prototype.registerHybridMethod("dropRelatedItems", &HybridEmailSpec::dropRelatedItems);
+      prototype.registerHybridMethod("dropSingleAttachment", &HybridEmailSpec::dropSingleAttachment);
+      prototype.registerHybridMethod("generateFilename", &HybridEmailSpec::generateFilename);
+      prototype.registerHybridMethod("getAltHeaderField", &HybridEmailSpec::getAltHeaderField);
+      prototype.registerHybridMethod("getAlternativeBody", &HybridEmailSpec::getAlternativeBody);
+      prototype.registerHybridMethod("getAlternativeBodyByContentType", &HybridEmailSpec::getAlternativeBodyByContentType);
+      prototype.registerHybridMethod("getAlternativeContentType", &HybridEmailSpec::getAlternativeContentType);
+      prototype.registerHybridMethod("getAttachedMessageAttr", &HybridEmailSpec::getAttachedMessageAttr);
+      prototype.registerHybridMethod("getAttachedMessageFilename", &HybridEmailSpec::getAttachedMessageFilename);
+      prototype.registerHybridMethod("getAttachmentAttr", &HybridEmailSpec::getAttachmentAttr);
+      prototype.registerHybridMethod("getAttachmentContentID", &HybridEmailSpec::getAttachmentContentID);
+      prototype.registerHybridMethod("getAttachmentContentType", &HybridEmailSpec::getAttachmentContentType);
+      prototype.registerHybridMethod("getAttachmentFilename", &HybridEmailSpec::getAttachmentFilename);
+      prototype.registerHybridMethod("getAttachmentHeader", &HybridEmailSpec::getAttachmentHeader);
+      prototype.registerHybridMethod("getAttachmentSize", &HybridEmailSpec::getAttachmentSize);
+      prototype.registerHybridMethod("getAttachmentString", &HybridEmailSpec::getAttachmentString);
+      prototype.registerHybridMethod("getAttachmentStringCrLf", &HybridEmailSpec::getAttachmentStringCrLf);
+      prototype.registerHybridMethod("getBcc", &HybridEmailSpec::getBcc);
+      prototype.registerHybridMethod("getBccAddr", &HybridEmailSpec::getBccAddr);
+      prototype.registerHybridMethod("getBccName", &HybridEmailSpec::getBccName);
+      prototype.registerHybridMethod("getCC", &HybridEmailSpec::getCC);
+      prototype.registerHybridMethod("getCcAddr", &HybridEmailSpec::getCcAddr);
+      prototype.registerHybridMethod("getCcName", &HybridEmailSpec::getCcName);
+      prototype.registerHybridMethod("getDeliveryStatusInfo", &HybridEmailSpec::getDeliveryStatusInfo);
+      prototype.registerHybridMethod("getHeaderField", &HybridEmailSpec::getHeaderField);
+      prototype.registerHybridMethod("getHeaderFieldName", &HybridEmailSpec::getHeaderFieldName);
+      prototype.registerHybridMethod("getHeaderFieldValue", &HybridEmailSpec::getHeaderFieldValue);
+      prototype.registerHybridMethod("getHtmlBody", &HybridEmailSpec::getHtmlBody);
+      prototype.registerHybridMethod("getImapUid", &HybridEmailSpec::getImapUid);
+      prototype.registerHybridMethod("getMime", &HybridEmailSpec::getMime);
+      prototype.registerHybridMethod("getNthTextPartOfType", &HybridEmailSpec::getNthTextPartOfType);
+      prototype.registerHybridMethod("getNumPartsOfType", &HybridEmailSpec::getNumPartsOfType);
+      prototype.registerHybridMethod("getPlainTextBody", &HybridEmailSpec::getPlainTextBody);
+      prototype.registerHybridMethod("getRelatedAttr", &HybridEmailSpec::getRelatedAttr);
+      prototype.registerHybridMethod("getRelatedContentID", &HybridEmailSpec::getRelatedContentID);
+      prototype.registerHybridMethod("getRelatedContentLocation", &HybridEmailSpec::getRelatedContentLocation);
+      prototype.registerHybridMethod("getRelatedContentType", &HybridEmailSpec::getRelatedContentType);
+      prototype.registerHybridMethod("getRelatedFilename", &HybridEmailSpec::getRelatedFilename);
+      prototype.registerHybridMethod("getRelatedString", &HybridEmailSpec::getRelatedString);
+      prototype.registerHybridMethod("getRelatedStringCrLf", &HybridEmailSpec::getRelatedStringCrLf);
+      prototype.registerHybridMethod("getReplacePattern", &HybridEmailSpec::getReplacePattern);
+      prototype.registerHybridMethod("getReplaceString", &HybridEmailSpec::getReplaceString);
+      prototype.registerHybridMethod("getReplaceString2", &HybridEmailSpec::getReplaceString2);
+      prototype.registerHybridMethod("getReport", &HybridEmailSpec::getReport);
+      prototype.registerHybridMethod("getTo", &HybridEmailSpec::getTo);
+      prototype.registerHybridMethod("getToAddr", &HybridEmailSpec::getToAddr);
+      prototype.registerHybridMethod("getToName", &HybridEmailSpec::getToName);
+      prototype.registerHybridMethod("getXml", &HybridEmailSpec::getXml);
+      prototype.registerHybridMethod("hasHeaderMatching", &HybridEmailSpec::hasHeaderMatching);
+      prototype.registerHybridMethod("hasHtmlBody", &HybridEmailSpec::hasHtmlBody);
+      prototype.registerHybridMethod("hasPlainTextBody", &HybridEmailSpec::hasPlainTextBody);
+      prototype.registerHybridMethod("isMultipartReport", &HybridEmailSpec::isMultipartReport);
+      prototype.registerHybridMethod("loadEml", &HybridEmailSpec::loadEml);
+      prototype.registerHybridMethod("loadXml", &HybridEmailSpec::loadXml);
+      prototype.registerHybridMethod("loadXmlString", &HybridEmailSpec::loadXmlString);
+      prototype.registerHybridMethod("qEncodeString", &HybridEmailSpec::qEncodeString);
+      prototype.registerHybridMethod("removeAttachedMessage", &HybridEmailSpec::removeAttachedMessage);
+      prototype.registerHybridMethod("removeAttachedMessages", &HybridEmailSpec::removeAttachedMessages);
+      prototype.registerHybridMethod("removeAttachmentPaths", &HybridEmailSpec::removeAttachmentPaths);
+      prototype.registerHybridMethod("removeHeaderField", &HybridEmailSpec::removeHeaderField);
+      prototype.registerHybridMethod("removeHtmlAlternative", &HybridEmailSpec::removeHtmlAlternative);
+      prototype.registerHybridMethod("removePlainTextAlternative", &HybridEmailSpec::removePlainTextAlternative);
+      prototype.registerHybridMethod("saveAllAttachments", &HybridEmailSpec::saveAllAttachments);
+      prototype.registerHybridMethod("saveAttachedFile", &HybridEmailSpec::saveAttachedFile);
+      prototype.registerHybridMethod("saveEml", &HybridEmailSpec::saveEml);
+      prototype.registerHybridMethod("saveRelatedItem", &HybridEmailSpec::saveRelatedItem);
+      prototype.registerHybridMethod("saveXml", &HybridEmailSpec::saveXml);
+      prototype.registerHybridMethod("setAttachmentCharset", &HybridEmailSpec::setAttachmentCharset);
+      prototype.registerHybridMethod("setAttachmentDisposition", &HybridEmailSpec::setAttachmentDisposition);
+      prototype.registerHybridMethod("setAttachmentFilename", &HybridEmailSpec::setAttachmentFilename);
+      prototype.registerHybridMethod("setDecryptCert", &HybridEmailSpec::setDecryptCert);
+      prototype.registerHybridMethod("setDecryptCert2", &HybridEmailSpec::setDecryptCert2);
+      prototype.registerHybridMethod("setDt", &HybridEmailSpec::setDt);
+      prototype.registerHybridMethod("setEdifactBody", &HybridEmailSpec::setEdifactBody);
+      prototype.registerHybridMethod("setEncryptCert", &HybridEmailSpec::setEncryptCert);
+      prototype.registerHybridMethod("setFromMimeText", &HybridEmailSpec::setFromMimeText);
+      prototype.registerHybridMethod("setFromXmlText", &HybridEmailSpec::setFromXmlText);
+      prototype.registerHybridMethod("setHtmlBody", &HybridEmailSpec::setHtmlBody);
+      prototype.registerHybridMethod("setRelatedFilename", &HybridEmailSpec::setRelatedFilename);
+      prototype.registerHybridMethod("setReplacePattern", &HybridEmailSpec::setReplacePattern);
+      prototype.registerHybridMethod("setSigningCert", &HybridEmailSpec::setSigningCert);
+      prototype.registerHybridMethod("setSigningCert2", &HybridEmailSpec::setSigningCert2);
+      prototype.registerHybridMethod("setTextBody", &HybridEmailSpec::setTextBody);
+      prototype.registerHybridMethod("uidlEquals", &HybridEmailSpec::uidlEquals);
+      prototype.registerHybridMethod("unSpamify", &HybridEmailSpec::unSpamify);
+      prototype.registerHybridMethod("unpackHtml", &HybridEmailSpec::unpackHtml);
+      prototype.registerHybridMethod("unzipAttachments", &HybridEmailSpec::unzipAttachments);
+      prototype.registerHybridMethod("useCertVault", &HybridEmailSpec::useCertVault);
+      prototype.registerHybridMethod("zipAttachments", &HybridEmailSpec::zipAttachments);
+      prototype.registerHybridMethod("computeGlobalKey2", &HybridEmailSpec::computeGlobalKey2);
+      prototype.registerHybridMethod("getMimeSb", &HybridEmailSpec::getMimeSb);
+      prototype.registerHybridMethod("getMimeBd", &HybridEmailSpec::getMimeBd);
+      prototype.registerHybridMethod("setFromMimeSb", &HybridEmailSpec::setFromMimeSb);
+      prototype.registerHybridMethod("setFromMimeBd", &HybridEmailSpec::setFromMimeBd);
+      prototype.registerHybridMethod("addAttachmentBd", &HybridEmailSpec::addAttachmentBd);
+      prototype.registerHybridMethod("addRelatedBd", &HybridEmailSpec::addRelatedBd);
+      prototype.registerHybridMethod("addRelatedBd2", &HybridEmailSpec::addRelatedBd2);
+      prototype.registerHybridMethod("getAttachmentBd", &HybridEmailSpec::getAttachmentBd);
+      prototype.registerHybridMethod("getAlternativeBodyBd", &HybridEmailSpec::getAlternativeBodyBd);
+      prototype.registerHybridMethod("applyFixups", &HybridEmailSpec::applyFixups);
+      prototype.registerHybridMethod("clear", &HybridEmailSpec::clear);
+      prototype.registerHybridMethod("convertInlineImages", &HybridEmailSpec::convertInlineImages);
+      prototype.registerHybridMethod("attachEmail", &HybridEmailSpec::attachEmail);
+      prototype.registerHybridMethod("getNthContentType", &HybridEmailSpec::getNthContentType);
+      prototype.registerHybridMethod("getNthBinaryPartOfTypeBd", &HybridEmailSpec::getNthBinaryPartOfTypeBd);
+      prototype.registerHybridMethod("getRelatedHeader", &HybridEmailSpec::getRelatedHeader);
+      prototype.registerHybridMethod("getHtmlBodySb", &HybridEmailSpec::getHtmlBodySb);
+      prototype.registerHybridMethod("lastDecryptCert", &HybridEmailSpec::lastDecryptCert);
+      prototype.registerHybridMethod("lastSignerCert", &HybridEmailSpec::lastSignerCert);
+      prototype.registerHybridMethod("makeCopy", &HybridEmailSpec::makeCopy);
+      prototype.registerHybridMethod("toDsn", &HybridEmailSpec::toDsn);
+      prototype.registerHybridMethod("toForward", &HybridEmailSpec::toForward);
+      prototype.registerHybridMethod("toMdn", &HybridEmailSpec::toMdn);
+      prototype.registerHybridMethod("toReply", &HybridEmailSpec::toReply);
+      prototype.registerHybridMethod("getAttachedEmail", &HybridEmailSpec::getAttachedEmail);
+      prototype.registerHybridMethod("getDigestEmail", &HybridEmailSpec::getDigestEmail);
+      prototype.registerHybridMethod("getDsnInfo", &HybridEmailSpec::getDsnInfo);
+      prototype.registerHybridMethod("linkedDomains", &HybridEmailSpec::linkedDomains);
+      prototype.registerHybridMethod("addPfxSourceBd", &HybridEmailSpec::addPfxSourceBd);
+      prototype.registerHybridMethod("setBodyBd", &HybridEmailSpec::setBodyBd);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat