@chilkat/react-native 11.6.1

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

@@ -0,0 +1,131 @@
+///
+/// HybridPrivateKeySpec.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 `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+// Forward declaration of `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+// Forward declaration of `HybridPublicKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPublicKeySpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <memory>
+#include "HybridBinDataSpec.hpp"
+#include "HybridStringBuilderSpec.hpp"
+#include "HybridJsonObjectSpec.hpp"
+#include <NitroModules/Promise.hpp>
+#include "HybridPublicKeySpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `PrivateKey`
+   * Inherit this class to create instances of `HybridPrivateKeySpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridPrivateKey: public HybridPrivateKeySpec {
+   * public:
+   *   HybridPrivateKey(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridPrivateKeySpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridPrivateKeySpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridPrivateKeySpec() 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 getBitLength() = 0;
+      virtual std::string getKeyType() = 0;
+      virtual std::string getPkcs8EncryptAlg() = 0;
+      virtual void setPkcs8EncryptAlg(const std::string& pkcs8EncryptAlg) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 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 getPkcs1ENC(const std::string& encoding) = 0;
+      virtual std::string getPkcs8ENC(const std::string& encoding) = 0;
+      virtual std::string getPkcs8EncryptedENC(const std::string& encoding, const std::string& password) = 0;
+      virtual std::string getPkcs8EncryptedPem(const std::string& password) = 0;
+      virtual std::string getPkcs8Pem() = 0;
+      virtual std::string getXml() = 0;
+      virtual void loadEncryptedPem(const std::string& pemStr, const std::string& password) = 0;
+      virtual void loadEncryptedPemFile(const std::string& path, const std::string& password) = 0;
+      virtual void loadPem(const std::string& str) = 0;
+      virtual void loadPemFile(const std::string& path) = 0;
+      virtual void loadPkcs8EncryptedFile(const std::string& path, const std::string& password) = 0;
+      virtual void loadPkcs8File(const std::string& path) = 0;
+      virtual void loadPvkFile(const std::string& path, const std::string& password) = 0;
+      virtual void loadXml(const std::string& xml) = 0;
+      virtual void loadXmlFile(const std::string& path) = 0;
+      virtual void savePkcs8EncryptedFile(const std::string& password, const std::string& path) = 0;
+      virtual void savePkcs8EncryptedPemFile(const std::string& password, const std::string& path) = 0;
+      virtual void savePkcs8File(const std::string& path) = 0;
+      virtual void savePkcs8PemFile(const std::string& path) = 0;
+      virtual void saveXmlFile(const std::string& path) = 0;
+      virtual std::string getPkcs1Pem() = 0;
+      virtual void loadPkcs1File(const std::string& path) = 0;
+      virtual void savePkcs1File(const std::string& path) = 0;
+      virtual void savePemFile(const std::string& path) = 0;
+      virtual std::string getJwk() = 0;
+      virtual void loadJwk(const std::string& jsonStr) = 0;
+      virtual std::string getJwkThumbprint(const std::string& hashAlg) = 0;
+      virtual void loadAnyFormat(const std::shared_ptr<HybridBinDataSpec>& privKeyData, const std::string& password) = 0;
+      virtual void loadEd25519(const std::string& privKey, const std::string& pubKey) = 0;
+      virtual void loadAnyFormatFile(const std::string& path, const std::string& password) = 0;
+      virtual std::string getRawHex(const std::shared_ptr<HybridStringBuilderSpec>& pubKey) = 0;
+      virtual void uploadToCloud(const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) = 0;
+      virtual std::shared_ptr<Promise<void>> uploadToCloudAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) = 0;
+      virtual void toPublicKey(const std::shared_ptr<HybridPublicKeySpec>& pubKey) = 0;
+      virtual void getPkcsBd(bool pkcs1, const std::string& password, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "PrivateKey";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,42 @@
+///
+/// HybridPrngSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridPrngSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridPrngSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridPrngSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridPrngSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridPrngSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridPrngSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridPrngSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridPrngSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridPrngSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridPrngSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridPrngSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridPrngSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("prngName", &HybridPrngSpec::getPrngName);
+      prototype.registerHybridSetter("prngName", &HybridPrngSpec::setPrngName);
+      prototype.registerHybridMethod("addEntropy", &HybridPrngSpec::addEntropy);
+      prototype.registerHybridMethod("exportEntropy", &HybridPrngSpec::exportEntropy);
+      prototype.registerHybridMethod("firebasePushId", &HybridPrngSpec::firebasePushId);
+      prototype.registerHybridMethod("genRandom", &HybridPrngSpec::genRandom);
+      prototype.registerHybridMethod("getEntropy", &HybridPrngSpec::getEntropy);
+      prototype.registerHybridMethod("importEntropy", &HybridPrngSpec::importEntropy);
+      prototype.registerHybridMethod("randomInt", &HybridPrngSpec::randomInt);
+      prototype.registerHybridMethod("randomPassword", &HybridPrngSpec::randomPassword);
+      prototype.registerHybridMethod("randomString", &HybridPrngSpec::randomString);
+      prototype.registerHybridMethod("genRandomBd", &HybridPrngSpec::genRandomBd);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,85 @@
+///
+/// HybridPrngSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridBinDataSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Prng`
+   * Inherit this class to create instances of `HybridPrngSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridPrng: public HybridPrngSpec {
+   * public:
+   *   HybridPrng(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridPrngSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridPrngSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridPrngSpec() 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 getPrngName() = 0;
+      virtual void setPrngName(const std::string& prngName) = 0;
+
+    public:
+      // Methods
+      virtual void addEntropy(const std::string& entropy, const std::string& encoding) = 0;
+      virtual std::string exportEntropy() = 0;
+      virtual std::string firebasePushId() = 0;
+      virtual std::string genRandom(double numBytes, const std::string& encoding) = 0;
+      virtual std::string getEntropy(double numBytes, const std::string& encoding) = 0;
+      virtual void importEntropy(const std::string& entropy) = 0;
+      virtual double randomInt(double low, double high) = 0;
+      virtual std::string randomPassword(double length, bool mustIncludeDigit, bool upperAndLowercase, const std::string& mustHaveOneOf, const std::string& excludeChars) = 0;
+      virtual std::string randomString(double length, bool bDigits, bool bLower, bool bUpper) = 0;
+      virtual void genRandomBd(double numBytes, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Prng";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,48 @@
+///
+/// HybridPublicKeySpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridPublicKeySpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridPublicKeySpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridPublicKeySpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridPublicKeySpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridPublicKeySpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridPublicKeySpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridPublicKeySpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridPublicKeySpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridPublicKeySpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridPublicKeySpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridPublicKeySpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridPublicKeySpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("keyType", &HybridPublicKeySpec::getKeyType);
+      prototype.registerHybridGetter("keySize", &HybridPublicKeySpec::getKeySize);
+      prototype.registerHybridGetter("empty", &HybridPublicKeySpec::getEmpty);
+      prototype.registerHybridMethod("getXml", &HybridPublicKeySpec::getXml);
+      prototype.registerHybridMethod("loadBase64", &HybridPublicKeySpec::loadBase64);
+      prototype.registerHybridMethod("saveXmlFile", &HybridPublicKeySpec::saveXmlFile);
+      prototype.registerHybridMethod("loadFromString", &HybridPublicKeySpec::loadFromString);
+      prototype.registerHybridMethod("loadFromFile", &HybridPublicKeySpec::loadFromFile);
+      prototype.registerHybridMethod("getPem", &HybridPublicKeySpec::getPem);
+      prototype.registerHybridMethod("getEncoded", &HybridPublicKeySpec::getEncoded);
+      prototype.registerHybridMethod("saveDerFile", &HybridPublicKeySpec::saveDerFile);
+      prototype.registerHybridMethod("savePemFile", &HybridPublicKeySpec::savePemFile);
+      prototype.registerHybridMethod("getJwk", &HybridPublicKeySpec::getJwk);
+      prototype.registerHybridMethod("getJwkThumbprint", &HybridPublicKeySpec::getJwkThumbprint);
+      prototype.registerHybridMethod("loadEd25519", &HybridPublicKeySpec::loadEd25519);
+      prototype.registerHybridMethod("loadBd", &HybridPublicKeySpec::loadBd);
+      prototype.registerHybridMethod("loadEcdsa", &HybridPublicKeySpec::loadEcdsa);
+      prototype.registerHybridMethod("getDerBd", &HybridPublicKeySpec::getDerBd);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,91 @@
+///
+/// HybridPublicKeySpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridBinDataSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `PublicKey`
+   * Inherit this class to create instances of `HybridPublicKeySpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridPublicKey: public HybridPublicKeySpec {
+   * public:
+   *   HybridPublicKey(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridPublicKeySpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridPublicKeySpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridPublicKeySpec() 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 getKeyType() = 0;
+      virtual double getKeySize() = 0;
+      virtual bool getEmpty() = 0;
+
+    public:
+      // Methods
+      virtual std::string getXml() = 0;
+      virtual void loadBase64(const std::string& keyStr) = 0;
+      virtual void saveXmlFile(const std::string& path) = 0;
+      virtual void loadFromString(const std::string& keyString) = 0;
+      virtual void loadFromFile(const std::string& path) = 0;
+      virtual std::string getPem(bool preferPkcs1) = 0;
+      virtual std::string getEncoded(bool preferPkcs1, const std::string& encoding) = 0;
+      virtual void saveDerFile(bool preferPkcs1, const std::string& path) = 0;
+      virtual void savePemFile(bool preferPkcs1, const std::string& path) = 0;
+      virtual std::string getJwk() = 0;
+      virtual std::string getJwkThumbprint(const std::string& hashAlg) = 0;
+      virtual void loadEd25519(const std::string& pubKey) = 0;
+      virtual void loadBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void loadEcdsa(const std::string& curveName, const std::string& qx, const std::string& qy) = 0;
+      virtual void getDerBd(bool preferPkcs1, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "PublicKey";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,150 @@
+///
+/// HybridRestSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridRestSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridRestSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridRestSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridRestSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridRestSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridRestSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridRestSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridRestSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridRestSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridRestSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridRestSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridRestSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("authorization", &HybridRestSpec::getAuthorization);
+      prototype.registerHybridSetter("authorization", &HybridRestSpec::setAuthorization);
+      prototype.registerHybridGetter("heartbeatMs", &HybridRestSpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridRestSpec::setHeartbeatMs);
+      prototype.registerHybridGetter("host", &HybridRestSpec::getHost);
+      prototype.registerHybridSetter("host", &HybridRestSpec::setHost);
+      prototype.registerHybridGetter("idleTimeoutMs", &HybridRestSpec::getIdleTimeoutMs);
+      prototype.registerHybridSetter("idleTimeoutMs", &HybridRestSpec::setIdleTimeoutMs);
+      prototype.registerHybridGetter("lastRequestHeader", &HybridRestSpec::getLastRequestHeader);
+      prototype.registerHybridGetter("lastRequestStartLine", &HybridRestSpec::getLastRequestStartLine);
+      prototype.registerHybridGetter("numResponseHeaders", &HybridRestSpec::getNumResponseHeaders);
+      prototype.registerHybridGetter("partSelector", &HybridRestSpec::getPartSelector);
+      prototype.registerHybridSetter("partSelector", &HybridRestSpec::setPartSelector);
+      prototype.registerHybridGetter("responseHeader", &HybridRestSpec::getResponseHeader);
+      prototype.registerHybridGetter("responseStatusCode", &HybridRestSpec::getResponseStatusCode);
+      prototype.registerHybridGetter("responseStatusText", &HybridRestSpec::getResponseStatusText);
+      prototype.registerHybridGetter("streamNonChunked", &HybridRestSpec::getStreamNonChunked);
+      prototype.registerHybridSetter("streamNonChunked", &HybridRestSpec::setStreamNonChunked);
+      prototype.registerHybridGetter("connectFailReason", &HybridRestSpec::getConnectFailReason);
+      prototype.registerHybridGetter("percentDoneOnSend", &HybridRestSpec::getPercentDoneOnSend);
+      prototype.registerHybridSetter("percentDoneOnSend", &HybridRestSpec::setPercentDoneOnSend);
+      prototype.registerHybridGetter("allowHeaderQB", &HybridRestSpec::getAllowHeaderQB);
+      prototype.registerHybridSetter("allowHeaderQB", &HybridRestSpec::setAllowHeaderQB);
+      prototype.registerHybridGetter("allowHeaderFolding", &HybridRestSpec::getAllowHeaderFolding);
+      prototype.registerHybridSetter("allowHeaderFolding", &HybridRestSpec::setAllowHeaderFolding);
+      prototype.registerHybridGetter("connectTimeoutMs", &HybridRestSpec::getConnectTimeoutMs);
+      prototype.registerHybridSetter("connectTimeoutMs", &HybridRestSpec::setConnectTimeoutMs);
+      prototype.registerHybridGetter("debugMode", &HybridRestSpec::getDebugMode);
+      prototype.registerHybridSetter("debugMode", &HybridRestSpec::setDebugMode);
+      prototype.registerHybridGetter("uncommonOptions", &HybridRestSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridRestSpec::setUncommonOptions);
+      prototype.registerHybridGetter("lastRedirectUrl", &HybridRestSpec::getLastRedirectUrl);
+      prototype.registerHybridGetter("enableSecrets", &HybridRestSpec::getEnableSecrets);
+      prototype.registerHybridSetter("enableSecrets", &HybridRestSpec::setEnableSecrets);
+      prototype.registerHybridGetter("onPercentDone", &HybridRestSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridRestSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridRestSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridRestSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("addHeader", &HybridRestSpec::addHeader);
+      prototype.registerHybridMethod("addQueryParam", &HybridRestSpec::addQueryParam);
+      prototype.registerHybridMethod("addQueryParams", &HybridRestSpec::addQueryParams);
+      prototype.registerHybridMethod("clearAllHeaders", &HybridRestSpec::clearAllHeaders);
+      prototype.registerHybridMethod("clearAllQueryParams", &HybridRestSpec::clearAllQueryParams);
+      prototype.registerHybridMethod("clearResponseBodyStream", &HybridRestSpec::clearResponseBodyStream);
+      prototype.registerHybridMethod("connect", &HybridRestSpec::connect);
+      prototype.registerHybridMethod("connectAsync", &HybridRestSpec::connectAsync);
+      prototype.registerHybridMethod("disconnect", &HybridRestSpec::disconnect);
+      prototype.registerHybridMethod("disconnectAsync", &HybridRestSpec::disconnectAsync);
+      prototype.registerHybridMethod("fullRequestFormUrlEncoded", &HybridRestSpec::fullRequestFormUrlEncoded);
+      prototype.registerHybridMethod("fullRequestFormUrlEncodedAsync", &HybridRestSpec::fullRequestFormUrlEncodedAsync);
+      prototype.registerHybridMethod("fullRequestMultipart", &HybridRestSpec::fullRequestMultipart);
+      prototype.registerHybridMethod("fullRequestMultipartAsync", &HybridRestSpec::fullRequestMultipartAsync);
+      prototype.registerHybridMethod("fullRequestNoBody", &HybridRestSpec::fullRequestNoBody);
+      prototype.registerHybridMethod("fullRequestNoBodyAsync", &HybridRestSpec::fullRequestNoBodyAsync);
+      prototype.registerHybridMethod("fullRequestStream", &HybridRestSpec::fullRequestStream);
+      prototype.registerHybridMethod("fullRequestStreamAsync", &HybridRestSpec::fullRequestStreamAsync);
+      prototype.registerHybridMethod("fullRequestString", &HybridRestSpec::fullRequestString);
+      prototype.registerHybridMethod("fullRequestStringAsync", &HybridRestSpec::fullRequestStringAsync);
+      prototype.registerHybridMethod("readRespBodyStream", &HybridRestSpec::readRespBodyStream);
+      prototype.registerHybridMethod("readRespBodyStreamAsync", &HybridRestSpec::readRespBodyStreamAsync);
+      prototype.registerHybridMethod("readRespBodyString", &HybridRestSpec::readRespBodyString);
+      prototype.registerHybridMethod("readRespBodyStringAsync", &HybridRestSpec::readRespBodyStringAsync);
+      prototype.registerHybridMethod("readResponseHeader", &HybridRestSpec::readResponseHeader);
+      prototype.registerHybridMethod("readResponseHeaderAsync", &HybridRestSpec::readResponseHeaderAsync);
+      prototype.registerHybridMethod("removeHeader", &HybridRestSpec::removeHeader);
+      prototype.registerHybridMethod("removeQueryParam", &HybridRestSpec::removeQueryParam);
+      prototype.registerHybridMethod("responseHdrByName", &HybridRestSpec::responseHdrByName);
+      prototype.registerHybridMethod("responseHdrName", &HybridRestSpec::responseHdrName);
+      prototype.registerHybridMethod("responseHdrValue", &HybridRestSpec::responseHdrValue);
+      prototype.registerHybridMethod("sendReqFormUrlEncoded", &HybridRestSpec::sendReqFormUrlEncoded);
+      prototype.registerHybridMethod("sendReqFormUrlEncodedAsync", &HybridRestSpec::sendReqFormUrlEncodedAsync);
+      prototype.registerHybridMethod("sendReqMultipart", &HybridRestSpec::sendReqMultipart);
+      prototype.registerHybridMethod("sendReqMultipartAsync", &HybridRestSpec::sendReqMultipartAsync);
+      prototype.registerHybridMethod("sendReqNoBody", &HybridRestSpec::sendReqNoBody);
+      prototype.registerHybridMethod("sendReqNoBodyAsync", &HybridRestSpec::sendReqNoBodyAsync);
+      prototype.registerHybridMethod("sendReqStreamBody", &HybridRestSpec::sendReqStreamBody);
+      prototype.registerHybridMethod("sendReqStreamBodyAsync", &HybridRestSpec::sendReqStreamBodyAsync);
+      prototype.registerHybridMethod("sendReqStringBody", &HybridRestSpec::sendReqStringBody);
+      prototype.registerHybridMethod("sendReqStringBodyAsync", &HybridRestSpec::sendReqStringBodyAsync);
+      prototype.registerHybridMethod("setAuthAws", &HybridRestSpec::setAuthAws);
+      prototype.registerHybridMethod("setAuthAzureStorage", &HybridRestSpec::setAuthAzureStorage);
+      prototype.registerHybridMethod("setAuthBasic", &HybridRestSpec::setAuthBasic);
+      prototype.registerHybridMethod("setAuthGoogle", &HybridRestSpec::setAuthGoogle);
+      prototype.registerHybridMethod("setAuthOAuth1", &HybridRestSpec::setAuthOAuth1);
+      prototype.registerHybridMethod("setAuthOAuth2", &HybridRestSpec::setAuthOAuth2);
+      prototype.registerHybridMethod("setMultipartBodyStream", &HybridRestSpec::setMultipartBodyStream);
+      prototype.registerHybridMethod("setMultipartBodyString", &HybridRestSpec::setMultipartBodyString);
+      prototype.registerHybridMethod("setResponseBodyStream", &HybridRestSpec::setResponseBodyStream);
+      prototype.registerHybridMethod("useConnection", &HybridRestSpec::useConnection);
+      prototype.registerHybridMethod("fullRequestSb", &HybridRestSpec::fullRequestSb);
+      prototype.registerHybridMethod("fullRequestSbAsync", &HybridRestSpec::fullRequestSbAsync);
+      prototype.registerHybridMethod("addQueryParamSb", &HybridRestSpec::addQueryParamSb);
+      prototype.registerHybridMethod("setMultipartBodySb", &HybridRestSpec::setMultipartBodySb);
+      prototype.registerHybridMethod("setMultipartBodyBd", &HybridRestSpec::setMultipartBodyBd);
+      prototype.registerHybridMethod("sendReqSb", &HybridRestSpec::sendReqSb);
+      prototype.registerHybridMethod("sendReqSbAsync", &HybridRestSpec::sendReqSbAsync);
+      prototype.registerHybridMethod("sendReqBd", &HybridRestSpec::sendReqBd);
+      prototype.registerHybridMethod("sendReqBdAsync", &HybridRestSpec::sendReqBdAsync);
+      prototype.registerHybridMethod("readRespSb", &HybridRestSpec::readRespSb);
+      prototype.registerHybridMethod("readRespSbAsync", &HybridRestSpec::readRespSbAsync);
+      prototype.registerHybridMethod("readRespBd", &HybridRestSpec::readRespBd);
+      prototype.registerHybridMethod("readRespBdAsync", &HybridRestSpec::readRespBdAsync);
+      prototype.registerHybridMethod("clearAllParts", &HybridRestSpec::clearAllParts);
+      prototype.registerHybridMethod("fullRequestNoBodySb", &HybridRestSpec::fullRequestNoBodySb);
+      prototype.registerHybridMethod("fullRequestNoBodySbAsync", &HybridRestSpec::fullRequestNoBodySbAsync);
+      prototype.registerHybridMethod("fullRequestBd", &HybridRestSpec::fullRequestBd);
+      prototype.registerHybridMethod("fullRequestBdAsync", &HybridRestSpec::fullRequestBdAsync);
+      prototype.registerHybridMethod("fullRequestNoBodyBd", &HybridRestSpec::fullRequestNoBodyBd);
+      prototype.registerHybridMethod("fullRequestNoBodyBdAsync", &HybridRestSpec::fullRequestNoBodyBdAsync);
+      prototype.registerHybridMethod("setAuthAzureSas", &HybridRestSpec::setAuthAzureSas);
+      prototype.registerHybridMethod("addMwsSignature", &HybridRestSpec::addMwsSignature);
+      prototype.registerHybridMethod("clearAuth", &HybridRestSpec::clearAuth);
+      prototype.registerHybridMethod("addPathParam", &HybridRestSpec::addPathParam);
+      prototype.registerHybridMethod("clearAllPathParams", &HybridRestSpec::clearAllPathParams);
+      prototype.registerHybridMethod("setAuthBasicSecure", &HybridRestSpec::setAuthBasicSecure);
+      prototype.registerHybridMethod("getLastDebugRequest", &HybridRestSpec::getLastDebugRequest);
+      prototype.registerHybridMethod("readRespChunkBd", &HybridRestSpec::readRespChunkBd);
+      prototype.registerHybridMethod("readRespChunkBdAsync", &HybridRestSpec::readRespChunkBdAsync);
+      prototype.registerHybridMethod("getLastJsonData", &HybridRestSpec::getLastJsonData);
+      prototype.registerHybridMethod("abort", &HybridRestSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat