@chilkat/react-native 11.6.1 → 11.7.0

package/cpp/HybridPdf.hpp

@@ -37,6 +37,8 @@ public:
   void setOwnerPassword(const std::string& value) override;
   std::string getUserPassword() override;
   void setUserPassword(const std::string& value) override;
+  bool getPreserveSignatures() override;
+  void setPreserveSignatures(bool value) override;
 
   // ---- Methods ----
   void loadFile(const std::string& filePath) override;
@@ -56,15 +58,32 @@ public:
   void getMetadata(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
   void addVerificationInfo(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions, const std::string& outFilePath) override;
   std::shared_ptr<Promise<void>> addVerificationInfoAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions, const std::string& outFilePath) override;
+  void addVerificationInfo2(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions) override;
   void signPdfBd(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions, const std::shared_ptr<HybridBinDataSpec>& bd) override;
   std::shared_ptr<Promise<void>> signPdfBdAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void signPdf2(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions) override;
   void getEmbeddedFileInfo(double index, const std::shared_ptr<HybridJsonObjectSpec>& json) override;
   void getEmbeddedFileBd(double index, const std::shared_ptr<HybridBinDataSpec>& bd) override;
   void addEmbeddedFiles(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::string& outFilePath) override;
   void addEmbeddedFilesBd(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridBinDataSpec>& bd) override;
   void updateMetadata(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& outFilePath) override;
+  void updateMetadata2(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
   void updateMetadataBd(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::shared_ptr<HybridBinDataSpec>& bd) override;
   void getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void optimize(const std::string& op, const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) override;
+  void writeFile(const std::string& path) override;
+  void writeBd(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void watermark(const std::string& op, const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) override;
+  void protection(const std::string& op, const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) override;
+  void extractText(const std::string& op, const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) override;
+  void extractTextSb(const std::string& op, const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridStringBuilderSpec>& sbOut, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) override;
+  void addEncryptCert(const std::shared_ptr<HybridCertSpec>& cert) override;
+  void clearEncryptCerts() override;
+  void setDecryptCert(const std::shared_ptr<HybridCertSpec>& cert) override;
+  void preLoadCheck(const std::string& path, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) override;
+  void preLoadCheckBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) override;
+  void textReplace(const std::string& op, const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) override;
+  void addEmbeddedFiles2(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
 
   // ---- Events (ReactNativeGen_DESIGN.md §6) ----
   std::optional<std::function<void(double)>> getOnPercentDone() override;
@@ -90,14 +109,31 @@ private:
   void getSignatureContent_impl(double index, const std::shared_ptr<HybridBinDataSpec>& bd);
   void getMetadata_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
   void addVerificationInfo_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions, const std::string& outFilePath);
+  void addVerificationInfo2_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions);
   void signPdfBd_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions, const std::shared_ptr<HybridBinDataSpec>& bd);
+  void signPdf2_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions);
   void getEmbeddedFileInfo_impl(double index, const std::shared_ptr<HybridJsonObjectSpec>& json);
   void getEmbeddedFileBd_impl(double index, const std::shared_ptr<HybridBinDataSpec>& bd);
   void addEmbeddedFiles_impl(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::string& outFilePath);
   void addEmbeddedFilesBd_impl(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridBinDataSpec>& bd);
   void updateMetadata_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& outFilePath);
+  void updateMetadata2_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
   void updateMetadataBd_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::shared_ptr<HybridBinDataSpec>& bd);
   void getLastJsonData_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void optimize_impl(const std::string& op, const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut);
+  void writeFile_impl(const std::string& path);
+  void writeBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+  void watermark_impl(const std::string& op, const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut);
+  void protection_impl(const std::string& op, const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut);
+  void extractText_impl(const std::string& op, const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut);
+  void extractTextSb_impl(const std::string& op, const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridStringBuilderSpec>& sbOut, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut);
+  void addEncryptCert_impl(const std::shared_ptr<HybridCertSpec>& cert);
+  void clearEncryptCerts_impl();
+  void setDecryptCert_impl(const std::shared_ptr<HybridCertSpec>& cert);
+  void preLoadCheck_impl(const std::string& path, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut);
+  void preLoadCheckBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut);
+  void textReplace_impl(const std::string& op, const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut);
+  void addEmbeddedFiles2_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
 };
 
 } // namespace margelo::nitro::chilkat

package/cpp/HybridSocket.cpp

@@ -617,6 +617,37 @@ double HybridSocket::getNumBytesAvailable() {
   this->beginCall();
   return static_cast<double>(this->ck().get_NumBytesAvailable());
 }
+std::string HybridSocket::getAlpnProtocols() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AlpnProtocols(_s);
+  return rt::stdString(_s);
+}
+void HybridSocket::setAlpnProtocols(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "alpnProtocols");
+  this->ck().put_AlpnProtocols(value.c_str());
+}
+bool HybridSocket::getRequireSniMatch() {
+  this->beginCall();
+  return this->ck().get_RequireSniMatch();
+}
+void HybridSocket::setRequireSniMatch(bool value) {
+  this->beginCall();
+  this->ck().put_RequireSniMatch(value);
+}
+double HybridSocket::getTlsTicketLifetimeSeconds() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_TlsTicketLifetimeSeconds());
+}
+void HybridSocket::setTlsTicketLifetimeSeconds(double value) {
+  this->beginCall();
+  this->ck().put_TlsTicketLifetimeSeconds(rt::toInt(value, "tlsTicketLifetimeSeconds"));
+}
+bool HybridSocket::getTlsSessionResumed() {
+  this->beginCall();
+  return this->ck().get_TlsSessionResumed();
+}
 
 // ---- Methods ----
 
@@ -1557,6 +1588,31 @@ std::shared_ptr<Promise<void>> HybridSocket::sshNewChannelAsync(const std::strin
   });
 }
 
+void HybridSocket::addSslServerCert(const std::shared_ptr<HybridCertSpec>& cert, const std::string& hostname) {
+  this->beginCall();
+  addSslServerCert_impl(cert, hostname);
+}
+void HybridSocket::addSslServerCert_impl(const std::shared_ptr<HybridCertSpec>& cert, const std::string& hostname) {
+  rt::checkNoNul(hostname, "hostname");
+  if (!this->ck().AddSslServerCert(rt::implOf<HybridCert>(cert, "cert").ck(), hostname.c_str())) throw this->fail("addSslServerCert");
+}
+
+void HybridSocket::clearSslServerCerts() {
+  this->beginCall();
+  clearSslServerCerts_impl();
+}
+void HybridSocket::clearSslServerCerts_impl() {
+  this->ck().ClearSslServerCerts();
+}
+
+void HybridSocket::setTlsTicketKey(const std::shared_ptr<HybridBinDataSpec>& binKey) {
+  this->beginCall();
+  setTlsTicketKey_impl(binKey);
+}
+void HybridSocket::setTlsTicketKey_impl(const std::shared_ptr<HybridBinDataSpec>& binKey) {
+  if (!this->ck().SetTlsTicketKey(rt::implOf<HybridBinData>(binKey, "binKey").ck())) throw this->fail("setTlsTicketKey");
+}
+
 // ---- Events ----
 std::optional<std::function<void(double)>> HybridSocket::getOnPercentDone() { return this->getOnPercentDoneCb(); }
 void HybridSocket::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }

package/cpp/HybridSocket.hpp

@@ -142,6 +142,13 @@ public:
   std::string getSniHostname() override;
   void setSniHostname(const std::string& value) override;
   double getNumBytesAvailable() override;
+  std::string getAlpnProtocols() override;
+  void setAlpnProtocols(const std::string& value) override;
+  bool getRequireSniMatch() override;
+  void setRequireSniMatch(bool value) override;
+  double getTlsTicketLifetimeSeconds() override;
+  void setTlsTicketLifetimeSeconds(double value) override;
+  bool getTlsSessionResumed() override;
 
   // ---- Methods ----
   void addSslAcceptableClientCaDn(const std::string& certAuthDN) override;
@@ -254,6 +261,9 @@ public:
   void getRcvdClientCert(double index, const std::shared_ptr<HybridCertSpec>& cert) override;
   void sshNewChannel(const std::string& hostname, double port, bool ssl, double maxWaitMs, const std::shared_ptr<HybridSocketSpec>& channel) override;
   std::shared_ptr<Promise<void>> sshNewChannelAsync(const std::string& hostname, double port, bool ssl, double maxWaitMs, const std::shared_ptr<HybridSocketSpec>& channel) override;
+  void addSslServerCert(const std::shared_ptr<HybridCertSpec>& cert, const std::string& hostname) override;
+  void clearSslServerCerts() override;
+  void setTlsTicketKey(const std::shared_ptr<HybridBinDataSpec>& binKey) override;
 
   // ---- Events (ReactNativeGen_DESIGN.md §6) ----
   std::optional<std::function<void(double)>> getOnPercentDone() override;
@@ -331,6 +341,9 @@ private:
   void getMyServerCert_impl(const std::shared_ptr<HybridCertSpec>& cert);
   void getRcvdClientCert_impl(double index, const std::shared_ptr<HybridCertSpec>& cert);
   void sshNewChannel_impl(const std::string& hostname, double port, bool ssl, double maxWaitMs, const std::shared_ptr<HybridSocketSpec>& channel);
+  void addSslServerCert_impl(const std::shared_ptr<HybridCertSpec>& cert, const std::string& hostname);
+  void clearSslServerCerts_impl();
+  void setTlsTicketKey_impl(const std::shared_ptr<HybridBinDataSpec>& binKey);
 };
 
 } // namespace margelo::nitro::chilkat

package/cpp/HybridSpider.cpp

@@ -386,19 +386,19 @@ void HybridSpider::clearSpideredUrls_impl() {
   this->ck().ClearSpideredUrls();
 }
 
-void HybridSpider::crawlNext() {
+bool HybridSpider::crawlNext() {
   this->beginCall();
-  crawlNext_impl();
+  return crawlNext_impl();
 }
-void HybridSpider::crawlNext_impl() {
-  if (!this->ck().CrawlNext()) throw this->fail("crawlNext");
+bool HybridSpider::crawlNext_impl() {
+  return this->ck().CrawlNext();
 }
-std::shared_ptr<Promise<void>> HybridSpider::crawlNextAsync() {
+std::shared_ptr<Promise<bool>> HybridSpider::crawlNextAsync() {
   this->beginCall();
   auto _self = this->shared_cast<HybridSpider>();
   std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
-  return rt::runAsync<void>("Spider.crawlNextAsync", std::move(_parts), [_self]() {
-    _self->crawlNext_impl();
+  return rt::runAsync<bool>("Spider.crawlNextAsync", std::move(_parts), [_self]() {
+    return _self->crawlNext_impl();
   });
 }
 
@@ -501,19 +501,19 @@ void HybridSpider::initialize_impl(const std::string& domain) {
   this->ck().Initialize(domain.c_str());
 }
 
-void HybridSpider::recrawlLast() {
+bool HybridSpider::recrawlLast() {
   this->beginCall();
-  recrawlLast_impl();
+  return recrawlLast_impl();
 }
-void HybridSpider::recrawlLast_impl() {
-  if (!this->ck().RecrawlLast()) throw this->fail("recrawlLast");
+bool HybridSpider::recrawlLast_impl() {
+  return this->ck().RecrawlLast();
 }
-std::shared_ptr<Promise<void>> HybridSpider::recrawlLastAsync() {
+std::shared_ptr<Promise<bool>> HybridSpider::recrawlLastAsync() {
   this->beginCall();
   auto _self = this->shared_cast<HybridSpider>();
   std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
-  return rt::runAsync<void>("Spider.recrawlLastAsync", std::move(_parts), [_self]() {
-    _self->recrawlLast_impl();
+  return rt::runAsync<bool>("Spider.recrawlLastAsync", std::move(_parts), [_self]() {
+    return _self->recrawlLast_impl();
   });
 }
 

package/cpp/HybridSpider.hpp

@@ -86,8 +86,8 @@ public:
   void clearFailedUrls() override;
   void clearOutboundLinks() override;
   void clearSpideredUrls() override;
-  void crawlNext() override;
-  std::shared_ptr<Promise<void>> crawlNextAsync() override;
+  bool crawlNext() override;
+  std::shared_ptr<Promise<bool>> crawlNextAsync() override;
   std::string fetchRobotsText() override;
   std::shared_ptr<Promise<std::string>> fetchRobotsTextAsync() override;
   std::string getAvoidPattern(double index) override;
@@ -98,8 +98,8 @@ public:
   std::string getUnspideredUrl(double index) override;
   std::string getUrlDomain(const std::string& url) override;
   void initialize(const std::string& domain) override;
-  void recrawlLast() override;
-  std::shared_ptr<Promise<void>> recrawlLastAsync() override;
+  bool recrawlLast() override;
+  std::shared_ptr<Promise<bool>> recrawlLastAsync() override;
   void skipUnspidered(double index) override;
   void sleepMs(double numMilliseconds) override;
 
@@ -120,7 +120,7 @@ private:
   void clearFailedUrls_impl();
   void clearOutboundLinks_impl();
   void clearSpideredUrls_impl();
-  void crawlNext_impl();
+  bool crawlNext_impl();
   std::string fetchRobotsText_impl();
   std::string getAvoidPattern_impl(double index);
   std::string getBaseDomain_impl(const std::string& domain);
@@ -130,7 +130,7 @@ private:
   std::string getUnspideredUrl_impl(double index);
   std::string getUrlDomain_impl(const std::string& url);
   void initialize_impl(const std::string& domain);
-  void recrawlLast_impl();
+  bool recrawlLast_impl();
   void skipUnspidered_impl(double index);
   void sleepMs_impl(double numMilliseconds);
 };

package/cpp/HybridStringBuilder.cpp

@@ -736,4 +736,12 @@ void HybridStringBuilder::appendLn_impl(const std::string& str) {
   if (!this->ck().AppendLn(str.c_str())) throw this->fail("appendLn");
 }
 
+void HybridStringBuilder::htmlToMarkdown() {
+  this->beginCall();
+  htmlToMarkdown_impl();
+}
+void HybridStringBuilder::htmlToMarkdown_impl() {
+  if (!this->ck().HtmlToMarkdown()) throw this->fail("htmlToMarkdown");
+}
+
 } // namespace margelo::nitro::chilkat

package/cpp/HybridStringBuilder.hpp

@@ -101,6 +101,7 @@ public:
   void markdownToHtml(const std::shared_ptr<HybridJsonObjectSpec>& options, const std::shared_ptr<HybridStringBuilderSpec>& sbHtml) override;
   void getRangeSb(double startIndex, double numChars, bool removeFlag, const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
   void appendLn(const std::string& str) override;
+  void htmlToMarkdown() override;
 
 private:
   void init();
@@ -173,6 +174,7 @@ private:
   void markdownToHtml_impl(const std::shared_ptr<HybridJsonObjectSpec>& options, const std::shared_ptr<HybridStringBuilderSpec>& sbHtml);
   void getRangeSb_impl(double startIndex, double numChars, bool removeFlag, const std::shared_ptr<HybridStringBuilderSpec>& sb);
   void appendLn_impl(const std::string& str);
+  void htmlToMarkdown_impl();
 };
 
 } // namespace margelo::nitro::chilkat

package/cpp/HybridZipEntry.cpp

@@ -368,21 +368,21 @@ std::shared_ptr<Promise<void>> HybridZipEntry::unzipToSbAsync(double lineEndingB
   });
 }
 
-void HybridZipEntry::getNextMatch(const std::string& pattern) {
+bool HybridZipEntry::getNextMatch(const std::string& pattern) {
   this->beginCall();
-  getNextMatch_impl(pattern);
+  return getNextMatch_impl(pattern);
 }
-void HybridZipEntry::getNextMatch_impl(const std::string& pattern) {
+bool HybridZipEntry::getNextMatch_impl(const std::string& pattern) {
   rt::checkNoNul(pattern, "pattern");
-  if (!this->ck().GetNextMatch(pattern.c_str())) throw this->fail("getNextMatch");
+  return this->ck().GetNextMatch(pattern.c_str());
 }
 
-void HybridZipEntry::getNext() {
+bool HybridZipEntry::getNext() {
   this->beginCall();
-  getNext_impl();
+  return getNext_impl();
 }
-void HybridZipEntry::getNext_impl() {
-  if (!this->ck().GetNext()) throw this->fail("getNext");
+bool HybridZipEntry::getNext_impl() {
+  return this->ck().GetNext();
 }
 
 // ---- Events ----

package/cpp/HybridZipEntry.hpp

@@ -72,8 +72,8 @@ public:
   std::shared_ptr<Promise<void>> unzipToBdAsync(const std::shared_ptr<HybridBinDataSpec>& binData) override;
   void unzipToSb(double lineEndingBehavior, const std::string& srcCharset, const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
   std::shared_ptr<Promise<void>> unzipToSbAsync(double lineEndingBehavior, const std::string& srcCharset, const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
-  void getNextMatch(const std::string& pattern) override;
-  void getNext() override;
+  bool getNextMatch(const std::string& pattern) override;
+  bool getNext() override;
 
   // ---- Events (ReactNativeGen_DESIGN.md §6) ----
   std::optional<std::function<void(double)>> getOnPercentDone() override;
@@ -95,8 +95,8 @@ private:
   void unzipToStream_impl(const std::shared_ptr<HybridStreamSpec>& toStream);
   void unzipToBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData);
   void unzipToSb_impl(double lineEndingBehavior, const std::string& srcCharset, const std::shared_ptr<HybridStringBuilderSpec>& sb);
-  void getNextMatch_impl(const std::string& pattern);
-  void getNext_impl();
+  bool getNextMatch_impl(const std::string& pattern);
+  bool getNext_impl();
 };
 
 } // namespace margelo::nitro::chilkat

package/cpp/runtime/ProgLang.hpp

@@ -5,5 +5,5 @@
 
 namespace margelo::nitro::chilkat {
 constexpr int PROGLANG_REACT_NATIVE = 25;
-constexpr const char* CHILKAT_RN_VERSION = "11.6.1";
+constexpr const char* CHILKAT_RN_VERSION = "11.7.0";
 } // namespace margelo::nitro::chilkat

package/nitro.json

@@ -39,6 +39,7 @@
     "Email": { "all": { "language": "c++", "implementationClassName": "HybridEmail" } },
     "EmailBundle": { "all": { "language": "c++", "implementationClassName": "HybridEmailBundle" } },
     "FileAccess": { "all": { "language": "c++", "implementationClassName": "HybridFileAccess" } },
+    "Formats": { "all": { "language": "c++", "implementationClassName": "HybridFormats" } },
     "Ftp2": { "all": { "language": "c++", "implementationClassName": "HybridFtp2" } },
     "Global": { "all": { "language": "c++", "implementationClassName": "HybridGlobal" } },
     "Gzip": { "all": { "language": "c++", "implementationClassName": "HybridGzip" } },

package/nitrogen/generated/android/ChilkatRN+autolinking.cmake

@@ -63,6 +63,7 @@ target_sources(
   ../nitrogen/generated/shared/c++/HybridEmailSpec.cpp
   ../nitrogen/generated/shared/c++/HybridEmailBundleSpec.cpp
   ../nitrogen/generated/shared/c++/HybridFileAccessSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridFormatsSpec.cpp
   ../nitrogen/generated/shared/c++/HybridFtp2Spec.cpp
   ../nitrogen/generated/shared/c++/HybridGlobalSpec.cpp
   ../nitrogen/generated/shared/c++/HybridGzipSpec.cpp

package/nitrogen/generated/android/ChilkatRNOnLoad.cpp

@@ -45,6 +45,7 @@
 #include "HybridEmail.hpp"
 #include "HybridEmailBundle.hpp"
 #include "HybridFileAccess.hpp"
+#include "HybridFormats.hpp"
 #include "HybridFtp2.hpp"
 #include "HybridGlobal.hpp"
 #include "HybridGzip.hpp"
@@ -403,6 +404,15 @@ void registerAllNatives() {
       return std::make_shared<HybridFileAccess>();
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Formats",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridFormats>,
+                    "The HybridObject \"HybridFormats\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridFormats>();
+    }
+  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "Ftp2",
     []() -> std::shared_ptr<HybridObject> {

package/nitrogen/generated/ios/ChilkatRNAutolinking.mm

@@ -40,6 +40,7 @@
 #include "HybridEmail.hpp"
 #include "HybridEmailBundle.hpp"
 #include "HybridFileAccess.hpp"
+#include "HybridFormats.hpp"
 #include "HybridFtp2.hpp"
 #include "HybridGlobal.hpp"
 #include "HybridGzip.hpp"
@@ -389,6 +390,15 @@
       return std::make_shared<HybridFileAccess>();
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Formats",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridFormats>,
+                    "The HybridObject \"HybridFormats\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridFormats>();
+    }
+  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "Ftp2",
     []() -> std::shared_ptr<HybridObject> {

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

@@ -142,12 +142,12 @@ namespace margelo::nitro::chilkat {
       virtual void setProviderParams(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
       virtual void setAskParams(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
       virtual void registerManualTools(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
-      virtual void getFunctionCalls(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
-      virtual void getSearchResults(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual bool getFunctionCalls(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual bool getSearchResults(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
       virtual void useMcp(const std::shared_ptr<HybridMcpSpec>& cMcp, const std::string& namePrefix) = 0;
       virtual std::shared_ptr<Promise<void>> useMcpAsync(const std::shared_ptr<HybridMcpSpec>& cMcp, const std::string& namePrefix) = 0;
       virtual void setOutputSchema(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& schema, bool strict) = 0;
-      virtual void getOutputJson(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual bool getOutputJson(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
       virtual void inputAddFnResult(const std::string& callId, const std::string& fnResult) = 0;
       virtual void registerJsTools(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool evalOnly, bool allowAllKeyword) = 0;
       virtual void streamingJsToolCall(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;

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

@@ -77,8 +77,8 @@ namespace margelo::nitro::chilkat {
     public:
       // Methods
       virtual std::string getNameserver(double index) = 0;
-      virtual void query(const std::string& recordType, const std::string& domain, const std::shared_ptr<HybridJsonObjectSpec>& answer) = 0;
-      virtual std::shared_ptr<Promise<void>> queryAsync(const std::string& recordType, const std::string& domain, const std::shared_ptr<HybridJsonObjectSpec>& answer) = 0;
+      virtual bool query(const std::string& recordType, const std::string& domain, const std::shared_ptr<HybridJsonObjectSpec>& answer) = 0;
+      virtual std::shared_ptr<Promise<bool>> queryAsync(const std::string& recordType, const std::string& domain, const std::shared_ptr<HybridJsonObjectSpec>& answer) = 0;
       virtual void addNameserver(const std::string& ipAddr, bool supportsTls) = 0;
       virtual void removeNameserver(const std::string& ipAddr) = 0;
       virtual void removeAllNameservers() = 0;

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

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

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

@@ -0,0 +1,75 @@
+///
+/// HybridFormatsSpec.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; }
+
+#include <string>
+#include <memory>
+#include "HybridJsonObjectSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Formats`
+   * Inherit this class to create instances of `HybridFormatsSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridFormats: public HybridFormatsSpec {
+   * public:
+   *   HybridFormats(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridFormatsSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridFormatsSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridFormatsSpec() 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;
+
+    public:
+      // Methods
+      virtual void barcode(const std::string& op, const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) = 0;
+      virtual void qrCode(const std::string& op, const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Formats";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -71,7 +71,7 @@ namespace margelo::nitro::chilkat {
       virtual bool contains(const std::string& key) = 0;
       virtual double lookupInt(const std::string& key) = 0;
       virtual std::string lookupStr(const std::string& key) = 0;
-      virtual void remove(const std::string& key) = 0;
+      virtual bool remove(const std::string& key) = 0;
       virtual void getKeys(const std::shared_ptr<HybridStringTableSpec>& strTable) = 0;
       virtual void addQueryParams(const std::string& queryParams) = 0;
       virtual void toXmlSb(const std::shared_ptr<HybridStringBuilderSpec>& sbXml) = 0;

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

@@ -26,6 +26,7 @@ namespace margelo::nitro::chilkat {
       prototype.registerHybridSetter("lastMethodSuccess", &HybridHttpCurlSpec::setLastMethodSuccess);
       prototype.registerHybridGetter("statusCode", &HybridHttpCurlSpec::getStatusCode);
       prototype.registerHybridGetter("responseBodyStr", &HybridHttpCurlSpec::getResponseBodyStr);
+      prototype.registerHybridGetter("responseHeader", &HybridHttpCurlSpec::getResponseHeader);
       prototype.registerHybridGetter("responseFilePath", &HybridHttpCurlSpec::getResponseFilePath);
       prototype.registerHybridSetter("responseFilePath", &HybridHttpCurlSpec::setResponseFilePath);
       prototype.registerHybridGetter("enableBodyVars", &HybridHttpCurlSpec::getEnableBodyVars);
@@ -49,6 +50,7 @@ namespace margelo::nitro::chilkat {
       prototype.registerHybridMethod("getResponseJson", &HybridHttpCurlSpec::getResponseJson);
       prototype.registerHybridMethod("getResponseXml", &HybridHttpCurlSpec::getResponseXml);
       prototype.registerHybridMethod("getResponseJarr", &HybridHttpCurlSpec::getResponseJarr);
+      prototype.registerHybridMethod("getResponseHeaderField", &HybridHttpCurlSpec::getResponseHeaderField);
       prototype.registerHybridMethod("setVar", &HybridHttpCurlSpec::setVar);
       prototype.registerHybridMethod("addTargetOutput", &HybridHttpCurlSpec::addTargetOutput);
       prototype.registerHybridMethod("clearVar", &HybridHttpCurlSpec::clearVar);

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

@@ -74,6 +74,7 @@ namespace margelo::nitro::chilkat {
       virtual void setLastMethodSuccess(bool lastMethodSuccess) = 0;
       virtual double getStatusCode() = 0;
       virtual std::string getResponseBodyStr() = 0;
+      virtual std::string getResponseHeader() = 0;
       virtual std::string getResponseFilePath() = 0;
       virtual void setResponseFilePath(const std::string& responseFilePath) = 0;
       virtual bool getEnableBodyVars() = 0;
@@ -100,6 +101,7 @@ namespace margelo::nitro::chilkat {
       virtual void getResponseJson(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
       virtual void getResponseXml(const std::shared_ptr<HybridXmlSpec>& xml) = 0;
       virtual void getResponseJarr(const std::shared_ptr<HybridJsonArraySpec>& jarr) = 0;
+      virtual std::string getResponseHeaderField(const std::string& name) = 0;
       virtual void setVar(const std::string& varName, const std::string& varValue) = 0;
       virtual void addTargetOutput(const std::string& jsonPath, const std::string& varName) = 0;
       virtual void clearVar(const std::string& varName) = 0;

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

@@ -327,6 +327,7 @@ namespace margelo::nitro::chilkat {
       prototype.registerHybridMethod("s3DeleteObjectsAsync", &HybridHttpSpec::s3DeleteObjectsAsync);
       prototype.registerHybridMethod("clearInMemoryCookies", &HybridHttpSpec::clearInMemoryCookies);
       prototype.registerHybridMethod("setDPoPKey", &HybridHttpSpec::setDPoPKey);
+      prototype.registerHybridMethod("setClientAssertionKey", &HybridHttpSpec::setClientAssertionKey);
       prototype.registerHybridMethod("abort", &HybridHttpSpec::abort);
     });
   }

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

@@ -393,6 +393,7 @@ namespace margelo::nitro::chilkat {
       virtual std::shared_ptr<Promise<void>> s3DeleteObjectsAsync(const std::string& bucketName, const std::shared_ptr<HybridStringTableSpec>& objectNames, const std::shared_ptr<HybridJsonObjectSpec>& jsonResponse) = 0;
       virtual void clearInMemoryCookies() = 0;
       virtual void setDPoPKey(const std::shared_ptr<HybridPrivateKeySpec>& privKey) = 0;
+      virtual void setClientAssertionKey(const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::string& kid) = 0;
       virtual void abort() = 0;
 
     protected: