@chilkat/react-native 11.6.1

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

@@ -0,0 +1,169 @@
+///
+/// HybridMimeSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridMimeSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridMimeSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridMimeSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridMimeSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridMimeSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridMimeSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridMimeSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridMimeSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridMimeSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridMimeSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridMimeSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridMimeSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("boundary", &HybridMimeSpec::getBoundary);
+      prototype.registerHybridSetter("boundary", &HybridMimeSpec::setBoundary);
+      prototype.registerHybridGetter("charset", &HybridMimeSpec::getCharset);
+      prototype.registerHybridSetter("charset", &HybridMimeSpec::setCharset);
+      prototype.registerHybridGetter("contentType", &HybridMimeSpec::getContentType);
+      prototype.registerHybridSetter("contentType", &HybridMimeSpec::setContentType);
+      prototype.registerHybridGetter("currentDateTime", &HybridMimeSpec::getCurrentDateTime);
+      prototype.registerHybridGetter("disposition", &HybridMimeSpec::getDisposition);
+      prototype.registerHybridSetter("disposition", &HybridMimeSpec::setDisposition);
+      prototype.registerHybridGetter("encoding", &HybridMimeSpec::getEncoding);
+      prototype.registerHybridSetter("encoding", &HybridMimeSpec::setEncoding);
+      prototype.registerHybridGetter("filename", &HybridMimeSpec::getFilename);
+      prototype.registerHybridSetter("filename", &HybridMimeSpec::setFilename);
+      prototype.registerHybridGetter("micalg", &HybridMimeSpec::getMicalg);
+      prototype.registerHybridSetter("micalg", &HybridMimeSpec::setMicalg);
+      prototype.registerHybridGetter("nameParam", &HybridMimeSpec::getNameParam);
+      prototype.registerHybridSetter("nameParam", &HybridMimeSpec::setNameParam);
+      prototype.registerHybridGetter("numHeaderFields", &HybridMimeSpec::getNumHeaderFields);
+      prototype.registerHybridGetter("numParts", &HybridMimeSpec::getNumParts);
+      prototype.registerHybridGetter("numSignerCerts", &HybridMimeSpec::getNumSignerCerts);
+      prototype.registerHybridGetter("pkcs7CryptAlg", &HybridMimeSpec::getPkcs7CryptAlg);
+      prototype.registerHybridSetter("pkcs7CryptAlg", &HybridMimeSpec::setPkcs7CryptAlg);
+      prototype.registerHybridGetter("pkcs7KeyLength", &HybridMimeSpec::getPkcs7KeyLength);
+      prototype.registerHybridSetter("pkcs7KeyLength", &HybridMimeSpec::setPkcs7KeyLength);
+      prototype.registerHybridGetter("protocol", &HybridMimeSpec::getProtocol);
+      prototype.registerHybridSetter("protocol", &HybridMimeSpec::setProtocol);
+      prototype.registerHybridGetter("signingHashAlg", &HybridMimeSpec::getSigningHashAlg);
+      prototype.registerHybridSetter("signingHashAlg", &HybridMimeSpec::setSigningHashAlg);
+      prototype.registerHybridGetter("unwrapExtras", &HybridMimeSpec::getUnwrapExtras);
+      prototype.registerHybridSetter("unwrapExtras", &HybridMimeSpec::setUnwrapExtras);
+      prototype.registerHybridGetter("useMmDescription", &HybridMimeSpec::getUseMmDescription);
+      prototype.registerHybridSetter("useMmDescription", &HybridMimeSpec::setUseMmDescription);
+      prototype.registerHybridGetter("useXPkcs7", &HybridMimeSpec::getUseXPkcs7);
+      prototype.registerHybridSetter("useXPkcs7", &HybridMimeSpec::setUseXPkcs7);
+      prototype.registerHybridGetter("signingAlg", &HybridMimeSpec::getSigningAlg);
+      prototype.registerHybridSetter("signingAlg", &HybridMimeSpec::setSigningAlg);
+      prototype.registerHybridGetter("oaepHash", &HybridMimeSpec::getOaepHash);
+      prototype.registerHybridSetter("oaepHash", &HybridMimeSpec::setOaepHash);
+      prototype.registerHybridGetter("oaepPadding", &HybridMimeSpec::getOaepPadding);
+      prototype.registerHybridSetter("oaepPadding", &HybridMimeSpec::setOaepPadding);
+      prototype.registerHybridGetter("oaepMgfHash", &HybridMimeSpec::getOaepMgfHash);
+      prototype.registerHybridSetter("oaepMgfHash", &HybridMimeSpec::setOaepMgfHash);
+      prototype.registerHybridGetter("cmsOptions", &HybridMimeSpec::getCmsOptions);
+      prototype.registerHybridSetter("cmsOptions", &HybridMimeSpec::setCmsOptions);
+      prototype.registerHybridGetter("uncommonOptions", &HybridMimeSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridMimeSpec::setUncommonOptions);
+      prototype.registerHybridGetter("numDecryptCerts", &HybridMimeSpec::getNumDecryptCerts);
+      prototype.registerHybridMethod("addContentLength", &HybridMimeSpec::addContentLength);
+      prototype.registerHybridMethod("addDecryptCert", &HybridMimeSpec::addDecryptCert);
+      prototype.registerHybridMethod("addDetachedSignature", &HybridMimeSpec::addDetachedSignature);
+      prototype.registerHybridMethod("addDetachedSignature2", &HybridMimeSpec::addDetachedSignature2);
+      prototype.registerHybridMethod("addDetachedSignaturePk", &HybridMimeSpec::addDetachedSignaturePk);
+      prototype.registerHybridMethod("addDetachedSignaturePk2", &HybridMimeSpec::addDetachedSignaturePk2);
+      prototype.registerHybridMethod("addEncryptCert", &HybridMimeSpec::addEncryptCert);
+      prototype.registerHybridMethod("addHeaderField", &HybridMimeSpec::addHeaderField);
+      prototype.registerHybridMethod("addPfxSourceFile", &HybridMimeSpec::addPfxSourceFile);
+      prototype.registerHybridMethod("appendPart", &HybridMimeSpec::appendPart);
+      prototype.registerHybridMethod("appendPartFromFile", &HybridMimeSpec::appendPartFromFile);
+      prototype.registerHybridMethod("asnBodyToXml", &HybridMimeSpec::asnBodyToXml);
+      prototype.registerHybridMethod("clearEncryptCerts", &HybridMimeSpec::clearEncryptCerts);
+      prototype.registerHybridMethod("containsEncryptedParts", &HybridMimeSpec::containsEncryptedParts);
+      prototype.registerHybridMethod("containsSignedParts", &HybridMimeSpec::containsSignedParts);
+      prototype.registerHybridMethod("convert8Bit", &HybridMimeSpec::convert8Bit);
+      prototype.registerHybridMethod("convertToMultipartAlt", &HybridMimeSpec::convertToMultipartAlt);
+      prototype.registerHybridMethod("convertToMultipartMixed", &HybridMimeSpec::convertToMultipartMixed);
+      prototype.registerHybridMethod("convertToSigned", &HybridMimeSpec::convertToSigned);
+      prototype.registerHybridMethod("convertToSignedPk", &HybridMimeSpec::convertToSignedPk);
+      prototype.registerHybridMethod("decrypt", &HybridMimeSpec::decrypt);
+      prototype.registerHybridMethod("decrypt2", &HybridMimeSpec::decrypt2);
+      prototype.registerHybridMethod("decryptUsingCert", &HybridMimeSpec::decryptUsingCert);
+      prototype.registerHybridMethod("decryptUsingPfxFile", &HybridMimeSpec::decryptUsingPfxFile);
+      prototype.registerHybridMethod("encrypt", &HybridMimeSpec::encrypt);
+      prototype.registerHybridMethod("encryptN", &HybridMimeSpec::encryptN);
+      prototype.registerHybridMethod("getBodyDecoded", &HybridMimeSpec::getBodyDecoded);
+      prototype.registerHybridMethod("getBodyEncoded", &HybridMimeSpec::getBodyEncoded);
+      prototype.registerHybridMethod("getEntireBody", &HybridMimeSpec::getEntireBody);
+      prototype.registerHybridMethod("getEntireHead", &HybridMimeSpec::getEntireHead);
+      prototype.registerHybridMethod("getHeaderField", &HybridMimeSpec::getHeaderField);
+      prototype.registerHybridMethod("getHeaderFieldAttribute", &HybridMimeSpec::getHeaderFieldAttribute);
+      prototype.registerHybridMethod("getHeaderFieldName", &HybridMimeSpec::getHeaderFieldName);
+      prototype.registerHybridMethod("getHeaderFieldValue", &HybridMimeSpec::getHeaderFieldValue);
+      prototype.registerHybridMethod("getMime", &HybridMimeSpec::getMime);
+      prototype.registerHybridMethod("getSignatureSigningTimeStr", &HybridMimeSpec::getSignatureSigningTimeStr);
+      prototype.registerHybridMethod("getXml", &HybridMimeSpec::getXml);
+      prototype.registerHybridMethod("hasSignatureSigningTime", &HybridMimeSpec::hasSignatureSigningTime);
+      prototype.registerHybridMethod("isApplicationData", &HybridMimeSpec::isApplicationData);
+      prototype.registerHybridMethod("isAttachment", &HybridMimeSpec::isAttachment);
+      prototype.registerHybridMethod("isAudio", &HybridMimeSpec::isAudio);
+      prototype.registerHybridMethod("isEncrypted", &HybridMimeSpec::isEncrypted);
+      prototype.registerHybridMethod("isHtml", &HybridMimeSpec::isHtml);
+      prototype.registerHybridMethod("isImage", &HybridMimeSpec::isImage);
+      prototype.registerHybridMethod("isMultipart", &HybridMimeSpec::isMultipart);
+      prototype.registerHybridMethod("isMultipartAlternative", &HybridMimeSpec::isMultipartAlternative);
+      prototype.registerHybridMethod("isMultipartMixed", &HybridMimeSpec::isMultipartMixed);
+      prototype.registerHybridMethod("isMultipartRelated", &HybridMimeSpec::isMultipartRelated);
+      prototype.registerHybridMethod("isPlainText", &HybridMimeSpec::isPlainText);
+      prototype.registerHybridMethod("isSigned", &HybridMimeSpec::isSigned);
+      prototype.registerHybridMethod("isText", &HybridMimeSpec::isText);
+      prototype.registerHybridMethod("isVideo", &HybridMimeSpec::isVideo);
+      prototype.registerHybridMethod("isXml", &HybridMimeSpec::isXml);
+      prototype.registerHybridMethod("loadMime", &HybridMimeSpec::loadMime);
+      prototype.registerHybridMethod("loadMimeFile", &HybridMimeSpec::loadMimeFile);
+      prototype.registerHybridMethod("loadXml", &HybridMimeSpec::loadXml);
+      prototype.registerHybridMethod("loadXmlFile", &HybridMimeSpec::loadXmlFile);
+      prototype.registerHybridMethod("newMessageRfc822", &HybridMimeSpec::newMessageRfc822);
+      prototype.registerHybridMethod("newMultipartAlternative", &HybridMimeSpec::newMultipartAlternative);
+      prototype.registerHybridMethod("newMultipartMixed", &HybridMimeSpec::newMultipartMixed);
+      prototype.registerHybridMethod("newMultipartRelated", &HybridMimeSpec::newMultipartRelated);
+      prototype.registerHybridMethod("removeHeaderField", &HybridMimeSpec::removeHeaderField);
+      prototype.registerHybridMethod("removePart", &HybridMimeSpec::removePart);
+      prototype.registerHybridMethod("saveBody", &HybridMimeSpec::saveBody);
+      prototype.registerHybridMethod("saveMime", &HybridMimeSpec::saveMime);
+      prototype.registerHybridMethod("saveXml", &HybridMimeSpec::saveXml);
+      prototype.registerHybridMethod("setBody", &HybridMimeSpec::setBody);
+      prototype.registerHybridMethod("setBodyFromEncoded", &HybridMimeSpec::setBodyFromEncoded);
+      prototype.registerHybridMethod("setBodyFromFile", &HybridMimeSpec::setBodyFromFile);
+      prototype.registerHybridMethod("setBodyFromHtml", &HybridMimeSpec::setBodyFromHtml);
+      prototype.registerHybridMethod("setBodyFromPlainText", &HybridMimeSpec::setBodyFromPlainText);
+      prototype.registerHybridMethod("setBodyFromXml", &HybridMimeSpec::setBodyFromXml);
+      prototype.registerHybridMethod("setHeaderField", &HybridMimeSpec::setHeaderField);
+      prototype.registerHybridMethod("setVerifyCert", &HybridMimeSpec::setVerifyCert);
+      prototype.registerHybridMethod("unwrapSecurity", &HybridMimeSpec::unwrapSecurity);
+      prototype.registerHybridMethod("urlEncodeBody", &HybridMimeSpec::urlEncodeBody);
+      prototype.registerHybridMethod("useCertVault", &HybridMimeSpec::useCertVault);
+      prototype.registerHybridMethod("verify", &HybridMimeSpec::verify);
+      prototype.registerHybridMethod("getStructure", &HybridMimeSpec::getStructure);
+      prototype.registerHybridMethod("getMimeSb", &HybridMimeSpec::getMimeSb);
+      prototype.registerHybridMethod("getMimeBd", &HybridMimeSpec::getMimeBd);
+      prototype.registerHybridMethod("loadMimeSb", &HybridMimeSpec::loadMimeSb);
+      prototype.registerHybridMethod("loadMimeBd", &HybridMimeSpec::loadMimeBd);
+      prototype.registerHybridMethod("getBodyBd", &HybridMimeSpec::getBodyBd);
+      prototype.registerHybridMethod("getLastJsonData", &HybridMimeSpec::getLastJsonData);
+      prototype.registerHybridMethod("lastDecryptCert", &HybridMimeSpec::lastDecryptCert);
+      prototype.registerHybridMethod("lastSignerCert", &HybridMimeSpec::lastSignerCert);
+      prototype.registerHybridMethod("partAt", &HybridMimeSpec::partAt);
+      prototype.registerHybridMethod("partsToFiles", &HybridMimeSpec::partsToFiles);
+      prototype.registerHybridMethod("addPfxSourceBd", &HybridMimeSpec::addPfxSourceBd);
+      prototype.registerHybridMethod("setBodyBd", &HybridMimeSpec::setBodyBd);
+      prototype.registerHybridMethod("getDecryptCertInfo", &HybridMimeSpec::getDecryptCertInfo);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,233 @@
+///
+/// HybridMimeSpec.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 `HybridCertSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridCertSpec; }
+// Forward declaration of `HybridPrivateKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPrivateKeySpec; }
+// Forward declaration of `HybridMimeSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridMimeSpec; }
+// Forward declaration of `HybridXmlCertVaultSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridXmlCertVaultSpec; }
+// Forward declaration of `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+// Forward declaration of `HybridStringTableSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringTableSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridCertSpec.hpp"
+#include "HybridPrivateKeySpec.hpp"
+#include "HybridMimeSpec.hpp"
+#include "HybridXmlCertVaultSpec.hpp"
+#include "HybridStringBuilderSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+#include "HybridJsonObjectSpec.hpp"
+#include "HybridStringTableSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Mime`
+   * Inherit this class to create instances of `HybridMimeSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridMime: public HybridMimeSpec {
+   * public:
+   *   HybridMime(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridMimeSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridMimeSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridMimeSpec() 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 getBoundary() = 0;
+      virtual void setBoundary(const std::string& boundary) = 0;
+      virtual std::string getCharset() = 0;
+      virtual void setCharset(const std::string& charset) = 0;
+      virtual std::string getContentType() = 0;
+      virtual void setContentType(const std::string& contentType) = 0;
+      virtual std::string getCurrentDateTime() = 0;
+      virtual std::string getDisposition() = 0;
+      virtual void setDisposition(const std::string& disposition) = 0;
+      virtual std::string getEncoding() = 0;
+      virtual void setEncoding(const std::string& encoding) = 0;
+      virtual std::string getFilename() = 0;
+      virtual void setFilename(const std::string& filename) = 0;
+      virtual std::string getMicalg() = 0;
+      virtual void setMicalg(const std::string& micalg) = 0;
+      virtual std::string getNameParam() = 0;
+      virtual void setNameParam(const std::string& nameParam) = 0;
+      virtual double getNumHeaderFields() = 0;
+      virtual double getNumParts() = 0;
+      virtual double getNumSignerCerts() = 0;
+      virtual std::string getPkcs7CryptAlg() = 0;
+      virtual void setPkcs7CryptAlg(const std::string& pkcs7CryptAlg) = 0;
+      virtual double getPkcs7KeyLength() = 0;
+      virtual void setPkcs7KeyLength(double pkcs7KeyLength) = 0;
+      virtual std::string getProtocol() = 0;
+      virtual void setProtocol(const std::string& protocol) = 0;
+      virtual std::string getSigningHashAlg() = 0;
+      virtual void setSigningHashAlg(const std::string& signingHashAlg) = 0;
+      virtual bool getUnwrapExtras() = 0;
+      virtual void setUnwrapExtras(bool unwrapExtras) = 0;
+      virtual bool getUseMmDescription() = 0;
+      virtual void setUseMmDescription(bool useMmDescription) = 0;
+      virtual bool getUseXPkcs7() = 0;
+      virtual void setUseXPkcs7(bool useXPkcs7) = 0;
+      virtual std::string getSigningAlg() = 0;
+      virtual void setSigningAlg(const std::string& signingAlg) = 0;
+      virtual std::string getOaepHash() = 0;
+      virtual void setOaepHash(const std::string& oaepHash) = 0;
+      virtual bool getOaepPadding() = 0;
+      virtual void setOaepPadding(bool oaepPadding) = 0;
+      virtual std::string getOaepMgfHash() = 0;
+      virtual void setOaepMgfHash(const std::string& oaepMgfHash) = 0;
+      virtual std::string getCmsOptions() = 0;
+      virtual void setCmsOptions(const std::string& cmsOptions) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+      virtual double getNumDecryptCerts() = 0;
+
+    public:
+      // Methods
+      virtual void addContentLength() = 0;
+      virtual void addDecryptCert(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void addDetachedSignature(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void addDetachedSignature2(const std::shared_ptr<HybridCertSpec>& cert, bool transferHeaderFields) = 0;
+      virtual void addDetachedSignaturePk(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey) = 0;
+      virtual void addDetachedSignaturePk2(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey, bool transferHeaderFields) = 0;
+      virtual void addEncryptCert(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void addHeaderField(const std::string& name, const std::string& value) = 0;
+      virtual void addPfxSourceFile(const std::string& pfxFilePath, const std::string& password) = 0;
+      virtual void appendPart(const std::shared_ptr<HybridMimeSpec>& mime) = 0;
+      virtual void appendPartFromFile(const std::string& filename) = 0;
+      virtual std::string asnBodyToXml() = 0;
+      virtual void clearEncryptCerts() = 0;
+      virtual bool containsEncryptedParts() = 0;
+      virtual bool containsSignedParts() = 0;
+      virtual void convert8Bit() = 0;
+      virtual void convertToMultipartAlt() = 0;
+      virtual void convertToMultipartMixed() = 0;
+      virtual void convertToSigned(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void convertToSignedPk(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey) = 0;
+      virtual void decrypt() = 0;
+      virtual void decrypt2(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey) = 0;
+      virtual void decryptUsingCert(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void decryptUsingPfxFile(const std::string& pfxFilePath, const std::string& pfxPassword) = 0;
+      virtual void encrypt(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void encryptN() = 0;
+      virtual std::string getBodyDecoded() = 0;
+      virtual std::string getBodyEncoded() = 0;
+      virtual std::string getEntireBody() = 0;
+      virtual std::string getEntireHead() = 0;
+      virtual std::string getHeaderField(const std::string& fieldName) = 0;
+      virtual std::string getHeaderFieldAttribute(const std::string& name, const std::string& attrName) = 0;
+      virtual std::string getHeaderFieldName(double index) = 0;
+      virtual std::string getHeaderFieldValue(double index) = 0;
+      virtual std::string getMime() = 0;
+      virtual std::string getSignatureSigningTimeStr(double index) = 0;
+      virtual std::string getXml() = 0;
+      virtual bool hasSignatureSigningTime(double index) = 0;
+      virtual bool isApplicationData() = 0;
+      virtual bool isAttachment() = 0;
+      virtual bool isAudio() = 0;
+      virtual bool isEncrypted() = 0;
+      virtual bool isHtml() = 0;
+      virtual bool isImage() = 0;
+      virtual bool isMultipart() = 0;
+      virtual bool isMultipartAlternative() = 0;
+      virtual bool isMultipartMixed() = 0;
+      virtual bool isMultipartRelated() = 0;
+      virtual bool isPlainText() = 0;
+      virtual bool isSigned() = 0;
+      virtual bool isText() = 0;
+      virtual bool isVideo() = 0;
+      virtual bool isXml() = 0;
+      virtual void loadMime(const std::string& mimeMsg) = 0;
+      virtual void loadMimeFile(const std::string& fileName) = 0;
+      virtual void loadXml(const std::string& xml) = 0;
+      virtual void loadXmlFile(const std::string& fileName) = 0;
+      virtual void newMessageRfc822(const std::shared_ptr<HybridMimeSpec>& mimeObject) = 0;
+      virtual void newMultipartAlternative() = 0;
+      virtual void newMultipartMixed() = 0;
+      virtual void newMultipartRelated() = 0;
+      virtual void removeHeaderField(const std::string& fieldName, bool bAllOccurrences) = 0;
+      virtual void removePart(double index) = 0;
+      virtual void saveBody(const std::string& filename) = 0;
+      virtual void saveMime(const std::string& filename) = 0;
+      virtual void saveXml(const std::string& filename) = 0;
+      virtual void setBody(const std::string& str) = 0;
+      virtual void setBodyFromEncoded(const std::string& encoding, const std::string& str) = 0;
+      virtual void setBodyFromFile(const std::string& fileName) = 0;
+      virtual void setBodyFromHtml(const std::string& str) = 0;
+      virtual void setBodyFromPlainText(const std::string& str) = 0;
+      virtual void setBodyFromXml(const std::string& str) = 0;
+      virtual void setHeaderField(const std::string& name, const std::string& value) = 0;
+      virtual void setVerifyCert(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void unwrapSecurity() = 0;
+      virtual void urlEncodeBody(const std::string& charset) = 0;
+      virtual void useCertVault(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) = 0;
+      virtual void verify() = 0;
+      virtual std::string getStructure(const std::string& fmt) = 0;
+      virtual void getMimeSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void getMimeBd(const std::shared_ptr<HybridBinDataSpec>& bindat) = 0;
+      virtual void loadMimeSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void loadMimeBd(const std::shared_ptr<HybridBinDataSpec>& bindat) = 0;
+      virtual void getBodyBd(const std::shared_ptr<HybridBinDataSpec>& binDat) = 0;
+      virtual void getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void lastDecryptCert(double index, const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void lastSignerCert(double index, const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void partAt(double index, const std::shared_ptr<HybridMimeSpec>& subPart) = 0;
+      virtual void partsToFiles(const std::string& path, const std::shared_ptr<HybridStringTableSpec>& st) = 0;
+      virtual void addPfxSourceBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& password) = 0;
+      virtual void setBodyBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void getDecryptCertInfo(const std::shared_ptr<HybridJsonObjectSpec>& certInfo) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Mime";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,69 @@
+///
+/// HybridNtlmSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridNtlmSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridNtlmSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridNtlmSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridNtlmSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridNtlmSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridNtlmSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridNtlmSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridNtlmSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridNtlmSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridNtlmSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridNtlmSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridNtlmSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("clientChallenge", &HybridNtlmSpec::getClientChallenge);
+      prototype.registerHybridSetter("clientChallenge", &HybridNtlmSpec::setClientChallenge);
+      prototype.registerHybridGetter("dnsComputerName", &HybridNtlmSpec::getDnsComputerName);
+      prototype.registerHybridSetter("dnsComputerName", &HybridNtlmSpec::setDnsComputerName);
+      prototype.registerHybridGetter("dnsDomainName", &HybridNtlmSpec::getDnsDomainName);
+      prototype.registerHybridSetter("dnsDomainName", &HybridNtlmSpec::setDnsDomainName);
+      prototype.registerHybridGetter("domain", &HybridNtlmSpec::getDomain);
+      prototype.registerHybridSetter("domain", &HybridNtlmSpec::setDomain);
+      prototype.registerHybridGetter("encodingMode", &HybridNtlmSpec::getEncodingMode);
+      prototype.registerHybridSetter("encodingMode", &HybridNtlmSpec::setEncodingMode);
+      prototype.registerHybridGetter("flags", &HybridNtlmSpec::getFlags);
+      prototype.registerHybridSetter("flags", &HybridNtlmSpec::setFlags);
+      prototype.registerHybridGetter("netBiosComputerName", &HybridNtlmSpec::getNetBiosComputerName);
+      prototype.registerHybridSetter("netBiosComputerName", &HybridNtlmSpec::setNetBiosComputerName);
+      prototype.registerHybridGetter("netBiosDomainName", &HybridNtlmSpec::getNetBiosDomainName);
+      prototype.registerHybridSetter("netBiosDomainName", &HybridNtlmSpec::setNetBiosDomainName);
+      prototype.registerHybridGetter("ntlmVersion", &HybridNtlmSpec::getNtlmVersion);
+      prototype.registerHybridSetter("ntlmVersion", &HybridNtlmSpec::setNtlmVersion);
+      prototype.registerHybridGetter("oemCodePage", &HybridNtlmSpec::getOemCodePage);
+      prototype.registerHybridSetter("oemCodePage", &HybridNtlmSpec::setOemCodePage);
+      prototype.registerHybridGetter("password", &HybridNtlmSpec::getPassword);
+      prototype.registerHybridSetter("password", &HybridNtlmSpec::setPassword);
+      prototype.registerHybridGetter("serverChallenge", &HybridNtlmSpec::getServerChallenge);
+      prototype.registerHybridSetter("serverChallenge", &HybridNtlmSpec::setServerChallenge);
+      prototype.registerHybridGetter("targetName", &HybridNtlmSpec::getTargetName);
+      prototype.registerHybridSetter("targetName", &HybridNtlmSpec::setTargetName);
+      prototype.registerHybridGetter("userName", &HybridNtlmSpec::getUserName);
+      prototype.registerHybridSetter("userName", &HybridNtlmSpec::setUserName);
+      prototype.registerHybridGetter("workstation", &HybridNtlmSpec::getWorkstation);
+      prototype.registerHybridSetter("workstation", &HybridNtlmSpec::setWorkstation);
+      prototype.registerHybridMethod("compareType3", &HybridNtlmSpec::compareType3);
+      prototype.registerHybridMethod("genType1", &HybridNtlmSpec::genType1);
+      prototype.registerHybridMethod("genType2", &HybridNtlmSpec::genType2);
+      prototype.registerHybridMethod("genType3", &HybridNtlmSpec::genType3);
+      prototype.registerHybridMethod("loadType3", &HybridNtlmSpec::loadType3);
+      prototype.registerHybridMethod("parseType1", &HybridNtlmSpec::parseType1);
+      prototype.registerHybridMethod("parseType2", &HybridNtlmSpec::parseType2);
+      prototype.registerHybridMethod("parseType3", &HybridNtlmSpec::parseType3);
+      prototype.registerHybridMethod("setFlag", &HybridNtlmSpec::setFlag);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,109 @@
+///
+/// HybridNtlmSpec.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
+
+
+
+#include <string>
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Ntlm`
+   * Inherit this class to create instances of `HybridNtlmSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridNtlm: public HybridNtlmSpec {
+   * public:
+   *   HybridNtlm(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridNtlmSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridNtlmSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridNtlmSpec() 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 getClientChallenge() = 0;
+      virtual void setClientChallenge(const std::string& clientChallenge) = 0;
+      virtual std::string getDnsComputerName() = 0;
+      virtual void setDnsComputerName(const std::string& dnsComputerName) = 0;
+      virtual std::string getDnsDomainName() = 0;
+      virtual void setDnsDomainName(const std::string& dnsDomainName) = 0;
+      virtual std::string getDomain() = 0;
+      virtual void setDomain(const std::string& domain) = 0;
+      virtual std::string getEncodingMode() = 0;
+      virtual void setEncodingMode(const std::string& encodingMode) = 0;
+      virtual std::string getFlags() = 0;
+      virtual void setFlags(const std::string& flags) = 0;
+      virtual std::string getNetBiosComputerName() = 0;
+      virtual void setNetBiosComputerName(const std::string& netBiosComputerName) = 0;
+      virtual std::string getNetBiosDomainName() = 0;
+      virtual void setNetBiosDomainName(const std::string& netBiosDomainName) = 0;
+      virtual double getNtlmVersion() = 0;
+      virtual void setNtlmVersion(double ntlmVersion) = 0;
+      virtual double getOemCodePage() = 0;
+      virtual void setOemCodePage(double oemCodePage) = 0;
+      virtual std::string getPassword() = 0;
+      virtual void setPassword(const std::string& password) = 0;
+      virtual std::string getServerChallenge() = 0;
+      virtual void setServerChallenge(const std::string& serverChallenge) = 0;
+      virtual std::string getTargetName() = 0;
+      virtual void setTargetName(const std::string& targetName) = 0;
+      virtual std::string getUserName() = 0;
+      virtual void setUserName(const std::string& userName) = 0;
+      virtual std::string getWorkstation() = 0;
+      virtual void setWorkstation(const std::string& workstation) = 0;
+
+    public:
+      // Methods
+      virtual bool compareType3(const std::string& msg1, const std::string& msg2) = 0;
+      virtual std::string genType1() = 0;
+      virtual std::string genType2(const std::string& type1Msg) = 0;
+      virtual std::string genType3(const std::string& type2Msg) = 0;
+      virtual void loadType3(const std::string& type3Msg) = 0;
+      virtual std::string parseType1(const std::string& type1Msg) = 0;
+      virtual std::string parseType2(const std::string& type2Msg) = 0;
+      virtual std::string parseType3(const std::string& type3Msg) = 0;
+      virtual void setFlag(const std::string& flagLetter, bool onOrOff) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Ntlm";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,67 @@
+///
+/// HybridOAuth1Spec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridOAuth1Spec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridOAuth1Spec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridOAuth1Spec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridOAuth1Spec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridOAuth1Spec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridOAuth1Spec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridOAuth1Spec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridOAuth1Spec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridOAuth1Spec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridOAuth1Spec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridOAuth1Spec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridOAuth1Spec::setLastMethodSuccess);
+      prototype.registerHybridGetter("authorizationHeader", &HybridOAuth1Spec::getAuthorizationHeader);
+      prototype.registerHybridGetter("baseString", &HybridOAuth1Spec::getBaseString);
+      prototype.registerHybridGetter("consumerKey", &HybridOAuth1Spec::getConsumerKey);
+      prototype.registerHybridSetter("consumerKey", &HybridOAuth1Spec::setConsumerKey);
+      prototype.registerHybridGetter("consumerSecret", &HybridOAuth1Spec::getConsumerSecret);
+      prototype.registerHybridSetter("consumerSecret", &HybridOAuth1Spec::setConsumerSecret);
+      prototype.registerHybridGetter("encodedSignature", &HybridOAuth1Spec::getEncodedSignature);
+      prototype.registerHybridGetter("generatedUrl", &HybridOAuth1Spec::getGeneratedUrl);
+      prototype.registerHybridGetter("hmacKey", &HybridOAuth1Spec::getHmacKey);
+      prototype.registerHybridGetter("nonce", &HybridOAuth1Spec::getNonce);
+      prototype.registerHybridSetter("nonce", &HybridOAuth1Spec::setNonce);
+      prototype.registerHybridGetter("oauthMethod", &HybridOAuth1Spec::getOauthMethod);
+      prototype.registerHybridSetter("oauthMethod", &HybridOAuth1Spec::setOauthMethod);
+      prototype.registerHybridGetter("oauthUrl", &HybridOAuth1Spec::getOauthUrl);
+      prototype.registerHybridSetter("oauthUrl", &HybridOAuth1Spec::setOauthUrl);
+      prototype.registerHybridGetter("oauthVersion", &HybridOAuth1Spec::getOauthVersion);
+      prototype.registerHybridSetter("oauthVersion", &HybridOAuth1Spec::setOauthVersion);
+      prototype.registerHybridGetter("queryString", &HybridOAuth1Spec::getQueryString);
+      prototype.registerHybridGetter("signature", &HybridOAuth1Spec::getSignature);
+      prototype.registerHybridGetter("signatureMethod", &HybridOAuth1Spec::getSignatureMethod);
+      prototype.registerHybridSetter("signatureMethod", &HybridOAuth1Spec::setSignatureMethod);
+      prototype.registerHybridGetter("timestamp", &HybridOAuth1Spec::getTimestamp);
+      prototype.registerHybridSetter("timestamp", &HybridOAuth1Spec::setTimestamp);
+      prototype.registerHybridGetter("token", &HybridOAuth1Spec::getToken);
+      prototype.registerHybridSetter("token", &HybridOAuth1Spec::setToken);
+      prototype.registerHybridGetter("tokenSecret", &HybridOAuth1Spec::getTokenSecret);
+      prototype.registerHybridSetter("tokenSecret", &HybridOAuth1Spec::setTokenSecret);
+      prototype.registerHybridGetter("realm", &HybridOAuth1Spec::getRealm);
+      prototype.registerHybridSetter("realm", &HybridOAuth1Spec::setRealm);
+      prototype.registerHybridGetter("uncommonOptions", &HybridOAuth1Spec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridOAuth1Spec::setUncommonOptions);
+      prototype.registerHybridMethod("addParam", &HybridOAuth1Spec::addParam);
+      prototype.registerHybridMethod("genNonce", &HybridOAuth1Spec::genNonce);
+      prototype.registerHybridMethod("genTimestamp", &HybridOAuth1Spec::genTimestamp);
+      prototype.registerHybridMethod("generate", &HybridOAuth1Spec::generate);
+      prototype.registerHybridMethod("removeParam", &HybridOAuth1Spec::removeParam);
+      prototype.registerHybridMethod("setRsaKey", &HybridOAuth1Spec::setRsaKey);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat