@chilkat/react-native 11.6.1

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

@@ -0,0 +1,38 @@
+///
+/// HybridAuthAzureSASSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridAuthAzureSASSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridAuthAzureSASSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridAuthAzureSASSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridAuthAzureSASSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridAuthAzureSASSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridAuthAzureSASSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridAuthAzureSASSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridAuthAzureSASSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridAuthAzureSASSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridAuthAzureSASSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridAuthAzureSASSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridAuthAzureSASSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("stringToSign", &HybridAuthAzureSASSpec::getStringToSign);
+      prototype.registerHybridSetter("stringToSign", &HybridAuthAzureSASSpec::setStringToSign);
+      prototype.registerHybridGetter("accessKey", &HybridAuthAzureSASSpec::getAccessKey);
+      prototype.registerHybridSetter("accessKey", &HybridAuthAzureSASSpec::setAccessKey);
+      prototype.registerHybridMethod("setTokenParam", &HybridAuthAzureSASSpec::setTokenParam);
+      prototype.registerHybridMethod("setNonTokenParam", &HybridAuthAzureSASSpec::setNonTokenParam);
+      prototype.registerHybridMethod("generateToken", &HybridAuthAzureSASSpec::generateToken);
+      prototype.registerHybridMethod("clear", &HybridAuthAzureSASSpec::clear);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,78 @@
+///
+/// HybridAuthAzureSASSpec.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
+
+
+
+#include <string>
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `AuthAzureSAS`
+   * Inherit this class to create instances of `HybridAuthAzureSASSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridAuthAzureSAS: public HybridAuthAzureSASSpec {
+   * public:
+   *   HybridAuthAzureSAS(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridAuthAzureSASSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridAuthAzureSASSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridAuthAzureSASSpec() 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 getStringToSign() = 0;
+      virtual void setStringToSign(const std::string& stringToSign) = 0;
+      virtual std::string getAccessKey() = 0;
+      virtual void setAccessKey(const std::string& accessKey) = 0;
+
+    public:
+      // Methods
+      virtual void setTokenParam(const std::string& name, const std::string& authParamName, const std::string& value) = 0;
+      virtual void setNonTokenParam(const std::string& name, const std::string& value) = 0;
+      virtual std::string generateToken() = 0;
+      virtual void clear() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "AuthAzureSAS";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,41 @@
+///
+/// HybridAuthAzureStorageSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridAuthAzureStorageSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridAuthAzureStorageSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridAuthAzureStorageSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridAuthAzureStorageSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridAuthAzureStorageSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridAuthAzureStorageSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridAuthAzureStorageSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridAuthAzureStorageSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridAuthAzureStorageSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridAuthAzureStorageSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridAuthAzureStorageSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridAuthAzureStorageSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("accessKey", &HybridAuthAzureStorageSpec::getAccessKey);
+      prototype.registerHybridSetter("accessKey", &HybridAuthAzureStorageSpec::setAccessKey);
+      prototype.registerHybridGetter("account", &HybridAuthAzureStorageSpec::getAccount);
+      prototype.registerHybridSetter("account", &HybridAuthAzureStorageSpec::setAccount);
+      prototype.registerHybridGetter("scheme", &HybridAuthAzureStorageSpec::getScheme);
+      prototype.registerHybridSetter("scheme", &HybridAuthAzureStorageSpec::setScheme);
+      prototype.registerHybridGetter("service", &HybridAuthAzureStorageSpec::getService);
+      prototype.registerHybridSetter("service", &HybridAuthAzureStorageSpec::setService);
+      prototype.registerHybridGetter("xMsVersion", &HybridAuthAzureStorageSpec::getXMsVersion);
+      prototype.registerHybridSetter("xMsVersion", &HybridAuthAzureStorageSpec::setXMsVersion);
+      prototype.registerHybridMethod("noop", &HybridAuthAzureStorageSpec::noop);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,81 @@
+///
+/// HybridAuthAzureStorageSpec.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
+
+
+
+#include <string>
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `AuthAzureStorage`
+   * Inherit this class to create instances of `HybridAuthAzureStorageSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridAuthAzureStorage: public HybridAuthAzureStorageSpec {
+   * public:
+   *   HybridAuthAzureStorage(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridAuthAzureStorageSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridAuthAzureStorageSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridAuthAzureStorageSpec() 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 getAccessKey() = 0;
+      virtual void setAccessKey(const std::string& accessKey) = 0;
+      virtual std::string getAccount() = 0;
+      virtual void setAccount(const std::string& account) = 0;
+      virtual std::string getScheme() = 0;
+      virtual void setScheme(const std::string& scheme) = 0;
+      virtual std::string getService() = 0;
+      virtual void setService(const std::string& service) = 0;
+      virtual std::string getXMsVersion() = 0;
+      virtual void setXMsVersion(const std::string& xMsVersion) = 0;
+
+    public:
+      // Methods
+      virtual void noop() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "AuthAzureStorage";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,56 @@
+///
+/// HybridAuthGoogleSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridAuthGoogleSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridAuthGoogleSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridAuthGoogleSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridAuthGoogleSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridAuthGoogleSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridAuthGoogleSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridAuthGoogleSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridAuthGoogleSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridAuthGoogleSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridAuthGoogleSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridAuthGoogleSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridAuthGoogleSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("accessToken", &HybridAuthGoogleSpec::getAccessToken);
+      prototype.registerHybridSetter("accessToken", &HybridAuthGoogleSpec::setAccessToken);
+      prototype.registerHybridGetter("emailAddress", &HybridAuthGoogleSpec::getEmailAddress);
+      prototype.registerHybridSetter("emailAddress", &HybridAuthGoogleSpec::setEmailAddress);
+      prototype.registerHybridGetter("expireNumSeconds", &HybridAuthGoogleSpec::getExpireNumSeconds);
+      prototype.registerHybridSetter("expireNumSeconds", &HybridAuthGoogleSpec::setExpireNumSeconds);
+      prototype.registerHybridGetter("jsonKey", &HybridAuthGoogleSpec::getJsonKey);
+      prototype.registerHybridSetter("jsonKey", &HybridAuthGoogleSpec::setJsonKey);
+      prototype.registerHybridGetter("numSecondsRemaining", &HybridAuthGoogleSpec::getNumSecondsRemaining);
+      prototype.registerHybridGetter("scope", &HybridAuthGoogleSpec::getScope);
+      prototype.registerHybridSetter("scope", &HybridAuthGoogleSpec::setScope);
+      prototype.registerHybridGetter("subEmailAddress", &HybridAuthGoogleSpec::getSubEmailAddress);
+      prototype.registerHybridSetter("subEmailAddress", &HybridAuthGoogleSpec::setSubEmailAddress);
+      prototype.registerHybridGetter("valid", &HybridAuthGoogleSpec::getValid);
+      prototype.registerHybridGetter("iat", &HybridAuthGoogleSpec::getIat);
+      prototype.registerHybridSetter("iat", &HybridAuthGoogleSpec::setIat);
+      prototype.registerHybridGetter("onPercentDone", &HybridAuthGoogleSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridAuthGoogleSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridAuthGoogleSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridAuthGoogleSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("getP12", &HybridAuthGoogleSpec::getP12);
+      prototype.registerHybridMethod("obtainAccessToken", &HybridAuthGoogleSpec::obtainAccessToken);
+      prototype.registerHybridMethod("obtainAccessTokenAsync", &HybridAuthGoogleSpec::obtainAccessTokenAsync);
+      prototype.registerHybridMethod("setP12", &HybridAuthGoogleSpec::setP12);
+      prototype.registerHybridMethod("addClaims", &HybridAuthGoogleSpec::addClaims);
+      prototype.registerHybridMethod("abort", &HybridAuthGoogleSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,108 @@
+///
+/// HybridAuthGoogleSpec.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 `HybridPfxSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPfxSpec; }
+// Forward declaration of `HybridSocketSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridSocketSpec; }
+// Forward declaration of `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <memory>
+#include "HybridPfxSpec.hpp"
+#include "HybridSocketSpec.hpp"
+#include <NitroModules/Promise.hpp>
+#include "HybridJsonObjectSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `AuthGoogle`
+   * Inherit this class to create instances of `HybridAuthGoogleSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridAuthGoogle: public HybridAuthGoogleSpec {
+   * public:
+   *   HybridAuthGoogle(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridAuthGoogleSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridAuthGoogleSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridAuthGoogleSpec() 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 getAccessToken() = 0;
+      virtual void setAccessToken(const std::string& accessToken) = 0;
+      virtual std::string getEmailAddress() = 0;
+      virtual void setEmailAddress(const std::string& emailAddress) = 0;
+      virtual double getExpireNumSeconds() = 0;
+      virtual void setExpireNumSeconds(double expireNumSeconds) = 0;
+      virtual std::string getJsonKey() = 0;
+      virtual void setJsonKey(const std::string& jsonKey) = 0;
+      virtual double getNumSecondsRemaining() = 0;
+      virtual std::string getScope() = 0;
+      virtual void setScope(const std::string& scope) = 0;
+      virtual std::string getSubEmailAddress() = 0;
+      virtual void setSubEmailAddress(const std::string& subEmailAddress) = 0;
+      virtual bool getValid() = 0;
+      virtual double getIat() = 0;
+      virtual void setIat(double iat) = 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::shared_ptr<HybridPfxSpec> getP12() = 0;
+      virtual void obtainAccessToken(const std::shared_ptr<HybridSocketSpec>& connection) = 0;
+      virtual std::shared_ptr<Promise<void>> obtainAccessTokenAsync(const std::shared_ptr<HybridSocketSpec>& connection) = 0;
+      virtual void setP12(const std::shared_ptr<HybridPfxSpec>& key) = 0;
+      virtual void addClaims(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 = "AuthGoogle";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,69 @@
+///
+/// HybridBinDataSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridBinDataSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridBinDataSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridBinDataSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridBinDataSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridBinDataSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridBinDataSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridBinDataSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridBinDataSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridBinDataSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridBinDataSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridBinDataSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridBinDataSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("numBytes", &HybridBinDataSpec::getNumBytes);
+      prototype.registerHybridMethod("loadEncoded", &HybridBinDataSpec::loadEncoded);
+      prototype.registerHybridMethod("getEncoded", &HybridBinDataSpec::getEncoded);
+      prototype.registerHybridMethod("appendEncoded", &HybridBinDataSpec::appendEncoded);
+      prototype.registerHybridMethod("clear", &HybridBinDataSpec::clear);
+      prototype.registerHybridMethod("loadFile", &HybridBinDataSpec::loadFile);
+      prototype.registerHybridMethod("getEncodedChunk", &HybridBinDataSpec::getEncodedChunk);
+      prototype.registerHybridMethod("removeChunk", &HybridBinDataSpec::removeChunk);
+      prototype.registerHybridMethod("writeFile", &HybridBinDataSpec::writeFile);
+      prototype.registerHybridMethod("getEncodedSb", &HybridBinDataSpec::getEncodedSb);
+      prototype.registerHybridMethod("appendBd", &HybridBinDataSpec::appendBd);
+      prototype.registerHybridMethod("appendString", &HybridBinDataSpec::appendString);
+      prototype.registerHybridMethod("appendSb", &HybridBinDataSpec::appendSb);
+      prototype.registerHybridMethod("appendBom", &HybridBinDataSpec::appendBom);
+      prototype.registerHybridMethod("appendEncodedSb", &HybridBinDataSpec::appendEncodedSb);
+      prototype.registerHybridMethod("contentsEqual", &HybridBinDataSpec::contentsEqual);
+      prototype.registerHybridMethod("secureClear", &HybridBinDataSpec::secureClear);
+      prototype.registerHybridMethod("getString", &HybridBinDataSpec::getString);
+      prototype.registerHybridMethod("appendByte", &HybridBinDataSpec::appendByte);
+      prototype.registerHybridMethod("appendInt4", &HybridBinDataSpec::appendInt4);
+      prototype.registerHybridMethod("appendInt2", &HybridBinDataSpec::appendInt2);
+      prototype.registerHybridMethod("appendPadded", &HybridBinDataSpec::appendPadded);
+      prototype.registerHybridMethod("findString", &HybridBinDataSpec::findString);
+      prototype.registerHybridMethod("getTextChunk", &HybridBinDataSpec::getTextChunk);
+      prototype.registerHybridMethod("getInt2", &HybridBinDataSpec::getInt2);
+      prototype.registerHybridMethod("getInt4", &HybridBinDataSpec::getInt4);
+      prototype.registerHybridMethod("getUInt2", &HybridBinDataSpec::getUInt2);
+      prototype.registerHybridMethod("getUInt4", &HybridBinDataSpec::getUInt4);
+      prototype.registerHybridMethod("removeByteVal", &HybridBinDataSpec::removeByteVal);
+      prototype.registerHybridMethod("writeAppendFile", &HybridBinDataSpec::writeAppendFile);
+      prototype.registerHybridMethod("getHash", &HybridBinDataSpec::getHash);
+      prototype.registerHybridMethod("appendCountedString", &HybridBinDataSpec::appendCountedString);
+      prototype.registerHybridMethod("getByte", &HybridBinDataSpec::getByte);
+      prototype.registerHybridMethod("isValidUtf8", &HybridBinDataSpec::isValidUtf8);
+      prototype.registerHybridMethod("byteSwap", &HybridBinDataSpec::byteSwap);
+      prototype.registerHybridMethod("charsetConvert", &HybridBinDataSpec::charsetConvert);
+      prototype.registerHybridMethod("appendData", &HybridBinDataSpec::appendData);
+      prototype.registerHybridMethod("getData", &HybridBinDataSpec::getData);
+      prototype.registerHybridMethod("getDataChunk", &HybridBinDataSpec::getDataChunk);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,116 @@
+///
+/// HybridBinDataSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridStringBuilderSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `BinData`
+   * Inherit this class to create instances of `HybridBinDataSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridBinData: public HybridBinDataSpec {
+   * public:
+   *   HybridBinData(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridBinDataSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridBinDataSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridBinDataSpec() 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 getNumBytes() = 0;
+
+    public:
+      // Methods
+      virtual void loadEncoded(const std::string& encData, const std::string& encoding) = 0;
+      virtual std::string getEncoded(const std::string& encoding) = 0;
+      virtual void appendEncoded(const std::string& encData, const std::string& encoding) = 0;
+      virtual void clear() = 0;
+      virtual void loadFile(const std::string& path) = 0;
+      virtual std::string getEncodedChunk(double offset, double numBytes, const std::string& encoding) = 0;
+      virtual void removeChunk(double offset, double numBytes) = 0;
+      virtual void writeFile(const std::string& path) = 0;
+      virtual void getEncodedSb(const std::string& encoding, const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void appendBd(const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual void appendString(const std::string& str, const std::string& charset) = 0;
+      virtual void appendSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset) = 0;
+      virtual void appendBom(const std::string& charset) = 0;
+      virtual void appendEncodedSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& encoding) = 0;
+      virtual bool contentsEqual(const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual void secureClear() = 0;
+      virtual std::string getString(const std::string& charset) = 0;
+      virtual void appendByte(double byteValue) = 0;
+      virtual void appendInt4(double value, bool littleEndian) = 0;
+      virtual void appendInt2(double value, bool littleEndian) = 0;
+      virtual void appendPadded(const std::string& str, const std::string& charset, bool padWithSpace, double fieldLen) = 0;
+      virtual double findString(const std::string& str, double startIdx, const std::string& charset) = 0;
+      virtual std::string getTextChunk(double startIdx, double numBytes, const std::string& charset) = 0;
+      virtual double getInt2(double index, bool littleEndian) = 0;
+      virtual double getInt4(double index, bool littleEndian) = 0;
+      virtual double getUInt2(double index, bool littleEndian) = 0;
+      virtual double getUInt4(double index, bool littleEndian) = 0;
+      virtual void removeByteVal(double value) = 0;
+      virtual void writeAppendFile(const std::string& path) = 0;
+      virtual std::string getHash(const std::string& algorithm, const std::string& encoding) = 0;
+      virtual void appendCountedString(double numCountBytes, bool bigEndian, const std::string& str, const std::string& charset) = 0;
+      virtual double getByte(double index) = 0;
+      virtual bool isValidUtf8() = 0;
+      virtual void byteSwap(double size) = 0;
+      virtual void charsetConvert(const std::string& fromCharset, const std::string& toCharset, bool allOrNone) = 0;
+      virtual void appendData(const std::shared_ptr<ArrayBuffer>& data) = 0;
+      virtual std::shared_ptr<ArrayBuffer> getData() = 0;
+      virtual std::shared_ptr<ArrayBuffer> getDataChunk(double offset, double numBytes) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "BinData";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,47 @@
+///
+/// HybridBz2Spec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridBz2Spec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridBz2Spec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridBz2Spec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridBz2Spec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridBz2Spec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridBz2Spec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridBz2Spec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridBz2Spec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridBz2Spec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridBz2Spec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridBz2Spec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridBz2Spec::setLastMethodSuccess);
+      prototype.registerHybridGetter("heartbeatMs", &HybridBz2Spec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridBz2Spec::setHeartbeatMs);
+      prototype.registerHybridGetter("abortCurrent", &HybridBz2Spec::getAbortCurrent);
+      prototype.registerHybridSetter("abortCurrent", &HybridBz2Spec::setAbortCurrent);
+      prototype.registerHybridGetter("onPercentDone", &HybridBz2Spec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridBz2Spec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridBz2Spec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridBz2Spec::setOnProgressInfo);
+      prototype.registerHybridMethod("compressFile", &HybridBz2Spec::compressFile);
+      prototype.registerHybridMethod("compressFileAsync", &HybridBz2Spec::compressFileAsync);
+      prototype.registerHybridMethod("uncompressFile", &HybridBz2Spec::uncompressFile);
+      prototype.registerHybridMethod("uncompressFileAsync", &HybridBz2Spec::uncompressFileAsync);
+      prototype.registerHybridMethod("compressBd", &HybridBz2Spec::compressBd);
+      prototype.registerHybridMethod("compressBdAsync", &HybridBz2Spec::compressBdAsync);
+      prototype.registerHybridMethod("uncompressBd", &HybridBz2Spec::uncompressBd);
+      prototype.registerHybridMethod("uncompressBdAsync", &HybridBz2Spec::uncompressBdAsync);
+      prototype.registerHybridMethod("abort", &HybridBz2Spec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat