@chilkat/react-native 11.6.1

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

@@ -0,0 +1,229 @@
+///
+/// HybridRestSpec.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 `HybridStreamSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStreamSpec; }
+// Forward declaration of `HybridAuthAwsSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridAuthAwsSpec; }
+// Forward declaration of `HybridAuthAzureStorageSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridAuthAzureStorageSpec; }
+// Forward declaration of `HybridAuthGoogleSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridAuthGoogleSpec; }
+// Forward declaration of `HybridOAuth1Spec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridOAuth1Spec; }
+// Forward declaration of `HybridOAuth2Spec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridOAuth2Spec; }
+// Forward declaration of `HybridSocketSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridSocketSpec; }
+// Forward declaration of `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridAuthAzureSASSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridAuthAzureSASSpec; }
+// Forward declaration of `HybridSecureStringSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridSecureStringSpec; }
+// Forward declaration of `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include "HybridStreamSpec.hpp"
+#include "HybridAuthAwsSpec.hpp"
+#include "HybridAuthAzureStorageSpec.hpp"
+#include "HybridAuthGoogleSpec.hpp"
+#include "HybridOAuth1Spec.hpp"
+#include "HybridOAuth2Spec.hpp"
+#include "HybridSocketSpec.hpp"
+#include "HybridStringBuilderSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+#include "HybridAuthAzureSASSpec.hpp"
+#include "HybridSecureStringSpec.hpp"
+#include "HybridJsonObjectSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Rest`
+   * Inherit this class to create instances of `HybridRestSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridRest: public HybridRestSpec {
+   * public:
+   *   HybridRest(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridRestSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridRestSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridRestSpec() 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 getAuthorization() = 0;
+      virtual void setAuthorization(const std::string& authorization) = 0;
+      virtual double getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 0;
+      virtual std::string getHost() = 0;
+      virtual void setHost(const std::string& host) = 0;
+      virtual double getIdleTimeoutMs() = 0;
+      virtual void setIdleTimeoutMs(double idleTimeoutMs) = 0;
+      virtual std::string getLastRequestHeader() = 0;
+      virtual std::string getLastRequestStartLine() = 0;
+      virtual double getNumResponseHeaders() = 0;
+      virtual std::string getPartSelector() = 0;
+      virtual void setPartSelector(const std::string& partSelector) = 0;
+      virtual std::string getResponseHeader() = 0;
+      virtual double getResponseStatusCode() = 0;
+      virtual std::string getResponseStatusText() = 0;
+      virtual bool getStreamNonChunked() = 0;
+      virtual void setStreamNonChunked(bool streamNonChunked) = 0;
+      virtual double getConnectFailReason() = 0;
+      virtual bool getPercentDoneOnSend() = 0;
+      virtual void setPercentDoneOnSend(bool percentDoneOnSend) = 0;
+      virtual bool getAllowHeaderQB() = 0;
+      virtual void setAllowHeaderQB(bool allowHeaderQB) = 0;
+      virtual bool getAllowHeaderFolding() = 0;
+      virtual void setAllowHeaderFolding(bool allowHeaderFolding) = 0;
+      virtual double getConnectTimeoutMs() = 0;
+      virtual void setConnectTimeoutMs(double connectTimeoutMs) = 0;
+      virtual bool getDebugMode() = 0;
+      virtual void setDebugMode(bool debugMode) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+      virtual std::string getLastRedirectUrl() = 0;
+      virtual bool getEnableSecrets() = 0;
+      virtual void setEnableSecrets(bool enableSecrets) = 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 addHeader(const std::string& name, const std::string& value) = 0;
+      virtual void addQueryParam(const std::string& name, const std::string& value) = 0;
+      virtual void addQueryParams(const std::string& queryString) = 0;
+      virtual void clearAllHeaders() = 0;
+      virtual void clearAllQueryParams() = 0;
+      virtual void clearResponseBodyStream() = 0;
+      virtual void connect(const std::string& hostname, double port, bool tls, bool autoReconnect) = 0;
+      virtual std::shared_ptr<Promise<void>> connectAsync(const std::string& hostname, double port, bool tls, bool autoReconnect) = 0;
+      virtual void disconnect(double maxWaitMs) = 0;
+      virtual std::shared_ptr<Promise<void>> disconnectAsync(double maxWaitMs) = 0;
+      virtual std::string fullRequestFormUrlEncoded(const std::string& httpVerb, const std::string& uriPath) = 0;
+      virtual std::shared_ptr<Promise<std::string>> fullRequestFormUrlEncodedAsync(const std::string& httpVerb, const std::string& uriPath) = 0;
+      virtual std::string fullRequestMultipart(const std::string& httpVerb, const std::string& uriPath) = 0;
+      virtual std::shared_ptr<Promise<std::string>> fullRequestMultipartAsync(const std::string& httpVerb, const std::string& uriPath) = 0;
+      virtual std::string fullRequestNoBody(const std::string& httpVerb, const std::string& uriPath) = 0;
+      virtual std::shared_ptr<Promise<std::string>> fullRequestNoBodyAsync(const std::string& httpVerb, const std::string& uriPath) = 0;
+      virtual std::string fullRequestStream(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStreamSpec>& stream) = 0;
+      virtual std::shared_ptr<Promise<std::string>> fullRequestStreamAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStreamSpec>& stream) = 0;
+      virtual std::string fullRequestString(const std::string& httpVerb, const std::string& uriPath, const std::string& bodyText) = 0;
+      virtual std::shared_ptr<Promise<std::string>> fullRequestStringAsync(const std::string& httpVerb, const std::string& uriPath, const std::string& bodyText) = 0;
+      virtual void readRespBodyStream(const std::shared_ptr<HybridStreamSpec>& stream, bool autoSetStreamCharset) = 0;
+      virtual std::shared_ptr<Promise<void>> readRespBodyStreamAsync(const std::shared_ptr<HybridStreamSpec>& stream, bool autoSetStreamCharset) = 0;
+      virtual std::string readRespBodyString() = 0;
+      virtual std::shared_ptr<Promise<std::string>> readRespBodyStringAsync() = 0;
+      virtual double readResponseHeader() = 0;
+      virtual std::shared_ptr<Promise<double>> readResponseHeaderAsync() = 0;
+      virtual void removeHeader(const std::string& name) = 0;
+      virtual void removeQueryParam(const std::string& name) = 0;
+      virtual std::string responseHdrByName(const std::string& name) = 0;
+      virtual std::string responseHdrName(double index) = 0;
+      virtual std::string responseHdrValue(double index) = 0;
+      virtual void sendReqFormUrlEncoded(const std::string& httpVerb, const std::string& uriPath) = 0;
+      virtual std::shared_ptr<Promise<void>> sendReqFormUrlEncodedAsync(const std::string& httpVerb, const std::string& uriPath) = 0;
+      virtual void sendReqMultipart(const std::string& httpVerb, const std::string& uriPath) = 0;
+      virtual std::shared_ptr<Promise<void>> sendReqMultipartAsync(const std::string& httpVerb, const std::string& uriPath) = 0;
+      virtual void sendReqNoBody(const std::string& httpVerb, const std::string& uriPath) = 0;
+      virtual std::shared_ptr<Promise<void>> sendReqNoBodyAsync(const std::string& httpVerb, const std::string& uriPath) = 0;
+      virtual void sendReqStreamBody(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStreamSpec>& stream) = 0;
+      virtual std::shared_ptr<Promise<void>> sendReqStreamBodyAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStreamSpec>& stream) = 0;
+      virtual void sendReqStringBody(const std::string& httpVerb, const std::string& uriPath, const std::string& bodyText) = 0;
+      virtual std::shared_ptr<Promise<void>> sendReqStringBodyAsync(const std::string& httpVerb, const std::string& uriPath, const std::string& bodyText) = 0;
+      virtual void setAuthAws(const std::shared_ptr<HybridAuthAwsSpec>& authProvider) = 0;
+      virtual void setAuthAzureStorage(const std::shared_ptr<HybridAuthAzureStorageSpec>& authProvider) = 0;
+      virtual void setAuthBasic(const std::string& username, const std::string& password) = 0;
+      virtual void setAuthGoogle(const std::shared_ptr<HybridAuthGoogleSpec>& authProvider) = 0;
+      virtual void setAuthOAuth1(const std::shared_ptr<HybridOAuth1Spec>& authProvider, bool useQueryParams) = 0;
+      virtual void setAuthOAuth2(const std::shared_ptr<HybridOAuth2Spec>& authProvider) = 0;
+      virtual void setMultipartBodyStream(const std::shared_ptr<HybridStreamSpec>& stream) = 0;
+      virtual void setMultipartBodyString(const std::string& bodyText) = 0;
+      virtual void setResponseBodyStream(double expectedStatus, bool autoSetStreamCharset, const std::shared_ptr<HybridStreamSpec>& responseStream) = 0;
+      virtual void useConnection(const std::shared_ptr<HybridSocketSpec>& connection, bool autoReconnect) = 0;
+      virtual void fullRequestSb(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& requestBody, const std::shared_ptr<HybridStringBuilderSpec>& responseBody) = 0;
+      virtual std::shared_ptr<Promise<void>> fullRequestSbAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& requestBody, const std::shared_ptr<HybridStringBuilderSpec>& responseBody) = 0;
+      virtual void addQueryParamSb(const std::string& name, const std::shared_ptr<HybridStringBuilderSpec>& value) = 0;
+      virtual void setMultipartBodySb(const std::shared_ptr<HybridStringBuilderSpec>& bodySb) = 0;
+      virtual void setMultipartBodyBd(const std::shared_ptr<HybridBinDataSpec>& bodyData) = 0;
+      virtual void sendReqSb(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& bodySb) = 0;
+      virtual std::shared_ptr<Promise<void>> sendReqSbAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& bodySb) = 0;
+      virtual void sendReqBd(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& body) = 0;
+      virtual std::shared_ptr<Promise<void>> sendReqBdAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& body) = 0;
+      virtual void readRespSb(const std::shared_ptr<HybridStringBuilderSpec>& responseBody) = 0;
+      virtual std::shared_ptr<Promise<void>> readRespSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& responseBody) = 0;
+      virtual void readRespBd(const std::shared_ptr<HybridBinDataSpec>& responseBody) = 0;
+      virtual std::shared_ptr<Promise<void>> readRespBdAsync(const std::shared_ptr<HybridBinDataSpec>& responseBody) = 0;
+      virtual void clearAllParts() = 0;
+      virtual void fullRequestNoBodySb(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual std::shared_ptr<Promise<void>> fullRequestNoBodySbAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void fullRequestBd(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& binData, const std::shared_ptr<HybridStringBuilderSpec>& responseBody) = 0;
+      virtual std::shared_ptr<Promise<void>> fullRequestBdAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& binData, const std::shared_ptr<HybridStringBuilderSpec>& responseBody) = 0;
+      virtual void fullRequestNoBodyBd(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual std::shared_ptr<Promise<void>> fullRequestNoBodyBdAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual void setAuthAzureSas(const std::shared_ptr<HybridAuthAzureSASSpec>& authProvider) = 0;
+      virtual void addMwsSignature(const std::string& httpVerb, const std::string& uriPath, const std::string& domain, const std::string& mwsSecretKey) = 0;
+      virtual void clearAuth() = 0;
+      virtual void addPathParam(const std::string& name, const std::string& value) = 0;
+      virtual void clearAllPathParams() = 0;
+      virtual void setAuthBasicSecure(const std::shared_ptr<HybridSecureStringSpec>& username, const std::shared_ptr<HybridSecureStringSpec>& password) = 0;
+      virtual void getLastDebugRequest(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual double readRespChunkBd(double minSize, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual std::shared_ptr<Promise<double>> readRespChunkBdAsync(double minSize, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void getLastJsonData(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 = "Rest";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,68 @@
+///
+/// HybridRsaSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridRsaSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridRsaSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridRsaSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridRsaSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridRsaSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridRsaSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridRsaSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridRsaSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridRsaSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridRsaSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridRsaSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridRsaSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("charset", &HybridRsaSpec::getCharset);
+      prototype.registerHybridSetter("charset", &HybridRsaSpec::setCharset);
+      prototype.registerHybridGetter("encodingMode", &HybridRsaSpec::getEncodingMode);
+      prototype.registerHybridSetter("encodingMode", &HybridRsaSpec::setEncodingMode);
+      prototype.registerHybridGetter("littleEndian", &HybridRsaSpec::getLittleEndian);
+      prototype.registerHybridSetter("littleEndian", &HybridRsaSpec::setLittleEndian);
+      prototype.registerHybridGetter("noUnpad", &HybridRsaSpec::getNoUnpad);
+      prototype.registerHybridSetter("noUnpad", &HybridRsaSpec::setNoUnpad);
+      prototype.registerHybridGetter("numBits", &HybridRsaSpec::getNumBits);
+      prototype.registerHybridGetter("oaepHash", &HybridRsaSpec::getOaepHash);
+      prototype.registerHybridSetter("oaepHash", &HybridRsaSpec::setOaepHash);
+      prototype.registerHybridGetter("oaepMgfHash", &HybridRsaSpec::getOaepMgfHash);
+      prototype.registerHybridSetter("oaepMgfHash", &HybridRsaSpec::setOaepMgfHash);
+      prototype.registerHybridGetter("pssSaltLen", &HybridRsaSpec::getPssSaltLen);
+      prototype.registerHybridSetter("pssSaltLen", &HybridRsaSpec::setPssSaltLen);
+      prototype.registerHybridGetter("oaepLabel", &HybridRsaSpec::getOaepLabel);
+      prototype.registerHybridSetter("oaepLabel", &HybridRsaSpec::setOaepLabel);
+      prototype.registerHybridGetter("uncommonOptions", &HybridRsaSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridRsaSpec::setUncommonOptions);
+      prototype.registerHybridGetter("pkcsPadding", &HybridRsaSpec::getPkcsPadding);
+      prototype.registerHybridSetter("pkcsPadding", &HybridRsaSpec::setPkcsPadding);
+      prototype.registerHybridMethod("decryptStringENC", &HybridRsaSpec::decryptStringENC);
+      prototype.registerHybridMethod("encryptStringENC", &HybridRsaSpec::encryptStringENC);
+      prototype.registerHybridMethod("signHashENC", &HybridRsaSpec::signHashENC);
+      prototype.registerHybridMethod("signStringENC", &HybridRsaSpec::signStringENC);
+      prototype.registerHybridMethod("snkToXml", &HybridRsaSpec::snkToXml);
+      prototype.registerHybridMethod("verifyHashENC", &HybridRsaSpec::verifyHashENC);
+      prototype.registerHybridMethod("verifyStringENC", &HybridRsaSpec::verifyStringENC);
+      prototype.registerHybridMethod("setX509Cert", &HybridRsaSpec::setX509Cert);
+      prototype.registerHybridMethod("decryptBd", &HybridRsaSpec::decryptBd);
+      prototype.registerHybridMethod("encryptBd", &HybridRsaSpec::encryptBd);
+      prototype.registerHybridMethod("signBd", &HybridRsaSpec::signBd);
+      prototype.registerHybridMethod("verifyBd", &HybridRsaSpec::verifyBd);
+      prototype.registerHybridMethod("genKey", &HybridRsaSpec::genKey);
+      prototype.registerHybridMethod("usePrivateKey", &HybridRsaSpec::usePrivateKey);
+      prototype.registerHybridMethod("usePublicKey", &HybridRsaSpec::usePublicKey);
+      prototype.registerHybridMethod("signRawBd", &HybridRsaSpec::signRawBd);
+      prototype.registerHybridMethod("verifyRawBd", &HybridRsaSpec::verifyRawBd);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,120 @@
+///
+/// HybridRsaSpec.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 `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridPrivateKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPrivateKeySpec; }
+// Forward declaration of `HybridPublicKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPublicKeySpec; }
+
+#include <string>
+#include <memory>
+#include "HybridCertSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+#include "HybridPrivateKeySpec.hpp"
+#include "HybridPublicKeySpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Rsa`
+   * Inherit this class to create instances of `HybridRsaSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridRsa: public HybridRsaSpec {
+   * public:
+   *   HybridRsa(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridRsaSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridRsaSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridRsaSpec() 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 getCharset() = 0;
+      virtual void setCharset(const std::string& charset) = 0;
+      virtual std::string getEncodingMode() = 0;
+      virtual void setEncodingMode(const std::string& encodingMode) = 0;
+      virtual bool getLittleEndian() = 0;
+      virtual void setLittleEndian(bool littleEndian) = 0;
+      virtual bool getNoUnpad() = 0;
+      virtual void setNoUnpad(bool noUnpad) = 0;
+      virtual double getNumBits() = 0;
+      virtual std::string getOaepHash() = 0;
+      virtual void setOaepHash(const std::string& oaepHash) = 0;
+      virtual std::string getOaepMgfHash() = 0;
+      virtual void setOaepMgfHash(const std::string& oaepMgfHash) = 0;
+      virtual double getPssSaltLen() = 0;
+      virtual void setPssSaltLen(double pssSaltLen) = 0;
+      virtual std::string getOaepLabel() = 0;
+      virtual void setOaepLabel(const std::string& oaepLabel) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+      virtual bool getPkcsPadding() = 0;
+      virtual void setPkcsPadding(bool pkcsPadding) = 0;
+
+    public:
+      // Methods
+      virtual std::string decryptStringENC(const std::string& str, bool usePrivateKey) = 0;
+      virtual std::string encryptStringENC(const std::string& str, bool bUsePrivateKey) = 0;
+      virtual std::string signHashENC(const std::string& encodedHash, const std::string& hashAlg) = 0;
+      virtual std::string signStringENC(const std::string& strToBeHashed, const std::string& hashAlgorithm) = 0;
+      virtual std::string snkToXml(const std::string& filename) = 0;
+      virtual void verifyHashENC(const std::string& encodedHash, const std::string& hashAlg, const std::string& encodedSig) = 0;
+      virtual void verifyStringENC(const std::string& originalString, const std::string& hashAlgorithm, const std::string& encodedSig) = 0;
+      virtual void setX509Cert(const std::shared_ptr<HybridCertSpec>& cert, bool usePrivateKey) = 0;
+      virtual void decryptBd(const std::shared_ptr<HybridBinDataSpec>& bd, bool usePrivateKey) = 0;
+      virtual void encryptBd(const std::shared_ptr<HybridBinDataSpec>& bd, bool usePrivateKey) = 0;
+      virtual void signBd(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlgorithm, const std::shared_ptr<HybridBinDataSpec>& bdSig) = 0;
+      virtual void verifyBd(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlgorithm, const std::shared_ptr<HybridBinDataSpec>& bdSig) = 0;
+      virtual void genKey(double numBits, const std::shared_ptr<HybridPrivateKeySpec>& privKey) = 0;
+      virtual void usePrivateKey(const std::shared_ptr<HybridPrivateKeySpec>& privKey) = 0;
+      virtual void usePublicKey(const std::shared_ptr<HybridPublicKeySpec>& pubKey) = 0;
+      virtual void signRawBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void verifyRawBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Rsa";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,64 @@
+///
+/// HybridSCardSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridSCardSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridSCardSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridSCardSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridSCardSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridSCardSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridSCardSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridSCardSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridSCardSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridSCardSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridSCardSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridSCardSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridSCardSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("context", &HybridSCardSpec::getContext);
+      prototype.registerHybridGetter("connectedReader", &HybridSCardSpec::getConnectedReader);
+      prototype.registerHybridGetter("activeProtocol", &HybridSCardSpec::getActiveProtocol);
+      prototype.registerHybridGetter("readerStatus", &HybridSCardSpec::getReaderStatus);
+      prototype.registerHybridGetter("cardAtr", &HybridSCardSpec::getCardAtr);
+      prototype.registerHybridGetter("scardError", &HybridSCardSpec::getScardError);
+      prototype.registerHybridGetter("pcscLibPath", &HybridSCardSpec::getPcscLibPath);
+      prototype.registerHybridSetter("pcscLibPath", &HybridSCardSpec::setPcscLibPath);
+      prototype.registerHybridGetter("onPercentDone", &HybridSCardSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridSCardSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridSCardSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridSCardSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("establishContext", &HybridSCardSpec::establishContext);
+      prototype.registerHybridMethod("releaseContext", &HybridSCardSpec::releaseContext);
+      prototype.registerHybridMethod("listReaders", &HybridSCardSpec::listReaders);
+      prototype.registerHybridMethod("connect", &HybridSCardSpec::connect);
+      prototype.registerHybridMethod("disconnect", &HybridSCardSpec::disconnect);
+      prototype.registerHybridMethod("checkStatus", &HybridSCardSpec::checkStatus);
+      prototype.registerHybridMethod("reconnect", &HybridSCardSpec::reconnect);
+      prototype.registerHybridMethod("getStatusChange", &HybridSCardSpec::getStatusChange);
+      prototype.registerHybridMethod("getStatusChangeAsync", &HybridSCardSpec::getStatusChangeAsync);
+      prototype.registerHybridMethod("getStatusChangeCancel", &HybridSCardSpec::getStatusChangeCancel);
+      prototype.registerHybridMethod("transmit", &HybridSCardSpec::transmit);
+      prototype.registerHybridMethod("beginTransaction", &HybridSCardSpec::beginTransaction);
+      prototype.registerHybridMethod("endTransaction", &HybridSCardSpec::endTransaction);
+      prototype.registerHybridMethod("transmitHex", &HybridSCardSpec::transmitHex);
+      prototype.registerHybridMethod("sendControl", &HybridSCardSpec::sendControl);
+      prototype.registerHybridMethod("sendControlHex", &HybridSCardSpec::sendControlHex);
+      prototype.registerHybridMethod("getAttrib", &HybridSCardSpec::getAttrib);
+      prototype.registerHybridMethod("getAttribStr", &HybridSCardSpec::getAttribStr);
+      prototype.registerHybridMethod("getAttribUint", &HybridSCardSpec::getAttribUint);
+      prototype.registerHybridMethod("listReaderGroups", &HybridSCardSpec::listReaderGroups);
+      prototype.registerHybridMethod("findSmartcards", &HybridSCardSpec::findSmartcards);
+      prototype.registerHybridMethod("abort", &HybridSCardSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,116 @@
+///
+/// HybridSCardSpec.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 `HybridStringTableSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringTableSpec; }
+// Forward declaration of `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <memory>
+#include "HybridStringTableSpec.hpp"
+#include "HybridJsonObjectSpec.hpp"
+#include <NitroModules/Promise.hpp>
+#include "HybridBinDataSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `SCard`
+   * Inherit this class to create instances of `HybridSCardSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridSCard: public HybridSCardSpec {
+   * public:
+   *   HybridSCard(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridSCardSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridSCardSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridSCardSpec() 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 getContext() = 0;
+      virtual std::string getConnectedReader() = 0;
+      virtual std::string getActiveProtocol() = 0;
+      virtual std::string getReaderStatus() = 0;
+      virtual std::string getCardAtr() = 0;
+      virtual std::string getScardError() = 0;
+      virtual std::string getPcscLibPath() = 0;
+      virtual void setPcscLibPath(const std::string& pcscLibPath) = 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 establishContext(const std::string& scope) = 0;
+      virtual void releaseContext() = 0;
+      virtual void listReaders(const std::shared_ptr<HybridStringTableSpec>& st) = 0;
+      virtual bool connect(const std::string& reader, const std::string& shareMode, const std::string& preferredProtocol) = 0;
+      virtual void disconnect(const std::string& disposition) = 0;
+      virtual bool checkStatus() = 0;
+      virtual void reconnect(const std::string& shareMode, const std::string& preferredProtocol, const std::string& action) = 0;
+      virtual void getStatusChange(double maxWaitMs, const std::shared_ptr<HybridStringTableSpec>& stReaderNames, const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual std::shared_ptr<Promise<void>> getStatusChangeAsync(double maxWaitMs, const std::shared_ptr<HybridStringTableSpec>& stReaderNames, const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void getStatusChangeCancel() = 0;
+      virtual void transmit(const std::string& protocolName, const std::shared_ptr<HybridBinDataSpec>& bdSend, const std::shared_ptr<HybridBinDataSpec>& bdRecv, double maxRecvLen) = 0;
+      virtual void beginTransaction() = 0;
+      virtual void endTransaction(const std::string& disposition) = 0;
+      virtual void transmitHex(const std::string& protocolName, const std::string& apduHex, const std::shared_ptr<HybridBinDataSpec>& bdRecv, double maxRecvLen) = 0;
+      virtual void sendControl(double controlCode, const std::shared_ptr<HybridBinDataSpec>& bdSend, const std::shared_ptr<HybridBinDataSpec>& bdRecv) = 0;
+      virtual void sendControlHex(double controlCode, const std::string& sendData, const std::shared_ptr<HybridBinDataSpec>& bdRecv) = 0;
+      virtual void getAttrib(const std::string& attr, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual std::string getAttribStr(const std::string& attr) = 0;
+      virtual double getAttribUint(const std::string& attr) = 0;
+      virtual void listReaderGroups(const std::shared_ptr<HybridStringTableSpec>& readerGroups) = 0;
+      virtual void findSmartcards(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 = "SCard";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,35 @@
+///
+/// HybridSFtpDirSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridSFtpDirSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridSFtpDirSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridSFtpDirSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridSFtpDirSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridSFtpDirSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridSFtpDirSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridSFtpDirSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridSFtpDirSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridSFtpDirSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridSFtpDirSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridSFtpDirSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridSFtpDirSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("numFilesAndDirs", &HybridSFtpDirSpec::getNumFilesAndDirs);
+      prototype.registerHybridGetter("originalPath", &HybridSFtpDirSpec::getOriginalPath);
+      prototype.registerHybridMethod("getFilename", &HybridSFtpDirSpec::getFilename);
+      prototype.registerHybridMethod("sort", &HybridSFtpDirSpec::sort);
+      prototype.registerHybridMethod("fileAt", &HybridSFtpDirSpec::fileAt);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat