@chilkat/react-native 11.6.1

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

@@ -0,0 +1,93 @@
+///
+/// HybridBz2Spec.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 <functional>
+#include <optional>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include "HybridBinDataSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Bz2`
+   * Inherit this class to create instances of `HybridBz2Spec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridBz2: public HybridBz2Spec {
+   * public:
+   *   HybridBz2(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridBz2Spec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridBz2Spec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridBz2Spec() 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 getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 0;
+      virtual bool getAbortCurrent() = 0;
+      virtual void setAbortCurrent(bool abortCurrent) = 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 compressFile(const std::string& inFilename, const std::string& toPath) = 0;
+      virtual std::shared_ptr<Promise<void>> compressFileAsync(const std::string& inFilename, const std::string& toPath) = 0;
+      virtual void uncompressFile(const std::string& inFilename, const std::string& toPath) = 0;
+      virtual std::shared_ptr<Promise<void>> uncompressFileAsync(const std::string& inFilename, const std::string& toPath) = 0;
+      virtual void compressBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual std::shared_ptr<Promise<void>> compressBdAsync(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void uncompressBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual std::shared_ptr<Promise<void>> uncompressBdAsync(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Bz2";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,57 @@
+///
+/// HybridCacheSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridCacheSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridCacheSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridCacheSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridCacheSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridCacheSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridCacheSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridCacheSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridCacheSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridCacheSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridCacheSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridCacheSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridCacheSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("lastEtagFetched", &HybridCacheSpec::getLastEtagFetched);
+      prototype.registerHybridGetter("lastExpirationFetchedStr", &HybridCacheSpec::getLastExpirationFetchedStr);
+      prototype.registerHybridGetter("lastHitExpired", &HybridCacheSpec::getLastHitExpired);
+      prototype.registerHybridGetter("lastKeyFetched", &HybridCacheSpec::getLastKeyFetched);
+      prototype.registerHybridGetter("level", &HybridCacheSpec::getLevel);
+      prototype.registerHybridSetter("level", &HybridCacheSpec::setLevel);
+      prototype.registerHybridGetter("numRoots", &HybridCacheSpec::getNumRoots);
+      prototype.registerHybridMethod("addRoot", &HybridCacheSpec::addRoot);
+      prototype.registerHybridMethod("deleteAll", &HybridCacheSpec::deleteAll);
+      prototype.registerHybridMethod("deleteAllExpired", &HybridCacheSpec::deleteAllExpired);
+      prototype.registerHybridMethod("deleteFromCache", &HybridCacheSpec::deleteFromCache);
+      prototype.registerHybridMethod("deleteOlderDt", &HybridCacheSpec::deleteOlderDt);
+      prototype.registerHybridMethod("deleteOlderStr", &HybridCacheSpec::deleteOlderStr);
+      prototype.registerHybridMethod("fetchText", &HybridCacheSpec::fetchText);
+      prototype.registerHybridMethod("getEtag", &HybridCacheSpec::getEtag);
+      prototype.registerHybridMethod("getExpirationStr", &HybridCacheSpec::getExpirationStr);
+      prototype.registerHybridMethod("getFilename", &HybridCacheSpec::getFilename);
+      prototype.registerHybridMethod("getRoot", &HybridCacheSpec::getRoot);
+      prototype.registerHybridMethod("isCached", &HybridCacheSpec::isCached);
+      prototype.registerHybridMethod("saveTextDt", &HybridCacheSpec::saveTextDt);
+      prototype.registerHybridMethod("saveTextNoExpire", &HybridCacheSpec::saveTextNoExpire);
+      prototype.registerHybridMethod("saveTextStr", &HybridCacheSpec::saveTextStr);
+      prototype.registerHybridMethod("updateExpirationDt", &HybridCacheSpec::updateExpirationDt);
+      prototype.registerHybridMethod("updateExpirationStr", &HybridCacheSpec::updateExpirationStr);
+      prototype.registerHybridMethod("fetchBd", &HybridCacheSpec::fetchBd);
+      prototype.registerHybridMethod("fetchSb", &HybridCacheSpec::fetchSb);
+      prototype.registerHybridMethod("saveBd", &HybridCacheSpec::saveBd);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,106 @@
+///
+/// HybridCacheSpec.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 `HybridCkDateTimeSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridCkDateTimeSpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridCkDateTimeSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+#include "HybridStringBuilderSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Cache`
+   * Inherit this class to create instances of `HybridCacheSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCache: public HybridCacheSpec {
+   * public:
+   *   HybridCache(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCacheSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCacheSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCacheSpec() 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 getLastEtagFetched() = 0;
+      virtual std::string getLastExpirationFetchedStr() = 0;
+      virtual bool getLastHitExpired() = 0;
+      virtual std::string getLastKeyFetched() = 0;
+      virtual double getLevel() = 0;
+      virtual void setLevel(double level) = 0;
+      virtual double getNumRoots() = 0;
+
+    public:
+      // Methods
+      virtual void addRoot(const std::string& path) = 0;
+      virtual double deleteAll() = 0;
+      virtual double deleteAllExpired() = 0;
+      virtual void deleteFromCache(const std::string& key) = 0;
+      virtual double deleteOlderDt(const std::shared_ptr<HybridCkDateTimeSpec>& dt) = 0;
+      virtual double deleteOlderStr(const std::string& dateTimeStr) = 0;
+      virtual std::string fetchText(const std::string& key) = 0;
+      virtual std::string getEtag(const std::string& key) = 0;
+      virtual std::string getExpirationStr(const std::string& url) = 0;
+      virtual std::string getFilename(const std::string& key) = 0;
+      virtual std::string getRoot(double index) = 0;
+      virtual bool isCached(const std::string& key) = 0;
+      virtual void saveTextDt(const std::string& key, const std::shared_ptr<HybridCkDateTimeSpec>& expireDateTime, const std::string& eTag, const std::string& itemTextData) = 0;
+      virtual void saveTextNoExpire(const std::string& key, const std::string& eTag, const std::string& itemTextData) = 0;
+      virtual void saveTextStr(const std::string& key, const std::string& expireDateTime, const std::string& eTag, const std::string& itemTextData) = 0;
+      virtual void updateExpirationDt(const std::string& key, const std::shared_ptr<HybridCkDateTimeSpec>& expireDateTime) = 0;
+      virtual void updateExpirationStr(const std::string& key, const std::string& expireDateTime) = 0;
+      virtual void fetchBd(const std::string& key, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void fetchSb(const std::string& key, const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void saveBd(const std::string& key, const std::string& expiration, const std::string& etag, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Cache";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,40 @@
+///
+/// HybridCertChainSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridCertChainSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridCertChainSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridCertChainSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridCertChainSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridCertChainSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridCertChainSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridCertChainSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridCertChainSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridCertChainSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridCertChainSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridCertChainSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridCertChainSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("numCerts", &HybridCertChainSpec::getNumCerts);
+      prototype.registerHybridGetter("numExpiredCerts", &HybridCertChainSpec::getNumExpiredCerts);
+      prototype.registerHybridGetter("reachesRoot", &HybridCertChainSpec::getReachesRoot);
+      prototype.registerHybridGetter("uncommonOptions", &HybridCertChainSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridCertChainSpec::setUncommonOptions);
+      prototype.registerHybridMethod("isRootTrusted", &HybridCertChainSpec::isRootTrusted);
+      prototype.registerHybridMethod("verifyCertSignatures", &HybridCertChainSpec::verifyCertSignatures);
+      prototype.registerHybridMethod("loadX5C", &HybridCertChainSpec::loadX5C);
+      prototype.registerHybridMethod("x509PKIPathv1", &HybridCertChainSpec::x509PKIPathv1);
+      prototype.registerHybridMethod("certAt", &HybridCertChainSpec::certAt);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,89 @@
+///
+/// HybridCertChainSpec.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 `HybridTrustedRootsSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridTrustedRootsSpec; }
+// Forward declaration of `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+// Forward declaration of `HybridCertSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridCertSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridTrustedRootsSpec.hpp"
+#include "HybridJsonObjectSpec.hpp"
+#include "HybridCertSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `CertChain`
+   * Inherit this class to create instances of `HybridCertChainSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCertChain: public HybridCertChainSpec {
+   * public:
+   *   HybridCertChain(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCertChainSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCertChainSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCertChainSpec() 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 getNumCerts() = 0;
+      virtual double getNumExpiredCerts() = 0;
+      virtual bool getReachesRoot() = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+
+    public:
+      // Methods
+      virtual bool isRootTrusted(const std::shared_ptr<HybridTrustedRootsSpec>& trustedRoots) = 0;
+      virtual bool verifyCertSignatures() = 0;
+      virtual void loadX5C(const std::shared_ptr<HybridJsonObjectSpec>& jwk) = 0;
+      virtual std::string x509PKIPathv1() = 0;
+      virtual void certAt(double index, const std::shared_ptr<HybridCertSpec>& cert) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "CertChain";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,138 @@
+///
+/// HybridCertSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridCertSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridCertSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridCertSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridCertSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridCertSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridCertSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridCertSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridCertSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridCertSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridCertSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridCertSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridCertSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("authorityKeyId", &HybridCertSpec::getAuthorityKeyId);
+      prototype.registerHybridGetter("avoidWindowsPkAccess", &HybridCertSpec::getAvoidWindowsPkAccess);
+      prototype.registerHybridSetter("avoidWindowsPkAccess", &HybridCertSpec::setAvoidWindowsPkAccess);
+      prototype.registerHybridGetter("certVersion", &HybridCertSpec::getCertVersion);
+      prototype.registerHybridGetter("expired", &HybridCertSpec::getExpired);
+      prototype.registerHybridGetter("forClientAuthentication", &HybridCertSpec::getForClientAuthentication);
+      prototype.registerHybridGetter("forCodeSigning", &HybridCertSpec::getForCodeSigning);
+      prototype.registerHybridGetter("forSecureEmail", &HybridCertSpec::getForSecureEmail);
+      prototype.registerHybridGetter("forServerAuthentication", &HybridCertSpec::getForServerAuthentication);
+      prototype.registerHybridGetter("forTimeStamping", &HybridCertSpec::getForTimeStamping);
+      prototype.registerHybridGetter("intendedKeyUsage", &HybridCertSpec::getIntendedKeyUsage);
+      prototype.registerHybridGetter("isRoot", &HybridCertSpec::getIsRoot);
+      prototype.registerHybridGetter("issuerC", &HybridCertSpec::getIssuerC);
+      prototype.registerHybridGetter("issuerCN", &HybridCertSpec::getIssuerCN);
+      prototype.registerHybridGetter("issuerDN", &HybridCertSpec::getIssuerDN);
+      prototype.registerHybridGetter("issuerE", &HybridCertSpec::getIssuerE);
+      prototype.registerHybridGetter("issuerL", &HybridCertSpec::getIssuerL);
+      prototype.registerHybridGetter("issuerO", &HybridCertSpec::getIssuerO);
+      prototype.registerHybridGetter("issuerOU", &HybridCertSpec::getIssuerOU);
+      prototype.registerHybridGetter("issuerS", &HybridCertSpec::getIssuerS);
+      prototype.registerHybridGetter("ocspUrl", &HybridCertSpec::getOcspUrl);
+      prototype.registerHybridGetter("privateKeyExportable", &HybridCertSpec::getPrivateKeyExportable);
+      prototype.registerHybridGetter("revoked", &HybridCertSpec::getRevoked);
+      prototype.registerHybridGetter("rfc822Name", &HybridCertSpec::getRfc822Name);
+      prototype.registerHybridGetter("selfSigned", &HybridCertSpec::getSelfSigned);
+      prototype.registerHybridGetter("serialNumber", &HybridCertSpec::getSerialNumber);
+      prototype.registerHybridGetter("sha1Thumbprint", &HybridCertSpec::getSha1Thumbprint);
+      prototype.registerHybridGetter("signatureVerified", &HybridCertSpec::getSignatureVerified);
+      prototype.registerHybridGetter("subjectC", &HybridCertSpec::getSubjectC);
+      prototype.registerHybridGetter("subjectCN", &HybridCertSpec::getSubjectCN);
+      prototype.registerHybridGetter("subjectDN", &HybridCertSpec::getSubjectDN);
+      prototype.registerHybridGetter("subjectE", &HybridCertSpec::getSubjectE);
+      prototype.registerHybridGetter("subjectKeyId", &HybridCertSpec::getSubjectKeyId);
+      prototype.registerHybridGetter("subjectL", &HybridCertSpec::getSubjectL);
+      prototype.registerHybridGetter("subjectO", &HybridCertSpec::getSubjectO);
+      prototype.registerHybridGetter("subjectOU", &HybridCertSpec::getSubjectOU);
+      prototype.registerHybridGetter("subjectS", &HybridCertSpec::getSubjectS);
+      prototype.registerHybridGetter("trustedRoot", &HybridCertSpec::getTrustedRoot);
+      prototype.registerHybridGetter("validFromStr", &HybridCertSpec::getValidFromStr);
+      prototype.registerHybridGetter("validToStr", &HybridCertSpec::getValidToStr);
+      prototype.registerHybridGetter("serialDecimal", &HybridCertSpec::getSerialDecimal);
+      prototype.registerHybridGetter("smartCardPin", &HybridCertSpec::getSmartCardPin);
+      prototype.registerHybridSetter("smartCardPin", &HybridCertSpec::setSmartCardPin);
+      prototype.registerHybridGetter("smartCardNoDialog", &HybridCertSpec::getSmartCardNoDialog);
+      prototype.registerHybridSetter("smartCardNoDialog", &HybridCertSpec::setSmartCardNoDialog);
+      prototype.registerHybridGetter("extendedKeyUsage", &HybridCertSpec::getExtendedKeyUsage);
+      prototype.registerHybridGetter("subjectAlternativeName", &HybridCertSpec::getSubjectAlternativeName);
+      prototype.registerHybridGetter("uncommonOptions", &HybridCertSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridCertSpec::setUncommonOptions);
+      prototype.registerHybridGetter("smartCardFailReason", &HybridCertSpec::getSmartCardFailReason);
+      prototype.registerHybridGetter("onPercentDone", &HybridCertSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridCertSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridCertSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridCertSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("checkRevoked", &HybridCertSpec::checkRevoked);
+      prototype.registerHybridMethod("exportCertDerFile", &HybridCertSpec::exportCertDerFile);
+      prototype.registerHybridMethod("exportCertPem", &HybridCertSpec::exportCertPem);
+      prototype.registerHybridMethod("exportCertPemFile", &HybridCertSpec::exportCertPemFile);
+      prototype.registerHybridMethod("exportCertXml", &HybridCertSpec::exportCertXml);
+      prototype.registerHybridMethod("exportToPfxFile", &HybridCertSpec::exportToPfxFile);
+      prototype.registerHybridMethod("findIssuer", &HybridCertSpec::findIssuer);
+      prototype.registerHybridMethod("getEncoded", &HybridCertSpec::getEncoded);
+      prototype.registerHybridMethod("getExtensionAsXml", &HybridCertSpec::getExtensionAsXml);
+      prototype.registerHybridMethod("getPrivateKeyPem", &HybridCertSpec::getPrivateKeyPem);
+      prototype.registerHybridMethod("getSpkiFingerprint", &HybridCertSpec::getSpkiFingerprint);
+      prototype.registerHybridMethod("hasPrivateKey", &HybridCertSpec::hasPrivateKey);
+      prototype.registerHybridMethod("loadByCommonName", &HybridCertSpec::loadByCommonName);
+      prototype.registerHybridMethod("loadByEmailAddress", &HybridCertSpec::loadByEmailAddress);
+      prototype.registerHybridMethod("loadByIssuerAndSerialNumber", &HybridCertSpec::loadByIssuerAndSerialNumber);
+      prototype.registerHybridMethod("loadFromBase64", &HybridCertSpec::loadFromBase64);
+      prototype.registerHybridMethod("loadFromFile", &HybridCertSpec::loadFromFile);
+      prototype.registerHybridMethod("loadPem", &HybridCertSpec::loadPem);
+      prototype.registerHybridMethod("loadPfxFile", &HybridCertSpec::loadPfxFile);
+      prototype.registerHybridMethod("pemFileToDerFile", &HybridCertSpec::pemFileToDerFile);
+      prototype.registerHybridMethod("saveToFile", &HybridCertSpec::saveToFile);
+      prototype.registerHybridMethod("setFromEncoded", &HybridCertSpec::setFromEncoded);
+      prototype.registerHybridMethod("setPrivateKey", &HybridCertSpec::setPrivateKey);
+      prototype.registerHybridMethod("setPrivateKeyPem", &HybridCertSpec::setPrivateKeyPem);
+      prototype.registerHybridMethod("useCertVault", &HybridCertSpec::useCertVault);
+      prototype.registerHybridMethod("verifySignature", &HybridCertSpec::verifySignature);
+      prototype.registerHybridMethod("exportToPfxBd", &HybridCertSpec::exportToPfxBd);
+      prototype.registerHybridMethod("exportCertDerBd", &HybridCertSpec::exportCertDerBd);
+      prototype.registerHybridMethod("loadPfxBd", &HybridCertSpec::loadPfxBd);
+      prototype.registerHybridMethod("loadFromBd", &HybridCertSpec::loadFromBd);
+      prototype.registerHybridMethod("hashOf", &HybridCertSpec::hashOf);
+      prototype.registerHybridMethod("checkSmartCardPin", &HybridCertSpec::checkSmartCardPin);
+      prototype.registerHybridMethod("x509PKIPathv1", &HybridCertSpec::x509PKIPathv1);
+      prototype.registerHybridMethod("loadFromSmartcard", &HybridCertSpec::loadFromSmartcard);
+      prototype.registerHybridMethod("loadByThumbprint", &HybridCertSpec::loadByThumbprint);
+      prototype.registerHybridMethod("loadBySubjectOid", &HybridCertSpec::loadBySubjectOid);
+      prototype.registerHybridMethod("getSubjectPart", &HybridCertSpec::getSubjectPart);
+      prototype.registerHybridMethod("getExtensionAsText", &HybridCertSpec::getExtensionAsText);
+      prototype.registerHybridMethod("getPubKeyDer", &HybridCertSpec::getPubKeyDer);
+      prototype.registerHybridMethod("getSignature", &HybridCertSpec::getSignature);
+      prototype.registerHybridMethod("getExtensionBd", &HybridCertSpec::getExtensionBd);
+      prototype.registerHybridMethod("linkPkcs11", &HybridCertSpec::linkPkcs11);
+      prototype.registerHybridMethod("uploadToCloud", &HybridCertSpec::uploadToCloud);
+      prototype.registerHybridMethod("uploadToCloudAsync", &HybridCertSpec::uploadToCloudAsync);
+      prototype.registerHybridMethod("setCloudSigner", &HybridCertSpec::setCloudSigner);
+      prototype.registerHybridMethod("setCloudSignerAsync", &HybridCertSpec::setCloudSignerAsync);
+      prototype.registerHybridMethod("isRsa", &HybridCertSpec::isRsa);
+      prototype.registerHybridMethod("isEcdsa", &HybridCertSpec::isEcdsa);
+      prototype.registerHybridMethod("unload", &HybridCertSpec::unload);
+      prototype.registerHybridMethod("getPrivateKey", &HybridCertSpec::getPrivateKey);
+      prototype.registerHybridMethod("getPublicKey", &HybridCertSpec::getPublicKey);
+      prototype.registerHybridMethod("getIssuer", &HybridCertSpec::getIssuer);
+      prototype.registerHybridMethod("buildCertChain", &HybridCertSpec::buildCertChain);
+      prototype.registerHybridMethod("abort", &HybridCertSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat