@chilkat/react-native 11.6.1

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

@@ -0,0 +1,80 @@
+///
+/// HybridWebSocketSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridWebSocketSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridWebSocketSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridWebSocketSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridWebSocketSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridWebSocketSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridWebSocketSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridWebSocketSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridWebSocketSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridWebSocketSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridWebSocketSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridWebSocketSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridWebSocketSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("idleTimeoutMs", &HybridWebSocketSpec::getIdleTimeoutMs);
+      prototype.registerHybridSetter("idleTimeoutMs", &HybridWebSocketSpec::setIdleTimeoutMs);
+      prototype.registerHybridGetter("frameOpcode", &HybridWebSocketSpec::getFrameOpcode);
+      prototype.registerHybridGetter("frameDataLen", &HybridWebSocketSpec::getFrameDataLen);
+      prototype.registerHybridGetter("finalFrame", &HybridWebSocketSpec::getFinalFrame);
+      prototype.registerHybridGetter("isConnected", &HybridWebSocketSpec::getIsConnected);
+      prototype.registerHybridGetter("closeAutoRespond", &HybridWebSocketSpec::getCloseAutoRespond);
+      prototype.registerHybridSetter("closeAutoRespond", &HybridWebSocketSpec::setCloseAutoRespond);
+      prototype.registerHybridGetter("pingAutoRespond", &HybridWebSocketSpec::getPingAutoRespond);
+      prototype.registerHybridSetter("pingAutoRespond", &HybridWebSocketSpec::setPingAutoRespond);
+      prototype.registerHybridGetter("needSendPong", &HybridWebSocketSpec::getNeedSendPong);
+      prototype.registerHybridGetter("closeReceived", &HybridWebSocketSpec::getCloseReceived);
+      prototype.registerHybridGetter("closeStatusCode", &HybridWebSocketSpec::getCloseStatusCode);
+      prototype.registerHybridGetter("closeReason", &HybridWebSocketSpec::getCloseReason);
+      prototype.registerHybridGetter("pongAutoConsume", &HybridWebSocketSpec::getPongAutoConsume);
+      prototype.registerHybridSetter("pongAutoConsume", &HybridWebSocketSpec::setPongAutoConsume);
+      prototype.registerHybridGetter("pongConsumed", &HybridWebSocketSpec::getPongConsumed);
+      prototype.registerHybridGetter("readFrameFailReason", &HybridWebSocketSpec::getReadFrameFailReason);
+      prototype.registerHybridGetter("frameOpcodeInt", &HybridWebSocketSpec::getFrameOpcodeInt);
+      prototype.registerHybridGetter("uncommonOptions", &HybridWebSocketSpec::getUncommonOptions);
+      prototype.registerHybridGetter("heartbeatMs", &HybridWebSocketSpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridWebSocketSpec::setHeartbeatMs);
+      prototype.registerHybridGetter("onPercentDone", &HybridWebSocketSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridWebSocketSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridWebSocketSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridWebSocketSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("useConnection", &HybridWebSocketSpec::useConnection);
+      prototype.registerHybridMethod("addClientHeaders", &HybridWebSocketSpec::addClientHeaders);
+      prototype.registerHybridMethod("validateServerHandshake", &HybridWebSocketSpec::validateServerHandshake);
+      prototype.registerHybridMethod("sendFrame", &HybridWebSocketSpec::sendFrame);
+      prototype.registerHybridMethod("sendFrameAsync", &HybridWebSocketSpec::sendFrameAsync);
+      prototype.registerHybridMethod("readFrame", &HybridWebSocketSpec::readFrame);
+      prototype.registerHybridMethod("readFrameAsync", &HybridWebSocketSpec::readFrameAsync);
+      prototype.registerHybridMethod("getFrameData", &HybridWebSocketSpec::getFrameData);
+      prototype.registerHybridMethod("getFrameDataBd", &HybridWebSocketSpec::getFrameDataBd);
+      prototype.registerHybridMethod("getFrameDataSb", &HybridWebSocketSpec::getFrameDataSb);
+      prototype.registerHybridMethod("sendFrameSb", &HybridWebSocketSpec::sendFrameSb);
+      prototype.registerHybridMethod("sendFrameSbAsync", &HybridWebSocketSpec::sendFrameSbAsync);
+      prototype.registerHybridMethod("sendFrameBd", &HybridWebSocketSpec::sendFrameBd);
+      prototype.registerHybridMethod("sendFrameBdAsync", &HybridWebSocketSpec::sendFrameBdAsync);
+      prototype.registerHybridMethod("pollDataAvailable", &HybridWebSocketSpec::pollDataAvailable);
+      prototype.registerHybridMethod("sendPing", &HybridWebSocketSpec::sendPing);
+      prototype.registerHybridMethod("sendPingAsync", &HybridWebSocketSpec::sendPingAsync);
+      prototype.registerHybridMethod("sendPong", &HybridWebSocketSpec::sendPong);
+      prototype.registerHybridMethod("sendPongAsync", &HybridWebSocketSpec::sendPongAsync);
+      prototype.registerHybridMethod("sendClose", &HybridWebSocketSpec::sendClose);
+      prototype.registerHybridMethod("sendCloseAsync", &HybridWebSocketSpec::sendCloseAsync);
+      prototype.registerHybridMethod("closeConnection", &HybridWebSocketSpec::closeConnection);
+      prototype.registerHybridMethod("shareConnection", &HybridWebSocketSpec::shareConnection);
+      prototype.registerHybridMethod("abort", &HybridWebSocketSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,135 @@
+///
+/// HybridWebSocketSpec.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 `HybridRestSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridRestSpec; }
+// 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; }
+// Forward declaration of `HybridWebSocketSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridWebSocketSpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <memory>
+#include "HybridRestSpec.hpp"
+#include <NitroModules/Promise.hpp>
+#include "HybridBinDataSpec.hpp"
+#include "HybridStringBuilderSpec.hpp"
+#include "HybridWebSocketSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `WebSocket`
+   * Inherit this class to create instances of `HybridWebSocketSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridWebSocket: public HybridWebSocketSpec {
+   * public:
+   *   HybridWebSocket(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridWebSocketSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridWebSocketSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridWebSocketSpec() 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 getIdleTimeoutMs() = 0;
+      virtual void setIdleTimeoutMs(double idleTimeoutMs) = 0;
+      virtual std::string getFrameOpcode() = 0;
+      virtual double getFrameDataLen() = 0;
+      virtual bool getFinalFrame() = 0;
+      virtual bool getIsConnected() = 0;
+      virtual bool getCloseAutoRespond() = 0;
+      virtual void setCloseAutoRespond(bool closeAutoRespond) = 0;
+      virtual bool getPingAutoRespond() = 0;
+      virtual void setPingAutoRespond(bool pingAutoRespond) = 0;
+      virtual bool getNeedSendPong() = 0;
+      virtual bool getCloseReceived() = 0;
+      virtual double getCloseStatusCode() = 0;
+      virtual std::string getCloseReason() = 0;
+      virtual bool getPongAutoConsume() = 0;
+      virtual void setPongAutoConsume(bool pongAutoConsume) = 0;
+      virtual bool getPongConsumed() = 0;
+      virtual double getReadFrameFailReason() = 0;
+      virtual double getFrameOpcodeInt() = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual double getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 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 useConnection(const std::shared_ptr<HybridRestSpec>& connection) = 0;
+      virtual void addClientHeaders() = 0;
+      virtual void validateServerHandshake() = 0;
+      virtual void sendFrame(const std::string& stringToSend, bool finalFrame) = 0;
+      virtual std::shared_ptr<Promise<void>> sendFrameAsync(const std::string& stringToSend, bool finalFrame) = 0;
+      virtual void readFrame() = 0;
+      virtual std::shared_ptr<Promise<void>> readFrameAsync() = 0;
+      virtual std::string getFrameData() = 0;
+      virtual void getFrameDataBd(const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual void getFrameDataSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void sendFrameSb(const std::shared_ptr<HybridStringBuilderSpec>& sbToSend, bool finalFrame) = 0;
+      virtual std::shared_ptr<Promise<void>> sendFrameSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sbToSend, bool finalFrame) = 0;
+      virtual void sendFrameBd(const std::shared_ptr<HybridBinDataSpec>& bdToSend, bool finalFrame) = 0;
+      virtual std::shared_ptr<Promise<void>> sendFrameBdAsync(const std::shared_ptr<HybridBinDataSpec>& bdToSend, bool finalFrame) = 0;
+      virtual bool pollDataAvailable() = 0;
+      virtual void sendPing(const std::string& pingData) = 0;
+      virtual std::shared_ptr<Promise<void>> sendPingAsync(const std::string& pingData) = 0;
+      virtual void sendPong() = 0;
+      virtual std::shared_ptr<Promise<void>> sendPongAsync() = 0;
+      virtual void sendClose(bool includeStatus, double statusCode, const std::string& reason) = 0;
+      virtual std::shared_ptr<Promise<void>> sendCloseAsync(bool includeStatus, double statusCode, const std::string& reason) = 0;
+      virtual void closeConnection() = 0;
+      virtual void shareConnection(const std::shared_ptr<HybridWebSocketSpec>& ws) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "WebSocket";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,45 @@
+///
+/// HybridXmlCertVaultSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridXmlCertVaultSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridXmlCertVaultSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridXmlCertVaultSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridXmlCertVaultSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridXmlCertVaultSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridXmlCertVaultSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridXmlCertVaultSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridXmlCertVaultSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridXmlCertVaultSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridXmlCertVaultSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridXmlCertVaultSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridXmlCertVaultSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("masterPassword", &HybridXmlCertVaultSpec::getMasterPassword);
+      prototype.registerHybridSetter("masterPassword", &HybridXmlCertVaultSpec::setMasterPassword);
+      prototype.registerHybridMethod("addCert", &HybridXmlCertVaultSpec::addCert);
+      prototype.registerHybridMethod("addCertChain", &HybridXmlCertVaultSpec::addCertChain);
+      prototype.registerHybridMethod("addCertEncoded", &HybridXmlCertVaultSpec::addCertEncoded);
+      prototype.registerHybridMethod("addCertFile", &HybridXmlCertVaultSpec::addCertFile);
+      prototype.registerHybridMethod("addCertString", &HybridXmlCertVaultSpec::addCertString);
+      prototype.registerHybridMethod("addPemFile", &HybridXmlCertVaultSpec::addPemFile);
+      prototype.registerHybridMethod("addPfx", &HybridXmlCertVaultSpec::addPfx);
+      prototype.registerHybridMethod("addPfxEncoded", &HybridXmlCertVaultSpec::addPfxEncoded);
+      prototype.registerHybridMethod("addPfxFile", &HybridXmlCertVaultSpec::addPfxFile);
+      prototype.registerHybridMethod("getXml", &HybridXmlCertVaultSpec::getXml);
+      prototype.registerHybridMethod("loadXml", &HybridXmlCertVaultSpec::loadXml);
+      prototype.registerHybridMethod("loadXmlFile", &HybridXmlCertVaultSpec::loadXmlFile);
+      prototype.registerHybridMethod("saveXml", &HybridXmlCertVaultSpec::saveXml);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,94 @@
+///
+/// HybridXmlCertVaultSpec.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 `HybridCertChainSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridCertChainSpec; }
+// Forward declaration of `HybridPfxSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPfxSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridCertSpec.hpp"
+#include "HybridCertChainSpec.hpp"
+#include "HybridPfxSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `XmlCertVault`
+   * Inherit this class to create instances of `HybridXmlCertVaultSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridXmlCertVault: public HybridXmlCertVaultSpec {
+   * public:
+   *   HybridXmlCertVault(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridXmlCertVaultSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridXmlCertVaultSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridXmlCertVaultSpec() 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 getMasterPassword() = 0;
+      virtual void setMasterPassword(const std::string& masterPassword) = 0;
+
+    public:
+      // Methods
+      virtual void addCert(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void addCertChain(const std::shared_ptr<HybridCertChainSpec>& certChain) = 0;
+      virtual void addCertEncoded(const std::string& encodedBytes, const std::string& encoding) = 0;
+      virtual void addCertFile(const std::string& path) = 0;
+      virtual void addCertString(const std::string& certData) = 0;
+      virtual void addPemFile(const std::string& path, const std::string& password) = 0;
+      virtual void addPfx(const std::shared_ptr<HybridPfxSpec>& pfx) = 0;
+      virtual void addPfxEncoded(const std::string& encodedBytes, const std::string& encoding, const std::string& password) = 0;
+      virtual void addPfxFile(const std::string& path, const std::string& password) = 0;
+      virtual std::string getXml() = 0;
+      virtual void loadXml(const std::string& xml) = 0;
+      virtual void loadXmlFile(const std::string& path) = 0;
+      virtual void saveXml(const std::string& path) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "XmlCertVault";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,99 @@
+///
+/// HybridXmlDSigGenSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridXmlDSigGenSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridXmlDSigGenSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridXmlDSigGenSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridXmlDSigGenSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridXmlDSigGenSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridXmlDSigGenSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridXmlDSigGenSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridXmlDSigGenSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridXmlDSigGenSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridXmlDSigGenSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridXmlDSigGenSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridXmlDSigGenSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("sigLocation", &HybridXmlDSigGenSpec::getSigLocation);
+      prototype.registerHybridSetter("sigLocation", &HybridXmlDSigGenSpec::setSigLocation);
+      prototype.registerHybridGetter("sigNamespaceUri", &HybridXmlDSigGenSpec::getSigNamespaceUri);
+      prototype.registerHybridSetter("sigNamespaceUri", &HybridXmlDSigGenSpec::setSigNamespaceUri);
+      prototype.registerHybridGetter("sigNamespacePrefix", &HybridXmlDSigGenSpec::getSigNamespacePrefix);
+      prototype.registerHybridSetter("sigNamespacePrefix", &HybridXmlDSigGenSpec::setSigNamespacePrefix);
+      prototype.registerHybridGetter("signingAlg", &HybridXmlDSigGenSpec::getSigningAlg);
+      prototype.registerHybridSetter("signingAlg", &HybridXmlDSigGenSpec::setSigningAlg);
+      prototype.registerHybridGetter("signedInfoCanonAlg", &HybridXmlDSigGenSpec::getSignedInfoCanonAlg);
+      prototype.registerHybridSetter("signedInfoCanonAlg", &HybridXmlDSigGenSpec::setSignedInfoCanonAlg);
+      prototype.registerHybridGetter("signedInfoPrefixList", &HybridXmlDSigGenSpec::getSignedInfoPrefixList);
+      prototype.registerHybridSetter("signedInfoPrefixList", &HybridXmlDSigGenSpec::setSignedInfoPrefixList);
+      prototype.registerHybridGetter("signedInfoDigestMethod", &HybridXmlDSigGenSpec::getSignedInfoDigestMethod);
+      prototype.registerHybridSetter("signedInfoDigestMethod", &HybridXmlDSigGenSpec::setSignedInfoDigestMethod);
+      prototype.registerHybridGetter("keyInfoType", &HybridXmlDSigGenSpec::getKeyInfoType);
+      prototype.registerHybridSetter("keyInfoType", &HybridXmlDSigGenSpec::setKeyInfoType);
+      prototype.registerHybridGetter("x509Type", &HybridXmlDSigGenSpec::getX509Type);
+      prototype.registerHybridSetter("x509Type", &HybridXmlDSigGenSpec::setX509Type);
+      prototype.registerHybridGetter("customKeyInfoXml", &HybridXmlDSigGenSpec::getCustomKeyInfoXml);
+      prototype.registerHybridSetter("customKeyInfoXml", &HybridXmlDSigGenSpec::setCustomKeyInfoXml);
+      prototype.registerHybridGetter("sigId", &HybridXmlDSigGenSpec::getSigId);
+      prototype.registerHybridSetter("sigId", &HybridXmlDSigGenSpec::setSigId);
+      prototype.registerHybridGetter("keyInfoKeyName", &HybridXmlDSigGenSpec::getKeyInfoKeyName);
+      prototype.registerHybridSetter("keyInfoKeyName", &HybridXmlDSigGenSpec::setKeyInfoKeyName);
+      prototype.registerHybridGetter("incNamespacePrefix", &HybridXmlDSigGenSpec::getIncNamespacePrefix);
+      prototype.registerHybridSetter("incNamespacePrefix", &HybridXmlDSigGenSpec::setIncNamespacePrefix);
+      prototype.registerHybridGetter("incNamespaceUri", &HybridXmlDSigGenSpec::getIncNamespaceUri);
+      prototype.registerHybridSetter("incNamespaceUri", &HybridXmlDSigGenSpec::setIncNamespaceUri);
+      prototype.registerHybridGetter("behaviors", &HybridXmlDSigGenSpec::getBehaviors);
+      prototype.registerHybridSetter("behaviors", &HybridXmlDSigGenSpec::setBehaviors);
+      prototype.registerHybridGetter("keyInfoId", &HybridXmlDSigGenSpec::getKeyInfoId);
+      prototype.registerHybridSetter("keyInfoId", &HybridXmlDSigGenSpec::setKeyInfoId);
+      prototype.registerHybridGetter("signedInfoId", &HybridXmlDSigGenSpec::getSignedInfoId);
+      prototype.registerHybridSetter("signedInfoId", &HybridXmlDSigGenSpec::setSignedInfoId);
+      prototype.registerHybridGetter("sigValueId", &HybridXmlDSigGenSpec::getSigValueId);
+      prototype.registerHybridSetter("sigValueId", &HybridXmlDSigGenSpec::setSigValueId);
+      prototype.registerHybridGetter("sigLocationMod", &HybridXmlDSigGenSpec::getSigLocationMod);
+      prototype.registerHybridSetter("sigLocationMod", &HybridXmlDSigGenSpec::setSigLocationMod);
+      prototype.registerHybridGetter("uncommonOptions", &HybridXmlDSigGenSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridXmlDSigGenSpec::setUncommonOptions);
+      prototype.registerHybridGetter("sigLocationIdx", &HybridXmlDSigGenSpec::getSigLocationIdx);
+      prototype.registerHybridSetter("sigLocationIdx", &HybridXmlDSigGenSpec::setSigLocationIdx);
+      prototype.registerHybridGetter("onPercentDone", &HybridXmlDSigGenSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridXmlDSigGenSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridXmlDSigGenSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridXmlDSigGenSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("addEnvelopedRef", &HybridXmlDSigGenSpec::addEnvelopedRef);
+      prototype.registerHybridMethod("addSameDocRef", &HybridXmlDSigGenSpec::addSameDocRef);
+      prototype.registerHybridMethod("setPrivateKey", &HybridXmlDSigGenSpec::setPrivateKey);
+      prototype.registerHybridMethod("createXmlDSig", &HybridXmlDSigGenSpec::createXmlDSig);
+      prototype.registerHybridMethod("createXmlDSigAsync", &HybridXmlDSigGenSpec::createXmlDSigAsync);
+      prototype.registerHybridMethod("setX509Cert", &HybridXmlDSigGenSpec::setX509Cert);
+      prototype.registerHybridMethod("setHmacKey", &HybridXmlDSigGenSpec::setHmacKey);
+      prototype.registerHybridMethod("addExternalFileRef", &HybridXmlDSigGenSpec::addExternalFileRef);
+      prototype.registerHybridMethod("addExternalBinaryRef", &HybridXmlDSigGenSpec::addExternalBinaryRef);
+      prototype.registerHybridMethod("addExternalTextRef", &HybridXmlDSigGenSpec::addExternalTextRef);
+      prototype.registerHybridMethod("addExternalXmlRef", &HybridXmlDSigGenSpec::addExternalXmlRef);
+      prototype.registerHybridMethod("createXmlDSigSb", &HybridXmlDSigGenSpec::createXmlDSigSb);
+      prototype.registerHybridMethod("createXmlDSigSbAsync", &HybridXmlDSigGenSpec::createXmlDSigSbAsync);
+      prototype.registerHybridMethod("constructSignedInfo", &HybridXmlDSigGenSpec::constructSignedInfo);
+      prototype.registerHybridMethod("setRefIdAttr", &HybridXmlDSigGenSpec::setRefIdAttr);
+      prototype.registerHybridMethod("addObject", &HybridXmlDSigGenSpec::addObject);
+      prototype.registerHybridMethod("addObjectRef", &HybridXmlDSigGenSpec::addObjectRef);
+      prototype.registerHybridMethod("addSignatureNamespace", &HybridXmlDSigGenSpec::addSignatureNamespace);
+      prototype.registerHybridMethod("setHttpObj", &HybridXmlDSigGenSpec::setHttpObj);
+      prototype.registerHybridMethod("addSameDocRef2", &HybridXmlDSigGenSpec::addSameDocRef2);
+      prototype.registerHybridMethod("addObjectRef2", &HybridXmlDSigGenSpec::addObjectRef2);
+      prototype.registerHybridMethod("setTsa", &HybridXmlDSigGenSpec::setTsa);
+      prototype.registerHybridMethod("abort", &HybridXmlDSigGenSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,163 @@
+///
+/// HybridXmlDSigGenSpec.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 `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+// Forward declaration of `HybridPrivateKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPrivateKeySpec; }
+// Forward declaration of `HybridCertSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridCertSpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridHttpSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridHttpSpec; }
+// Forward declaration of `HybridXmlSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridXmlSpec; }
+// Forward declaration of `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <memory>
+#include "HybridStringBuilderSpec.hpp"
+#include "HybridPrivateKeySpec.hpp"
+#include <NitroModules/Promise.hpp>
+#include "HybridCertSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+#include "HybridHttpSpec.hpp"
+#include "HybridXmlSpec.hpp"
+#include "HybridJsonObjectSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `XmlDSigGen`
+   * Inherit this class to create instances of `HybridXmlDSigGenSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridXmlDSigGen: public HybridXmlDSigGenSpec {
+   * public:
+   *   HybridXmlDSigGen(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridXmlDSigGenSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridXmlDSigGenSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridXmlDSigGenSpec() 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 getSigLocation() = 0;
+      virtual void setSigLocation(const std::string& sigLocation) = 0;
+      virtual std::string getSigNamespaceUri() = 0;
+      virtual void setSigNamespaceUri(const std::string& sigNamespaceUri) = 0;
+      virtual std::string getSigNamespacePrefix() = 0;
+      virtual void setSigNamespacePrefix(const std::string& sigNamespacePrefix) = 0;
+      virtual std::string getSigningAlg() = 0;
+      virtual void setSigningAlg(const std::string& signingAlg) = 0;
+      virtual std::string getSignedInfoCanonAlg() = 0;
+      virtual void setSignedInfoCanonAlg(const std::string& signedInfoCanonAlg) = 0;
+      virtual std::string getSignedInfoPrefixList() = 0;
+      virtual void setSignedInfoPrefixList(const std::string& signedInfoPrefixList) = 0;
+      virtual std::string getSignedInfoDigestMethod() = 0;
+      virtual void setSignedInfoDigestMethod(const std::string& signedInfoDigestMethod) = 0;
+      virtual std::string getKeyInfoType() = 0;
+      virtual void setKeyInfoType(const std::string& keyInfoType) = 0;
+      virtual std::string getX509Type() = 0;
+      virtual void setX509Type(const std::string& x509Type) = 0;
+      virtual std::string getCustomKeyInfoXml() = 0;
+      virtual void setCustomKeyInfoXml(const std::string& customKeyInfoXml) = 0;
+      virtual std::string getSigId() = 0;
+      virtual void setSigId(const std::string& sigId) = 0;
+      virtual std::string getKeyInfoKeyName() = 0;
+      virtual void setKeyInfoKeyName(const std::string& keyInfoKeyName) = 0;
+      virtual std::string getIncNamespacePrefix() = 0;
+      virtual void setIncNamespacePrefix(const std::string& incNamespacePrefix) = 0;
+      virtual std::string getIncNamespaceUri() = 0;
+      virtual void setIncNamespaceUri(const std::string& incNamespaceUri) = 0;
+      virtual std::string getBehaviors() = 0;
+      virtual void setBehaviors(const std::string& behaviors) = 0;
+      virtual std::string getKeyInfoId() = 0;
+      virtual void setKeyInfoId(const std::string& keyInfoId) = 0;
+      virtual std::string getSignedInfoId() = 0;
+      virtual void setSignedInfoId(const std::string& signedInfoId) = 0;
+      virtual std::string getSigValueId() = 0;
+      virtual void setSigValueId(const std::string& sigValueId) = 0;
+      virtual double getSigLocationMod() = 0;
+      virtual void setSigLocationMod(double sigLocationMod) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+      virtual double getSigLocationIdx() = 0;
+      virtual void setSigLocationIdx(double sigLocationIdx) = 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 addEnvelopedRef(const std::string& id, const std::shared_ptr<HybridStringBuilderSpec>& content, const std::string& digestMethod, const std::string& canonMethod, const std::string& refType) = 0;
+      virtual void addSameDocRef(const std::string& id, const std::string& digestMethod, const std::string& canonMethod, const std::string& prefixList, const std::string& refType) = 0;
+      virtual void setPrivateKey(const std::shared_ptr<HybridPrivateKeySpec>& privKey) = 0;
+      virtual std::string createXmlDSig(const std::string& inXml) = 0;
+      virtual std::shared_ptr<Promise<std::string>> createXmlDSigAsync(const std::string& inXml) = 0;
+      virtual void setX509Cert(const std::shared_ptr<HybridCertSpec>& cert, bool usePrivateKey) = 0;
+      virtual void setHmacKey(const std::string& key, const std::string& encoding) = 0;
+      virtual void addExternalFileRef(const std::string& uri, const std::string& localFilePath, const std::string& digestMethod, const std::string& refType) = 0;
+      virtual void addExternalBinaryRef(const std::string& uri, const std::shared_ptr<HybridBinDataSpec>& content, const std::string& digestMethod, const std::string& refType) = 0;
+      virtual void addExternalTextRef(const std::string& uri, const std::shared_ptr<HybridStringBuilderSpec>& content, const std::string& charset, bool includeBom, const std::string& digestMethod, const std::string& refType) = 0;
+      virtual void addExternalXmlRef(const std::string& uri, const std::shared_ptr<HybridStringBuilderSpec>& content, const std::string& digestMethod, const std::string& canonMethod, const std::string& refType) = 0;
+      virtual void createXmlDSigSb(const std::shared_ptr<HybridStringBuilderSpec>& sbXml) = 0;
+      virtual std::shared_ptr<Promise<void>> createXmlDSigSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sbXml) = 0;
+      virtual std::string constructSignedInfo(const std::shared_ptr<HybridStringBuilderSpec>& sbXml) = 0;
+      virtual void setRefIdAttr(const std::string& uriOrId, const std::string& value) = 0;
+      virtual void addObject(const std::string& id, const std::string& content, const std::string& mimeType, const std::string& encoding) = 0;
+      virtual void addObjectRef(const std::string& id, const std::string& digestMethod, const std::string& canonMethod, const std::string& prefixList, const std::string& refType) = 0;
+      virtual void addSignatureNamespace(const std::string& nsPrefix, const std::string& nsUri) = 0;
+      virtual void setHttpObj(const std::shared_ptr<HybridHttpSpec>& http) = 0;
+      virtual void addSameDocRef2(const std::string& id, const std::string& digestMethod, const std::shared_ptr<HybridXmlSpec>& transforms, const std::string& refType) = 0;
+      virtual void addObjectRef2(const std::string& id, const std::string& digestMethod, const std::shared_ptr<HybridXmlSpec>& transforms, const std::string& refType) = 0;
+      virtual void setTsa(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "XmlDSigGen";
+  };
+
+} // namespace margelo::nitro::chilkat