@chilkat/react-native 11.6.1

package/cpp/HybridMime.hpp

@@ -0,0 +1,266 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Mime: the Nitro HybridObject over Chilkat's CkMime (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridMimeSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkMime.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridMime final : public HybridMimeSpec, public ChilkatObject<CkMime> {
+public:
+  HybridMime();                                  // `new Mime()` from JS
+  explicit HybridMime(CkMime* 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 getBoundary() override;
+  void setBoundary(const std::string& value) override;
+  std::string getCharset() override;
+  void setCharset(const std::string& value) override;
+  std::string getContentType() override;
+  void setContentType(const std::string& value) override;
+  std::string getCurrentDateTime() override;
+  std::string getDisposition() override;
+  void setDisposition(const std::string& value) override;
+  std::string getEncoding() override;
+  void setEncoding(const std::string& value) override;
+  std::string getFilename() override;
+  void setFilename(const std::string& value) override;
+  std::string getMicalg() override;
+  void setMicalg(const std::string& value) override;
+  std::string getNameParam() override;
+  void setNameParam(const std::string& value) override;
+  double getNumHeaderFields() override;
+  double getNumParts() override;
+  double getNumSignerCerts() override;
+  std::string getPkcs7CryptAlg() override;
+  void setPkcs7CryptAlg(const std::string& value) override;
+  double getPkcs7KeyLength() override;
+  void setPkcs7KeyLength(double value) override;
+  std::string getProtocol() override;
+  void setProtocol(const std::string& value) override;
+  std::string getSigningHashAlg() override;
+  void setSigningHashAlg(const std::string& value) override;
+  bool getUnwrapExtras() override;
+  void setUnwrapExtras(bool value) override;
+  bool getUseMmDescription() override;
+  void setUseMmDescription(bool value) override;
+  bool getUseXPkcs7() override;
+  void setUseXPkcs7(bool value) override;
+  std::string getSigningAlg() override;
+  void setSigningAlg(const std::string& value) override;
+  std::string getOaepHash() override;
+  void setOaepHash(const std::string& value) override;
+  bool getOaepPadding() override;
+  void setOaepPadding(bool value) override;
+  std::string getOaepMgfHash() override;
+  void setOaepMgfHash(const std::string& value) override;
+  std::string getCmsOptions() override;
+  void setCmsOptions(const std::string& value) override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+  double getNumDecryptCerts() override;
+
+  // ---- Methods ----
+  void addContentLength() override;
+  void addDecryptCert(const std::shared_ptr<HybridCertSpec>& cert) override;
+  void addDetachedSignature(const std::shared_ptr<HybridCertSpec>& cert) override;
+  void addDetachedSignature2(const std::shared_ptr<HybridCertSpec>& cert, bool transferHeaderFields) override;
+  void addDetachedSignaturePk(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey) override;
+  void addDetachedSignaturePk2(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey, bool transferHeaderFields) override;
+  void addEncryptCert(const std::shared_ptr<HybridCertSpec>& cert) override;
+  void addHeaderField(const std::string& name, const std::string& value) override;
+  void addPfxSourceFile(const std::string& pfxFilePath, const std::string& password) override;
+  void appendPart(const std::shared_ptr<HybridMimeSpec>& mime) override;
+  void appendPartFromFile(const std::string& filename) override;
+  std::string asnBodyToXml() override;
+  void clearEncryptCerts() override;
+  bool containsEncryptedParts() override;
+  bool containsSignedParts() override;
+  void convert8Bit() override;
+  void convertToMultipartAlt() override;
+  void convertToMultipartMixed() override;
+  void convertToSigned(const std::shared_ptr<HybridCertSpec>& cert) override;
+  void convertToSignedPk(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey) override;
+  void decrypt() override;
+  void decrypt2(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey) override;
+  void decryptUsingCert(const std::shared_ptr<HybridCertSpec>& cert) override;
+  void decryptUsingPfxFile(const std::string& pfxFilePath, const std::string& pfxPassword) override;
+  void encrypt(const std::shared_ptr<HybridCertSpec>& cert) override;
+  void encryptN() override;
+  std::string getBodyDecoded() override;
+  std::string getBodyEncoded() override;
+  std::string getEntireBody() override;
+  std::string getEntireHead() override;
+  std::string getHeaderField(const std::string& fieldName) override;
+  std::string getHeaderFieldAttribute(const std::string& name, const std::string& attrName) override;
+  std::string getHeaderFieldName(double index) override;
+  std::string getHeaderFieldValue(double index) override;
+  std::string getMime() override;
+  std::string getSignatureSigningTimeStr(double index) override;
+  std::string getXml() override;
+  bool hasSignatureSigningTime(double index) override;
+  bool isApplicationData() override;
+  bool isAttachment() override;
+  bool isAudio() override;
+  bool isEncrypted() override;
+  bool isHtml() override;
+  bool isImage() override;
+  bool isMultipart() override;
+  bool isMultipartAlternative() override;
+  bool isMultipartMixed() override;
+  bool isMultipartRelated() override;
+  bool isPlainText() override;
+  bool isSigned() override;
+  bool isText() override;
+  bool isVideo() override;
+  bool isXml() override;
+  void loadMime(const std::string& mimeMsg) override;
+  void loadMimeFile(const std::string& fileName) override;
+  void loadXml(const std::string& xml) override;
+  void loadXmlFile(const std::string& fileName) override;
+  void newMessageRfc822(const std::shared_ptr<HybridMimeSpec>& mimeObject) override;
+  void newMultipartAlternative() override;
+  void newMultipartMixed() override;
+  void newMultipartRelated() override;
+  void removeHeaderField(const std::string& fieldName, bool bAllOccurrences) override;
+  void removePart(double index) override;
+  void saveBody(const std::string& filename) override;
+  void saveMime(const std::string& filename) override;
+  void saveXml(const std::string& filename) override;
+  void setBody(const std::string& str) override;
+  void setBodyFromEncoded(const std::string& encoding, const std::string& str) override;
+  void setBodyFromFile(const std::string& fileName) override;
+  void setBodyFromHtml(const std::string& str) override;
+  void setBodyFromPlainText(const std::string& str) override;
+  void setBodyFromXml(const std::string& str) override;
+  void setHeaderField(const std::string& name, const std::string& value) override;
+  void setVerifyCert(const std::shared_ptr<HybridCertSpec>& cert) override;
+  void unwrapSecurity() override;
+  void urlEncodeBody(const std::string& charset) override;
+  void useCertVault(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) override;
+  void verify() override;
+  std::string getStructure(const std::string& fmt) override;
+  void getMimeSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void getMimeBd(const std::shared_ptr<HybridBinDataSpec>& bindat) override;
+  void loadMimeSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void loadMimeBd(const std::shared_ptr<HybridBinDataSpec>& bindat) override;
+  void getBodyBd(const std::shared_ptr<HybridBinDataSpec>& binDat) override;
+  void getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void lastDecryptCert(double index, const std::shared_ptr<HybridCertSpec>& cert) override;
+  void lastSignerCert(double index, const std::shared_ptr<HybridCertSpec>& cert) override;
+  void partAt(double index, const std::shared_ptr<HybridMimeSpec>& subPart) override;
+  void partsToFiles(const std::string& path, const std::shared_ptr<HybridStringTableSpec>& st) override;
+  void addPfxSourceBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& password) override;
+  void setBodyBd(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void getDecryptCertInfo(const std::shared_ptr<HybridJsonObjectSpec>& certInfo) override;
+
+private:
+  void init();
+  void addContentLength_impl();
+  void addDecryptCert_impl(const std::shared_ptr<HybridCertSpec>& cert);
+  void addDetachedSignature_impl(const std::shared_ptr<HybridCertSpec>& cert);
+  void addDetachedSignature2_impl(const std::shared_ptr<HybridCertSpec>& cert, bool transferHeaderFields);
+  void addDetachedSignaturePk_impl(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey);
+  void addDetachedSignaturePk2_impl(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey, bool transferHeaderFields);
+  void addEncryptCert_impl(const std::shared_ptr<HybridCertSpec>& cert);
+  void addHeaderField_impl(const std::string& name, const std::string& value);
+  void addPfxSourceFile_impl(const std::string& pfxFilePath, const std::string& password);
+  void appendPart_impl(const std::shared_ptr<HybridMimeSpec>& mime);
+  void appendPartFromFile_impl(const std::string& filename);
+  std::string asnBodyToXml_impl();
+  void clearEncryptCerts_impl();
+  bool containsEncryptedParts_impl();
+  bool containsSignedParts_impl();
+  void convert8Bit_impl();
+  void convertToMultipartAlt_impl();
+  void convertToMultipartMixed_impl();
+  void convertToSigned_impl(const std::shared_ptr<HybridCertSpec>& cert);
+  void convertToSignedPk_impl(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey);
+  void decrypt_impl();
+  void decrypt2_impl(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey);
+  void decryptUsingCert_impl(const std::shared_ptr<HybridCertSpec>& cert);
+  void decryptUsingPfxFile_impl(const std::string& pfxFilePath, const std::string& pfxPassword);
+  void encrypt_impl(const std::shared_ptr<HybridCertSpec>& cert);
+  void encryptN_impl();
+  std::string getBodyDecoded_impl();
+  std::string getBodyEncoded_impl();
+  std::string getEntireBody_impl();
+  std::string getEntireHead_impl();
+  std::string getHeaderField_impl(const std::string& fieldName);
+  std::string getHeaderFieldAttribute_impl(const std::string& name, const std::string& attrName);
+  std::string getHeaderFieldName_impl(double index);
+  std::string getHeaderFieldValue_impl(double index);
+  std::string getMime_impl();
+  std::string getSignatureSigningTimeStr_impl(double index);
+  std::string getXml_impl();
+  bool hasSignatureSigningTime_impl(double index);
+  bool isApplicationData_impl();
+  bool isAttachment_impl();
+  bool isAudio_impl();
+  bool isEncrypted_impl();
+  bool isHtml_impl();
+  bool isImage_impl();
+  bool isMultipart_impl();
+  bool isMultipartAlternative_impl();
+  bool isMultipartMixed_impl();
+  bool isMultipartRelated_impl();
+  bool isPlainText_impl();
+  bool isSigned_impl();
+  bool isText_impl();
+  bool isVideo_impl();
+  bool isXml_impl();
+  void loadMime_impl(const std::string& mimeMsg);
+  void loadMimeFile_impl(const std::string& fileName);
+  void loadXml_impl(const std::string& xml);
+  void loadXmlFile_impl(const std::string& fileName);
+  void newMessageRfc822_impl(const std::shared_ptr<HybridMimeSpec>& mimeObject);
+  void newMultipartAlternative_impl();
+  void newMultipartMixed_impl();
+  void newMultipartRelated_impl();
+  void removeHeaderField_impl(const std::string& fieldName, bool bAllOccurrences);
+  void removePart_impl(double index);
+  void saveBody_impl(const std::string& filename);
+  void saveMime_impl(const std::string& filename);
+  void saveXml_impl(const std::string& filename);
+  void setBody_impl(const std::string& str);
+  void setBodyFromEncoded_impl(const std::string& encoding, const std::string& str);
+  void setBodyFromFile_impl(const std::string& fileName);
+  void setBodyFromHtml_impl(const std::string& str);
+  void setBodyFromPlainText_impl(const std::string& str);
+  void setBodyFromXml_impl(const std::string& str);
+  void setHeaderField_impl(const std::string& name, const std::string& value);
+  void setVerifyCert_impl(const std::shared_ptr<HybridCertSpec>& cert);
+  void unwrapSecurity_impl();
+  void urlEncodeBody_impl(const std::string& charset);
+  void useCertVault_impl(const std::shared_ptr<HybridXmlCertVaultSpec>& vault);
+  void verify_impl();
+  std::string getStructure_impl(const std::string& fmt);
+  void getMimeSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void getMimeBd_impl(const std::shared_ptr<HybridBinDataSpec>& bindat);
+  void loadMimeSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void loadMimeBd_impl(const std::shared_ptr<HybridBinDataSpec>& bindat);
+  void getBodyBd_impl(const std::shared_ptr<HybridBinDataSpec>& binDat);
+  void getLastJsonData_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void lastDecryptCert_impl(double index, const std::shared_ptr<HybridCertSpec>& cert);
+  void lastSignerCert_impl(double index, const std::shared_ptr<HybridCertSpec>& cert);
+  void partAt_impl(double index, const std::shared_ptr<HybridMimeSpec>& subPart);
+  void partsToFiles_impl(const std::string& path, const std::shared_ptr<HybridStringTableSpec>& st);
+  void addPfxSourceBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& password);
+  void setBodyBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+  void getDecryptCertInfo_impl(const std::shared_ptr<HybridJsonObjectSpec>& certInfo);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridNtlm.cpp

@@ -0,0 +1,333 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridNtlm.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridNtlm::HybridNtlm()
+    : HybridObject(HybridNtlmSpec::TAG), ChilkatObject<CkNtlm>("Ntlm", CkNtlm::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridNtlm::HybridNtlm(CkNtlm* owned)
+    : HybridObject(HybridNtlmSpec::TAG), ChilkatObject<CkNtlm>("Ntlm", owned) {
+  init();
+}
+
+void HybridNtlm::init() {
+}
+
+void HybridNtlm::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridNtlm::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridNtlm::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridNtlm::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridNtlm::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridNtlm::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridNtlm::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridNtlm::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridNtlm::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridNtlm::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridNtlm::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridNtlm::getClientChallenge() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ClientChallenge(_s);
+  return rt::stdString(_s);
+}
+void HybridNtlm::setClientChallenge(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "clientChallenge");
+  this->ck().put_ClientChallenge(value.c_str());
+}
+std::string HybridNtlm::getDnsComputerName() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DnsComputerName(_s);
+  return rt::stdString(_s);
+}
+void HybridNtlm::setDnsComputerName(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "dnsComputerName");
+  this->ck().put_DnsComputerName(value.c_str());
+}
+std::string HybridNtlm::getDnsDomainName() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DnsDomainName(_s);
+  return rt::stdString(_s);
+}
+void HybridNtlm::setDnsDomainName(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "dnsDomainName");
+  this->ck().put_DnsDomainName(value.c_str());
+}
+std::string HybridNtlm::getDomain() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Domain(_s);
+  return rt::stdString(_s);
+}
+void HybridNtlm::setDomain(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "domain");
+  this->ck().put_Domain(value.c_str());
+}
+std::string HybridNtlm::getEncodingMode() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_EncodingMode(_s);
+  return rt::stdString(_s);
+}
+void HybridNtlm::setEncodingMode(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "encodingMode");
+  this->ck().put_EncodingMode(value.c_str());
+}
+std::string HybridNtlm::getFlags() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Flags(_s);
+  return rt::stdString(_s);
+}
+void HybridNtlm::setFlags(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "flags");
+  this->ck().put_Flags(value.c_str());
+}
+std::string HybridNtlm::getNetBiosComputerName() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_NetBiosComputerName(_s);
+  return rt::stdString(_s);
+}
+void HybridNtlm::setNetBiosComputerName(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "netBiosComputerName");
+  this->ck().put_NetBiosComputerName(value.c_str());
+}
+std::string HybridNtlm::getNetBiosDomainName() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_NetBiosDomainName(_s);
+  return rt::stdString(_s);
+}
+void HybridNtlm::setNetBiosDomainName(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "netBiosDomainName");
+  this->ck().put_NetBiosDomainName(value.c_str());
+}
+double HybridNtlm::getNtlmVersion() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NtlmVersion());
+}
+void HybridNtlm::setNtlmVersion(double value) {
+  this->beginCall();
+  this->ck().put_NtlmVersion(rt::toInt(value, "ntlmVersion"));
+}
+double HybridNtlm::getOemCodePage() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_OemCodePage());
+}
+void HybridNtlm::setOemCodePage(double value) {
+  this->beginCall();
+  this->ck().put_OemCodePage(rt::toInt(value, "oemCodePage"));
+}
+std::string HybridNtlm::getPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Password(_s);
+  return rt::stdString(_s);
+}
+void HybridNtlm::setPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "password");
+  this->ck().put_Password(value.c_str());
+}
+std::string HybridNtlm::getServerChallenge() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ServerChallenge(_s);
+  return rt::stdString(_s);
+}
+void HybridNtlm::setServerChallenge(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "serverChallenge");
+  this->ck().put_ServerChallenge(value.c_str());
+}
+std::string HybridNtlm::getTargetName() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TargetName(_s);
+  return rt::stdString(_s);
+}
+void HybridNtlm::setTargetName(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "targetName");
+  this->ck().put_TargetName(value.c_str());
+}
+std::string HybridNtlm::getUserName() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UserName(_s);
+  return rt::stdString(_s);
+}
+void HybridNtlm::setUserName(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "userName");
+  this->ck().put_UserName(value.c_str());
+}
+std::string HybridNtlm::getWorkstation() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Workstation(_s);
+  return rt::stdString(_s);
+}
+void HybridNtlm::setWorkstation(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "workstation");
+  this->ck().put_Workstation(value.c_str());
+}
+
+// ---- Methods ----
+
+bool HybridNtlm::compareType3(const std::string& msg1, const std::string& msg2) {
+  this->beginCall();
+  return compareType3_impl(msg1, msg2);
+}
+bool HybridNtlm::compareType3_impl(const std::string& msg1, const std::string& msg2) {
+  rt::checkNoNul(msg1, "msg1");
+  rt::checkNoNul(msg2, "msg2");
+  return this->ck().CompareType3(msg1.c_str(), msg2.c_str());
+}
+
+std::string HybridNtlm::genType1() {
+  this->beginCall();
+  return genType1_impl();
+}
+std::string HybridNtlm::genType1_impl() {
+  CkString _out;
+  if (!this->ck().GenType1(_out)) throw this->fail("genType1");
+  return rt::stdString(_out);
+}
+
+std::string HybridNtlm::genType2(const std::string& type1Msg) {
+  this->beginCall();
+  return genType2_impl(type1Msg);
+}
+std::string HybridNtlm::genType2_impl(const std::string& type1Msg) {
+  rt::checkNoNul(type1Msg, "type1Msg");
+  CkString _out;
+  if (!this->ck().GenType2(type1Msg.c_str(), _out)) throw this->fail("genType2");
+  return rt::stdString(_out);
+}
+
+std::string HybridNtlm::genType3(const std::string& type2Msg) {
+  this->beginCall();
+  return genType3_impl(type2Msg);
+}
+std::string HybridNtlm::genType3_impl(const std::string& type2Msg) {
+  rt::checkNoNul(type2Msg, "type2Msg");
+  CkString _out;
+  if (!this->ck().GenType3(type2Msg.c_str(), _out)) throw this->fail("genType3");
+  return rt::stdString(_out);
+}
+
+void HybridNtlm::loadType3(const std::string& type3Msg) {
+  this->beginCall();
+  loadType3_impl(type3Msg);
+}
+void HybridNtlm::loadType3_impl(const std::string& type3Msg) {
+  rt::checkNoNul(type3Msg, "type3Msg");
+  if (!this->ck().LoadType3(type3Msg.c_str())) throw this->fail("loadType3");
+}
+
+std::string HybridNtlm::parseType1(const std::string& type1Msg) {
+  this->beginCall();
+  return parseType1_impl(type1Msg);
+}
+std::string HybridNtlm::parseType1_impl(const std::string& type1Msg) {
+  rt::checkNoNul(type1Msg, "type1Msg");
+  CkString _out;
+  if (!this->ck().ParseType1(type1Msg.c_str(), _out)) throw this->fail("parseType1");
+  return rt::stdString(_out);
+}
+
+std::string HybridNtlm::parseType2(const std::string& type2Msg) {
+  this->beginCall();
+  return parseType2_impl(type2Msg);
+}
+std::string HybridNtlm::parseType2_impl(const std::string& type2Msg) {
+  rt::checkNoNul(type2Msg, "type2Msg");
+  CkString _out;
+  if (!this->ck().ParseType2(type2Msg.c_str(), _out)) throw this->fail("parseType2");
+  return rt::stdString(_out);
+}
+
+std::string HybridNtlm::parseType3(const std::string& type3Msg) {
+  this->beginCall();
+  return parseType3_impl(type3Msg);
+}
+std::string HybridNtlm::parseType3_impl(const std::string& type3Msg) {
+  rt::checkNoNul(type3Msg, "type3Msg");
+  CkString _out;
+  if (!this->ck().ParseType3(type3Msg.c_str(), _out)) throw this->fail("parseType3");
+  return rt::stdString(_out);
+}
+
+void HybridNtlm::setFlag(const std::string& flagLetter, bool onOrOff) {
+  this->beginCall();
+  setFlag_impl(flagLetter, onOrOff);
+}
+void HybridNtlm::setFlag_impl(const std::string& flagLetter, bool onOrOff) {
+  rt::checkNoNul(flagLetter, "flagLetter");
+  if (!this->ck().SetFlag(flagLetter.c_str(), onOrOff)) throw this->fail("setFlag");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridNtlm.hpp

@@ -0,0 +1,83 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Ntlm: the Nitro HybridObject over Chilkat's CkNtlm (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridNtlmSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkNtlm.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridNtlm final : public HybridNtlmSpec, public ChilkatObject<CkNtlm> {
+public:
+  HybridNtlm();                                  // `new Ntlm()` from JS
+  explicit HybridNtlm(CkNtlm* 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 getClientChallenge() override;
+  void setClientChallenge(const std::string& value) override;
+  std::string getDnsComputerName() override;
+  void setDnsComputerName(const std::string& value) override;
+  std::string getDnsDomainName() override;
+  void setDnsDomainName(const std::string& value) override;
+  std::string getDomain() override;
+  void setDomain(const std::string& value) override;
+  std::string getEncodingMode() override;
+  void setEncodingMode(const std::string& value) override;
+  std::string getFlags() override;
+  void setFlags(const std::string& value) override;
+  std::string getNetBiosComputerName() override;
+  void setNetBiosComputerName(const std::string& value) override;
+  std::string getNetBiosDomainName() override;
+  void setNetBiosDomainName(const std::string& value) override;
+  double getNtlmVersion() override;
+  void setNtlmVersion(double value) override;
+  double getOemCodePage() override;
+  void setOemCodePage(double value) override;
+  std::string getPassword() override;
+  void setPassword(const std::string& value) override;
+  std::string getServerChallenge() override;
+  void setServerChallenge(const std::string& value) override;
+  std::string getTargetName() override;
+  void setTargetName(const std::string& value) override;
+  std::string getUserName() override;
+  void setUserName(const std::string& value) override;
+  std::string getWorkstation() override;
+  void setWorkstation(const std::string& value) override;
+
+  // ---- Methods ----
+  bool compareType3(const std::string& msg1, const std::string& msg2) override;
+  std::string genType1() override;
+  std::string genType2(const std::string& type1Msg) override;
+  std::string genType3(const std::string& type2Msg) override;
+  void loadType3(const std::string& type3Msg) override;
+  std::string parseType1(const std::string& type1Msg) override;
+  std::string parseType2(const std::string& type2Msg) override;
+  std::string parseType3(const std::string& type3Msg) override;
+  void setFlag(const std::string& flagLetter, bool onOrOff) override;
+
+private:
+  void init();
+  bool compareType3_impl(const std::string& msg1, const std::string& msg2);
+  std::string genType1_impl();
+  std::string genType2_impl(const std::string& type1Msg);
+  std::string genType3_impl(const std::string& type2Msg);
+  void loadType3_impl(const std::string& type3Msg);
+  std::string parseType1_impl(const std::string& type1Msg);
+  std::string parseType2_impl(const std::string& type2Msg);
+  std::string parseType3_impl(const std::string& type3Msg);
+  void setFlag_impl(const std::string& flagLetter, bool onOrOff);
+};
+
+} // namespace margelo::nitro::chilkat