@chilkat/react-native 11.6.1

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

@@ -0,0 +1,124 @@
+///
+/// HybridPemSpec.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 `HybridCertChainSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridCertChainSpec; }
+// Forward declaration of `HybridPublicKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPublicKeySpec; }
+// Forward declaration of `HybridJavaKeyStoreSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJavaKeyStoreSpec; }
+// Forward declaration of `HybridPfxSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPfxSpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridCertSpec.hpp"
+#include "HybridPrivateKeySpec.hpp"
+#include "HybridCertChainSpec.hpp"
+#include "HybridPublicKeySpec.hpp"
+#include "HybridJavaKeyStoreSpec.hpp"
+#include "HybridPfxSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Pem`
+   * Inherit this class to create instances of `HybridPemSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridPem: public HybridPemSpec {
+   * public:
+   *   HybridPem(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridPemSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridPemSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridPemSpec() 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 getAppendMode() = 0;
+      virtual void setAppendMode(bool appendMode) = 0;
+      virtual double getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 0;
+      virtual double getNumCerts() = 0;
+      virtual double getNumCsrs() = 0;
+      virtual double getNumPrivateKeys() = 0;
+      virtual double getNumPublicKeys() = 0;
+      virtual std::string getPrivateKeyFormat() = 0;
+      virtual void setPrivateKeyFormat(const std::string& privateKeyFormat) = 0;
+      virtual std::string getPublicKeyFormat() = 0;
+      virtual void setPublicKeyFormat(const std::string& publicKeyFormat) = 0;
+      virtual double getNumCrls() = 0;
+
+    public:
+      // Methods
+      virtual void addCert(const std::shared_ptr<HybridCertSpec>& cert, bool includeChain) = 0;
+      virtual void addPrivateKey(const std::shared_ptr<HybridPrivateKeySpec>& privateKey) = 0;
+      virtual void addPrivateKey2(const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridCertChainSpec>& certChain) = 0;
+      virtual void addPublicKey(const std::shared_ptr<HybridPublicKeySpec>& pubkey) = 0;
+      virtual void clear() = 0;
+      virtual std::string getEncodedItem(const std::string& itemType, const std::string& itemSubType, const std::string& encoding, double index) = 0;
+      virtual void loadP7bFile(const std::string& path) = 0;
+      virtual void loadPem(const std::string& pemContent, const std::string& password) = 0;
+      virtual void loadPemFile(const std::string& path, const std::string& password) = 0;
+      virtual void removeCert(double index) = 0;
+      virtual void removePrivateKey(double index) = 0;
+      virtual std::string toPem() = 0;
+      virtual std::string toPemEx(bool extendedAttrs, bool noKeys, bool noCerts, bool noCaCerts, const std::string& encryptAlg, const std::string& password) = 0;
+      virtual void addItem(const std::string& itemType, const std::string& encoding, const std::string& itemData) = 0;
+      virtual void certAt(double index, const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void privateKeyAt(double index, const std::shared_ptr<HybridPrivateKeySpec>& privKey) = 0;
+      virtual void publicKeyAt(double index, const std::shared_ptr<HybridPublicKeySpec>& pubKey) = 0;
+      virtual void toJksObj(const std::string& aliasName, const std::string& password, const std::shared_ptr<HybridJavaKeyStoreSpec>& jksObj) = 0;
+      virtual void toPfxObj(const std::shared_ptr<HybridPfxSpec>& pfxObj) = 0;
+      virtual void addP7b(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Pem";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,61 @@
+///
+/// HybridPfxSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridPfxSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridPfxSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridPfxSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridPfxSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridPfxSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridPfxSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridPfxSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridPfxSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridPfxSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridPfxSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridPfxSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridPfxSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("numCerts", &HybridPfxSpec::getNumCerts);
+      prototype.registerHybridGetter("numPrivateKeys", &HybridPfxSpec::getNumPrivateKeys);
+      prototype.registerHybridGetter("algorithmId", &HybridPfxSpec::getAlgorithmId);
+      prototype.registerHybridSetter("algorithmId", &HybridPfxSpec::setAlgorithmId);
+      prototype.registerHybridGetter("pbes2CryptAlg", &HybridPfxSpec::getPbes2CryptAlg);
+      prototype.registerHybridSetter("pbes2CryptAlg", &HybridPfxSpec::setPbes2CryptAlg);
+      prototype.registerHybridGetter("pbes2HmacAlg", &HybridPfxSpec::getPbes2HmacAlg);
+      prototype.registerHybridSetter("pbes2HmacAlg", &HybridPfxSpec::setPbes2HmacAlg);
+      prototype.registerHybridGetter("uncommonOptions", &HybridPfxSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridPfxSpec::setUncommonOptions);
+      prototype.registerHybridMethod("addCert", &HybridPfxSpec::addCert);
+      prototype.registerHybridMethod("addPrivateKey", &HybridPfxSpec::addPrivateKey);
+      prototype.registerHybridMethod("loadPem", &HybridPfxSpec::loadPem);
+      prototype.registerHybridMethod("loadPfxEncoded", &HybridPfxSpec::loadPfxEncoded);
+      prototype.registerHybridMethod("loadPfxFile", &HybridPfxSpec::loadPfxFile);
+      prototype.registerHybridMethod("toEncodedString", &HybridPfxSpec::toEncodedString);
+      prototype.registerHybridMethod("toFile", &HybridPfxSpec::toFile);
+      prototype.registerHybridMethod("toPem", &HybridPfxSpec::toPem);
+      prototype.registerHybridMethod("toPemEx", &HybridPfxSpec::toPemEx);
+      prototype.registerHybridMethod("useCertVault", &HybridPfxSpec::useCertVault);
+      prototype.registerHybridMethod("setSafeBagAttr", &HybridPfxSpec::setSafeBagAttr);
+      prototype.registerHybridMethod("importToWindows", &HybridPfxSpec::importToWindows);
+      prototype.registerHybridMethod("getSafeBagAttr", &HybridPfxSpec::getSafeBagAttr);
+      prototype.registerHybridMethod("importToKeychain", &HybridPfxSpec::importToKeychain);
+      prototype.registerHybridMethod("getLastJsonData", &HybridPfxSpec::getLastJsonData);
+      prototype.registerHybridMethod("certAt", &HybridPfxSpec::certAt);
+      prototype.registerHybridMethod("certByLocalKeyId", &HybridPfxSpec::certByLocalKeyId);
+      prototype.registerHybridMethod("privateKeyAt", &HybridPfxSpec::privateKeyAt);
+      prototype.registerHybridMethod("toJksObj", &HybridPfxSpec::toJksObj);
+      prototype.registerHybridMethod("loadPfxBd", &HybridPfxSpec::loadPfxBd);
+      prototype.registerHybridMethod("toBd", &HybridPfxSpec::toBd);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,122 @@
+///
+/// HybridPfxSpec.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 `HybridCertChainSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridCertChainSpec; }
+// Forward declaration of `HybridXmlCertVaultSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridXmlCertVaultSpec; }
+// Forward declaration of `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+// Forward declaration of `HybridJavaKeyStoreSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJavaKeyStoreSpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridCertSpec.hpp"
+#include "HybridPrivateKeySpec.hpp"
+#include "HybridCertChainSpec.hpp"
+#include "HybridXmlCertVaultSpec.hpp"
+#include "HybridJsonObjectSpec.hpp"
+#include "HybridJavaKeyStoreSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Pfx`
+   * Inherit this class to create instances of `HybridPfxSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridPfx: public HybridPfxSpec {
+   * public:
+   *   HybridPfx(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridPfxSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridPfxSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridPfxSpec() 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 getNumPrivateKeys() = 0;
+      virtual std::string getAlgorithmId() = 0;
+      virtual void setAlgorithmId(const std::string& algorithmId) = 0;
+      virtual std::string getPbes2CryptAlg() = 0;
+      virtual void setPbes2CryptAlg(const std::string& pbes2CryptAlg) = 0;
+      virtual std::string getPbes2HmacAlg() = 0;
+      virtual void setPbes2HmacAlg(const std::string& pbes2HmacAlg) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+
+    public:
+      // Methods
+      virtual void addCert(const std::shared_ptr<HybridCertSpec>& cert, bool includeChain) = 0;
+      virtual void addPrivateKey(const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridCertChainSpec>& certChain) = 0;
+      virtual void loadPem(const std::string& pemStr, const std::string& password) = 0;
+      virtual void loadPfxEncoded(const std::string& encodedData, const std::string& encoding, const std::string& password) = 0;
+      virtual void loadPfxFile(const std::string& path, const std::string& password) = 0;
+      virtual std::string toEncodedString(const std::string& password, const std::string& encoding) = 0;
+      virtual void toFile(const std::string& password, const std::string& path) = 0;
+      virtual std::string toPem() = 0;
+      virtual std::string toPemEx(bool extendedAttrs, bool noKeys, bool noCerts, bool noCaCerts, const std::string& encryptAlg, const std::string& password) = 0;
+      virtual void useCertVault(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) = 0;
+      virtual void setSafeBagAttr(bool forPrivateKey, double index, const std::string& name, const std::string& value, const std::string& encoding) = 0;
+      virtual void importToWindows(bool exportable, bool userProtected, bool machineKeyset, bool allowOverwriteKey, bool allowExport, const std::string& leafStore, const std::string& intermediateStore, const std::string& rootStore, const std::string& extraOptions) = 0;
+      virtual std::string getSafeBagAttr(bool forPrivateKey, double index, const std::string& attrName) = 0;
+      virtual void importToKeychain(const std::shared_ptr<HybridJsonObjectSpec>& opts) = 0;
+      virtual void getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void certAt(double index, const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void certByLocalKeyId(const std::string& localKeyId, const std::string& encoding, const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void privateKeyAt(double index, const std::shared_ptr<HybridPrivateKeySpec>& privKey) = 0;
+      virtual void toJksObj(const std::string& aliasName, const std::string& password, const std::shared_ptr<HybridJavaKeyStoreSpec>& jksObj) = 0;
+      virtual void loadPfxBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& password) = 0;
+      virtual void toBd(const std::string& password, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Pfx";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,60 @@
+///
+/// HybridPkcs11Spec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridPkcs11Spec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridPkcs11Spec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridPkcs11Spec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridPkcs11Spec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridPkcs11Spec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridPkcs11Spec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridPkcs11Spec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridPkcs11Spec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridPkcs11Spec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridPkcs11Spec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridPkcs11Spec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridPkcs11Spec::setLastMethodSuccess);
+      prototype.registerHybridGetter("sharedLibPath", &HybridPkcs11Spec::getSharedLibPath);
+      prototype.registerHybridSetter("sharedLibPath", &HybridPkcs11Spec::setSharedLibPath);
+      prototype.registerHybridGetter("numCerts", &HybridPkcs11Spec::getNumCerts);
+      prototype.registerHybridGetter("sigContextPin", &HybridPkcs11Spec::getSigContextPin);
+      prototype.registerHybridSetter("sigContextPin", &HybridPkcs11Spec::setSigContextPin);
+      prototype.registerHybridGetter("uncommonOptions", &HybridPkcs11Spec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridPkcs11Spec::setUncommonOptions);
+      prototype.registerHybridMethod("initialize", &HybridPkcs11Spec::initialize);
+      prototype.registerHybridMethod("discover", &HybridPkcs11Spec::discover);
+      prototype.registerHybridMethod("openSession", &HybridPkcs11Spec::openSession);
+      prototype.registerHybridMethod("closeSession", &HybridPkcs11Spec::closeSession);
+      prototype.registerHybridMethod("login", &HybridPkcs11Spec::login);
+      prototype.registerHybridMethod("logout", &HybridPkcs11Spec::logout);
+      prototype.registerHybridMethod("findAllCerts", &HybridPkcs11Spec::findAllCerts);
+      prototype.registerHybridMethod("getCert", &HybridPkcs11Spec::getCert);
+      prototype.registerHybridMethod("findCert", &HybridPkcs11Spec::findCert);
+      prototype.registerHybridMethod("setPin", &HybridPkcs11Spec::setPin);
+      prototype.registerHybridMethod("initPin", &HybridPkcs11Spec::initPin);
+      prototype.registerHybridMethod("initToken", &HybridPkcs11Spec::initToken);
+      prototype.registerHybridMethod("findAllKeys", &HybridPkcs11Spec::findAllKeys);
+      prototype.registerHybridMethod("genSecretKey", &HybridPkcs11Spec::genSecretKey);
+      prototype.registerHybridMethod("genRsaKey", &HybridPkcs11Spec::genRsaKey);
+      prototype.registerHybridMethod("genEcKey", &HybridPkcs11Spec::genEcKey);
+      prototype.registerHybridMethod("createPkcs11Object", &HybridPkcs11Spec::createPkcs11Object);
+      prototype.registerHybridMethod("quickSession", &HybridPkcs11Spec::quickSession);
+      prototype.registerHybridMethod("importPrivateKey", &HybridPkcs11Spec::importPrivateKey);
+      prototype.registerHybridMethod("destroyObject", &HybridPkcs11Spec::destroyObject);
+      prototype.registerHybridMethod("findObject", &HybridPkcs11Spec::findObject);
+      prototype.registerHybridMethod("importSshKey", &HybridPkcs11Spec::importSshKey);
+      prototype.registerHybridMethod("exportPublicKey", &HybridPkcs11Spec::exportPublicKey);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,115 @@
+///
+/// HybridPkcs11Spec.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; }
+// Forward declaration of `HybridCertSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridCertSpec; }
+// Forward declaration of `HybridPublicKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPublicKeySpec; }
+// Forward declaration of `HybridPrivateKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPrivateKeySpec; }
+// Forward declaration of `HybridSshKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridSshKeySpec; }
+
+#include <string>
+#include <memory>
+#include "HybridJsonObjectSpec.hpp"
+#include "HybridCertSpec.hpp"
+#include "HybridPublicKeySpec.hpp"
+#include "HybridPrivateKeySpec.hpp"
+#include "HybridSshKeySpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Pkcs11`
+   * Inherit this class to create instances of `HybridPkcs11Spec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridPkcs11: public HybridPkcs11Spec {
+   * public:
+   *   HybridPkcs11(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridPkcs11Spec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridPkcs11Spec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridPkcs11Spec() 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 getSharedLibPath() = 0;
+      virtual void setSharedLibPath(const std::string& sharedLibPath) = 0;
+      virtual double getNumCerts() = 0;
+      virtual std::string getSigContextPin() = 0;
+      virtual void setSigContextPin(const std::string& sigContextPin) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+
+    public:
+      // Methods
+      virtual void initialize() = 0;
+      virtual void discover(bool onlyTokensPresent, const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void openSession(double slotId, bool readWrite) = 0;
+      virtual void closeSession() = 0;
+      virtual void login(double userType, const std::string& pin) = 0;
+      virtual void logout() = 0;
+      virtual void findAllCerts() = 0;
+      virtual void getCert(double index, const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void findCert(const std::string& certPart, const std::string& partValue, const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void setPin(const std::string& oldPin, const std::string& newPin) = 0;
+      virtual void initPin(const std::string& pin) = 0;
+      virtual void initToken(double slotId, const std::string& pin, const std::string& tokenLabel) = 0;
+      virtual void findAllKeys(const std::string& keyClass, const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual double genSecretKey(const std::string& keyType, const std::shared_ptr<HybridJsonObjectSpec>& jsonTemplate) = 0;
+      virtual void genRsaKey(const std::shared_ptr<HybridJsonObjectSpec>& publicAttrs, const std::shared_ptr<HybridJsonObjectSpec>& privateAttrs, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut, const std::shared_ptr<HybridPublicKeySpec>& pubKey) = 0;
+      virtual void genEcKey(const std::shared_ptr<HybridJsonObjectSpec>& publicAttrs, const std::shared_ptr<HybridJsonObjectSpec>& privateAttrs, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut, const std::shared_ptr<HybridPublicKeySpec>& pubKey) = 0;
+      virtual double createPkcs11Object(const std::shared_ptr<HybridJsonObjectSpec>& attrs) = 0;
+      virtual void quickSession(double userType, const std::string& pin) = 0;
+      virtual double importPrivateKey(const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridJsonObjectSpec>& jsonTemplate) = 0;
+      virtual void destroyObject(double hObject) = 0;
+      virtual double findObject(const std::shared_ptr<HybridJsonObjectSpec>& jsonTemplate) = 0;
+      virtual double importSshKey(const std::shared_ptr<HybridSshKeySpec>& sshKey, const std::shared_ptr<HybridJsonObjectSpec>& jsonTemplate) = 0;
+      virtual void exportPublicKey(double keyHandle, const std::shared_ptr<HybridPublicKeySpec>& pubKey) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Pkcs11";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,76 @@
+///
+/// HybridPrivateKeySpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridPrivateKeySpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridPrivateKeySpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridPrivateKeySpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridPrivateKeySpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridPrivateKeySpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridPrivateKeySpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridPrivateKeySpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridPrivateKeySpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridPrivateKeySpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridPrivateKeySpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridPrivateKeySpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridPrivateKeySpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("bitLength", &HybridPrivateKeySpec::getBitLength);
+      prototype.registerHybridGetter("keyType", &HybridPrivateKeySpec::getKeyType);
+      prototype.registerHybridGetter("pkcs8EncryptAlg", &HybridPrivateKeySpec::getPkcs8EncryptAlg);
+      prototype.registerHybridSetter("pkcs8EncryptAlg", &HybridPrivateKeySpec::setPkcs8EncryptAlg);
+      prototype.registerHybridGetter("uncommonOptions", &HybridPrivateKeySpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridPrivateKeySpec::setUncommonOptions);
+      prototype.registerHybridGetter("onPercentDone", &HybridPrivateKeySpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridPrivateKeySpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridPrivateKeySpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridPrivateKeySpec::setOnProgressInfo);
+      prototype.registerHybridMethod("getPkcs1ENC", &HybridPrivateKeySpec::getPkcs1ENC);
+      prototype.registerHybridMethod("getPkcs8ENC", &HybridPrivateKeySpec::getPkcs8ENC);
+      prototype.registerHybridMethod("getPkcs8EncryptedENC", &HybridPrivateKeySpec::getPkcs8EncryptedENC);
+      prototype.registerHybridMethod("getPkcs8EncryptedPem", &HybridPrivateKeySpec::getPkcs8EncryptedPem);
+      prototype.registerHybridMethod("getPkcs8Pem", &HybridPrivateKeySpec::getPkcs8Pem);
+      prototype.registerHybridMethod("getXml", &HybridPrivateKeySpec::getXml);
+      prototype.registerHybridMethod("loadEncryptedPem", &HybridPrivateKeySpec::loadEncryptedPem);
+      prototype.registerHybridMethod("loadEncryptedPemFile", &HybridPrivateKeySpec::loadEncryptedPemFile);
+      prototype.registerHybridMethod("loadPem", &HybridPrivateKeySpec::loadPem);
+      prototype.registerHybridMethod("loadPemFile", &HybridPrivateKeySpec::loadPemFile);
+      prototype.registerHybridMethod("loadPkcs8EncryptedFile", &HybridPrivateKeySpec::loadPkcs8EncryptedFile);
+      prototype.registerHybridMethod("loadPkcs8File", &HybridPrivateKeySpec::loadPkcs8File);
+      prototype.registerHybridMethod("loadPvkFile", &HybridPrivateKeySpec::loadPvkFile);
+      prototype.registerHybridMethod("loadXml", &HybridPrivateKeySpec::loadXml);
+      prototype.registerHybridMethod("loadXmlFile", &HybridPrivateKeySpec::loadXmlFile);
+      prototype.registerHybridMethod("savePkcs8EncryptedFile", &HybridPrivateKeySpec::savePkcs8EncryptedFile);
+      prototype.registerHybridMethod("savePkcs8EncryptedPemFile", &HybridPrivateKeySpec::savePkcs8EncryptedPemFile);
+      prototype.registerHybridMethod("savePkcs8File", &HybridPrivateKeySpec::savePkcs8File);
+      prototype.registerHybridMethod("savePkcs8PemFile", &HybridPrivateKeySpec::savePkcs8PemFile);
+      prototype.registerHybridMethod("saveXmlFile", &HybridPrivateKeySpec::saveXmlFile);
+      prototype.registerHybridMethod("getPkcs1Pem", &HybridPrivateKeySpec::getPkcs1Pem);
+      prototype.registerHybridMethod("loadPkcs1File", &HybridPrivateKeySpec::loadPkcs1File);
+      prototype.registerHybridMethod("savePkcs1File", &HybridPrivateKeySpec::savePkcs1File);
+      prototype.registerHybridMethod("savePemFile", &HybridPrivateKeySpec::savePemFile);
+      prototype.registerHybridMethod("getJwk", &HybridPrivateKeySpec::getJwk);
+      prototype.registerHybridMethod("loadJwk", &HybridPrivateKeySpec::loadJwk);
+      prototype.registerHybridMethod("getJwkThumbprint", &HybridPrivateKeySpec::getJwkThumbprint);
+      prototype.registerHybridMethod("loadAnyFormat", &HybridPrivateKeySpec::loadAnyFormat);
+      prototype.registerHybridMethod("loadEd25519", &HybridPrivateKeySpec::loadEd25519);
+      prototype.registerHybridMethod("loadAnyFormatFile", &HybridPrivateKeySpec::loadAnyFormatFile);
+      prototype.registerHybridMethod("getRawHex", &HybridPrivateKeySpec::getRawHex);
+      prototype.registerHybridMethod("uploadToCloud", &HybridPrivateKeySpec::uploadToCloud);
+      prototype.registerHybridMethod("uploadToCloudAsync", &HybridPrivateKeySpec::uploadToCloudAsync);
+      prototype.registerHybridMethod("toPublicKey", &HybridPrivateKeySpec::toPublicKey);
+      prototype.registerHybridMethod("getPkcsBd", &HybridPrivateKeySpec::getPkcsBd);
+      prototype.registerHybridMethod("abort", &HybridPrivateKeySpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat