@chilkat/react-native 11.6.1

package/cpp/HybridDh.hpp

@@ -0,0 +1,47 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Dh: the Nitro HybridObject over Chilkat's CkDh (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridDhSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkDh.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridDh final : public HybridDhSpec, public ChilkatObject<CkDh> {
+public:
+  HybridDh();                                  // `new Dh()` from JS
+  explicit HybridDh(CkDh* owned);  // wraps an object a Chilkat method returned
+  void dispose() override;
+
+  // ---- Properties ----
+  std::string getLastErrorHtml() override;
+  std::string getLastErrorText() override;
+  std::string getLastErrorXml() override;
+  std::string getVersion() override;
+  std::string getDebugLogFilePath() override;
+  void setDebugLogFilePath(const std::string& value) override;
+  bool getVerboseLogging() override;
+  void setVerboseLogging(bool value) override;
+  bool getLastMethodSuccess() override;
+  void setLastMethodSuccess(bool value) override;
+  double getG() override;
+  std::string getP() override;
+
+  // ---- Methods ----
+  std::string createE(double numBits) override;
+  std::string findK(const std::string& e) override;
+  void genPG(double numBits, double g) override;
+  void setPG(const std::string& p, double g) override;
+  void useKnownPrime(double index) override;
+
+private:
+  void init();
+  std::string createE_impl(double numBits);
+  std::string findK_impl(const std::string& e);
+  void genPG_impl(double numBits, double g);
+  void setPG_impl(const std::string& p, double g);
+  void useKnownPrime_impl(double index);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridDirTree.cpp

@@ -0,0 +1,167 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridDirTree.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridDirTree::HybridDirTree()
+    : HybridObject(HybridDirTreeSpec::TAG), ChilkatObject<CkDirTree>("DirTree", CkDirTree::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridDirTree::HybridDirTree(CkDirTree* owned)
+    : HybridObject(HybridDirTreeSpec::TAG), ChilkatObject<CkDirTree>("DirTree", owned) {
+  init();
+}
+
+void HybridDirTree::init() {
+}
+
+void HybridDirTree::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridDirTree::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDirTree::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDirTree::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDirTree::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDirTree::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridDirTree::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridDirTree::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridDirTree::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridDirTree::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridDirTree::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridDirTree::getBaseDir() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_BaseDir(_s);
+  return rt::stdString(_s);
+}
+void HybridDirTree::setBaseDir(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "baseDir");
+  this->ck().put_BaseDir(value.c_str());
+}
+bool HybridDirTree::getDoneIterating() {
+  this->beginCall();
+  return this->ck().get_DoneIterating();
+}
+double HybridDirTree::getFileSize32() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_FileSize32());
+}
+double HybridDirTree::getFileSize64() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_FileSize64());
+}
+std::string HybridDirTree::getFullPath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_FullPath(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDirTree::getFullUncPath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_FullUncPath(_s);
+  return rt::stdString(_s);
+}
+bool HybridDirTree::getIsDirectory() {
+  this->beginCall();
+  return this->ck().get_IsDirectory();
+}
+bool HybridDirTree::getRecurse() {
+  this->beginCall();
+  return this->ck().get_Recurse();
+}
+void HybridDirTree::setRecurse(bool value) {
+  this->beginCall();
+  this->ck().put_Recurse(value);
+}
+std::string HybridDirTree::getRelativePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_RelativePath(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDirTree::getFileSizeStr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_FileSizeStr(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDirTree::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridDirTree::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+
+// ---- Methods ----
+
+void HybridDirTree::advancePosition() {
+  this->beginCall();
+  advancePosition_impl();
+}
+void HybridDirTree::advancePosition_impl() {
+  if (!this->ck().AdvancePosition()) throw this->fail("advancePosition");
+}
+
+void HybridDirTree::beginIterate() {
+  this->beginCall();
+  beginIterate_impl();
+}
+void HybridDirTree::beginIterate_impl() {
+  if (!this->ck().BeginIterate()) throw this->fail("beginIterate");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridDirTree.hpp

@@ -0,0 +1,53 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// DirTree: the Nitro HybridObject over Chilkat's CkDirTree (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridDirTreeSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkDirTree.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridDirTree final : public HybridDirTreeSpec, public ChilkatObject<CkDirTree> {
+public:
+  HybridDirTree();                                  // `new DirTree()` from JS
+  explicit HybridDirTree(CkDirTree* owned);  // wraps an object a Chilkat method returned
+  void dispose() override;
+
+  // ---- Properties ----
+  std::string getLastErrorHtml() override;
+  std::string getLastErrorText() override;
+  std::string getLastErrorXml() override;
+  std::string getVersion() override;
+  std::string getDebugLogFilePath() override;
+  void setDebugLogFilePath(const std::string& value) override;
+  bool getVerboseLogging() override;
+  void setVerboseLogging(bool value) override;
+  bool getLastMethodSuccess() override;
+  void setLastMethodSuccess(bool value) override;
+  std::string getBaseDir() override;
+  void setBaseDir(const std::string& value) override;
+  bool getDoneIterating() override;
+  double getFileSize32() override;
+  double getFileSize64() override;
+  std::string getFullPath() override;
+  std::string getFullUncPath() override;
+  bool getIsDirectory() override;
+  bool getRecurse() override;
+  void setRecurse(bool value) override;
+  std::string getRelativePath() override;
+  std::string getFileSizeStr() override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+
+  // ---- Methods ----
+  void advancePosition() override;
+  void beginIterate() override;
+
+private:
+  void init();
+  void advancePosition_impl();
+  void beginIterate_impl();
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridDkim.cpp

@@ -0,0 +1,249 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridDkim.hpp"
+#include "HybridBinData.hpp"
+#include "HybridPrivateKey.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridDkim::HybridDkim()
+    : HybridObject(HybridDkimSpec::TAG), ChilkatObject<CkDkim>("Dkim", CkDkim::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridDkim::HybridDkim(CkDkim* owned)
+    : HybridObject(HybridDkimSpec::TAG), ChilkatObject<CkDkim>("Dkim", owned) {
+  init();
+}
+
+void HybridDkim::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridDkim::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridDkim::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDkim::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDkim::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDkim::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDkim::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridDkim::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridDkim::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridDkim::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridDkim::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridDkim::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridDkim::getDkimAlg() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DkimAlg(_s);
+  return rt::stdString(_s);
+}
+void HybridDkim::setDkimAlg(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "dkimAlg");
+  this->ck().put_DkimAlg(value.c_str());
+}
+double HybridDkim::getDkimBodyLengthCount() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_DkimBodyLengthCount());
+}
+void HybridDkim::setDkimBodyLengthCount(double value) {
+  this->beginCall();
+  this->ck().put_DkimBodyLengthCount(rt::toInt(value, "dkimBodyLengthCount"));
+}
+std::string HybridDkim::getDkimCanon() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DkimCanon(_s);
+  return rt::stdString(_s);
+}
+void HybridDkim::setDkimCanon(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "dkimCanon");
+  this->ck().put_DkimCanon(value.c_str());
+}
+std::string HybridDkim::getDkimDomain() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DkimDomain(_s);
+  return rt::stdString(_s);
+}
+void HybridDkim::setDkimDomain(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "dkimDomain");
+  this->ck().put_DkimDomain(value.c_str());
+}
+std::string HybridDkim::getDkimHeaders() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DkimHeaders(_s);
+  return rt::stdString(_s);
+}
+void HybridDkim::setDkimHeaders(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "dkimHeaders");
+  this->ck().put_DkimHeaders(value.c_str());
+}
+std::string HybridDkim::getDkimSelector() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DkimSelector(_s);
+  return rt::stdString(_s);
+}
+void HybridDkim::setDkimSelector(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "dkimSelector");
+  this->ck().put_DkimSelector(value.c_str());
+}
+double HybridDkim::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridDkim::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+bool HybridDkim::getAbortCurrent() {
+  this->beginCall();
+  return this->ck().get_AbortCurrent();
+}
+void HybridDkim::setAbortCurrent(bool value) {
+  this->beginCall();
+  this->ck().put_AbortCurrent(value);
+}
+std::string HybridDkim::getVerifyInfo() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_VerifyInfo(_s);
+  return rt::stdString(_s);
+}
+
+// ---- Methods ----
+
+void HybridDkim::loadPublicKey(const std::string& selector, const std::string& domain, const std::string& publicKey) {
+  this->beginCall();
+  loadPublicKey_impl(selector, domain, publicKey);
+}
+void HybridDkim::loadPublicKey_impl(const std::string& selector, const std::string& domain, const std::string& publicKey) {
+  rt::checkNoNul(selector, "selector");
+  rt::checkNoNul(domain, "domain");
+  rt::checkNoNul(publicKey, "publicKey");
+  if (!this->ck().LoadPublicKey(selector.c_str(), domain.c_str(), publicKey.c_str())) throw this->fail("loadPublicKey");
+}
+
+void HybridDkim::loadPublicKeyFile(const std::string& selector, const std::string& domain, const std::string& publicKeyFilepath) {
+  this->beginCall();
+  loadPublicKeyFile_impl(selector, domain, publicKeyFilepath);
+}
+void HybridDkim::loadPublicKeyFile_impl(const std::string& selector, const std::string& domain, const std::string& publicKeyFilepath) {
+  rt::checkNoNul(selector, "selector");
+  rt::checkNoNul(domain, "domain");
+  rt::checkNoNul(publicKeyFilepath, "publicKeyFilepath");
+  if (!this->ck().LoadPublicKeyFile(selector.c_str(), domain.c_str(), publicKeyFilepath.c_str())) throw this->fail("loadPublicKeyFile");
+}
+
+void HybridDkim::prefetchPublicKey(const std::string& selector, const std::string& domain) {
+  this->beginCall();
+  prefetchPublicKey_impl(selector, domain);
+}
+void HybridDkim::prefetchPublicKey_impl(const std::string& selector, const std::string& domain) {
+  rt::checkNoNul(selector, "selector");
+  rt::checkNoNul(domain, "domain");
+  if (!this->ck().PrefetchPublicKey(selector.c_str(), domain.c_str())) throw this->fail("prefetchPublicKey");
+}
+std::shared_ptr<Promise<void>> HybridDkim::prefetchPublicKeyAsync(const std::string& selector, const std::string& domain) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridDkim>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Dkim.prefetchPublicKeyAsync", std::move(_parts), [_self, selector, domain]() {
+    _self->prefetchPublicKey_impl(selector, domain);
+  });
+}
+
+void HybridDkim::dkimSign(const std::shared_ptr<HybridBinDataSpec>& mimeData) {
+  this->beginCall();
+  dkimSign_impl(mimeData);
+}
+void HybridDkim::dkimSign_impl(const std::shared_ptr<HybridBinDataSpec>& mimeData) {
+  if (!this->ck().DkimSign(rt::implOf<HybridBinData>(mimeData, "mimeData").ck())) throw this->fail("dkimSign");
+}
+
+void HybridDkim::setDkimPrivateKey(const std::shared_ptr<HybridPrivateKeySpec>& privateKey) {
+  this->beginCall();
+  setDkimPrivateKey_impl(privateKey);
+}
+void HybridDkim::setDkimPrivateKey_impl(const std::shared_ptr<HybridPrivateKeySpec>& privateKey) {
+  if (!this->ck().SetDkimPrivateKey(rt::implOf<HybridPrivateKey>(privateKey, "privateKey").ck())) throw this->fail("setDkimPrivateKey");
+}
+
+void HybridDkim::dkimVerify(double sigIndex, const std::shared_ptr<HybridBinDataSpec>& mimeData) {
+  this->beginCall();
+  dkimVerify_impl(sigIndex, mimeData);
+}
+void HybridDkim::dkimVerify_impl(double sigIndex, const std::shared_ptr<HybridBinDataSpec>& mimeData) {
+  if (!this->ck().DkimVerify(rt::toInt(sigIndex, "sigIndex"), rt::implOf<HybridBinData>(mimeData, "mimeData").ck())) throw this->fail("dkimVerify");
+}
+
+double HybridDkim::numDkimSigs(const std::shared_ptr<HybridBinDataSpec>& mimeData) {
+  this->beginCall();
+  return numDkimSigs_impl(mimeData);
+}
+double HybridDkim::numDkimSigs_impl(const std::shared_ptr<HybridBinDataSpec>& mimeData) {
+  return static_cast<double>(this->ck().NumDkimSigs(rt::implOf<HybridBinData>(mimeData, "mimeData").ck()));
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridDkim::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridDkim::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridDkim::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridDkim::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridDkim::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridDkim.hpp

@@ -0,0 +1,74 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Dkim: the Nitro HybridObject over Chilkat's CkDkim (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridDkimSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkDkim.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridDkim final : public HybridDkimSpec, public ChilkatObject<CkDkim> {
+public:
+  HybridDkim();                                  // `new Dkim()` from JS
+  explicit HybridDkim(CkDkim* owned);  // wraps an object a Chilkat method returned
+  void dispose() override;
+
+  // ---- Properties ----
+  std::string getLastErrorHtml() override;
+  std::string getLastErrorText() override;
+  std::string getLastErrorXml() override;
+  std::string getVersion() override;
+  std::string getDebugLogFilePath() override;
+  void setDebugLogFilePath(const std::string& value) override;
+  bool getVerboseLogging() override;
+  void setVerboseLogging(bool value) override;
+  bool getLastMethodSuccess() override;
+  void setLastMethodSuccess(bool value) override;
+  std::string getDkimAlg() override;
+  void setDkimAlg(const std::string& value) override;
+  double getDkimBodyLengthCount() override;
+  void setDkimBodyLengthCount(double value) override;
+  std::string getDkimCanon() override;
+  void setDkimCanon(const std::string& value) override;
+  std::string getDkimDomain() override;
+  void setDkimDomain(const std::string& value) override;
+  std::string getDkimHeaders() override;
+  void setDkimHeaders(const std::string& value) override;
+  std::string getDkimSelector() override;
+  void setDkimSelector(const std::string& value) override;
+  double getHeartbeatMs() override;
+  void setHeartbeatMs(double value) override;
+  bool getAbortCurrent() override;
+  void setAbortCurrent(bool value) override;
+  std::string getVerifyInfo() override;
+
+  // ---- Methods ----
+  void loadPublicKey(const std::string& selector, const std::string& domain, const std::string& publicKey) override;
+  void loadPublicKeyFile(const std::string& selector, const std::string& domain, const std::string& publicKeyFilepath) override;
+  void prefetchPublicKey(const std::string& selector, const std::string& domain) override;
+  std::shared_ptr<Promise<void>> prefetchPublicKeyAsync(const std::string& selector, const std::string& domain) override;
+  void dkimSign(const std::shared_ptr<HybridBinDataSpec>& mimeData) override;
+  void setDkimPrivateKey(const std::shared_ptr<HybridPrivateKeySpec>& privateKey) override;
+  void dkimVerify(double sigIndex, const std::shared_ptr<HybridBinDataSpec>& mimeData) override;
+  double numDkimSigs(const std::shared_ptr<HybridBinDataSpec>& mimeData) override;
+
+  // ---- Events (ReactNativeGen_DESIGN.md §6) ----
+  std::optional<std::function<void(double)>> getOnPercentDone() override;
+  void setOnPercentDone(const std::optional<std::function<void(double)>>& cb) override;
+  std::optional<std::function<void(const std::string&, const std::string&)>> getOnProgressInfo() override;
+  void setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) override;
+  void abort() override;
+
+private:
+  void init();
+  void loadPublicKey_impl(const std::string& selector, const std::string& domain, const std::string& publicKey);
+  void loadPublicKeyFile_impl(const std::string& selector, const std::string& domain, const std::string& publicKeyFilepath);
+  void prefetchPublicKey_impl(const std::string& selector, const std::string& domain);
+  void dkimSign_impl(const std::shared_ptr<HybridBinDataSpec>& mimeData);
+  void setDkimPrivateKey_impl(const std::shared_ptr<HybridPrivateKeySpec>& privateKey);
+  void dkimVerify_impl(double sigIndex, const std::shared_ptr<HybridBinDataSpec>& mimeData);
+  double numDkimSigs_impl(const std::shared_ptr<HybridBinDataSpec>& mimeData);
+};
+
+} // namespace margelo::nitro::chilkat