@chilkat/react-native 11.6.1

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

@@ -0,0 +1,115 @@
+///
+/// HybridCkDateTimeSpec.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 `HybridDtObjSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridDtObjSpec; }
+// Forward declaration of `HybridCkDateTimeSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridCkDateTimeSpec; }
+// Forward declaration of `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridDtObjSpec.hpp"
+#include "HybridCkDateTimeSpec.hpp"
+#include "HybridStringBuilderSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `CkDateTime`
+   * Inherit this class to create instances of `HybridCkDateTimeSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCkDateTime: public HybridCkDateTimeSpec {
+   * public:
+   *   HybridCkDateTime(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCkDateTimeSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCkDateTimeSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCkDateTimeSpec() 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 getIsDst() = 0;
+      virtual double getUtcOffset() = 0;
+
+    public:
+      // Methods
+      virtual void addDays(double numDays) = 0;
+      virtual void deSerialize(const std::string& serializedDateTime) = 0;
+      virtual double getAsDateTimeTicks(bool bLocal) = 0;
+      virtual double getAsDosDate(bool bLocal) = 0;
+      virtual double getAsOleDate(bool bLocal) = 0;
+      virtual std::string getAsRfc822(bool bLocal) = 0;
+      virtual double getAsUnixTime(bool bLocal) = 0;
+      virtual double getAsUnixTime64(bool bLocal) = 0;
+      virtual double getAsUnixTimeDbl(bool bLocal) = 0;
+      virtual std::string serialize() = 0;
+      virtual void setFromCurrentSystemTime() = 0;
+      virtual void setFromDateTimeTicks(bool bLocal, double ticks) = 0;
+      virtual void setFromDosDate(bool bLocal, double t) = 0;
+      virtual void setFromDtObj(const std::shared_ptr<HybridDtObjSpec>& dt) = 0;
+      virtual void setFromNtpTime(double ntpSeconds) = 0;
+      virtual void setFromOleDate(bool bLocal, double dt) = 0;
+      virtual void setFromRfc822(const std::string& rfc822Str) = 0;
+      virtual void setFromUnixTime(bool bLocal, double t) = 0;
+      virtual void setFromUnixTime64(bool bLocal, double t) = 0;
+      virtual void setFromUnixTimeDbl(bool bLocal, double d) = 0;
+      virtual void setFromTimestamp(const std::string& timestamp) = 0;
+      virtual std::string getAsTimestamp(bool bLocal) = 0;
+      virtual double diffSeconds(const std::shared_ptr<HybridCkDateTimeSpec>& dateTimeArg) = 0;
+      virtual void addSeconds(double numSeconds) = 0;
+      virtual std::string getAsUnixTimeStr(bool bLocal) = 0;
+      virtual std::string getAsIso8601(const std::string& formatStr, bool bLocal) = 0;
+      virtual bool expiresWithin(double n, const std::string& units) = 0;
+      virtual bool olderThan(double n, const std::string& units) = 0;
+      virtual void ulidValidate(const std::string& ulid) = 0;
+      virtual std::string ulidGenerate(bool bLocal) = 0;
+      virtual void setFromUlid(bool bLocal, const std::string& ulid) = 0;
+      virtual void ulidIncrement(const std::shared_ptr<HybridStringBuilderSpec>& ulid) = 0;
+      virtual void setFromNtpServer(const std::string& jsonStr) = 0;
+      virtual void toDtObj(bool bLocal, const std::shared_ptr<HybridDtObjSpec>& dtObj) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "CkDateTime";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,44 @@
+///
+/// HybridCodeSignSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridCodeSignSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridCodeSignSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridCodeSignSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridCodeSignSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridCodeSignSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridCodeSignSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridCodeSignSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridCodeSignSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridCodeSignSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridCodeSignSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridCodeSignSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridCodeSignSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("uncommonOptions", &HybridCodeSignSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridCodeSignSpec::setUncommonOptions);
+      prototype.registerHybridGetter("heartbeatMs", &HybridCodeSignSpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridCodeSignSpec::setHeartbeatMs);
+      prototype.registerHybridGetter("onPercentDone", &HybridCodeSignSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridCodeSignSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridCodeSignSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridCodeSignSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("verifySignature", &HybridCodeSignSpec::verifySignature);
+      prototype.registerHybridMethod("removeSignature", &HybridCodeSignSpec::removeSignature);
+      prototype.registerHybridMethod("addSignature", &HybridCodeSignSpec::addSignature);
+      prototype.registerHybridMethod("addSignatureAsync", &HybridCodeSignSpec::addSignatureAsync);
+      prototype.registerHybridMethod("getSignerCert", &HybridCodeSignSpec::getSignerCert);
+      prototype.registerHybridMethod("abort", &HybridCodeSignSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,93 @@
+///
+/// HybridCodeSignSpec.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 `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+// Forward declaration of `HybridCertSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridCertSpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <memory>
+#include "HybridJsonObjectSpec.hpp"
+#include "HybridCertSpec.hpp"
+#include <NitroModules/Promise.hpp>
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `CodeSign`
+   * Inherit this class to create instances of `HybridCodeSignSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCodeSign: public HybridCodeSignSpec {
+   * public:
+   *   HybridCodeSign(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCodeSignSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCodeSignSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCodeSignSpec() 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 getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+      virtual double getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 0;
+      virtual std::optional<std::function<void(double /* pctDone */)>> getOnPercentDone() = 0;
+      virtual void setOnPercentDone(const std::optional<std::function<void(double /* pctDone */)>>& onPercentDone) = 0;
+      virtual std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>> getOnProgressInfo() = 0;
+      virtual void setOnProgressInfo(const std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>>& onProgressInfo) = 0;
+
+    public:
+      // Methods
+      virtual void verifySignature(const std::string& path, const std::shared_ptr<HybridJsonObjectSpec>& sigInfo) = 0;
+      virtual void removeSignature(const std::string& path) = 0;
+      virtual void addSignature(const std::string& path, const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridJsonObjectSpec>& options) = 0;
+      virtual std::shared_ptr<Promise<void>> addSignatureAsync(const std::string& path, const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridJsonObjectSpec>& options) = 0;
+      virtual void getSignerCert(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "CodeSign";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,79 @@
+///
+/// HybridCompressionSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridCompressionSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridCompressionSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridCompressionSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridCompressionSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridCompressionSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridCompressionSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridCompressionSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridCompressionSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridCompressionSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridCompressionSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridCompressionSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridCompressionSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("algorithm", &HybridCompressionSpec::getAlgorithm);
+      prototype.registerHybridSetter("algorithm", &HybridCompressionSpec::setAlgorithm);
+      prototype.registerHybridGetter("charset", &HybridCompressionSpec::getCharset);
+      prototype.registerHybridSetter("charset", &HybridCompressionSpec::setCharset);
+      prototype.registerHybridGetter("encodingMode", &HybridCompressionSpec::getEncodingMode);
+      prototype.registerHybridSetter("encodingMode", &HybridCompressionSpec::setEncodingMode);
+      prototype.registerHybridGetter("heartbeatMs", &HybridCompressionSpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridCompressionSpec::setHeartbeatMs);
+      prototype.registerHybridGetter("deflateLevel", &HybridCompressionSpec::getDeflateLevel);
+      prototype.registerHybridSetter("deflateLevel", &HybridCompressionSpec::setDeflateLevel);
+      prototype.registerHybridGetter("uncommonOptions", &HybridCompressionSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridCompressionSpec::setUncommonOptions);
+      prototype.registerHybridGetter("firstChunk", &HybridCompressionSpec::getFirstChunk);
+      prototype.registerHybridSetter("firstChunk", &HybridCompressionSpec::setFirstChunk);
+      prototype.registerHybridGetter("lastChunk", &HybridCompressionSpec::getLastChunk);
+      prototype.registerHybridSetter("lastChunk", &HybridCompressionSpec::setLastChunk);
+      prototype.registerHybridGetter("onPercentDone", &HybridCompressionSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridCompressionSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridCompressionSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridCompressionSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("compressFile", &HybridCompressionSpec::compressFile);
+      prototype.registerHybridMethod("compressFileAsync", &HybridCompressionSpec::compressFileAsync);
+      prototype.registerHybridMethod("compressStream", &HybridCompressionSpec::compressStream);
+      prototype.registerHybridMethod("compressStreamAsync", &HybridCompressionSpec::compressStreamAsync);
+      prototype.registerHybridMethod("compressStringENC", &HybridCompressionSpec::compressStringENC);
+      prototype.registerHybridMethod("compressStringENCAsync", &HybridCompressionSpec::compressStringENCAsync);
+      prototype.registerHybridMethod("decompressFile", &HybridCompressionSpec::decompressFile);
+      prototype.registerHybridMethod("decompressFileAsync", &HybridCompressionSpec::decompressFileAsync);
+      prototype.registerHybridMethod("decompressStream", &HybridCompressionSpec::decompressStream);
+      prototype.registerHybridMethod("decompressStreamAsync", &HybridCompressionSpec::decompressStreamAsync);
+      prototype.registerHybridMethod("decompressStringENC", &HybridCompressionSpec::decompressStringENC);
+      prototype.registerHybridMethod("decompressStringENCAsync", &HybridCompressionSpec::decompressStringENCAsync);
+      prototype.registerHybridMethod("compressBd", &HybridCompressionSpec::compressBd);
+      prototype.registerHybridMethod("compressBdAsync", &HybridCompressionSpec::compressBdAsync);
+      prototype.registerHybridMethod("decompressBd", &HybridCompressionSpec::decompressBd);
+      prototype.registerHybridMethod("decompressBdAsync", &HybridCompressionSpec::decompressBdAsync);
+      prototype.registerHybridMethod("compressSb", &HybridCompressionSpec::compressSb);
+      prototype.registerHybridMethod("compressSbAsync", &HybridCompressionSpec::compressSbAsync);
+      prototype.registerHybridMethod("decompressSb", &HybridCompressionSpec::decompressSb);
+      prototype.registerHybridMethod("decompressSbAsync", &HybridCompressionSpec::decompressSbAsync);
+      prototype.registerHybridMethod("compressEncryptFile", &HybridCompressionSpec::compressEncryptFile);
+      prototype.registerHybridMethod("compressEncryptFileAsync", &HybridCompressionSpec::compressEncryptFileAsync);
+      prototype.registerHybridMethod("decryptDecompressFile", &HybridCompressionSpec::decryptDecompressFile);
+      prototype.registerHybridMethod("decryptDecompressFileAsync", &HybridCompressionSpec::decryptDecompressFileAsync);
+      prototype.registerHybridMethod("compressBd2", &HybridCompressionSpec::compressBd2);
+      prototype.registerHybridMethod("compressBd2Async", &HybridCompressionSpec::compressBd2Async);
+      prototype.registerHybridMethod("decompressBd2", &HybridCompressionSpec::decompressBd2);
+      prototype.registerHybridMethod("decompressBd2Async", &HybridCompressionSpec::decompressBd2Async);
+      prototype.registerHybridMethod("abort", &HybridCompressionSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,134 @@
+///
+/// HybridCompressionSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridStreamSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStreamSpec; }
+// Forward declaration of `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; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include "HybridStreamSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+#include "HybridStringBuilderSpec.hpp"
+#include "HybridJsonObjectSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Compression`
+   * Inherit this class to create instances of `HybridCompressionSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCompression: public HybridCompressionSpec {
+   * public:
+   *   HybridCompression(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCompressionSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCompressionSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCompressionSpec() 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 getAlgorithm() = 0;
+      virtual void setAlgorithm(const std::string& algorithm) = 0;
+      virtual std::string getCharset() = 0;
+      virtual void setCharset(const std::string& charset) = 0;
+      virtual std::string getEncodingMode() = 0;
+      virtual void setEncodingMode(const std::string& encodingMode) = 0;
+      virtual double getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 0;
+      virtual double getDeflateLevel() = 0;
+      virtual void setDeflateLevel(double deflateLevel) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+      virtual bool getFirstChunk() = 0;
+      virtual void setFirstChunk(bool firstChunk) = 0;
+      virtual bool getLastChunk() = 0;
+      virtual void setLastChunk(bool lastChunk) = 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 compressFile(const std::string& srcPath, const std::string& destPath) = 0;
+      virtual std::shared_ptr<Promise<void>> compressFileAsync(const std::string& srcPath, const std::string& destPath) = 0;
+      virtual void compressStream(const std::shared_ptr<HybridStreamSpec>& strm) = 0;
+      virtual std::shared_ptr<Promise<void>> compressStreamAsync(const std::shared_ptr<HybridStreamSpec>& strm) = 0;
+      virtual std::string compressStringENC(const std::string& str) = 0;
+      virtual std::shared_ptr<Promise<std::string>> compressStringENCAsync(const std::string& str) = 0;
+      virtual void decompressFile(const std::string& srcPath, const std::string& destPath) = 0;
+      virtual std::shared_ptr<Promise<void>> decompressFileAsync(const std::string& srcPath, const std::string& destPath) = 0;
+      virtual void decompressStream(const std::shared_ptr<HybridStreamSpec>& strm) = 0;
+      virtual std::shared_ptr<Promise<void>> decompressStreamAsync(const std::shared_ptr<HybridStreamSpec>& strm) = 0;
+      virtual std::string decompressStringENC(const std::string& encodedCompressedData) = 0;
+      virtual std::shared_ptr<Promise<std::string>> decompressStringENCAsync(const std::string& encodedCompressedData) = 0;
+      virtual void compressBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual std::shared_ptr<Promise<void>> compressBdAsync(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void decompressBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual std::shared_ptr<Promise<void>> decompressBdAsync(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void compressSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual std::shared_ptr<Promise<void>> compressSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual void decompressSb(const std::shared_ptr<HybridBinDataSpec>& binData, const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual std::shared_ptr<Promise<void>> decompressSbAsync(const std::shared_ptr<HybridBinDataSpec>& binData, const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void compressEncryptFile(const std::shared_ptr<HybridJsonObjectSpec>& cryptParams, const std::string& srcPath, const std::string& destPath) = 0;
+      virtual std::shared_ptr<Promise<void>> compressEncryptFileAsync(const std::shared_ptr<HybridJsonObjectSpec>& cryptParams, const std::string& srcPath, const std::string& destPath) = 0;
+      virtual void decryptDecompressFile(const std::shared_ptr<HybridJsonObjectSpec>& cryptParams, const std::string& srcPath, const std::string& destPath) = 0;
+      virtual std::shared_ptr<Promise<void>> decryptDecompressFileAsync(const std::shared_ptr<HybridJsonObjectSpec>& cryptParams, const std::string& srcPath, const std::string& destPath) = 0;
+      virtual void compressBd2(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridBinDataSpec>& bdOut) = 0;
+      virtual std::shared_ptr<Promise<void>> compressBd2Async(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridBinDataSpec>& bdOut) = 0;
+      virtual void decompressBd2(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridBinDataSpec>& bdOut) = 0;
+      virtual std::shared_ptr<Promise<void>> decompressBd2Async(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridBinDataSpec>& bdOut) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Compression";
+  };
+
+} // namespace margelo::nitro::chilkat