@chilkat/react-native 11.6.1

package/cpp/HybridCkDateTime.cpp

@@ -0,0 +1,384 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridCkDateTime.hpp"
+#include "HybridDtObj.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridCkDateTime::HybridCkDateTime()
+    : HybridObject(HybridCkDateTimeSpec::TAG), ChilkatObject<CkDateTime>("CkDateTime", CkDateTime::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridCkDateTime::HybridCkDateTime(CkDateTime* owned)
+    : HybridObject(HybridCkDateTimeSpec::TAG), ChilkatObject<CkDateTime>("CkDateTime", owned) {
+  init();
+}
+
+void HybridCkDateTime::init() {
+}
+
+void HybridCkDateTime::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridCkDateTime::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCkDateTime::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCkDateTime::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCkDateTime::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCkDateTime::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridCkDateTime::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridCkDateTime::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridCkDateTime::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridCkDateTime::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridCkDateTime::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridCkDateTime::getIsDst() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_IsDst());
+}
+double HybridCkDateTime::getUtcOffset() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_UtcOffset());
+}
+
+// ---- Methods ----
+
+void HybridCkDateTime::addDays(double numDays) {
+  this->beginCall();
+  addDays_impl(numDays);
+}
+void HybridCkDateTime::addDays_impl(double numDays) {
+  if (!this->ck().AddDays(rt::toInt(numDays, "numDays"))) throw this->fail("addDays");
+}
+
+void HybridCkDateTime::deSerialize(const std::string& serializedDateTime) {
+  this->beginCall();
+  deSerialize_impl(serializedDateTime);
+}
+void HybridCkDateTime::deSerialize_impl(const std::string& serializedDateTime) {
+  rt::checkNoNul(serializedDateTime, "serializedDateTime");
+  this->ck().DeSerialize(serializedDateTime.c_str());
+}
+
+double HybridCkDateTime::getAsDateTimeTicks(bool bLocal) {
+  this->beginCall();
+  return getAsDateTimeTicks_impl(bLocal);
+}
+double HybridCkDateTime::getAsDateTimeTicks_impl(bool bLocal) {
+  return static_cast<double>(this->ck().GetAsDateTimeTicks(bLocal));
+}
+
+double HybridCkDateTime::getAsDosDate(bool bLocal) {
+  this->beginCall();
+  return getAsDosDate_impl(bLocal);
+}
+double HybridCkDateTime::getAsDosDate_impl(bool bLocal) {
+  return static_cast<double>(this->ck().GetAsDosDate(bLocal));
+}
+
+double HybridCkDateTime::getAsOleDate(bool bLocal) {
+  this->beginCall();
+  return getAsOleDate_impl(bLocal);
+}
+double HybridCkDateTime::getAsOleDate_impl(bool bLocal) {
+  return static_cast<double>(this->ck().GetAsOleDate(bLocal));
+}
+
+std::string HybridCkDateTime::getAsRfc822(bool bLocal) {
+  this->beginCall();
+  return getAsRfc822_impl(bLocal);
+}
+std::string HybridCkDateTime::getAsRfc822_impl(bool bLocal) {
+  CkString _out;
+  if (!this->ck().GetAsRfc822(bLocal, _out)) throw this->fail("getAsRfc822");
+  return rt::stdString(_out);
+}
+
+double HybridCkDateTime::getAsUnixTime(bool bLocal) {
+  this->beginCall();
+  return getAsUnixTime_impl(bLocal);
+}
+double HybridCkDateTime::getAsUnixTime_impl(bool bLocal) {
+  return static_cast<double>(this->ck().GetAsUnixTime(bLocal));
+}
+
+double HybridCkDateTime::getAsUnixTime64(bool bLocal) {
+  this->beginCall();
+  return getAsUnixTime64_impl(bLocal);
+}
+double HybridCkDateTime::getAsUnixTime64_impl(bool bLocal) {
+  return static_cast<double>(this->ck().GetAsUnixTime64(bLocal));
+}
+
+double HybridCkDateTime::getAsUnixTimeDbl(bool bLocal) {
+  this->beginCall();
+  return getAsUnixTimeDbl_impl(bLocal);
+}
+double HybridCkDateTime::getAsUnixTimeDbl_impl(bool bLocal) {
+  return static_cast<double>(this->ck().GetAsUnixTimeDbl(bLocal));
+}
+
+std::string HybridCkDateTime::serialize() {
+  this->beginCall();
+  return serialize_impl();
+}
+std::string HybridCkDateTime::serialize_impl() {
+  CkString _out;
+  if (!this->ck().Serialize(_out)) throw this->fail("serialize");
+  return rt::stdString(_out);
+}
+
+void HybridCkDateTime::setFromCurrentSystemTime() {
+  this->beginCall();
+  setFromCurrentSystemTime_impl();
+}
+void HybridCkDateTime::setFromCurrentSystemTime_impl() {
+  if (!this->ck().SetFromCurrentSystemTime()) throw this->fail("setFromCurrentSystemTime");
+}
+
+void HybridCkDateTime::setFromDateTimeTicks(bool bLocal, double ticks) {
+  this->beginCall();
+  setFromDateTimeTicks_impl(bLocal, ticks);
+}
+void HybridCkDateTime::setFromDateTimeTicks_impl(bool bLocal, double ticks) {
+  if (!this->ck().SetFromDateTimeTicks(bLocal, rt::toInt64(ticks, "ticks"))) throw this->fail("setFromDateTimeTicks");
+}
+
+void HybridCkDateTime::setFromDosDate(bool bLocal, double t) {
+  this->beginCall();
+  setFromDosDate_impl(bLocal, t);
+}
+void HybridCkDateTime::setFromDosDate_impl(bool bLocal, double t) {
+  if (!this->ck().SetFromDosDate(bLocal, rt::toULong(t, "t"))) throw this->fail("setFromDosDate");
+}
+
+void HybridCkDateTime::setFromDtObj(const std::shared_ptr<HybridDtObjSpec>& dt) {
+  this->beginCall();
+  setFromDtObj_impl(dt);
+}
+void HybridCkDateTime::setFromDtObj_impl(const std::shared_ptr<HybridDtObjSpec>& dt) {
+  if (!this->ck().SetFromDtObj(rt::implOf<HybridDtObj>(dt, "dt").ck())) throw this->fail("setFromDtObj");
+}
+
+void HybridCkDateTime::setFromNtpTime(double ntpSeconds) {
+  this->beginCall();
+  setFromNtpTime_impl(ntpSeconds);
+}
+void HybridCkDateTime::setFromNtpTime_impl(double ntpSeconds) {
+  if (!this->ck().SetFromNtpTime(rt::toInt(ntpSeconds, "ntpSeconds"))) throw this->fail("setFromNtpTime");
+}
+
+void HybridCkDateTime::setFromOleDate(bool bLocal, double dt) {
+  this->beginCall();
+  setFromOleDate_impl(bLocal, dt);
+}
+void HybridCkDateTime::setFromOleDate_impl(bool bLocal, double dt) {
+  if (!this->ck().SetFromOleDate(bLocal, rt::toDouble(dt, "dt"))) throw this->fail("setFromOleDate");
+}
+
+void HybridCkDateTime::setFromRfc822(const std::string& rfc822Str) {
+  this->beginCall();
+  setFromRfc822_impl(rfc822Str);
+}
+void HybridCkDateTime::setFromRfc822_impl(const std::string& rfc822Str) {
+  rt::checkNoNul(rfc822Str, "rfc822Str");
+  if (!this->ck().SetFromRfc822(rfc822Str.c_str())) throw this->fail("setFromRfc822");
+}
+
+void HybridCkDateTime::setFromUnixTime(bool bLocal, double t) {
+  this->beginCall();
+  setFromUnixTime_impl(bLocal, t);
+}
+void HybridCkDateTime::setFromUnixTime_impl(bool bLocal, double t) {
+  if (!this->ck().SetFromUnixTime(bLocal, static_cast<time_t>(rt::toInt64(t, "t")))) throw this->fail("setFromUnixTime");
+}
+
+void HybridCkDateTime::setFromUnixTime64(bool bLocal, double t) {
+  this->beginCall();
+  setFromUnixTime64_impl(bLocal, t);
+}
+void HybridCkDateTime::setFromUnixTime64_impl(bool bLocal, double t) {
+  if (!this->ck().SetFromUnixTime64(bLocal, rt::toInt64(t, "t"))) throw this->fail("setFromUnixTime64");
+}
+
+void HybridCkDateTime::setFromUnixTimeDbl(bool bLocal, double d) {
+  this->beginCall();
+  setFromUnixTimeDbl_impl(bLocal, d);
+}
+void HybridCkDateTime::setFromUnixTimeDbl_impl(bool bLocal, double d) {
+  if (!this->ck().SetFromUnixTimeDbl(bLocal, rt::toDouble(d, "d"))) throw this->fail("setFromUnixTimeDbl");
+}
+
+void HybridCkDateTime::setFromTimestamp(const std::string& timestamp) {
+  this->beginCall();
+  setFromTimestamp_impl(timestamp);
+}
+void HybridCkDateTime::setFromTimestamp_impl(const std::string& timestamp) {
+  rt::checkNoNul(timestamp, "timestamp");
+  if (!this->ck().SetFromTimestamp(timestamp.c_str())) throw this->fail("setFromTimestamp");
+}
+
+std::string HybridCkDateTime::getAsTimestamp(bool bLocal) {
+  this->beginCall();
+  return getAsTimestamp_impl(bLocal);
+}
+std::string HybridCkDateTime::getAsTimestamp_impl(bool bLocal) {
+  CkString _out;
+  if (!this->ck().GetAsTimestamp(bLocal, _out)) throw this->fail("getAsTimestamp");
+  return rt::stdString(_out);
+}
+
+double HybridCkDateTime::diffSeconds(const std::shared_ptr<HybridCkDateTimeSpec>& dateTimeArg) {
+  this->beginCall();
+  return diffSeconds_impl(dateTimeArg);
+}
+double HybridCkDateTime::diffSeconds_impl(const std::shared_ptr<HybridCkDateTimeSpec>& dateTimeArg) {
+  return static_cast<double>(this->ck().DiffSeconds(rt::implOf<HybridCkDateTime>(dateTimeArg, "dateTimeArg").ck()));
+}
+
+void HybridCkDateTime::addSeconds(double numSeconds) {
+  this->beginCall();
+  addSeconds_impl(numSeconds);
+}
+void HybridCkDateTime::addSeconds_impl(double numSeconds) {
+  if (!this->ck().AddSeconds(rt::toInt(numSeconds, "numSeconds"))) throw this->fail("addSeconds");
+}
+
+std::string HybridCkDateTime::getAsUnixTimeStr(bool bLocal) {
+  this->beginCall();
+  return getAsUnixTimeStr_impl(bLocal);
+}
+std::string HybridCkDateTime::getAsUnixTimeStr_impl(bool bLocal) {
+  CkString _out;
+  if (!this->ck().GetAsUnixTimeStr(bLocal, _out)) throw this->fail("getAsUnixTimeStr");
+  return rt::stdString(_out);
+}
+
+std::string HybridCkDateTime::getAsIso8601(const std::string& formatStr, bool bLocal) {
+  this->beginCall();
+  return getAsIso8601_impl(formatStr, bLocal);
+}
+std::string HybridCkDateTime::getAsIso8601_impl(const std::string& formatStr, bool bLocal) {
+  rt::checkNoNul(formatStr, "formatStr");
+  CkString _out;
+  if (!this->ck().GetAsIso8601(formatStr.c_str(), bLocal, _out)) throw this->fail("getAsIso8601");
+  return rt::stdString(_out);
+}
+
+bool HybridCkDateTime::expiresWithin(double n, const std::string& units) {
+  this->beginCall();
+  return expiresWithin_impl(n, units);
+}
+bool HybridCkDateTime::expiresWithin_impl(double n, const std::string& units) {
+  rt::checkNoNul(units, "units");
+  return this->ck().ExpiresWithin(rt::toInt(n, "n"), units.c_str());
+}
+
+bool HybridCkDateTime::olderThan(double n, const std::string& units) {
+  this->beginCall();
+  return olderThan_impl(n, units);
+}
+bool HybridCkDateTime::olderThan_impl(double n, const std::string& units) {
+  rt::checkNoNul(units, "units");
+  return this->ck().OlderThan(rt::toInt(n, "n"), units.c_str());
+}
+
+void HybridCkDateTime::ulidValidate(const std::string& ulid) {
+  this->beginCall();
+  ulidValidate_impl(ulid);
+}
+void HybridCkDateTime::ulidValidate_impl(const std::string& ulid) {
+  rt::checkNoNul(ulid, "ulid");
+  if (!this->ck().UlidValidate(ulid.c_str())) throw this->fail("ulidValidate");
+}
+
+std::string HybridCkDateTime::ulidGenerate(bool bLocal) {
+  this->beginCall();
+  return ulidGenerate_impl(bLocal);
+}
+std::string HybridCkDateTime::ulidGenerate_impl(bool bLocal) {
+  CkString _out;
+  if (!this->ck().UlidGenerate(bLocal, _out)) throw this->fail("ulidGenerate");
+  return rt::stdString(_out);
+}
+
+void HybridCkDateTime::setFromUlid(bool bLocal, const std::string& ulid) {
+  this->beginCall();
+  setFromUlid_impl(bLocal, ulid);
+}
+void HybridCkDateTime::setFromUlid_impl(bool bLocal, const std::string& ulid) {
+  rt::checkNoNul(ulid, "ulid");
+  if (!this->ck().SetFromUlid(bLocal, ulid.c_str())) throw this->fail("setFromUlid");
+}
+
+void HybridCkDateTime::ulidIncrement(const std::shared_ptr<HybridStringBuilderSpec>& ulid) {
+  this->beginCall();
+  ulidIncrement_impl(ulid);
+}
+void HybridCkDateTime::ulidIncrement_impl(const std::shared_ptr<HybridStringBuilderSpec>& ulid) {
+  if (!this->ck().UlidIncrement(rt::implOf<HybridStringBuilder>(ulid, "ulid").ck())) throw this->fail("ulidIncrement");
+}
+
+void HybridCkDateTime::setFromNtpServer(const std::string& jsonStr) {
+  this->beginCall();
+  setFromNtpServer_impl(jsonStr);
+}
+void HybridCkDateTime::setFromNtpServer_impl(const std::string& jsonStr) {
+  rt::checkNoNul(jsonStr, "jsonStr");
+  if (!this->ck().SetFromNtpServer(jsonStr.c_str())) throw this->fail("setFromNtpServer");
+}
+
+void HybridCkDateTime::toDtObj(bool bLocal, const std::shared_ptr<HybridDtObjSpec>& dtObj) {
+  this->beginCall();
+  toDtObj_impl(bLocal, dtObj);
+}
+void HybridCkDateTime::toDtObj_impl(bool bLocal, const std::shared_ptr<HybridDtObjSpec>& dtObj) {
+  this->ck().ToDtObj(bLocal, rt::implOf<HybridDtObj>(dtObj, "dtObj").ck());
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridCkDateTime.hpp

@@ -0,0 +1,105 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// CkDateTime: the Nitro HybridObject over Chilkat's CkDateTime (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridCkDateTimeSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkDateTime.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridCkDateTime final : public HybridCkDateTimeSpec, public ChilkatObject<CkDateTime> {
+public:
+  HybridCkDateTime();                                  // `new CkDateTime()` from JS
+  explicit HybridCkDateTime(CkDateTime* 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 getIsDst() override;
+  double getUtcOffset() override;
+
+  // ---- Methods ----
+  void addDays(double numDays) override;
+  void deSerialize(const std::string& serializedDateTime) override;
+  double getAsDateTimeTicks(bool bLocal) override;
+  double getAsDosDate(bool bLocal) override;
+  double getAsOleDate(bool bLocal) override;
+  std::string getAsRfc822(bool bLocal) override;
+  double getAsUnixTime(bool bLocal) override;
+  double getAsUnixTime64(bool bLocal) override;
+  double getAsUnixTimeDbl(bool bLocal) override;
+  std::string serialize() override;
+  void setFromCurrentSystemTime() override;
+  void setFromDateTimeTicks(bool bLocal, double ticks) override;
+  void setFromDosDate(bool bLocal, double t) override;
+  void setFromDtObj(const std::shared_ptr<HybridDtObjSpec>& dt) override;
+  void setFromNtpTime(double ntpSeconds) override;
+  void setFromOleDate(bool bLocal, double dt) override;
+  void setFromRfc822(const std::string& rfc822Str) override;
+  void setFromUnixTime(bool bLocal, double t) override;
+  void setFromUnixTime64(bool bLocal, double t) override;
+  void setFromUnixTimeDbl(bool bLocal, double d) override;
+  void setFromTimestamp(const std::string& timestamp) override;
+  std::string getAsTimestamp(bool bLocal) override;
+  double diffSeconds(const std::shared_ptr<HybridCkDateTimeSpec>& dateTimeArg) override;
+  void addSeconds(double numSeconds) override;
+  std::string getAsUnixTimeStr(bool bLocal) override;
+  std::string getAsIso8601(const std::string& formatStr, bool bLocal) override;
+  bool expiresWithin(double n, const std::string& units) override;
+  bool olderThan(double n, const std::string& units) override;
+  void ulidValidate(const std::string& ulid) override;
+  std::string ulidGenerate(bool bLocal) override;
+  void setFromUlid(bool bLocal, const std::string& ulid) override;
+  void ulidIncrement(const std::shared_ptr<HybridStringBuilderSpec>& ulid) override;
+  void setFromNtpServer(const std::string& jsonStr) override;
+  void toDtObj(bool bLocal, const std::shared_ptr<HybridDtObjSpec>& dtObj) override;
+
+private:
+  void init();
+  void addDays_impl(double numDays);
+  void deSerialize_impl(const std::string& serializedDateTime);
+  double getAsDateTimeTicks_impl(bool bLocal);
+  double getAsDosDate_impl(bool bLocal);
+  double getAsOleDate_impl(bool bLocal);
+  std::string getAsRfc822_impl(bool bLocal);
+  double getAsUnixTime_impl(bool bLocal);
+  double getAsUnixTime64_impl(bool bLocal);
+  double getAsUnixTimeDbl_impl(bool bLocal);
+  std::string serialize_impl();
+  void setFromCurrentSystemTime_impl();
+  void setFromDateTimeTicks_impl(bool bLocal, double ticks);
+  void setFromDosDate_impl(bool bLocal, double t);
+  void setFromDtObj_impl(const std::shared_ptr<HybridDtObjSpec>& dt);
+  void setFromNtpTime_impl(double ntpSeconds);
+  void setFromOleDate_impl(bool bLocal, double dt);
+  void setFromRfc822_impl(const std::string& rfc822Str);
+  void setFromUnixTime_impl(bool bLocal, double t);
+  void setFromUnixTime64_impl(bool bLocal, double t);
+  void setFromUnixTimeDbl_impl(bool bLocal, double d);
+  void setFromTimestamp_impl(const std::string& timestamp);
+  std::string getAsTimestamp_impl(bool bLocal);
+  double diffSeconds_impl(const std::shared_ptr<HybridCkDateTimeSpec>& dateTimeArg);
+  void addSeconds_impl(double numSeconds);
+  std::string getAsUnixTimeStr_impl(bool bLocal);
+  std::string getAsIso8601_impl(const std::string& formatStr, bool bLocal);
+  bool expiresWithin_impl(double n, const std::string& units);
+  bool olderThan_impl(double n, const std::string& units);
+  void ulidValidate_impl(const std::string& ulid);
+  std::string ulidGenerate_impl(bool bLocal);
+  void setFromUlid_impl(bool bLocal, const std::string& ulid);
+  void ulidIncrement_impl(const std::shared_ptr<HybridStringBuilderSpec>& ulid);
+  void setFromNtpServer_impl(const std::string& jsonStr);
+  void toDtObj_impl(bool bLocal, const std::shared_ptr<HybridDtObjSpec>& dtObj);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridCodeSign.cpp

@@ -0,0 +1,156 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridCodeSign.hpp"
+#include "HybridCert.hpp"
+#include "HybridJsonObject.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridCodeSign::HybridCodeSign()
+    : HybridObject(HybridCodeSignSpec::TAG), ChilkatObject<CkCodeSign>("CodeSign", CkCodeSign::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridCodeSign::HybridCodeSign(CkCodeSign* owned)
+    : HybridObject(HybridCodeSignSpec::TAG), ChilkatObject<CkCodeSign>("CodeSign", owned) {
+  init();
+}
+
+void HybridCodeSign::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridCodeSign::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridCodeSign::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCodeSign::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCodeSign::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCodeSign::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCodeSign::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridCodeSign::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridCodeSign::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridCodeSign::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridCodeSign::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridCodeSign::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridCodeSign::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridCodeSign::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+double HybridCodeSign::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridCodeSign::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+
+// ---- Methods ----
+
+void HybridCodeSign::verifySignature(const std::string& path, const std::shared_ptr<HybridJsonObjectSpec>& sigInfo) {
+  this->beginCall();
+  verifySignature_impl(path, sigInfo);
+}
+void HybridCodeSign::verifySignature_impl(const std::string& path, const std::shared_ptr<HybridJsonObjectSpec>& sigInfo) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().VerifySignature(path.c_str(), rt::implOf<HybridJsonObject>(sigInfo, "sigInfo").ck())) throw this->fail("verifySignature");
+}
+
+void HybridCodeSign::removeSignature(const std::string& path) {
+  this->beginCall();
+  removeSignature_impl(path);
+}
+void HybridCodeSign::removeSignature_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().RemoveSignature(path.c_str())) throw this->fail("removeSignature");
+}
+
+void HybridCodeSign::addSignature(const std::string& path, const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridJsonObjectSpec>& options) {
+  this->beginCall();
+  addSignature_impl(path, cert, options);
+}
+void HybridCodeSign::addSignature_impl(const std::string& path, const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridJsonObjectSpec>& options) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().AddSignature(path.c_str(), rt::implOf<HybridCert>(cert, "cert").ck(), rt::implOf<HybridJsonObject>(options, "options").ck())) throw this->fail("addSignature");
+}
+std::shared_ptr<Promise<void>> HybridCodeSign::addSignatureAsync(const std::string& path, const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridJsonObjectSpec>& options) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCodeSign>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(cert);
+  _parts.push_back(options);
+  return rt::runAsync<void>("CodeSign.addSignatureAsync", std::move(_parts), [_self, path, cert, options]() {
+    _self->addSignature_impl(path, cert, options);
+  });
+}
+
+void HybridCodeSign::getSignerCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  getSignerCert_impl(cert);
+}
+void HybridCodeSign::getSignerCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().GetSignerCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("getSignerCert");
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridCodeSign::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridCodeSign::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridCodeSign::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridCodeSign::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridCodeSign::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat