@chilkat/react-native 11.6.1

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

@@ -0,0 +1,109 @@
+///
+/// HybridDkimSpec.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 `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridPrivateKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPrivateKeySpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include "HybridBinDataSpec.hpp"
+#include "HybridPrivateKeySpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Dkim`
+   * Inherit this class to create instances of `HybridDkimSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridDkim: public HybridDkimSpec {
+   * public:
+   *   HybridDkim(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridDkimSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridDkimSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridDkimSpec() 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 getDkimAlg() = 0;
+      virtual void setDkimAlg(const std::string& dkimAlg) = 0;
+      virtual double getDkimBodyLengthCount() = 0;
+      virtual void setDkimBodyLengthCount(double dkimBodyLengthCount) = 0;
+      virtual std::string getDkimCanon() = 0;
+      virtual void setDkimCanon(const std::string& dkimCanon) = 0;
+      virtual std::string getDkimDomain() = 0;
+      virtual void setDkimDomain(const std::string& dkimDomain) = 0;
+      virtual std::string getDkimHeaders() = 0;
+      virtual void setDkimHeaders(const std::string& dkimHeaders) = 0;
+      virtual std::string getDkimSelector() = 0;
+      virtual void setDkimSelector(const std::string& dkimSelector) = 0;
+      virtual double getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 0;
+      virtual bool getAbortCurrent() = 0;
+      virtual void setAbortCurrent(bool abortCurrent) = 0;
+      virtual std::string getVerifyInfo() = 0;
+      virtual std::optional<std::function<void(double /* pctDone */)>> getOnPercentDone() = 0;
+      virtual void setOnPercentDone(const std::optional<std::function<void(double /* pctDone */)>>& onPercentDone) = 0;
+      virtual std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>> getOnProgressInfo() = 0;
+      virtual void setOnProgressInfo(const std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>>& onProgressInfo) = 0;
+
+    public:
+      // Methods
+      virtual void loadPublicKey(const std::string& selector, const std::string& domain, const std::string& publicKey) = 0;
+      virtual void loadPublicKeyFile(const std::string& selector, const std::string& domain, const std::string& publicKeyFilepath) = 0;
+      virtual void prefetchPublicKey(const std::string& selector, const std::string& domain) = 0;
+      virtual std::shared_ptr<Promise<void>> prefetchPublicKeyAsync(const std::string& selector, const std::string& domain) = 0;
+      virtual void dkimSign(const std::shared_ptr<HybridBinDataSpec>& mimeData) = 0;
+      virtual void setDkimPrivateKey(const std::shared_ptr<HybridPrivateKeySpec>& privateKey) = 0;
+      virtual void dkimVerify(double sigIndex, const std::shared_ptr<HybridBinDataSpec>& mimeData) = 0;
+      virtual double numDkimSigs(const std::shared_ptr<HybridBinDataSpec>& mimeData) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Dkim";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,51 @@
+///
+/// HybridDnsSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridDnsSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridDnsSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridDnsSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridDnsSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridDnsSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridDnsSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridDnsSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridDnsSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridDnsSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridDnsSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridDnsSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridDnsSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("numNameservers", &HybridDnsSpec::getNumNameservers);
+      prototype.registerHybridGetter("heartbeatMs", &HybridDnsSpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridDnsSpec::setHeartbeatMs);
+      prototype.registerHybridGetter("maxWaitMs", &HybridDnsSpec::getMaxWaitMs);
+      prototype.registerHybridSetter("maxWaitMs", &HybridDnsSpec::setMaxWaitMs);
+      prototype.registerHybridGetter("tlsPref", &HybridDnsSpec::getTlsPref);
+      prototype.registerHybridSetter("tlsPref", &HybridDnsSpec::setTlsPref);
+      prototype.registerHybridGetter("uncommonOptions", &HybridDnsSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridDnsSpec::setUncommonOptions);
+      prototype.registerHybridGetter("onPercentDone", &HybridDnsSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridDnsSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridDnsSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridDnsSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("getNameserver", &HybridDnsSpec::getNameserver);
+      prototype.registerHybridMethod("query", &HybridDnsSpec::query);
+      prototype.registerHybridMethod("queryAsync", &HybridDnsSpec::queryAsync);
+      prototype.registerHybridMethod("addNameserver", &HybridDnsSpec::addNameserver);
+      prototype.registerHybridMethod("removeNameserver", &HybridDnsSpec::removeNameserver);
+      prototype.registerHybridMethod("removeAllNameservers", &HybridDnsSpec::removeAllNameservers);
+      prototype.registerHybridMethod("addDefaultNameservers", &HybridDnsSpec::addDefaultNameservers);
+      prototype.registerHybridMethod("abort", &HybridDnsSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,97 @@
+///
+/// HybridDnsSpec.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 `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <memory>
+#include "HybridJsonObjectSpec.hpp"
+#include <NitroModules/Promise.hpp>
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Dns`
+   * Inherit this class to create instances of `HybridDnsSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridDns: public HybridDnsSpec {
+   * public:
+   *   HybridDns(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridDnsSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridDnsSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridDnsSpec() 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 getNumNameservers() = 0;
+      virtual double getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 0;
+      virtual double getMaxWaitMs() = 0;
+      virtual void setMaxWaitMs(double maxWaitMs) = 0;
+      virtual double getTlsPref() = 0;
+      virtual void setTlsPref(double tlsPref) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+      virtual std::optional<std::function<void(double /* pctDone */)>> getOnPercentDone() = 0;
+      virtual void setOnPercentDone(const std::optional<std::function<void(double /* pctDone */)>>& onPercentDone) = 0;
+      virtual std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>> getOnProgressInfo() = 0;
+      virtual void setOnProgressInfo(const std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>>& onProgressInfo) = 0;
+
+    public:
+      // Methods
+      virtual std::string getNameserver(double index) = 0;
+      virtual void query(const std::string& recordType, const std::string& domain, const std::shared_ptr<HybridJsonObjectSpec>& answer) = 0;
+      virtual std::shared_ptr<Promise<void>> queryAsync(const std::string& recordType, const std::string& domain, const std::shared_ptr<HybridJsonObjectSpec>& answer) = 0;
+      virtual void addNameserver(const std::string& ipAddr, bool supportsTls) = 0;
+      virtual void removeNameserver(const std::string& ipAddr) = 0;
+      virtual void removeAllNameservers() = 0;
+      virtual void addDefaultNameservers() = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Dns";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,73 @@
+///
+/// HybridDsaSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridDsaSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridDsaSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridDsaSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridDsaSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridDsaSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridDsaSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridDsaSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridDsaSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridDsaSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridDsaSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridDsaSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridDsaSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("groupSize", &HybridDsaSpec::getGroupSize);
+      prototype.registerHybridSetter("groupSize", &HybridDsaSpec::setGroupSize);
+      prototype.registerHybridGetter("hexG", &HybridDsaSpec::getHexG);
+      prototype.registerHybridGetter("hexP", &HybridDsaSpec::getHexP);
+      prototype.registerHybridGetter("hexQ", &HybridDsaSpec::getHexQ);
+      prototype.registerHybridGetter("hexX", &HybridDsaSpec::getHexX);
+      prototype.registerHybridGetter("hexY", &HybridDsaSpec::getHexY);
+      prototype.registerHybridGetter("uncommonOptions", &HybridDsaSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridDsaSpec::setUncommonOptions);
+      prototype.registerHybridMethod("fromDerFile", &HybridDsaSpec::fromDerFile);
+      prototype.registerHybridMethod("fromEncryptedPem", &HybridDsaSpec::fromEncryptedPem);
+      prototype.registerHybridMethod("fromPem", &HybridDsaSpec::fromPem);
+      prototype.registerHybridMethod("fromPublicDerFile", &HybridDsaSpec::fromPublicDerFile);
+      prototype.registerHybridMethod("fromPublicPem", &HybridDsaSpec::fromPublicPem);
+      prototype.registerHybridMethod("fromXml", &HybridDsaSpec::fromXml);
+      prototype.registerHybridMethod("genKey", &HybridDsaSpec::genKey);
+      prototype.registerHybridMethod("genKeyFromParamsDerFile", &HybridDsaSpec::genKeyFromParamsDerFile);
+      prototype.registerHybridMethod("genKeyFromParamsPem", &HybridDsaSpec::genKeyFromParamsPem);
+      prototype.registerHybridMethod("genKeyFromParamsPemFile", &HybridDsaSpec::genKeyFromParamsPemFile);
+      prototype.registerHybridMethod("getEncodedHash", &HybridDsaSpec::getEncodedHash);
+      prototype.registerHybridMethod("getEncodedSignature", &HybridDsaSpec::getEncodedSignature);
+      prototype.registerHybridMethod("loadText", &HybridDsaSpec::loadText);
+      prototype.registerHybridMethod("saveText", &HybridDsaSpec::saveText);
+      prototype.registerHybridMethod("setEncodedHash", &HybridDsaSpec::setEncodedHash);
+      prototype.registerHybridMethod("setEncodedSignature", &HybridDsaSpec::setEncodedSignature);
+      prototype.registerHybridMethod("setEncodedSignatureRS", &HybridDsaSpec::setEncodedSignatureRS);
+      prototype.registerHybridMethod("setKeyExplicit", &HybridDsaSpec::setKeyExplicit);
+      prototype.registerHybridMethod("setPubKeyExplicit", &HybridDsaSpec::setPubKeyExplicit);
+      prototype.registerHybridMethod("signHash", &HybridDsaSpec::signHash);
+      prototype.registerHybridMethod("toDerFile", &HybridDsaSpec::toDerFile);
+      prototype.registerHybridMethod("toEncryptedPem", &HybridDsaSpec::toEncryptedPem);
+      prototype.registerHybridMethod("toPem", &HybridDsaSpec::toPem);
+      prototype.registerHybridMethod("toPublicDerFile", &HybridDsaSpec::toPublicDerFile);
+      prototype.registerHybridMethod("toPublicPem", &HybridDsaSpec::toPublicPem);
+      prototype.registerHybridMethod("toXml", &HybridDsaSpec::toXml);
+      prototype.registerHybridMethod("verify", &HybridDsaSpec::verify);
+      prototype.registerHybridMethod("verifyKey", &HybridDsaSpec::verifyKey);
+      prototype.registerHybridMethod("genKey2", &HybridDsaSpec::genKey2);
+      prototype.registerHybridMethod("genKeyFromPQG", &HybridDsaSpec::genKeyFromPQG);
+      prototype.registerHybridMethod("fromDerBd", &HybridDsaSpec::fromDerBd);
+      prototype.registerHybridMethod("fromPublicDerBd", &HybridDsaSpec::fromPublicDerBd);
+      prototype.registerHybridMethod("genKeyFromParamsDerBd", &HybridDsaSpec::genKeyFromParamsDerBd);
+      prototype.registerHybridMethod("toDerBd", &HybridDsaSpec::toDerBd);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,116 @@
+///
+/// HybridDsaSpec.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 `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridBinDataSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Dsa`
+   * Inherit this class to create instances of `HybridDsaSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridDsa: public HybridDsaSpec {
+   * public:
+   *   HybridDsa(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridDsaSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridDsaSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridDsaSpec() 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 getGroupSize() = 0;
+      virtual void setGroupSize(double groupSize) = 0;
+      virtual std::string getHexG() = 0;
+      virtual std::string getHexP() = 0;
+      virtual std::string getHexQ() = 0;
+      virtual std::string getHexX() = 0;
+      virtual std::string getHexY() = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+
+    public:
+      // Methods
+      virtual void fromDerFile(const std::string& path) = 0;
+      virtual void fromEncryptedPem(const std::string& password, const std::string& pemData) = 0;
+      virtual void fromPem(const std::string& pemData) = 0;
+      virtual void fromPublicDerFile(const std::string& path) = 0;
+      virtual void fromPublicPem(const std::string& pemData) = 0;
+      virtual void fromXml(const std::string& xmlKey) = 0;
+      virtual void genKey(double numBits) = 0;
+      virtual void genKeyFromParamsDerFile(const std::string& path) = 0;
+      virtual void genKeyFromParamsPem(const std::string& pem) = 0;
+      virtual void genKeyFromParamsPemFile(const std::string& path) = 0;
+      virtual std::string getEncodedHash(const std::string& encoding) = 0;
+      virtual std::string getEncodedSignature(const std::string& encoding) = 0;
+      virtual std::string loadText(const std::string& path) = 0;
+      virtual void saveText(const std::string& strToSave, const std::string& path) = 0;
+      virtual void setEncodedHash(const std::string& encoding, const std::string& encodedHash) = 0;
+      virtual void setEncodedSignature(const std::string& encoding, const std::string& encodedSig) = 0;
+      virtual void setEncodedSignatureRS(const std::string& encoding, const std::string& encodedR, const std::string& encodedS) = 0;
+      virtual void setKeyExplicit(double groupSizeInBytes, const std::string& pHex, const std::string& qHex, const std::string& gHex, const std::string& xHex) = 0;
+      virtual void setPubKeyExplicit(double groupSizeInBytes, const std::string& pHex, const std::string& qHex, const std::string& gHex, const std::string& yHex) = 0;
+      virtual void signHash() = 0;
+      virtual void toDerFile(const std::string& path) = 0;
+      virtual std::string toEncryptedPem(const std::string& password) = 0;
+      virtual std::string toPem() = 0;
+      virtual void toPublicDerFile(const std::string& path) = 0;
+      virtual std::string toPublicPem() = 0;
+      virtual std::string toXml(bool bPublicOnly) = 0;
+      virtual void verify() = 0;
+      virtual bool verifyKey() = 0;
+      virtual void genKey2(double keyLenBits, double modLenBits) = 0;
+      virtual void genKeyFromPQG(const std::string& pHex, const std::string& qHex, const std::string& gHex) = 0;
+      virtual void fromDerBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void fromPublicDerBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void genKeyFromParamsDerBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void toDerBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Dsa";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,50 @@
+///
+/// HybridDtObjSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridDtObjSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridDtObjSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridDtObjSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridDtObjSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridDtObjSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridDtObjSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridDtObjSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridDtObjSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridDtObjSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridDtObjSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridDtObjSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridDtObjSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("day", &HybridDtObjSpec::getDay);
+      prototype.registerHybridSetter("day", &HybridDtObjSpec::setDay);
+      prototype.registerHybridGetter("hour", &HybridDtObjSpec::getHour);
+      prototype.registerHybridSetter("hour", &HybridDtObjSpec::setHour);
+      prototype.registerHybridGetter("minute", &HybridDtObjSpec::getMinute);
+      prototype.registerHybridSetter("minute", &HybridDtObjSpec::setMinute);
+      prototype.registerHybridGetter("month", &HybridDtObjSpec::getMonth);
+      prototype.registerHybridSetter("month", &HybridDtObjSpec::setMonth);
+      prototype.registerHybridGetter("second", &HybridDtObjSpec::getSecond);
+      prototype.registerHybridSetter("second", &HybridDtObjSpec::setSecond);
+      prototype.registerHybridGetter("structTmMonth", &HybridDtObjSpec::getStructTmMonth);
+      prototype.registerHybridSetter("structTmMonth", &HybridDtObjSpec::setStructTmMonth);
+      prototype.registerHybridGetter("structTmYear", &HybridDtObjSpec::getStructTmYear);
+      prototype.registerHybridSetter("structTmYear", &HybridDtObjSpec::setStructTmYear);
+      prototype.registerHybridGetter("utc", &HybridDtObjSpec::getUtc);
+      prototype.registerHybridSetter("utc", &HybridDtObjSpec::setUtc);
+      prototype.registerHybridGetter("year", &HybridDtObjSpec::getYear);
+      prototype.registerHybridSetter("year", &HybridDtObjSpec::setYear);
+      prototype.registerHybridMethod("deSerialize", &HybridDtObjSpec::deSerialize);
+      prototype.registerHybridMethod("serialize", &HybridDtObjSpec::serialize);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,90 @@
+///
+/// HybridDtObjSpec.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 `DtObj`
+   * Inherit this class to create instances of `HybridDtObjSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridDtObj: public HybridDtObjSpec {
+   * public:
+   *   HybridDtObj(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridDtObjSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridDtObjSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridDtObjSpec() 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 getDay() = 0;
+      virtual void setDay(double day) = 0;
+      virtual double getHour() = 0;
+      virtual void setHour(double hour) = 0;
+      virtual double getMinute() = 0;
+      virtual void setMinute(double minute) = 0;
+      virtual double getMonth() = 0;
+      virtual void setMonth(double month) = 0;
+      virtual double getSecond() = 0;
+      virtual void setSecond(double second) = 0;
+      virtual double getStructTmMonth() = 0;
+      virtual void setStructTmMonth(double structTmMonth) = 0;
+      virtual double getStructTmYear() = 0;
+      virtual void setStructTmYear(double structTmYear) = 0;
+      virtual bool getUtc() = 0;
+      virtual void setUtc(bool utc) = 0;
+      virtual double getYear() = 0;
+      virtual void setYear(double year) = 0;
+
+    public:
+      // Methods
+      virtual void deSerialize(const std::string& serializedDtObj) = 0;
+      virtual std::string serialize() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "DtObj";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,41 @@
+///
+/// HybridEccSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridEccSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridEccSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridEccSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridEccSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridEccSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridEccSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridEccSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridEccSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridEccSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridEccSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridEccSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridEccSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("asnFormat", &HybridEccSpec::getAsnFormat);
+      prototype.registerHybridSetter("asnFormat", &HybridEccSpec::setAsnFormat);
+      prototype.registerHybridMethod("sharedSecretENC", &HybridEccSpec::sharedSecretENC);
+      prototype.registerHybridMethod("signHashENC", &HybridEccSpec::signHashENC);
+      prototype.registerHybridMethod("verifyHashENC", &HybridEccSpec::verifyHashENC);
+      prototype.registerHybridMethod("signBd", &HybridEccSpec::signBd);
+      prototype.registerHybridMethod("verifyBd", &HybridEccSpec::verifyBd);
+      prototype.registerHybridMethod("signBdUsingCert", &HybridEccSpec::signBdUsingCert);
+      prototype.registerHybridMethod("signHashUsingCert", &HybridEccSpec::signHashUsingCert);
+      prototype.registerHybridMethod("genKey", &HybridEccSpec::genKey);
+      prototype.registerHybridMethod("genKey2", &HybridEccSpec::genKey2);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat