@chilkat/react-native 11.6.1

package/cpp/HybridEmailBundle.hpp

@@ -0,0 +1,64 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// EmailBundle: the Nitro HybridObject over Chilkat's CkEmailBundle (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridEmailBundleSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkEmailBundle.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridEmailBundle final : public HybridEmailBundleSpec, public ChilkatObject<CkEmailBundle> {
+public:
+  HybridEmailBundle();                                  // `new EmailBundle()` from JS
+  explicit HybridEmailBundle(CkEmailBundle* 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 getMessageCount() override;
+
+  // ---- Methods ----
+  void addEmail(const std::shared_ptr<HybridEmailSpec>& email) override;
+  std::string getXml() override;
+  void loadXml(const std::string& path) override;
+  void loadXmlString(const std::string& xmlStr) override;
+  void removeEmail(const std::shared_ptr<HybridEmailSpec>& email) override;
+  void removeEmailByIndex(double index) override;
+  void saveXml(const std::string& path) override;
+  void sortByDate(bool ascending) override;
+  void sortByRecipient(bool ascending) override;
+  void sortBySender(bool ascending) override;
+  void sortBySubject(bool ascending) override;
+  void findEmail(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridEmailSpec>& email) override;
+  void emailAt(double index, const std::shared_ptr<HybridEmailSpec>& email) override;
+  void clear() override;
+
+private:
+  void init();
+  void addEmail_impl(const std::shared_ptr<HybridEmailSpec>& email);
+  std::string getXml_impl();
+  void loadXml_impl(const std::string& path);
+  void loadXmlString_impl(const std::string& xmlStr);
+  void removeEmail_impl(const std::shared_ptr<HybridEmailSpec>& email);
+  void removeEmailByIndex_impl(double index);
+  void saveXml_impl(const std::string& path);
+  void sortByDate_impl(bool ascending);
+  void sortByRecipient_impl(bool ascending);
+  void sortBySender_impl(bool ascending);
+  void sortBySubject_impl(bool ascending);
+  void findEmail_impl(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridEmailSpec>& email);
+  void emailAt_impl(double index, const std::shared_ptr<HybridEmailSpec>& email);
+  void clear_impl();
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridFileAccess.cpp

@@ -0,0 +1,631 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridFileAccess.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCkDateTime.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridFileAccess::HybridFileAccess()
+    : HybridObject(HybridFileAccessSpec::TAG), ChilkatObject<CkFileAccess>("FileAccess", CkFileAccess::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridFileAccess::HybridFileAccess(CkFileAccess* owned)
+    : HybridObject(HybridFileAccessSpec::TAG), ChilkatObject<CkFileAccess>("FileAccess", owned) {
+  init();
+}
+
+void HybridFileAccess::init() {
+}
+
+void HybridFileAccess::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridFileAccess::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridFileAccess::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridFileAccess::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridFileAccess::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridFileAccess::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridFileAccess::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridFileAccess::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridFileAccess::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridFileAccess::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridFileAccess::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridFileAccess::getCurrentDir() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_CurrentDir(_s);
+  return rt::stdString(_s);
+}
+bool HybridFileAccess::getEndOfFile() {
+  this->beginCall();
+  return this->ck().get_EndOfFile();
+}
+double HybridFileAccess::getFileOpenError() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_FileOpenError());
+}
+std::string HybridFileAccess::getFileOpenErrorMsg() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_FileOpenErrorMsg(_s);
+  return rt::stdString(_s);
+}
+bool HybridFileAccess::getLockFileOnOpen() {
+  this->beginCall();
+  return this->ck().get_LockFileOnOpen();
+}
+void HybridFileAccess::setLockFileOnOpen(bool value) {
+  this->beginCall();
+  this->ck().put_LockFileOnOpen(value);
+}
+
+// ---- Methods ----
+
+void HybridFileAccess::appendAnsi(const std::string& text) {
+  this->beginCall();
+  appendAnsi_impl(text);
+}
+void HybridFileAccess::appendAnsi_impl(const std::string& text) {
+  rt::checkNoNul(text, "text");
+  if (!this->ck().AppendAnsi(text.c_str())) throw this->fail("appendAnsi");
+}
+
+void HybridFileAccess::appendText(const std::string& str, const std::string& charset) {
+  this->beginCall();
+  appendText_impl(str, charset);
+}
+void HybridFileAccess::appendText_impl(const std::string& str, const std::string& charset) {
+  rt::checkNoNul(str, "str");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().AppendText(str.c_str(), charset.c_str())) throw this->fail("appendText");
+}
+
+void HybridFileAccess::appendUnicodeBOM() {
+  this->beginCall();
+  appendUnicodeBOM_impl();
+}
+void HybridFileAccess::appendUnicodeBOM_impl() {
+  if (!this->ck().AppendUnicodeBOM()) throw this->fail("appendUnicodeBOM");
+}
+
+void HybridFileAccess::appendUtf8BOM() {
+  this->beginCall();
+  appendUtf8BOM_impl();
+}
+void HybridFileAccess::appendUtf8BOM_impl() {
+  if (!this->ck().AppendUtf8BOM()) throw this->fail("appendUtf8BOM");
+}
+
+void HybridFileAccess::dirAutoCreate(const std::string& filePath) {
+  this->beginCall();
+  dirAutoCreate_impl(filePath);
+}
+void HybridFileAccess::dirAutoCreate_impl(const std::string& filePath) {
+  rt::checkNoNul(filePath, "filePath");
+  if (!this->ck().DirAutoCreate(filePath.c_str())) throw this->fail("dirAutoCreate");
+}
+
+void HybridFileAccess::dirCreate(const std::string& dirPath) {
+  this->beginCall();
+  dirCreate_impl(dirPath);
+}
+void HybridFileAccess::dirCreate_impl(const std::string& dirPath) {
+  rt::checkNoNul(dirPath, "dirPath");
+  if (!this->ck().DirCreate(dirPath.c_str())) throw this->fail("dirCreate");
+}
+
+void HybridFileAccess::dirDelete(const std::string& dirPath) {
+  this->beginCall();
+  dirDelete_impl(dirPath);
+}
+void HybridFileAccess::dirDelete_impl(const std::string& dirPath) {
+  rt::checkNoNul(dirPath, "dirPath");
+  if (!this->ck().DirDelete(dirPath.c_str())) throw this->fail("dirDelete");
+}
+
+void HybridFileAccess::dirEnsureExists(const std::string& dirPath) {
+  this->beginCall();
+  dirEnsureExists_impl(dirPath);
+}
+void HybridFileAccess::dirEnsureExists_impl(const std::string& dirPath) {
+  rt::checkNoNul(dirPath, "dirPath");
+  if (!this->ck().DirEnsureExists(dirPath.c_str())) throw this->fail("dirEnsureExists");
+}
+
+void HybridFileAccess::fileClose() {
+  this->beginCall();
+  fileClose_impl();
+}
+void HybridFileAccess::fileClose_impl() {
+  this->ck().FileClose();
+}
+
+bool HybridFileAccess::fileContentsEqual(const std::string& filePath1, const std::string& filePath2) {
+  this->beginCall();
+  return fileContentsEqual_impl(filePath1, filePath2);
+}
+bool HybridFileAccess::fileContentsEqual_impl(const std::string& filePath1, const std::string& filePath2) {
+  rt::checkNoNul(filePath1, "filePath1");
+  rt::checkNoNul(filePath2, "filePath2");
+  return this->ck().FileContentsEqual(filePath1.c_str(), filePath2.c_str());
+}
+
+void HybridFileAccess::fileCopy(const std::string& existingFilepath, const std::string& newFilepath, bool failIfExists) {
+  this->beginCall();
+  fileCopy_impl(existingFilepath, newFilepath, failIfExists);
+}
+void HybridFileAccess::fileCopy_impl(const std::string& existingFilepath, const std::string& newFilepath, bool failIfExists) {
+  rt::checkNoNul(existingFilepath, "existingFilepath");
+  rt::checkNoNul(newFilepath, "newFilepath");
+  if (!this->ck().FileCopy(existingFilepath.c_str(), newFilepath.c_str(), failIfExists)) throw this->fail("fileCopy");
+}
+
+void HybridFileAccess::fileDelete(const std::string& filePath) {
+  this->beginCall();
+  fileDelete_impl(filePath);
+}
+void HybridFileAccess::fileDelete_impl(const std::string& filePath) {
+  rt::checkNoNul(filePath, "filePath");
+  if (!this->ck().FileDelete(filePath.c_str())) throw this->fail("fileDelete");
+}
+
+bool HybridFileAccess::fileExists(const std::string& filePath) {
+  this->beginCall();
+  return fileExists_impl(filePath);
+}
+bool HybridFileAccess::fileExists_impl(const std::string& filePath) {
+  rt::checkNoNul(filePath, "filePath");
+  return this->ck().FileExists(filePath.c_str());
+}
+
+double HybridFileAccess::fileExists3(const std::string& path) {
+  this->beginCall();
+  return fileExists3_impl(path);
+}
+double HybridFileAccess::fileExists3_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  return static_cast<double>(this->ck().FileExists3(path.c_str()));
+}
+
+void HybridFileAccess::fileOpen(const std::string& filePath, double accessMode, double shareMode, double createDisposition, double attributes) {
+  this->beginCall();
+  fileOpen_impl(filePath, accessMode, shareMode, createDisposition, attributes);
+}
+void HybridFileAccess::fileOpen_impl(const std::string& filePath, double accessMode, double shareMode, double createDisposition, double attributes) {
+  rt::checkNoNul(filePath, "filePath");
+  if (!this->ck().FileOpen(filePath.c_str(), rt::toULong(accessMode, "accessMode"), rt::toULong(shareMode, "shareMode"), rt::toULong(createDisposition, "createDisposition"), rt::toULong(attributes, "attributes"))) throw this->fail("fileOpen");
+}
+
+void HybridFileAccess::fileRename(const std::string& existingFilepath, const std::string& newFilepath) {
+  this->beginCall();
+  fileRename_impl(existingFilepath, newFilepath);
+}
+void HybridFileAccess::fileRename_impl(const std::string& existingFilepath, const std::string& newFilepath) {
+  rt::checkNoNul(existingFilepath, "existingFilepath");
+  rt::checkNoNul(newFilepath, "newFilepath");
+  if (!this->ck().FileRename(existingFilepath.c_str(), newFilepath.c_str())) throw this->fail("fileRename");
+}
+
+void HybridFileAccess::fileSeek(double offset, double origin) {
+  this->beginCall();
+  fileSeek_impl(offset, origin);
+}
+void HybridFileAccess::fileSeek_impl(double offset, double origin) {
+  if (!this->ck().FileSeek(rt::toInt(offset, "offset"), rt::toInt(origin, "origin"))) throw this->fail("fileSeek");
+}
+
+double HybridFileAccess::fileSize(const std::string& filePath) {
+  this->beginCall();
+  return fileSize_impl(filePath);
+}
+double HybridFileAccess::fileSize_impl(const std::string& filePath) {
+  rt::checkNoNul(filePath, "filePath");
+  return static_cast<double>(this->ck().FileSize(filePath.c_str()));
+}
+
+std::string HybridFileAccess::genBlockId(double index, double length, const std::string& encoding) {
+  this->beginCall();
+  return genBlockId_impl(index, length, encoding);
+}
+std::string HybridFileAccess::genBlockId_impl(double index, double length, const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().GenBlockId(rt::toInt(index, "index"), rt::toInt(length, "length"), encoding.c_str(), _out)) throw this->fail("genBlockId");
+  return rt::stdString(_out);
+}
+
+double HybridFileAccess::getNumBlocks(double blockSize) {
+  this->beginCall();
+  return getNumBlocks_impl(blockSize);
+}
+double HybridFileAccess::getNumBlocks_impl(double blockSize) {
+  return static_cast<double>(this->ck().GetNumBlocks(rt::toInt(blockSize, "blockSize")));
+}
+
+std::string HybridFileAccess::getTempFilename(const std::string& dirPath, const std::string& prefix) {
+  this->beginCall();
+  return getTempFilename_impl(dirPath, prefix);
+}
+std::string HybridFileAccess::getTempFilename_impl(const std::string& dirPath, const std::string& prefix) {
+  rt::checkNoNul(dirPath, "dirPath");
+  rt::checkNoNul(prefix, "prefix");
+  CkString _out;
+  if (!this->ck().GetTempFilename(dirPath.c_str(), prefix.c_str(), _out)) throw this->fail("getTempFilename");
+  return rt::stdString(_out);
+}
+
+void HybridFileAccess::openForAppend(const std::string& filePath) {
+  this->beginCall();
+  openForAppend_impl(filePath);
+}
+void HybridFileAccess::openForAppend_impl(const std::string& filePath) {
+  rt::checkNoNul(filePath, "filePath");
+  if (!this->ck().OpenForAppend(filePath.c_str())) throw this->fail("openForAppend");
+}
+
+void HybridFileAccess::openForRead(const std::string& filePath) {
+  this->beginCall();
+  openForRead_impl(filePath);
+}
+void HybridFileAccess::openForRead_impl(const std::string& filePath) {
+  rt::checkNoNul(filePath, "filePath");
+  if (!this->ck().OpenForRead(filePath.c_str())) throw this->fail("openForRead");
+}
+
+void HybridFileAccess::openForReadWrite(const std::string& filePath) {
+  this->beginCall();
+  openForReadWrite_impl(filePath);
+}
+void HybridFileAccess::openForReadWrite_impl(const std::string& filePath) {
+  rt::checkNoNul(filePath, "filePath");
+  if (!this->ck().OpenForReadWrite(filePath.c_str())) throw this->fail("openForReadWrite");
+}
+
+void HybridFileAccess::openForWrite(const std::string& filePath) {
+  this->beginCall();
+  openForWrite_impl(filePath);
+}
+void HybridFileAccess::openForWrite_impl(const std::string& filePath) {
+  rt::checkNoNul(filePath, "filePath");
+  if (!this->ck().OpenForWrite(filePath.c_str())) throw this->fail("openForWrite");
+}
+
+std::string HybridFileAccess::readBinaryToEncoded(const std::string& filePath, const std::string& encoding) {
+  this->beginCall();
+  return readBinaryToEncoded_impl(filePath, encoding);
+}
+std::string HybridFileAccess::readBinaryToEncoded_impl(const std::string& filePath, const std::string& encoding) {
+  rt::checkNoNul(filePath, "filePath");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().ReadBinaryToEncoded(filePath.c_str(), encoding.c_str(), _out)) throw this->fail("readBinaryToEncoded");
+  return rt::stdString(_out);
+}
+
+std::string HybridFileAccess::readEntireTextFile(const std::string& filePath, const std::string& charset) {
+  this->beginCall();
+  return readEntireTextFile_impl(filePath, charset);
+}
+std::string HybridFileAccess::readEntireTextFile_impl(const std::string& filePath, const std::string& charset) {
+  rt::checkNoNul(filePath, "filePath");
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().ReadEntireTextFile(filePath.c_str(), charset.c_str(), _out)) throw this->fail("readEntireTextFile");
+  return rt::stdString(_out);
+}
+
+void HybridFileAccess::reassembleFile(const std::string& partsDirPath, const std::string& partPrefix, const std::string& partExtension, const std::string& reassembledFilename) {
+  this->beginCall();
+  reassembleFile_impl(partsDirPath, partPrefix, partExtension, reassembledFilename);
+}
+void HybridFileAccess::reassembleFile_impl(const std::string& partsDirPath, const std::string& partPrefix, const std::string& partExtension, const std::string& reassembledFilename) {
+  rt::checkNoNul(partsDirPath, "partsDirPath");
+  rt::checkNoNul(partPrefix, "partPrefix");
+  rt::checkNoNul(partExtension, "partExtension");
+  rt::checkNoNul(reassembledFilename, "reassembledFilename");
+  if (!this->ck().ReassembleFile(partsDirPath.c_str(), partPrefix.c_str(), partExtension.c_str(), reassembledFilename.c_str())) throw this->fail("reassembleFile");
+}
+
+double HybridFileAccess::replaceStrings(const std::string& filePath, const std::string& charset, const std::string& existingString, const std::string& replacementString) {
+  this->beginCall();
+  return replaceStrings_impl(filePath, charset, existingString, replacementString);
+}
+double HybridFileAccess::replaceStrings_impl(const std::string& filePath, const std::string& charset, const std::string& existingString, const std::string& replacementString) {
+  rt::checkNoNul(filePath, "filePath");
+  rt::checkNoNul(charset, "charset");
+  rt::checkNoNul(existingString, "existingString");
+  rt::checkNoNul(replacementString, "replacementString");
+  return static_cast<double>(this->ck().ReplaceStrings(filePath.c_str(), charset.c_str(), existingString.c_str(), replacementString.c_str()));
+}
+
+void HybridFileAccess::setCurrentDir(const std::string& dirPath) {
+  this->beginCall();
+  setCurrentDir_impl(dirPath);
+}
+void HybridFileAccess::setCurrentDir_impl(const std::string& dirPath) {
+  rt::checkNoNul(dirPath, "dirPath");
+  if (!this->ck().SetCurrentDir(dirPath.c_str())) throw this->fail("setCurrentDir");
+}
+
+void HybridFileAccess::setFileTimes(const std::string& filePath, const std::shared_ptr<HybridCkDateTimeSpec>& createTime, const std::shared_ptr<HybridCkDateTimeSpec>& lastAccessTime, const std::shared_ptr<HybridCkDateTimeSpec>& lastModTime) {
+  this->beginCall();
+  setFileTimes_impl(filePath, createTime, lastAccessTime, lastModTime);
+}
+void HybridFileAccess::setFileTimes_impl(const std::string& filePath, const std::shared_ptr<HybridCkDateTimeSpec>& createTime, const std::shared_ptr<HybridCkDateTimeSpec>& lastAccessTime, const std::shared_ptr<HybridCkDateTimeSpec>& lastModTime) {
+  rt::checkNoNul(filePath, "filePath");
+  if (!this->ck().SetFileTimes(filePath.c_str(), rt::implOf<HybridCkDateTime>(createTime, "createTime").ck(), rt::implOf<HybridCkDateTime>(lastAccessTime, "lastAccessTime").ck(), rt::implOf<HybridCkDateTime>(lastModTime, "lastModTime").ck())) throw this->fail("setFileTimes");
+}
+
+void HybridFileAccess::setLastModified(const std::string& filePath, const std::shared_ptr<HybridCkDateTimeSpec>& lastModified) {
+  this->beginCall();
+  setLastModified_impl(filePath, lastModified);
+}
+void HybridFileAccess::setLastModified_impl(const std::string& filePath, const std::shared_ptr<HybridCkDateTimeSpec>& lastModified) {
+  rt::checkNoNul(filePath, "filePath");
+  if (!this->ck().SetLastModified(filePath.c_str(), rt::implOf<HybridCkDateTime>(lastModified, "lastModified").ck())) throw this->fail("setLastModified");
+}
+
+void HybridFileAccess::splitFile(const std::string& fileToSplit, const std::string& partPrefix, const std::string& partExtension, double partSize, const std::string& destDir) {
+  this->beginCall();
+  splitFile_impl(fileToSplit, partPrefix, partExtension, partSize, destDir);
+}
+void HybridFileAccess::splitFile_impl(const std::string& fileToSplit, const std::string& partPrefix, const std::string& partExtension, double partSize, const std::string& destDir) {
+  rt::checkNoNul(fileToSplit, "fileToSplit");
+  rt::checkNoNul(partPrefix, "partPrefix");
+  rt::checkNoNul(partExtension, "partExtension");
+  rt::checkNoNul(destDir, "destDir");
+  if (!this->ck().SplitFile(fileToSplit.c_str(), partPrefix.c_str(), partExtension.c_str(), rt::toInt(partSize, "partSize"), destDir.c_str())) throw this->fail("splitFile");
+}
+
+void HybridFileAccess::treeDelete(const std::string& path) {
+  this->beginCall();
+  treeDelete_impl(path);
+}
+void HybridFileAccess::treeDelete_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().TreeDelete(path.c_str())) throw this->fail("treeDelete");
+}
+
+void HybridFileAccess::writeEntireTextFile(const std::string& filePath, const std::string& textData, const std::string& charset, bool includedPreamble) {
+  this->beginCall();
+  writeEntireTextFile_impl(filePath, textData, charset, includedPreamble);
+}
+void HybridFileAccess::writeEntireTextFile_impl(const std::string& filePath, const std::string& textData, const std::string& charset, bool includedPreamble) {
+  rt::checkNoNul(filePath, "filePath");
+  rt::checkNoNul(textData, "textData");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().WriteEntireTextFile(filePath.c_str(), textData.c_str(), charset.c_str(), includedPreamble)) throw this->fail("writeEntireTextFile");
+}
+
+void HybridFileAccess::fileReadBd(double maxNumBytes, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  fileReadBd_impl(maxNumBytes, binData);
+}
+void HybridFileAccess::fileReadBd_impl(double maxNumBytes, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  if (!this->ck().FileReadBd(rt::toInt(maxNumBytes, "maxNumBytes"), rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("fileReadBd");
+}
+
+void HybridFileAccess::fileWriteBd(const std::shared_ptr<HybridBinDataSpec>& binData, double offset, double numBytes) {
+  this->beginCall();
+  fileWriteBd_impl(binData, offset, numBytes);
+}
+void HybridFileAccess::fileWriteBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData, double offset, double numBytes) {
+  if (!this->ck().FileWriteBd(rt::implOf<HybridBinData>(binData, "binData").ck(), rt::toInt(offset, "offset"), rt::toInt(numBytes, "numBytes"))) throw this->fail("fileWriteBd");
+}
+
+std::string HybridFileAccess::getFileName(const std::string& path) {
+  this->beginCall();
+  return getFileName_impl(path);
+}
+std::string HybridFileAccess::getFileName_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  CkString _out;
+  if (!this->ck().GetFileName(path.c_str(), _out)) throw this->fail("getFileName");
+  return rt::stdString(_out);
+}
+
+std::string HybridFileAccess::getDirectoryName(const std::string& path) {
+  this->beginCall();
+  return getDirectoryName_impl(path);
+}
+std::string HybridFileAccess::getDirectoryName_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  CkString _out;
+  if (!this->ck().GetDirectoryName(path.c_str(), _out)) throw this->fail("getDirectoryName");
+  return rt::stdString(_out);
+}
+
+std::string HybridFileAccess::getExtension(const std::string& path) {
+  this->beginCall();
+  return getExtension_impl(path);
+}
+std::string HybridFileAccess::getExtension_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  CkString _out;
+  if (!this->ck().GetExtension(path.c_str(), _out)) throw this->fail("getExtension");
+  return rt::stdString(_out);
+}
+
+std::string HybridFileAccess::getFileNameWithoutExtension(const std::string& path) {
+  this->beginCall();
+  return getFileNameWithoutExtension_impl(path);
+}
+std::string HybridFileAccess::getFileNameWithoutExtension_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  CkString _out;
+  if (!this->ck().GetFileNameWithoutExtension(path.c_str(), _out)) throw this->fail("getFileNameWithoutExtension");
+  return rt::stdString(_out);
+}
+
+void HybridFileAccess::appendSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset) {
+  this->beginCall();
+  appendSb_impl(sb, charset);
+}
+void HybridFileAccess::appendSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset) {
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().AppendSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck(), charset.c_str())) throw this->fail("appendSb");
+}
+
+void HybridFileAccess::appendBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  appendBd_impl(bd);
+}
+void HybridFileAccess::appendBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().AppendBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("appendBd");
+}
+
+double HybridFileAccess::fileType(const std::string& path) {
+  this->beginCall();
+  return fileType_impl(path);
+}
+double HybridFileAccess::fileType_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  return static_cast<double>(this->ck().FileType(path.c_str()));
+}
+
+std::string HybridFileAccess::symlinkTarget(const std::string& linkPath) {
+  this->beginCall();
+  return symlinkTarget_impl(linkPath);
+}
+std::string HybridFileAccess::symlinkTarget_impl(const std::string& linkPath) {
+  rt::checkNoNul(linkPath, "linkPath");
+  CkString _out;
+  if (!this->ck().SymlinkTarget(linkPath.c_str(), _out)) throw this->fail("symlinkTarget");
+  return rt::stdString(_out);
+}
+
+void HybridFileAccess::symlinkCreate(const std::string& targetPath, const std::string& linkPath) {
+  this->beginCall();
+  symlinkCreate_impl(targetPath, linkPath);
+}
+void HybridFileAccess::symlinkCreate_impl(const std::string& targetPath, const std::string& linkPath) {
+  rt::checkNoNul(targetPath, "targetPath");
+  rt::checkNoNul(linkPath, "linkPath");
+  if (!this->ck().SymlinkCreate(targetPath.c_str(), linkPath.c_str())) throw this->fail("symlinkCreate");
+}
+
+void HybridFileAccess::readBlockBd(double blockIndex, double blockSize, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  readBlockBd_impl(blockIndex, blockSize, bd);
+}
+void HybridFileAccess::readBlockBd_impl(double blockIndex, double blockSize, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().ReadBlockBd(rt::toInt(blockIndex, "blockIndex"), rt::toInt(blockSize, "blockSize"), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("readBlockBd");
+}
+
+std::string HybridFileAccess::fileSizeStr(const std::string& filePath) {
+  this->beginCall();
+  return fileSizeStr_impl(filePath);
+}
+std::string HybridFileAccess::fileSizeStr_impl(const std::string& filePath) {
+  rt::checkNoNul(filePath, "filePath");
+  CkString _out;
+  if (!this->ck().FileSizeStr(filePath.c_str(), _out)) throw this->fail("fileSizeStr");
+  return rt::stdString(_out);
+}
+
+double HybridFileAccess::readNextFragment(bool startAtBeginning, const std::string& beginMarker, const std::string& endMarker, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  return readNextFragment_impl(startAtBeginning, beginMarker, endMarker, charset, sb);
+}
+double HybridFileAccess::readNextFragment_impl(bool startAtBeginning, const std::string& beginMarker, const std::string& endMarker, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  rt::checkNoNul(beginMarker, "beginMarker");
+  rt::checkNoNul(endMarker, "endMarker");
+  rt::checkNoNul(charset, "charset");
+  return static_cast<double>(this->ck().ReadNextFragment(startAtBeginning, beginMarker.c_str(), endMarker.c_str(), charset.c_str(), rt::implOf<HybridStringBuilder>(sb, "sb").ck()));
+}
+
+void HybridFileAccess::truncate() {
+  this->beginCall();
+  truncate_impl();
+}
+void HybridFileAccess::truncate_impl() {
+  if (!this->ck().Truncate()) throw this->fail("truncate");
+}
+
+void HybridFileAccess::fileWrite2(const std::shared_ptr<ArrayBuffer>& byteData) {
+  this->beginCall();
+  rt::ByteView _byteData = rt::viewOf(byteData);
+  fileWrite2_impl(_byteData.data, _byteData.size);
+}
+void HybridFileAccess::fileWrite2_impl(const uint8_t* byteDataData, size_t byteDataSize) {
+  if (!this->ck().FileWrite2(static_cast<const void*>(byteDataData), static_cast<unsigned long>(byteDataSize))) throw this->fail("fileWrite2");
+}
+
+double HybridFileAccess::fileSize64(const std::string& filePath) {
+  this->beginCall();
+  return fileSize64_impl(filePath);
+}
+double HybridFileAccess::fileSize64_impl(const std::string& filePath) {
+  rt::checkNoNul(filePath, "filePath");
+  return static_cast<double>(this->ck().FileSize64(filePath.c_str()));
+}
+
+bool HybridFileAccess::dirExists(const std::string& dirPath) {
+  this->beginCall();
+  return dirExists_impl(dirPath);
+}
+bool HybridFileAccess::dirExists_impl(const std::string& dirPath) {
+  rt::checkNoNul(dirPath, "dirPath");
+  return this->ck().DirExists(dirPath.c_str());
+}
+
+std::string HybridFileAccess::getFileTimeStr(const std::string& path, double which) {
+  this->beginCall();
+  return getFileTimeStr_impl(path, which);
+}
+std::string HybridFileAccess::getFileTimeStr_impl(const std::string& path, double which) {
+  rt::checkNoNul(path, "path");
+  CkString _out;
+  if (!this->ck().GetFileTimeStr(path.c_str(), rt::toInt(which, "which"), _out)) throw this->fail("getFileTimeStr");
+  return rt::stdString(_out);
+}
+
+} // namespace margelo::nitro::chilkat