@chilkat/react-native 11.6.1

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

@@ -0,0 +1,110 @@
+///
+/// HybridOAuth1Spec.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 `HybridPrivateKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPrivateKeySpec; }
+
+#include <string>
+#include <memory>
+#include "HybridPrivateKeySpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `OAuth1`
+   * Inherit this class to create instances of `HybridOAuth1Spec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridOAuth1: public HybridOAuth1Spec {
+   * public:
+   *   HybridOAuth1(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridOAuth1Spec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridOAuth1Spec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridOAuth1Spec() 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 getAuthorizationHeader() = 0;
+      virtual std::string getBaseString() = 0;
+      virtual std::string getConsumerKey() = 0;
+      virtual void setConsumerKey(const std::string& consumerKey) = 0;
+      virtual std::string getConsumerSecret() = 0;
+      virtual void setConsumerSecret(const std::string& consumerSecret) = 0;
+      virtual std::string getEncodedSignature() = 0;
+      virtual std::string getGeneratedUrl() = 0;
+      virtual std::string getHmacKey() = 0;
+      virtual std::string getNonce() = 0;
+      virtual void setNonce(const std::string& nonce) = 0;
+      virtual std::string getOauthMethod() = 0;
+      virtual void setOauthMethod(const std::string& oauthMethod) = 0;
+      virtual std::string getOauthUrl() = 0;
+      virtual void setOauthUrl(const std::string& oauthUrl) = 0;
+      virtual std::string getOauthVersion() = 0;
+      virtual void setOauthVersion(const std::string& oauthVersion) = 0;
+      virtual std::string getQueryString() = 0;
+      virtual std::string getSignature() = 0;
+      virtual std::string getSignatureMethod() = 0;
+      virtual void setSignatureMethod(const std::string& signatureMethod) = 0;
+      virtual std::string getTimestamp() = 0;
+      virtual void setTimestamp(const std::string& timestamp) = 0;
+      virtual std::string getToken() = 0;
+      virtual void setToken(const std::string& token) = 0;
+      virtual std::string getTokenSecret() = 0;
+      virtual void setTokenSecret(const std::string& tokenSecret) = 0;
+      virtual std::string getRealm() = 0;
+      virtual void setRealm(const std::string& realm) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+
+    public:
+      // Methods
+      virtual void addParam(const std::string& name, const std::string& value) = 0;
+      virtual void genNonce(double numBytes) = 0;
+      virtual void genTimestamp() = 0;
+      virtual void generate() = 0;
+      virtual void removeParam(const std::string& name) = 0;
+      virtual void setRsaKey(const std::shared_ptr<HybridPrivateKeySpec>& privKey) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "OAuth1";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,107 @@
+///
+/// HybridOAuth2Spec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridOAuth2Spec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridOAuth2Spec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridOAuth2Spec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridOAuth2Spec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridOAuth2Spec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridOAuth2Spec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridOAuth2Spec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridOAuth2Spec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridOAuth2Spec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridOAuth2Spec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridOAuth2Spec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridOAuth2Spec::setLastMethodSuccess);
+      prototype.registerHybridGetter("authorizationEndpoint", &HybridOAuth2Spec::getAuthorizationEndpoint);
+      prototype.registerHybridSetter("authorizationEndpoint", &HybridOAuth2Spec::setAuthorizationEndpoint);
+      prototype.registerHybridGetter("tokenEndpoint", &HybridOAuth2Spec::getTokenEndpoint);
+      prototype.registerHybridSetter("tokenEndpoint", &HybridOAuth2Spec::setTokenEndpoint);
+      prototype.registerHybridGetter("clientId", &HybridOAuth2Spec::getClientId);
+      prototype.registerHybridSetter("clientId", &HybridOAuth2Spec::setClientId);
+      prototype.registerHybridGetter("clientSecret", &HybridOAuth2Spec::getClientSecret);
+      prototype.registerHybridSetter("clientSecret", &HybridOAuth2Spec::setClientSecret);
+      prototype.registerHybridGetter("scope", &HybridOAuth2Spec::getScope);
+      prototype.registerHybridSetter("scope", &HybridOAuth2Spec::setScope);
+      prototype.registerHybridGetter("codeChallenge", &HybridOAuth2Spec::getCodeChallenge);
+      prototype.registerHybridSetter("codeChallenge", &HybridOAuth2Spec::setCodeChallenge);
+      prototype.registerHybridGetter("codeChallengeMethod", &HybridOAuth2Spec::getCodeChallengeMethod);
+      prototype.registerHybridSetter("codeChallengeMethod", &HybridOAuth2Spec::setCodeChallengeMethod);
+      prototype.registerHybridGetter("accessTokenResponse", &HybridOAuth2Spec::getAccessTokenResponse);
+      prototype.registerHybridGetter("authFlowState", &HybridOAuth2Spec::getAuthFlowState);
+      prototype.registerHybridGetter("failureInfo", &HybridOAuth2Spec::getFailureInfo);
+      prototype.registerHybridGetter("redirectAllowHtml", &HybridOAuth2Spec::getRedirectAllowHtml);
+      prototype.registerHybridSetter("redirectAllowHtml", &HybridOAuth2Spec::setRedirectAllowHtml);
+      prototype.registerHybridGetter("redirectDenyHtml", &HybridOAuth2Spec::getRedirectDenyHtml);
+      prototype.registerHybridSetter("redirectDenyHtml", &HybridOAuth2Spec::setRedirectDenyHtml);
+      prototype.registerHybridGetter("accessToken", &HybridOAuth2Spec::getAccessToken);
+      prototype.registerHybridSetter("accessToken", &HybridOAuth2Spec::setAccessToken);
+      prototype.registerHybridGetter("tokenType", &HybridOAuth2Spec::getTokenType);
+      prototype.registerHybridSetter("tokenType", &HybridOAuth2Spec::setTokenType);
+      prototype.registerHybridGetter("refreshToken", &HybridOAuth2Spec::getRefreshToken);
+      prototype.registerHybridSetter("refreshToken", &HybridOAuth2Spec::setRefreshToken);
+      prototype.registerHybridGetter("listenPort", &HybridOAuth2Spec::getListenPort);
+      prototype.registerHybridSetter("listenPort", &HybridOAuth2Spec::setListenPort);
+      prototype.registerHybridGetter("localHost", &HybridOAuth2Spec::getLocalHost);
+      prototype.registerHybridSetter("localHost", &HybridOAuth2Spec::setLocalHost);
+      prototype.registerHybridGetter("resource", &HybridOAuth2Spec::getResource);
+      prototype.registerHybridSetter("resource", &HybridOAuth2Spec::setResource);
+      prototype.registerHybridGetter("listenPortRangeEnd", &HybridOAuth2Spec::getListenPortRangeEnd);
+      prototype.registerHybridSetter("listenPortRangeEnd", &HybridOAuth2Spec::setListenPortRangeEnd);
+      prototype.registerHybridGetter("appCallbackUrl", &HybridOAuth2Spec::getAppCallbackUrl);
+      prototype.registerHybridSetter("appCallbackUrl", &HybridOAuth2Spec::setAppCallbackUrl);
+      prototype.registerHybridGetter("useBasicAuth", &HybridOAuth2Spec::getUseBasicAuth);
+      prototype.registerHybridSetter("useBasicAuth", &HybridOAuth2Spec::setUseBasicAuth);
+      prototype.registerHybridGetter("includeNonce", &HybridOAuth2Spec::getIncludeNonce);
+      prototype.registerHybridSetter("includeNonce", &HybridOAuth2Spec::setIncludeNonce);
+      prototype.registerHybridGetter("responseMode", &HybridOAuth2Spec::getResponseMode);
+      prototype.registerHybridSetter("responseMode", &HybridOAuth2Spec::setResponseMode);
+      prototype.registerHybridGetter("responseType", &HybridOAuth2Spec::getResponseType);
+      prototype.registerHybridSetter("responseType", &HybridOAuth2Spec::setResponseType);
+      prototype.registerHybridGetter("nonceLength", &HybridOAuth2Spec::getNonceLength);
+      prototype.registerHybridSetter("nonceLength", &HybridOAuth2Spec::setNonceLength);
+      prototype.registerHybridGetter("uncommonOptions", &HybridOAuth2Spec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridOAuth2Spec::setUncommonOptions);
+      prototype.registerHybridGetter("redirectReqReceived", &HybridOAuth2Spec::getRedirectReqReceived);
+      prototype.registerHybridGetter("stateParam", &HybridOAuth2Spec::getStateParam);
+      prototype.registerHybridSetter("stateParam", &HybridOAuth2Spec::setStateParam);
+      prototype.registerHybridGetter("listenPortSelected", &HybridOAuth2Spec::getListenPortSelected);
+      prototype.registerHybridGetter("oob", &HybridOAuth2Spec::getOob);
+      prototype.registerHybridSetter("oob", &HybridOAuth2Spec::setOob);
+      prototype.registerHybridGetter("enableSecrets", &HybridOAuth2Spec::getEnableSecrets);
+      prototype.registerHybridSetter("enableSecrets", &HybridOAuth2Spec::setEnableSecrets);
+      prototype.registerHybridGetter("onPercentDone", &HybridOAuth2Spec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridOAuth2Spec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridOAuth2Spec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridOAuth2Spec::setOnProgressInfo);
+      prototype.registerHybridMethod("startAuth", &HybridOAuth2Spec::startAuth);
+      prototype.registerHybridMethod("cancel", &HybridOAuth2Spec::cancel);
+      prototype.registerHybridMethod("sleepMs", &HybridOAuth2Spec::sleepMs);
+      prototype.registerHybridMethod("refreshAccessToken", &HybridOAuth2Spec::refreshAccessToken);
+      prototype.registerHybridMethod("refreshAccessTokenAsync", &HybridOAuth2Spec::refreshAccessTokenAsync);
+      prototype.registerHybridMethod("useConnection", &HybridOAuth2Spec::useConnection);
+      prototype.registerHybridMethod("getRedirectRequestParam", &HybridOAuth2Spec::getRedirectRequestParam);
+      prototype.registerHybridMethod("setRefreshHeader", &HybridOAuth2Spec::setRefreshHeader);
+      prototype.registerHybridMethod("addTokenQueryParam", &HybridOAuth2Spec::addTokenQueryParam);
+      prototype.registerHybridMethod("addAuthQueryParam", &HybridOAuth2Spec::addAuthQueryParam);
+      prototype.registerHybridMethod("addRefreshQueryParam", &HybridOAuth2Spec::addRefreshQueryParam);
+      prototype.registerHybridMethod("launchBrowser", &HybridOAuth2Spec::launchBrowser);
+      prototype.registerHybridMethod("exchangeCodeForToken", &HybridOAuth2Spec::exchangeCodeForToken);
+      prototype.registerHybridMethod("exchangeCodeForTokenAsync", &HybridOAuth2Spec::exchangeCodeForTokenAsync);
+      prototype.registerHybridMethod("getAccessTokenResponseSb", &HybridOAuth2Spec::getAccessTokenResponseSb);
+      prototype.registerHybridMethod("abort", &HybridOAuth2Spec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,156 @@
+///
+/// HybridOAuth2Spec.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 `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; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include "HybridSocketSpec.hpp"
+#include "HybridStringBuilderSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `OAuth2`
+   * Inherit this class to create instances of `HybridOAuth2Spec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridOAuth2: public HybridOAuth2Spec {
+   * public:
+   *   HybridOAuth2(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridOAuth2Spec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridOAuth2Spec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridOAuth2Spec() 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 getAuthorizationEndpoint() = 0;
+      virtual void setAuthorizationEndpoint(const std::string& authorizationEndpoint) = 0;
+      virtual std::string getTokenEndpoint() = 0;
+      virtual void setTokenEndpoint(const std::string& tokenEndpoint) = 0;
+      virtual std::string getClientId() = 0;
+      virtual void setClientId(const std::string& clientId) = 0;
+      virtual std::string getClientSecret() = 0;
+      virtual void setClientSecret(const std::string& clientSecret) = 0;
+      virtual std::string getScope() = 0;
+      virtual void setScope(const std::string& scope) = 0;
+      virtual bool getCodeChallenge() = 0;
+      virtual void setCodeChallenge(bool codeChallenge) = 0;
+      virtual std::string getCodeChallengeMethod() = 0;
+      virtual void setCodeChallengeMethod(const std::string& codeChallengeMethod) = 0;
+      virtual std::string getAccessTokenResponse() = 0;
+      virtual double getAuthFlowState() = 0;
+      virtual std::string getFailureInfo() = 0;
+      virtual std::string getRedirectAllowHtml() = 0;
+      virtual void setRedirectAllowHtml(const std::string& redirectAllowHtml) = 0;
+      virtual std::string getRedirectDenyHtml() = 0;
+      virtual void setRedirectDenyHtml(const std::string& redirectDenyHtml) = 0;
+      virtual std::string getAccessToken() = 0;
+      virtual void setAccessToken(const std::string& accessToken) = 0;
+      virtual std::string getTokenType() = 0;
+      virtual void setTokenType(const std::string& tokenType) = 0;
+      virtual std::string getRefreshToken() = 0;
+      virtual void setRefreshToken(const std::string& refreshToken) = 0;
+      virtual double getListenPort() = 0;
+      virtual void setListenPort(double listenPort) = 0;
+      virtual std::string getLocalHost() = 0;
+      virtual void setLocalHost(const std::string& localHost) = 0;
+      virtual std::string getResource() = 0;
+      virtual void setResource(const std::string& resource) = 0;
+      virtual double getListenPortRangeEnd() = 0;
+      virtual void setListenPortRangeEnd(double listenPortRangeEnd) = 0;
+      virtual std::string getAppCallbackUrl() = 0;
+      virtual void setAppCallbackUrl(const std::string& appCallbackUrl) = 0;
+      virtual bool getUseBasicAuth() = 0;
+      virtual void setUseBasicAuth(bool useBasicAuth) = 0;
+      virtual bool getIncludeNonce() = 0;
+      virtual void setIncludeNonce(bool includeNonce) = 0;
+      virtual std::string getResponseMode() = 0;
+      virtual void setResponseMode(const std::string& responseMode) = 0;
+      virtual std::string getResponseType() = 0;
+      virtual void setResponseType(const std::string& responseType) = 0;
+      virtual double getNonceLength() = 0;
+      virtual void setNonceLength(double nonceLength) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+      virtual std::string getRedirectReqReceived() = 0;
+      virtual std::string getStateParam() = 0;
+      virtual void setStateParam(const std::string& stateParam) = 0;
+      virtual double getListenPortSelected() = 0;
+      virtual bool getOob() = 0;
+      virtual void setOob(bool oob) = 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 std::string startAuth() = 0;
+      virtual void cancel() = 0;
+      virtual void sleepMs(double millisec) = 0;
+      virtual void refreshAccessToken() = 0;
+      virtual std::shared_ptr<Promise<void>> refreshAccessTokenAsync() = 0;
+      virtual void useConnection(const std::shared_ptr<HybridSocketSpec>& sock) = 0;
+      virtual std::string getRedirectRequestParam(const std::string& paramName) = 0;
+      virtual void setRefreshHeader(const std::string& name, const std::string& value) = 0;
+      virtual void addTokenQueryParam(const std::string& name, const std::string& value) = 0;
+      virtual void addAuthQueryParam(const std::string& name, const std::string& value) = 0;
+      virtual void addRefreshQueryParam(const std::string& name, const std::string& value) = 0;
+      virtual void launchBrowser(const std::string& url) = 0;
+      virtual void exchangeCodeForToken(const std::string& code) = 0;
+      virtual std::shared_ptr<Promise<void>> exchangeCodeForTokenAsync(const std::string& code) = 0;
+      virtual void getAccessTokenResponseSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "OAuth2";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,73 @@
+///
+/// HybridPdfSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridPdfSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridPdfSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridPdfSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridPdfSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridPdfSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridPdfSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridPdfSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridPdfSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridPdfSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridPdfSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridPdfSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridPdfSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("numSignatures", &HybridPdfSpec::getNumSignatures);
+      prototype.registerHybridGetter("numPages", &HybridPdfSpec::getNumPages);
+      prototype.registerHybridGetter("uncommonOptions", &HybridPdfSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridPdfSpec::setUncommonOptions);
+      prototype.registerHybridGetter("sigAllocateSize", &HybridPdfSpec::getSigAllocateSize);
+      prototype.registerHybridSetter("sigAllocateSize", &HybridPdfSpec::setSigAllocateSize);
+      prototype.registerHybridGetter("numEmbeddedFiles", &HybridPdfSpec::getNumEmbeddedFiles);
+      prototype.registerHybridGetter("hasCertificationSig", &HybridPdfSpec::getHasCertificationSig);
+      prototype.registerHybridGetter("ownerPassword", &HybridPdfSpec::getOwnerPassword);
+      prototype.registerHybridSetter("ownerPassword", &HybridPdfSpec::setOwnerPassword);
+      prototype.registerHybridGetter("userPassword", &HybridPdfSpec::getUserPassword);
+      prototype.registerHybridSetter("userPassword", &HybridPdfSpec::setUserPassword);
+      prototype.registerHybridGetter("onPercentDone", &HybridPdfSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridPdfSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridPdfSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridPdfSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("loadFile", &HybridPdfSpec::loadFile);
+      prototype.registerHybridMethod("loadBd", &HybridPdfSpec::loadBd);
+      prototype.registerHybridMethod("verifySignature", &HybridPdfSpec::verifySignature);
+      prototype.registerHybridMethod("signPdf", &HybridPdfSpec::signPdf);
+      prototype.registerHybridMethod("signPdfAsync", &HybridPdfSpec::signPdfAsync);
+      prototype.registerHybridMethod("getDss", &HybridPdfSpec::getDss);
+      prototype.registerHybridMethod("setHttpObj", &HybridPdfSpec::setHttpObj);
+      prototype.registerHybridMethod("setSigningCert", &HybridPdfSpec::setSigningCert);
+      prototype.registerHybridMethod("setSigningCert2", &HybridPdfSpec::setSigningCert2);
+      prototype.registerHybridMethod("addSigningCert", &HybridPdfSpec::addSigningCert);
+      prototype.registerHybridMethod("setSignatureJpeg", &HybridPdfSpec::setSignatureJpeg);
+      prototype.registerHybridMethod("getSignerCert", &HybridPdfSpec::getSignerCert);
+      prototype.registerHybridMethod("getUnsignedSigFields", &HybridPdfSpec::getUnsignedSigFields);
+      prototype.registerHybridMethod("getSignatureContent", &HybridPdfSpec::getSignatureContent);
+      prototype.registerHybridMethod("getMetadata", &HybridPdfSpec::getMetadata);
+      prototype.registerHybridMethod("addVerificationInfo", &HybridPdfSpec::addVerificationInfo);
+      prototype.registerHybridMethod("addVerificationInfoAsync", &HybridPdfSpec::addVerificationInfoAsync);
+      prototype.registerHybridMethod("signPdfBd", &HybridPdfSpec::signPdfBd);
+      prototype.registerHybridMethod("signPdfBdAsync", &HybridPdfSpec::signPdfBdAsync);
+      prototype.registerHybridMethod("getEmbeddedFileInfo", &HybridPdfSpec::getEmbeddedFileInfo);
+      prototype.registerHybridMethod("getEmbeddedFileBd", &HybridPdfSpec::getEmbeddedFileBd);
+      prototype.registerHybridMethod("addEmbeddedFiles", &HybridPdfSpec::addEmbeddedFiles);
+      prototype.registerHybridMethod("addEmbeddedFilesBd", &HybridPdfSpec::addEmbeddedFilesBd);
+      prototype.registerHybridMethod("updateMetadata", &HybridPdfSpec::updateMetadata);
+      prototype.registerHybridMethod("updateMetadataBd", &HybridPdfSpec::updateMetadataBd);
+      prototype.registerHybridMethod("getLastJsonData", &HybridPdfSpec::getLastJsonData);
+      prototype.registerHybridMethod("abort", &HybridPdfSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,134 @@
+///
+/// HybridPdfSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+// Forward declaration of `HybridHttpSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridHttpSpec; }
+// 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 `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <memory>
+#include "HybridBinDataSpec.hpp"
+#include "HybridJsonObjectSpec.hpp"
+#include <NitroModules/Promise.hpp>
+#include "HybridHttpSpec.hpp"
+#include "HybridCertSpec.hpp"
+#include "HybridPrivateKeySpec.hpp"
+#include "HybridStringBuilderSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Pdf`
+   * Inherit this class to create instances of `HybridPdfSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridPdf: public HybridPdfSpec {
+   * public:
+   *   HybridPdf(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridPdfSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridPdfSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridPdfSpec() 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 getNumSignatures() = 0;
+      virtual double getNumPages() = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+      virtual double getSigAllocateSize() = 0;
+      virtual void setSigAllocateSize(double sigAllocateSize) = 0;
+      virtual double getNumEmbeddedFiles() = 0;
+      virtual bool getHasCertificationSig() = 0;
+      virtual std::string getOwnerPassword() = 0;
+      virtual void setOwnerPassword(const std::string& ownerPassword) = 0;
+      virtual std::string getUserPassword() = 0;
+      virtual void setUserPassword(const std::string& userPassword) = 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 loadFile(const std::string& filePath) = 0;
+      virtual void loadBd(const std::shared_ptr<HybridBinDataSpec>& pdfData) = 0;
+      virtual void verifySignature(double index, const std::shared_ptr<HybridJsonObjectSpec>& sigInfo) = 0;
+      virtual void signPdf(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions, const std::string& outFilePath) = 0;
+      virtual std::shared_ptr<Promise<void>> signPdfAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions, const std::string& outFilePath) = 0;
+      virtual void getDss(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void setHttpObj(const std::shared_ptr<HybridHttpSpec>& http) = 0;
+      virtual void setSigningCert(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void setSigningCert2(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey) = 0;
+      virtual void addSigningCert(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void setSignatureJpeg(const std::shared_ptr<HybridBinDataSpec>& jpgData) = 0;
+      virtual void getSignerCert(double index, const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void getUnsignedSigFields(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void getSignatureContent(double index, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void getMetadata(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void addVerificationInfo(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions, const std::string& outFilePath) = 0;
+      virtual std::shared_ptr<Promise<void>> addVerificationInfoAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions, const std::string& outFilePath) = 0;
+      virtual void signPdfBd(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual std::shared_ptr<Promise<void>> signPdfBdAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void getEmbeddedFileInfo(double index, const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void getEmbeddedFileBd(double index, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void addEmbeddedFiles(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::string& outFilePath) = 0;
+      virtual void addEmbeddedFilesBd(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void updateMetadata(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& outFilePath) = 0;
+      virtual void updateMetadataBd(const std::shared_ptr<HybridStringBuilderSpec>& sb, 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 = "Pdf";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,63 @@
+///
+/// HybridPemSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridPemSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridPemSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridPemSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridPemSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridPemSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridPemSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridPemSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridPemSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridPemSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridPemSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridPemSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridPemSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("appendMode", &HybridPemSpec::getAppendMode);
+      prototype.registerHybridSetter("appendMode", &HybridPemSpec::setAppendMode);
+      prototype.registerHybridGetter("heartbeatMs", &HybridPemSpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridPemSpec::setHeartbeatMs);
+      prototype.registerHybridGetter("numCerts", &HybridPemSpec::getNumCerts);
+      prototype.registerHybridGetter("numCsrs", &HybridPemSpec::getNumCsrs);
+      prototype.registerHybridGetter("numPrivateKeys", &HybridPemSpec::getNumPrivateKeys);
+      prototype.registerHybridGetter("numPublicKeys", &HybridPemSpec::getNumPublicKeys);
+      prototype.registerHybridGetter("privateKeyFormat", &HybridPemSpec::getPrivateKeyFormat);
+      prototype.registerHybridSetter("privateKeyFormat", &HybridPemSpec::setPrivateKeyFormat);
+      prototype.registerHybridGetter("publicKeyFormat", &HybridPemSpec::getPublicKeyFormat);
+      prototype.registerHybridSetter("publicKeyFormat", &HybridPemSpec::setPublicKeyFormat);
+      prototype.registerHybridGetter("numCrls", &HybridPemSpec::getNumCrls);
+      prototype.registerHybridMethod("addCert", &HybridPemSpec::addCert);
+      prototype.registerHybridMethod("addPrivateKey", &HybridPemSpec::addPrivateKey);
+      prototype.registerHybridMethod("addPrivateKey2", &HybridPemSpec::addPrivateKey2);
+      prototype.registerHybridMethod("addPublicKey", &HybridPemSpec::addPublicKey);
+      prototype.registerHybridMethod("clear", &HybridPemSpec::clear);
+      prototype.registerHybridMethod("getEncodedItem", &HybridPemSpec::getEncodedItem);
+      prototype.registerHybridMethod("loadP7bFile", &HybridPemSpec::loadP7bFile);
+      prototype.registerHybridMethod("loadPem", &HybridPemSpec::loadPem);
+      prototype.registerHybridMethod("loadPemFile", &HybridPemSpec::loadPemFile);
+      prototype.registerHybridMethod("removeCert", &HybridPemSpec::removeCert);
+      prototype.registerHybridMethod("removePrivateKey", &HybridPemSpec::removePrivateKey);
+      prototype.registerHybridMethod("toPem", &HybridPemSpec::toPem);
+      prototype.registerHybridMethod("toPemEx", &HybridPemSpec::toPemEx);
+      prototype.registerHybridMethod("addItem", &HybridPemSpec::addItem);
+      prototype.registerHybridMethod("certAt", &HybridPemSpec::certAt);
+      prototype.registerHybridMethod("privateKeyAt", &HybridPemSpec::privateKeyAt);
+      prototype.registerHybridMethod("publicKeyAt", &HybridPemSpec::publicKeyAt);
+      prototype.registerHybridMethod("toJksObj", &HybridPemSpec::toJksObj);
+      prototype.registerHybridMethod("toPfxObj", &HybridPemSpec::toPfxObj);
+      prototype.registerHybridMethod("addP7b", &HybridPemSpec::addP7b);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat