@chilkat/react-native 11.6.1

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

@@ -0,0 +1,205 @@
+///
+/// HybridCertSpec.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 `HybridXmlCertVaultSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridXmlCertVaultSpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridPkcs11Spec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPkcs11Spec; }
+// Forward declaration of `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+// Forward declaration of `HybridPublicKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPublicKeySpec; }
+// Forward declaration of `HybridCertChainSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridCertChainSpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <memory>
+#include "HybridCertSpec.hpp"
+#include "HybridPrivateKeySpec.hpp"
+#include "HybridXmlCertVaultSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+#include "HybridPkcs11Spec.hpp"
+#include "HybridJsonObjectSpec.hpp"
+#include <NitroModules/Promise.hpp>
+#include "HybridPublicKeySpec.hpp"
+#include "HybridCertChainSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Cert`
+   * Inherit this class to create instances of `HybridCertSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCert: public HybridCertSpec {
+   * public:
+   *   HybridCert(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCertSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCertSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCertSpec() 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 getAuthorityKeyId() = 0;
+      virtual bool getAvoidWindowsPkAccess() = 0;
+      virtual void setAvoidWindowsPkAccess(bool avoidWindowsPkAccess) = 0;
+      virtual double getCertVersion() = 0;
+      virtual bool getExpired() = 0;
+      virtual bool getForClientAuthentication() = 0;
+      virtual bool getForCodeSigning() = 0;
+      virtual bool getForSecureEmail() = 0;
+      virtual bool getForServerAuthentication() = 0;
+      virtual bool getForTimeStamping() = 0;
+      virtual double getIntendedKeyUsage() = 0;
+      virtual bool getIsRoot() = 0;
+      virtual std::string getIssuerC() = 0;
+      virtual std::string getIssuerCN() = 0;
+      virtual std::string getIssuerDN() = 0;
+      virtual std::string getIssuerE() = 0;
+      virtual std::string getIssuerL() = 0;
+      virtual std::string getIssuerO() = 0;
+      virtual std::string getIssuerOU() = 0;
+      virtual std::string getIssuerS() = 0;
+      virtual std::string getOcspUrl() = 0;
+      virtual bool getPrivateKeyExportable() = 0;
+      virtual bool getRevoked() = 0;
+      virtual std::string getRfc822Name() = 0;
+      virtual bool getSelfSigned() = 0;
+      virtual std::string getSerialNumber() = 0;
+      virtual std::string getSha1Thumbprint() = 0;
+      virtual bool getSignatureVerified() = 0;
+      virtual std::string getSubjectC() = 0;
+      virtual std::string getSubjectCN() = 0;
+      virtual std::string getSubjectDN() = 0;
+      virtual std::string getSubjectE() = 0;
+      virtual std::string getSubjectKeyId() = 0;
+      virtual std::string getSubjectL() = 0;
+      virtual std::string getSubjectO() = 0;
+      virtual std::string getSubjectOU() = 0;
+      virtual std::string getSubjectS() = 0;
+      virtual bool getTrustedRoot() = 0;
+      virtual std::string getValidFromStr() = 0;
+      virtual std::string getValidToStr() = 0;
+      virtual std::string getSerialDecimal() = 0;
+      virtual std::string getSmartCardPin() = 0;
+      virtual void setSmartCardPin(const std::string& smartCardPin) = 0;
+      virtual bool getSmartCardNoDialog() = 0;
+      virtual void setSmartCardNoDialog(bool smartCardNoDialog) = 0;
+      virtual std::string getExtendedKeyUsage() = 0;
+      virtual std::string getSubjectAlternativeName() = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+      virtual double getSmartCardFailReason() = 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 double checkRevoked() = 0;
+      virtual void exportCertDerFile(const std::string& path) = 0;
+      virtual std::string exportCertPem() = 0;
+      virtual void exportCertPemFile(const std::string& path) = 0;
+      virtual std::string exportCertXml() = 0;
+      virtual void exportToPfxFile(const std::string& pfxFilename, const std::string& pfxPassword, bool bIncludeCertChain) = 0;
+      virtual std::shared_ptr<HybridCertSpec> findIssuer() = 0;
+      virtual std::string getEncoded() = 0;
+      virtual std::string getExtensionAsXml(const std::string& oid) = 0;
+      virtual std::string getPrivateKeyPem() = 0;
+      virtual std::string getSpkiFingerprint(const std::string& hashAlg, const std::string& encoding) = 0;
+      virtual bool hasPrivateKey() = 0;
+      virtual void loadByCommonName(const std::string& cn) = 0;
+      virtual void loadByEmailAddress(const std::string& emailAddress) = 0;
+      virtual void loadByIssuerAndSerialNumber(const std::string& issuerCN, const std::string& serialNumber) = 0;
+      virtual void loadFromBase64(const std::string& encodedCert) = 0;
+      virtual void loadFromFile(const std::string& path) = 0;
+      virtual void loadPem(const std::string& strPem) = 0;
+      virtual void loadPfxFile(const std::string& pfxPath, const std::string& password) = 0;
+      virtual void pemFileToDerFile(const std::string& fromPath, const std::string& toPath) = 0;
+      virtual void saveToFile(const std::string& path) = 0;
+      virtual void setFromEncoded(const std::string& encodedCert) = 0;
+      virtual void setPrivateKey(const std::shared_ptr<HybridPrivateKeySpec>& privKey) = 0;
+      virtual void setPrivateKeyPem(const std::string& privKeyPem) = 0;
+      virtual void useCertVault(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) = 0;
+      virtual bool verifySignature() = 0;
+      virtual void exportToPfxBd(const std::string& password, bool includeCertChain, const std::shared_ptr<HybridBinDataSpec>& pfxData) = 0;
+      virtual void exportCertDerBd(const std::shared_ptr<HybridBinDataSpec>& cerData) = 0;
+      virtual void loadPfxBd(const std::shared_ptr<HybridBinDataSpec>& pfxData, const std::string& password) = 0;
+      virtual void loadFromBd(const std::shared_ptr<HybridBinDataSpec>& certBytes) = 0;
+      virtual std::string hashOf(const std::string& part, const std::string& hashAlg, const std::string& encoding) = 0;
+      virtual double checkSmartCardPin() = 0;
+      virtual std::string x509PKIPathv1() = 0;
+      virtual void loadFromSmartcard(const std::string& certSpec) = 0;
+      virtual void loadByThumbprint(const std::string& thumbprint, const std::string& encoding) = 0;
+      virtual void loadBySubjectOid(const std::string& oid, const std::string& value) = 0;
+      virtual std::string getSubjectPart(const std::string& partNameOrOid) = 0;
+      virtual std::string getExtensionAsText(const std::string& oid) = 0;
+      virtual void getPubKeyDer(bool preferPkcs1, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void getSignature(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void getExtensionBd(const std::string& oid, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void linkPkcs11(const std::shared_ptr<HybridPkcs11Spec>& session) = 0;
+      virtual void uploadToCloud(const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) = 0;
+      virtual std::shared_ptr<Promise<void>> uploadToCloudAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) = 0;
+      virtual void setCloudSigner(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual std::shared_ptr<Promise<void>> setCloudSignerAsync(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual bool isRsa() = 0;
+      virtual bool isEcdsa() = 0;
+      virtual void unload() = 0;
+      virtual void getPrivateKey(const std::shared_ptr<HybridPrivateKeySpec>& privKey) = 0;
+      virtual void getPublicKey(const std::shared_ptr<HybridPublicKeySpec>& pubKey) = 0;
+      virtual void getIssuer(const std::shared_ptr<HybridCertSpec>& issuer) = 0;
+      virtual void buildCertChain(const std::shared_ptr<HybridCertChainSpec>& certChain) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Cert";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,55 @@
+///
+/// HybridCertStoreSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridCertStoreSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridCertStoreSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridCertStoreSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridCertStoreSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridCertStoreSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridCertStoreSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridCertStoreSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridCertStoreSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridCertStoreSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridCertStoreSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridCertStoreSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridCertStoreSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("avoidWindowsPkAccess", &HybridCertStoreSpec::getAvoidWindowsPkAccess);
+      prototype.registerHybridSetter("avoidWindowsPkAccess", &HybridCertStoreSpec::setAvoidWindowsPkAccess);
+      prototype.registerHybridGetter("numCertificates", &HybridCertStoreSpec::getNumCertificates);
+      prototype.registerHybridGetter("smartCardPin", &HybridCertStoreSpec::getSmartCardPin);
+      prototype.registerHybridSetter("smartCardPin", &HybridCertStoreSpec::setSmartCardPin);
+      prototype.registerHybridGetter("uncommonOptions", &HybridCertStoreSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridCertStoreSpec::setUncommonOptions);
+      prototype.registerHybridMethod("addCertificate", &HybridCertStoreSpec::addCertificate);
+      prototype.registerHybridMethod("createFileStore", &HybridCertStoreSpec::createFileStore);
+      prototype.registerHybridMethod("createMemoryStore", &HybridCertStoreSpec::createMemoryStore);
+      prototype.registerHybridMethod("createRegistryStore", &HybridCertStoreSpec::createRegistryStore);
+      prototype.registerHybridMethod("loadPemFile", &HybridCertStoreSpec::loadPemFile);
+      prototype.registerHybridMethod("loadPemStr", &HybridCertStoreSpec::loadPemStr);
+      prototype.registerHybridMethod("loadPfxFile", &HybridCertStoreSpec::loadPfxFile);
+      prototype.registerHybridMethod("openCurrentUserStore", &HybridCertStoreSpec::openCurrentUserStore);
+      prototype.registerHybridMethod("openFileStore", &HybridCertStoreSpec::openFileStore);
+      prototype.registerHybridMethod("openLocalSystemStore", &HybridCertStoreSpec::openLocalSystemStore);
+      prototype.registerHybridMethod("openRegistryStore", &HybridCertStoreSpec::openRegistryStore);
+      prototype.registerHybridMethod("openWindowsStore", &HybridCertStoreSpec::openWindowsStore);
+      prototype.registerHybridMethod("removeCertificate", &HybridCertStoreSpec::removeCertificate);
+      prototype.registerHybridMethod("openSmartcard", &HybridCertStoreSpec::openSmartcard);
+      prototype.registerHybridMethod("closeCertStore", &HybridCertStoreSpec::closeCertStore);
+      prototype.registerHybridMethod("findCert", &HybridCertStoreSpec::findCert);
+      prototype.registerHybridMethod("loadPfxBd", &HybridCertStoreSpec::loadPfxBd);
+      prototype.registerHybridMethod("getCert", &HybridCertStoreSpec::getCert);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,104 @@
+///
+/// HybridCertStoreSpec.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 `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridCertSpec.hpp"
+#include "HybridJsonObjectSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `CertStore`
+   * Inherit this class to create instances of `HybridCertStoreSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCertStore: public HybridCertStoreSpec {
+   * public:
+   *   HybridCertStore(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCertStoreSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCertStoreSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCertStoreSpec() 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 getAvoidWindowsPkAccess() = 0;
+      virtual void setAvoidWindowsPkAccess(bool avoidWindowsPkAccess) = 0;
+      virtual double getNumCertificates() = 0;
+      virtual std::string getSmartCardPin() = 0;
+      virtual void setSmartCardPin(const std::string& smartCardPin) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+
+    public:
+      // Methods
+      virtual void addCertificate(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void createFileStore(const std::string& filename) = 0;
+      virtual void createMemoryStore() = 0;
+      virtual void createRegistryStore(const std::string& regRoot, const std::string& regPath) = 0;
+      virtual void loadPemFile(const std::string& pemPath) = 0;
+      virtual void loadPemStr(const std::string& pemString) = 0;
+      virtual void loadPfxFile(const std::string& pfxFilename, const std::string& password) = 0;
+      virtual void openCurrentUserStore(bool bReadOnly) = 0;
+      virtual void openFileStore(const std::string& filename, bool bReadOnly) = 0;
+      virtual void openLocalSystemStore(bool bReadOnly) = 0;
+      virtual void openRegistryStore(const std::string& regRoot, const std::string& regPath, bool bReadOnly) = 0;
+      virtual void openWindowsStore(const std::string& storeLocation, const std::string& storeName, bool bReadOnly) = 0;
+      virtual void removeCertificate(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void openSmartcard(const std::string& csp) = 0;
+      virtual void closeCertStore() = 0;
+      virtual void findCert(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void loadPfxBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& password) = 0;
+      virtual void getCert(double index, const std::shared_ptr<HybridCertSpec>& cert) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "CertStore";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,61 @@
+///
+/// HybridCharsetSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridCharsetSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridCharsetSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridCharsetSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridCharsetSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridCharsetSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridCharsetSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridCharsetSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridCharsetSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridCharsetSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridCharsetSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridCharsetSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridCharsetSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("altToCharset", &HybridCharsetSpec::getAltToCharset);
+      prototype.registerHybridSetter("altToCharset", &HybridCharsetSpec::setAltToCharset);
+      prototype.registerHybridGetter("errorAction", &HybridCharsetSpec::getErrorAction);
+      prototype.registerHybridSetter("errorAction", &HybridCharsetSpec::setErrorAction);
+      prototype.registerHybridGetter("fromCharset", &HybridCharsetSpec::getFromCharset);
+      prototype.registerHybridSetter("fromCharset", &HybridCharsetSpec::setFromCharset);
+      prototype.registerHybridGetter("lastInputAsHex", &HybridCharsetSpec::getLastInputAsHex);
+      prototype.registerHybridGetter("lastInputAsQP", &HybridCharsetSpec::getLastInputAsQP);
+      prototype.registerHybridGetter("lastOutputAsHex", &HybridCharsetSpec::getLastOutputAsHex);
+      prototype.registerHybridGetter("lastOutputAsQP", &HybridCharsetSpec::getLastOutputAsQP);
+      prototype.registerHybridGetter("saveLast", &HybridCharsetSpec::getSaveLast);
+      prototype.registerHybridSetter("saveLast", &HybridCharsetSpec::setSaveLast);
+      prototype.registerHybridGetter("toCharset", &HybridCharsetSpec::getToCharset);
+      prototype.registerHybridSetter("toCharset", &HybridCharsetSpec::setToCharset);
+      prototype.registerHybridMethod("charsetToCodePage", &HybridCharsetSpec::charsetToCodePage);
+      prototype.registerHybridMethod("codePageToCharset", &HybridCharsetSpec::codePageToCharset);
+      prototype.registerHybridMethod("convertFile", &HybridCharsetSpec::convertFile);
+      prototype.registerHybridMethod("convertFileNoPreamble", &HybridCharsetSpec::convertFileNoPreamble);
+      prototype.registerHybridMethod("convertHtmlFile", &HybridCharsetSpec::convertHtmlFile);
+      prototype.registerHybridMethod("entityEncodeDec", &HybridCharsetSpec::entityEncodeDec);
+      prototype.registerHybridMethod("entityEncodeHex", &HybridCharsetSpec::entityEncodeHex);
+      prototype.registerHybridMethod("getHtmlFileCharset", &HybridCharsetSpec::getHtmlFileCharset);
+      prototype.registerHybridMethod("htmlDecodeToStr", &HybridCharsetSpec::htmlDecodeToStr);
+      prototype.registerHybridMethod("htmlEntityDecodeFile", &HybridCharsetSpec::htmlEntityDecodeFile);
+      prototype.registerHybridMethod("lowerCase", &HybridCharsetSpec::lowerCase);
+      prototype.registerHybridMethod("readFileToString", &HybridCharsetSpec::readFileToString);
+      prototype.registerHybridMethod("setErrorString", &HybridCharsetSpec::setErrorString);
+      prototype.registerHybridMethod("upperCase", &HybridCharsetSpec::upperCase);
+      prototype.registerHybridMethod("urlDecodeStr", &HybridCharsetSpec::urlDecodeStr);
+      prototype.registerHybridMethod("verifyFile", &HybridCharsetSpec::verifyFile);
+      prototype.registerHybridMethod("writeStringToFile", &HybridCharsetSpec::writeStringToFile);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,101 @@
+///
+/// HybridCharsetSpec.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 `Charset`
+   * Inherit this class to create instances of `HybridCharsetSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCharset: public HybridCharsetSpec {
+   * public:
+   *   HybridCharset(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCharsetSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCharsetSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCharsetSpec() 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 getAltToCharset() = 0;
+      virtual void setAltToCharset(const std::string& altToCharset) = 0;
+      virtual double getErrorAction() = 0;
+      virtual void setErrorAction(double errorAction) = 0;
+      virtual std::string getFromCharset() = 0;
+      virtual void setFromCharset(const std::string& fromCharset) = 0;
+      virtual std::string getLastInputAsHex() = 0;
+      virtual std::string getLastInputAsQP() = 0;
+      virtual std::string getLastOutputAsHex() = 0;
+      virtual std::string getLastOutputAsQP() = 0;
+      virtual bool getSaveLast() = 0;
+      virtual void setSaveLast(bool saveLast) = 0;
+      virtual std::string getToCharset() = 0;
+      virtual void setToCharset(const std::string& toCharset) = 0;
+
+    public:
+      // Methods
+      virtual double charsetToCodePage(const std::string& charsetName) = 0;
+      virtual std::string codePageToCharset(double codePage) = 0;
+      virtual void convertFile(const std::string& inPath, const std::string& destPath) = 0;
+      virtual void convertFileNoPreamble(const std::string& inPath, const std::string& destPath) = 0;
+      virtual void convertHtmlFile(const std::string& inPath, const std::string& destPath) = 0;
+      virtual std::string entityEncodeDec(const std::string& str) = 0;
+      virtual std::string entityEncodeHex(const std::string& str) = 0;
+      virtual std::string getHtmlFileCharset(const std::string& htmlFilePath) = 0;
+      virtual std::string htmlDecodeToStr(const std::string& inStr) = 0;
+      virtual void htmlEntityDecodeFile(const std::string& inPath, const std::string& destPath) = 0;
+      virtual std::string lowerCase(const std::string& inStr) = 0;
+      virtual std::string readFileToString(const std::string& path, const std::string& charset) = 0;
+      virtual void setErrorString(const std::string& str, const std::string& charset) = 0;
+      virtual std::string upperCase(const std::string& inStr) = 0;
+      virtual std::string urlDecodeStr(const std::string& inStr) = 0;
+      virtual bool verifyFile(const std::string& charset, const std::string& path) = 0;
+      virtual void writeStringToFile(const std::string& textData, const std::string& path, const std::string& charset) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Charset";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,66 @@
+///
+/// HybridCkDateTimeSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridCkDateTimeSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridCkDateTimeSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridCkDateTimeSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridCkDateTimeSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridCkDateTimeSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridCkDateTimeSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridCkDateTimeSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridCkDateTimeSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridCkDateTimeSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridCkDateTimeSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridCkDateTimeSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridCkDateTimeSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("isDst", &HybridCkDateTimeSpec::getIsDst);
+      prototype.registerHybridGetter("utcOffset", &HybridCkDateTimeSpec::getUtcOffset);
+      prototype.registerHybridMethod("addDays", &HybridCkDateTimeSpec::addDays);
+      prototype.registerHybridMethod("deSerialize", &HybridCkDateTimeSpec::deSerialize);
+      prototype.registerHybridMethod("getAsDateTimeTicks", &HybridCkDateTimeSpec::getAsDateTimeTicks);
+      prototype.registerHybridMethod("getAsDosDate", &HybridCkDateTimeSpec::getAsDosDate);
+      prototype.registerHybridMethod("getAsOleDate", &HybridCkDateTimeSpec::getAsOleDate);
+      prototype.registerHybridMethod("getAsRfc822", &HybridCkDateTimeSpec::getAsRfc822);
+      prototype.registerHybridMethod("getAsUnixTime", &HybridCkDateTimeSpec::getAsUnixTime);
+      prototype.registerHybridMethod("getAsUnixTime64", &HybridCkDateTimeSpec::getAsUnixTime64);
+      prototype.registerHybridMethod("getAsUnixTimeDbl", &HybridCkDateTimeSpec::getAsUnixTimeDbl);
+      prototype.registerHybridMethod("serialize", &HybridCkDateTimeSpec::serialize);
+      prototype.registerHybridMethod("setFromCurrentSystemTime", &HybridCkDateTimeSpec::setFromCurrentSystemTime);
+      prototype.registerHybridMethod("setFromDateTimeTicks", &HybridCkDateTimeSpec::setFromDateTimeTicks);
+      prototype.registerHybridMethod("setFromDosDate", &HybridCkDateTimeSpec::setFromDosDate);
+      prototype.registerHybridMethod("setFromDtObj", &HybridCkDateTimeSpec::setFromDtObj);
+      prototype.registerHybridMethod("setFromNtpTime", &HybridCkDateTimeSpec::setFromNtpTime);
+      prototype.registerHybridMethod("setFromOleDate", &HybridCkDateTimeSpec::setFromOleDate);
+      prototype.registerHybridMethod("setFromRfc822", &HybridCkDateTimeSpec::setFromRfc822);
+      prototype.registerHybridMethod("setFromUnixTime", &HybridCkDateTimeSpec::setFromUnixTime);
+      prototype.registerHybridMethod("setFromUnixTime64", &HybridCkDateTimeSpec::setFromUnixTime64);
+      prototype.registerHybridMethod("setFromUnixTimeDbl", &HybridCkDateTimeSpec::setFromUnixTimeDbl);
+      prototype.registerHybridMethod("setFromTimestamp", &HybridCkDateTimeSpec::setFromTimestamp);
+      prototype.registerHybridMethod("getAsTimestamp", &HybridCkDateTimeSpec::getAsTimestamp);
+      prototype.registerHybridMethod("diffSeconds", &HybridCkDateTimeSpec::diffSeconds);
+      prototype.registerHybridMethod("addSeconds", &HybridCkDateTimeSpec::addSeconds);
+      prototype.registerHybridMethod("getAsUnixTimeStr", &HybridCkDateTimeSpec::getAsUnixTimeStr);
+      prototype.registerHybridMethod("getAsIso8601", &HybridCkDateTimeSpec::getAsIso8601);
+      prototype.registerHybridMethod("expiresWithin", &HybridCkDateTimeSpec::expiresWithin);
+      prototype.registerHybridMethod("olderThan", &HybridCkDateTimeSpec::olderThan);
+      prototype.registerHybridMethod("ulidValidate", &HybridCkDateTimeSpec::ulidValidate);
+      prototype.registerHybridMethod("ulidGenerate", &HybridCkDateTimeSpec::ulidGenerate);
+      prototype.registerHybridMethod("setFromUlid", &HybridCkDateTimeSpec::setFromUlid);
+      prototype.registerHybridMethod("ulidIncrement", &HybridCkDateTimeSpec::ulidIncrement);
+      prototype.registerHybridMethod("setFromNtpServer", &HybridCkDateTimeSpec::setFromNtpServer);
+      prototype.registerHybridMethod("toDtObj", &HybridCkDateTimeSpec::toDtObj);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat