@chilkat/react-native 11.6.1

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

@@ -0,0 +1,78 @@
+///
+/// HybridSFtpDirSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridSFtpFileSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridSFtpFileSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridSFtpFileSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `SFtpDir`
+   * Inherit this class to create instances of `HybridSFtpDirSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridSFtpDir: public HybridSFtpDirSpec {
+   * public:
+   *   HybridSFtpDir(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridSFtpDirSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridSFtpDirSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridSFtpDirSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getLastErrorHtml() = 0;
+      virtual std::string getLastErrorText() = 0;
+      virtual std::string getLastErrorXml() = 0;
+      virtual std::string getVersion() = 0;
+      virtual std::string getDebugLogFilePath() = 0;
+      virtual void setDebugLogFilePath(const std::string& debugLogFilePath) = 0;
+      virtual bool getVerboseLogging() = 0;
+      virtual void setVerboseLogging(bool verboseLogging) = 0;
+      virtual bool getLastMethodSuccess() = 0;
+      virtual void setLastMethodSuccess(bool lastMethodSuccess) = 0;
+      virtual double getNumFilesAndDirs() = 0;
+      virtual std::string getOriginalPath() = 0;
+
+    public:
+      // Methods
+      virtual std::string getFilename(double index) = 0;
+      virtual void sort(const std::string& field, bool ascending) = 0;
+      virtual void fileAt(double index, const std::shared_ptr<HybridSFtpFileSpec>& fileObj) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "SFtpDir";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,57 @@
+///
+/// HybridSFtpFileSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridSFtpFileSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridSFtpFileSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridSFtpFileSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridSFtpFileSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridSFtpFileSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridSFtpFileSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridSFtpFileSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridSFtpFileSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridSFtpFileSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridSFtpFileSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridSFtpFileSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridSFtpFileSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("createTimeStr", &HybridSFtpFileSpec::getCreateTimeStr);
+      prototype.registerHybridGetter("fileType", &HybridSFtpFileSpec::getFileType);
+      prototype.registerHybridGetter("filename", &HybridSFtpFileSpec::getFilename);
+      prototype.registerHybridGetter("gid", &HybridSFtpFileSpec::getGid);
+      prototype.registerHybridGetter("group", &HybridSFtpFileSpec::getGroup);
+      prototype.registerHybridGetter("isAppendOnly", &HybridSFtpFileSpec::getIsAppendOnly);
+      prototype.registerHybridGetter("isArchive", &HybridSFtpFileSpec::getIsArchive);
+      prototype.registerHybridGetter("isCaseInsensitive", &HybridSFtpFileSpec::getIsCaseInsensitive);
+      prototype.registerHybridGetter("isCompressed", &HybridSFtpFileSpec::getIsCompressed);
+      prototype.registerHybridGetter("isDirectory", &HybridSFtpFileSpec::getIsDirectory);
+      prototype.registerHybridGetter("isEncrypted", &HybridSFtpFileSpec::getIsEncrypted);
+      prototype.registerHybridGetter("isHidden", &HybridSFtpFileSpec::getIsHidden);
+      prototype.registerHybridGetter("isImmutable", &HybridSFtpFileSpec::getIsImmutable);
+      prototype.registerHybridGetter("isReadOnly", &HybridSFtpFileSpec::getIsReadOnly);
+      prototype.registerHybridGetter("isRegular", &HybridSFtpFileSpec::getIsRegular);
+      prototype.registerHybridGetter("isSparse", &HybridSFtpFileSpec::getIsSparse);
+      prototype.registerHybridGetter("isSymLink", &HybridSFtpFileSpec::getIsSymLink);
+      prototype.registerHybridGetter("isSync", &HybridSFtpFileSpec::getIsSync);
+      prototype.registerHybridGetter("isSystem", &HybridSFtpFileSpec::getIsSystem);
+      prototype.registerHybridGetter("lastAccessTimeStr", &HybridSFtpFileSpec::getLastAccessTimeStr);
+      prototype.registerHybridGetter("lastModifiedTimeStr", &HybridSFtpFileSpec::getLastModifiedTimeStr);
+      prototype.registerHybridGetter("owner", &HybridSFtpFileSpec::getOwner);
+      prototype.registerHybridGetter("permissions", &HybridSFtpFileSpec::getPermissions);
+      prototype.registerHybridGetter("size32", &HybridSFtpFileSpec::getSize32);
+      prototype.registerHybridGetter("size64", &HybridSFtpFileSpec::getSize64);
+      prototype.registerHybridGetter("sizeStr", &HybridSFtpFileSpec::getSizeStr);
+      prototype.registerHybridGetter("uid", &HybridSFtpFileSpec::getUid);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,98 @@
+///
+/// HybridSFtpFileSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `SFtpFile`
+   * Inherit this class to create instances of `HybridSFtpFileSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridSFtpFile: public HybridSFtpFileSpec {
+   * public:
+   *   HybridSFtpFile(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridSFtpFileSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridSFtpFileSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridSFtpFileSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getLastErrorHtml() = 0;
+      virtual std::string getLastErrorText() = 0;
+      virtual std::string getLastErrorXml() = 0;
+      virtual std::string getVersion() = 0;
+      virtual std::string getDebugLogFilePath() = 0;
+      virtual void setDebugLogFilePath(const std::string& debugLogFilePath) = 0;
+      virtual bool getVerboseLogging() = 0;
+      virtual void setVerboseLogging(bool verboseLogging) = 0;
+      virtual bool getLastMethodSuccess() = 0;
+      virtual void setLastMethodSuccess(bool lastMethodSuccess) = 0;
+      virtual std::string getCreateTimeStr() = 0;
+      virtual std::string getFileType() = 0;
+      virtual std::string getFilename() = 0;
+      virtual double getGid() = 0;
+      virtual std::string getGroup() = 0;
+      virtual bool getIsAppendOnly() = 0;
+      virtual bool getIsArchive() = 0;
+      virtual bool getIsCaseInsensitive() = 0;
+      virtual bool getIsCompressed() = 0;
+      virtual bool getIsDirectory() = 0;
+      virtual bool getIsEncrypted() = 0;
+      virtual bool getIsHidden() = 0;
+      virtual bool getIsImmutable() = 0;
+      virtual bool getIsReadOnly() = 0;
+      virtual bool getIsRegular() = 0;
+      virtual bool getIsSparse() = 0;
+      virtual bool getIsSymLink() = 0;
+      virtual bool getIsSync() = 0;
+      virtual bool getIsSystem() = 0;
+      virtual std::string getLastAccessTimeStr() = 0;
+      virtual std::string getLastModifiedTimeStr() = 0;
+      virtual std::string getOwner() = 0;
+      virtual double getPermissions() = 0;
+      virtual double getSize32() = 0;
+      virtual double getSize64() = 0;
+      virtual std::string getSizeStr() = 0;
+      virtual double getUid() = 0;
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "SFtpFile";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,284 @@
+///
+/// HybridSFtpSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridSFtpSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridSFtpSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridSFtpSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridSFtpSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridSFtpSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridSFtpSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridSFtpSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridSFtpSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridSFtpSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridSFtpSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridSFtpSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridSFtpSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("authFailReason", &HybridSFtpSpec::getAuthFailReason);
+      prototype.registerHybridGetter("bandwidthThrottleDown", &HybridSFtpSpec::getBandwidthThrottleDown);
+      prototype.registerHybridSetter("bandwidthThrottleDown", &HybridSFtpSpec::setBandwidthThrottleDown);
+      prototype.registerHybridGetter("bandwidthThrottleUp", &HybridSFtpSpec::getBandwidthThrottleUp);
+      prototype.registerHybridSetter("bandwidthThrottleUp", &HybridSFtpSpec::setBandwidthThrottleUp);
+      prototype.registerHybridGetter("clientIdentifier", &HybridSFtpSpec::getClientIdentifier);
+      prototype.registerHybridSetter("clientIdentifier", &HybridSFtpSpec::setClientIdentifier);
+      prototype.registerHybridGetter("clientIpAddress", &HybridSFtpSpec::getClientIpAddress);
+      prototype.registerHybridSetter("clientIpAddress", &HybridSFtpSpec::setClientIpAddress);
+      prototype.registerHybridGetter("connectTimeoutMs", &HybridSFtpSpec::getConnectTimeoutMs);
+      prototype.registerHybridSetter("connectTimeoutMs", &HybridSFtpSpec::setConnectTimeoutMs);
+      prototype.registerHybridGetter("disconnectCode", &HybridSFtpSpec::getDisconnectCode);
+      prototype.registerHybridGetter("disconnectReason", &HybridSFtpSpec::getDisconnectReason);
+      prototype.registerHybridGetter("enableCache", &HybridSFtpSpec::getEnableCache);
+      prototype.registerHybridSetter("enableCache", &HybridSFtpSpec::setEnableCache);
+      prototype.registerHybridGetter("enableCompression", &HybridSFtpSpec::getEnableCompression);
+      prototype.registerHybridSetter("enableCompression", &HybridSFtpSpec::setEnableCompression);
+      prototype.registerHybridGetter("filenameCharset", &HybridSFtpSpec::getFilenameCharset);
+      prototype.registerHybridSetter("filenameCharset", &HybridSFtpSpec::setFilenameCharset);
+      prototype.registerHybridGetter("forceCipher", &HybridSFtpSpec::getForceCipher);
+      prototype.registerHybridSetter("forceCipher", &HybridSFtpSpec::setForceCipher);
+      prototype.registerHybridGetter("forceV3", &HybridSFtpSpec::getForceV3);
+      prototype.registerHybridSetter("forceV3", &HybridSFtpSpec::setForceV3);
+      prototype.registerHybridGetter("heartbeatMs", &HybridSFtpSpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridSFtpSpec::setHeartbeatMs);
+      prototype.registerHybridGetter("hostKeyAlg", &HybridSFtpSpec::getHostKeyAlg);
+      prototype.registerHybridSetter("hostKeyAlg", &HybridSFtpSpec::setHostKeyAlg);
+      prototype.registerHybridGetter("hostKeyFingerprint", &HybridSFtpSpec::getHostKeyFingerprint);
+      prototype.registerHybridGetter("httpProxyAuthMethod", &HybridSFtpSpec::getHttpProxyAuthMethod);
+      prototype.registerHybridSetter("httpProxyAuthMethod", &HybridSFtpSpec::setHttpProxyAuthMethod);
+      prototype.registerHybridGetter("httpProxyDomain", &HybridSFtpSpec::getHttpProxyDomain);
+      prototype.registerHybridSetter("httpProxyDomain", &HybridSFtpSpec::setHttpProxyDomain);
+      prototype.registerHybridGetter("httpProxyHostname", &HybridSFtpSpec::getHttpProxyHostname);
+      prototype.registerHybridSetter("httpProxyHostname", &HybridSFtpSpec::setHttpProxyHostname);
+      prototype.registerHybridGetter("httpProxyPassword", &HybridSFtpSpec::getHttpProxyPassword);
+      prototype.registerHybridSetter("httpProxyPassword", &HybridSFtpSpec::setHttpProxyPassword);
+      prototype.registerHybridGetter("httpProxyPort", &HybridSFtpSpec::getHttpProxyPort);
+      prototype.registerHybridSetter("httpProxyPort", &HybridSFtpSpec::setHttpProxyPort);
+      prototype.registerHybridGetter("httpProxyUsername", &HybridSFtpSpec::getHttpProxyUsername);
+      prototype.registerHybridSetter("httpProxyUsername", &HybridSFtpSpec::setHttpProxyUsername);
+      prototype.registerHybridGetter("idleTimeoutMs", &HybridSFtpSpec::getIdleTimeoutMs);
+      prototype.registerHybridSetter("idleTimeoutMs", &HybridSFtpSpec::setIdleTimeoutMs);
+      prototype.registerHybridGetter("includeDotDirs", &HybridSFtpSpec::getIncludeDotDirs);
+      prototype.registerHybridSetter("includeDotDirs", &HybridSFtpSpec::setIncludeDotDirs);
+      prototype.registerHybridGetter("initializeFailCode", &HybridSFtpSpec::getInitializeFailCode);
+      prototype.registerHybridGetter("initializeFailReason", &HybridSFtpSpec::getInitializeFailReason);
+      prototype.registerHybridGetter("isConnected", &HybridSFtpSpec::getIsConnected);
+      prototype.registerHybridGetter("keepSessionLog", &HybridSFtpSpec::getKeepSessionLog);
+      prototype.registerHybridSetter("keepSessionLog", &HybridSFtpSpec::setKeepSessionLog);
+      prototype.registerHybridGetter("maxPacketSize", &HybridSFtpSpec::getMaxPacketSize);
+      prototype.registerHybridSetter("maxPacketSize", &HybridSFtpSpec::setMaxPacketSize);
+      prototype.registerHybridGetter("passwordChangeRequested", &HybridSFtpSpec::getPasswordChangeRequested);
+      prototype.registerHybridGetter("percentDoneScale", &HybridSFtpSpec::getPercentDoneScale);
+      prototype.registerHybridSetter("percentDoneScale", &HybridSFtpSpec::setPercentDoneScale);
+      prototype.registerHybridGetter("preferIpv6", &HybridSFtpSpec::getPreferIpv6);
+      prototype.registerHybridSetter("preferIpv6", &HybridSFtpSpec::setPreferIpv6);
+      prototype.registerHybridGetter("preserveDate", &HybridSFtpSpec::getPreserveDate);
+      prototype.registerHybridSetter("preserveDate", &HybridSFtpSpec::setPreserveDate);
+      prototype.registerHybridGetter("protocolVersion", &HybridSFtpSpec::getProtocolVersion);
+      prototype.registerHybridGetter("readDirMustMatch", &HybridSFtpSpec::getReadDirMustMatch);
+      prototype.registerHybridSetter("readDirMustMatch", &HybridSFtpSpec::setReadDirMustMatch);
+      prototype.registerHybridGetter("readDirMustNotMatch", &HybridSFtpSpec::getReadDirMustNotMatch);
+      prototype.registerHybridSetter("readDirMustNotMatch", &HybridSFtpSpec::setReadDirMustNotMatch);
+      prototype.registerHybridGetter("sessionLog", &HybridSFtpSpec::getSessionLog);
+      prototype.registerHybridGetter("soRcvBuf", &HybridSFtpSpec::getSoRcvBuf);
+      prototype.registerHybridSetter("soRcvBuf", &HybridSFtpSpec::setSoRcvBuf);
+      prototype.registerHybridGetter("soSndBuf", &HybridSFtpSpec::getSoSndBuf);
+      prototype.registerHybridSetter("soSndBuf", &HybridSFtpSpec::setSoSndBuf);
+      prototype.registerHybridGetter("socksHostname", &HybridSFtpSpec::getSocksHostname);
+      prototype.registerHybridSetter("socksHostname", &HybridSFtpSpec::setSocksHostname);
+      prototype.registerHybridGetter("socksPassword", &HybridSFtpSpec::getSocksPassword);
+      prototype.registerHybridSetter("socksPassword", &HybridSFtpSpec::setSocksPassword);
+      prototype.registerHybridGetter("socksPort", &HybridSFtpSpec::getSocksPort);
+      prototype.registerHybridSetter("socksPort", &HybridSFtpSpec::setSocksPort);
+      prototype.registerHybridGetter("socksUsername", &HybridSFtpSpec::getSocksUsername);
+      prototype.registerHybridSetter("socksUsername", &HybridSFtpSpec::setSocksUsername);
+      prototype.registerHybridGetter("socksVersion", &HybridSFtpSpec::getSocksVersion);
+      prototype.registerHybridSetter("socksVersion", &HybridSFtpSpec::setSocksVersion);
+      prototype.registerHybridGetter("syncMustMatch", &HybridSFtpSpec::getSyncMustMatch);
+      prototype.registerHybridSetter("syncMustMatch", &HybridSFtpSpec::setSyncMustMatch);
+      prototype.registerHybridGetter("syncMustNotMatch", &HybridSFtpSpec::getSyncMustNotMatch);
+      prototype.registerHybridSetter("syncMustNotMatch", &HybridSFtpSpec::setSyncMustNotMatch);
+      prototype.registerHybridGetter("tcpNoDelay", &HybridSFtpSpec::getTcpNoDelay);
+      prototype.registerHybridSetter("tcpNoDelay", &HybridSFtpSpec::setTcpNoDelay);
+      prototype.registerHybridGetter("uploadChunkSize", &HybridSFtpSpec::getUploadChunkSize);
+      prototype.registerHybridSetter("uploadChunkSize", &HybridSFtpSpec::setUploadChunkSize);
+      prototype.registerHybridGetter("utcMode", &HybridSFtpSpec::getUtcMode);
+      prototype.registerHybridSetter("utcMode", &HybridSFtpSpec::setUtcMode);
+      prototype.registerHybridGetter("abortCurrent", &HybridSFtpSpec::getAbortCurrent);
+      prototype.registerHybridSetter("abortCurrent", &HybridSFtpSpec::setAbortCurrent);
+      prototype.registerHybridGetter("syncDirectives", &HybridSFtpSpec::getSyncDirectives);
+      prototype.registerHybridSetter("syncDirectives", &HybridSFtpSpec::setSyncDirectives);
+      prototype.registerHybridGetter("xferByteCount", &HybridSFtpSpec::getXferByteCount);
+      prototype.registerHybridGetter("xferByteCount64", &HybridSFtpSpec::getXferByteCount64);
+      prototype.registerHybridGetter("serverIdentifier", &HybridSFtpSpec::getServerIdentifier);
+      prototype.registerHybridGetter("uncommonOptions", &HybridSFtpSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridSFtpSpec::setUncommonOptions);
+      prototype.registerHybridGetter("syncMustMatchDir", &HybridSFtpSpec::getSyncMustMatchDir);
+      prototype.registerHybridSetter("syncMustMatchDir", &HybridSFtpSpec::setSyncMustMatchDir);
+      prototype.registerHybridGetter("syncMustNotMatchDir", &HybridSFtpSpec::getSyncMustNotMatchDir);
+      prototype.registerHybridSetter("syncMustNotMatchDir", &HybridSFtpSpec::setSyncMustNotMatchDir);
+      prototype.registerHybridGetter("syncCreateAllLocalDirs", &HybridSFtpSpec::getSyncCreateAllLocalDirs);
+      prototype.registerHybridSetter("syncCreateAllLocalDirs", &HybridSFtpSpec::setSyncCreateAllLocalDirs);
+      prototype.registerHybridGetter("lastStatusCode", &HybridSFtpSpec::getLastStatusCode);
+      prototype.registerHybridGetter("lastStatusMessage", &HybridSFtpSpec::getLastStatusMessage);
+      prototype.registerHybridGetter("userAuthBanner", &HybridSFtpSpec::getUserAuthBanner);
+      prototype.registerHybridSetter("userAuthBanner", &HybridSFtpSpec::setUserAuthBanner);
+      prototype.registerHybridGetter("enableSecrets", &HybridSFtpSpec::getEnableSecrets);
+      prototype.registerHybridSetter("enableSecrets", &HybridSFtpSpec::setEnableSecrets);
+      prototype.registerHybridGetter("onPercentDone", &HybridSFtpSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridSFtpSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridSFtpSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridSFtpSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("authenticatePk", &HybridSFtpSpec::authenticatePk);
+      prototype.registerHybridMethod("authenticatePkAsync", &HybridSFtpSpec::authenticatePkAsync);
+      prototype.registerHybridMethod("authenticatePw", &HybridSFtpSpec::authenticatePw);
+      prototype.registerHybridMethod("authenticatePwAsync", &HybridSFtpSpec::authenticatePwAsync);
+      prototype.registerHybridMethod("authenticatePwPk", &HybridSFtpSpec::authenticatePwPk);
+      prototype.registerHybridMethod("authenticatePwPkAsync", &HybridSFtpSpec::authenticatePwPkAsync);
+      prototype.registerHybridMethod("clearCache", &HybridSFtpSpec::clearCache);
+      prototype.registerHybridMethod("clearSessionLog", &HybridSFtpSpec::clearSessionLog);
+      prototype.registerHybridMethod("closeHandle", &HybridSFtpSpec::closeHandle);
+      prototype.registerHybridMethod("closeHandleAsync", &HybridSFtpSpec::closeHandleAsync);
+      prototype.registerHybridMethod("connect", &HybridSFtpSpec::connect);
+      prototype.registerHybridMethod("connectAsync", &HybridSFtpSpec::connectAsync);
+      prototype.registerHybridMethod("connectThroughSsh", &HybridSFtpSpec::connectThroughSsh);
+      prototype.registerHybridMethod("connectThroughSshAsync", &HybridSFtpSpec::connectThroughSshAsync);
+      prototype.registerHybridMethod("copyFileAttr", &HybridSFtpSpec::copyFileAttr);
+      prototype.registerHybridMethod("copyFileAttrAsync", &HybridSFtpSpec::copyFileAttrAsync);
+      prototype.registerHybridMethod("createDir", &HybridSFtpSpec::createDir);
+      prototype.registerHybridMethod("createDirAsync", &HybridSFtpSpec::createDirAsync);
+      prototype.registerHybridMethod("disconnect", &HybridSFtpSpec::disconnect);
+      prototype.registerHybridMethod("downloadFile", &HybridSFtpSpec::downloadFile);
+      prototype.registerHybridMethod("downloadFileAsync", &HybridSFtpSpec::downloadFileAsync);
+      prototype.registerHybridMethod("downloadFileByName", &HybridSFtpSpec::downloadFileByName);
+      prototype.registerHybridMethod("downloadFileByNameAsync", &HybridSFtpSpec::downloadFileByNameAsync);
+      prototype.registerHybridMethod("eof", &HybridSFtpSpec::eof);
+      prototype.registerHybridMethod("getFileCreateTimeStr", &HybridSFtpSpec::getFileCreateTimeStr);
+      prototype.registerHybridMethod("getFileCreateTimeStrAsync", &HybridSFtpSpec::getFileCreateTimeStrAsync);
+      prototype.registerHybridMethod("getFileGroup", &HybridSFtpSpec::getFileGroup);
+      prototype.registerHybridMethod("getFileGroupAsync", &HybridSFtpSpec::getFileGroupAsync);
+      prototype.registerHybridMethod("getFileLastAccessStr", &HybridSFtpSpec::getFileLastAccessStr);
+      prototype.registerHybridMethod("getFileLastAccessStrAsync", &HybridSFtpSpec::getFileLastAccessStrAsync);
+      prototype.registerHybridMethod("getFileLastModifiedStr", &HybridSFtpSpec::getFileLastModifiedStr);
+      prototype.registerHybridMethod("getFileLastModifiedStrAsync", &HybridSFtpSpec::getFileLastModifiedStrAsync);
+      prototype.registerHybridMethod("getFileOwner", &HybridSFtpSpec::getFileOwner);
+      prototype.registerHybridMethod("getFileOwnerAsync", &HybridSFtpSpec::getFileOwnerAsync);
+      prototype.registerHybridMethod("getFilePermissions", &HybridSFtpSpec::getFilePermissions);
+      prototype.registerHybridMethod("getFilePermissionsAsync", &HybridSFtpSpec::getFilePermissionsAsync);
+      prototype.registerHybridMethod("getFileSize32", &HybridSFtpSpec::getFileSize32);
+      prototype.registerHybridMethod("getFileSize32Async", &HybridSFtpSpec::getFileSize32Async);
+      prototype.registerHybridMethod("getFileSize64", &HybridSFtpSpec::getFileSize64);
+      prototype.registerHybridMethod("getFileSize64Async", &HybridSFtpSpec::getFileSize64Async);
+      prototype.registerHybridMethod("getFileSizeStr", &HybridSFtpSpec::getFileSizeStr);
+      prototype.registerHybridMethod("getFileSizeStrAsync", &HybridSFtpSpec::getFileSizeStrAsync);
+      prototype.registerHybridMethod("initializeSftp", &HybridSFtpSpec::initializeSftp);
+      prototype.registerHybridMethod("initializeSftpAsync", &HybridSFtpSpec::initializeSftpAsync);
+      prototype.registerHybridMethod("lastReadFailed", &HybridSFtpSpec::lastReadFailed);
+      prototype.registerHybridMethod("lastReadNumBytes", &HybridSFtpSpec::lastReadNumBytes);
+      prototype.registerHybridMethod("openDir", &HybridSFtpSpec::openDir);
+      prototype.registerHybridMethod("openDirAsync", &HybridSFtpSpec::openDirAsync);
+      prototype.registerHybridMethod("openFile", &HybridSFtpSpec::openFile);
+      prototype.registerHybridMethod("openFileAsync", &HybridSFtpSpec::openFileAsync);
+      prototype.registerHybridMethod("readFileText", &HybridSFtpSpec::readFileText);
+      prototype.registerHybridMethod("readFileTextAsync", &HybridSFtpSpec::readFileTextAsync);
+      prototype.registerHybridMethod("readFileText32", &HybridSFtpSpec::readFileText32);
+      prototype.registerHybridMethod("readFileText32Async", &HybridSFtpSpec::readFileText32Async);
+      prototype.registerHybridMethod("readFileText64", &HybridSFtpSpec::readFileText64);
+      prototype.registerHybridMethod("readFileText64Async", &HybridSFtpSpec::readFileText64Async);
+      prototype.registerHybridMethod("readFileText64s", &HybridSFtpSpec::readFileText64s);
+      prototype.registerHybridMethod("readFileText64sAsync", &HybridSFtpSpec::readFileText64sAsync);
+      prototype.registerHybridMethod("realPath", &HybridSFtpSpec::realPath);
+      prototype.registerHybridMethod("realPathAsync", &HybridSFtpSpec::realPathAsync);
+      prototype.registerHybridMethod("removeDir", &HybridSFtpSpec::removeDir);
+      prototype.registerHybridMethod("removeDirAsync", &HybridSFtpSpec::removeDirAsync);
+      prototype.registerHybridMethod("removeFile", &HybridSFtpSpec::removeFile);
+      prototype.registerHybridMethod("removeFileAsync", &HybridSFtpSpec::removeFileAsync);
+      prototype.registerHybridMethod("renameFileOrDir", &HybridSFtpSpec::renameFileOrDir);
+      prototype.registerHybridMethod("renameFileOrDirAsync", &HybridSFtpSpec::renameFileOrDirAsync);
+      prototype.registerHybridMethod("resumeDownloadFileByName", &HybridSFtpSpec::resumeDownloadFileByName);
+      prototype.registerHybridMethod("resumeDownloadFileByNameAsync", &HybridSFtpSpec::resumeDownloadFileByNameAsync);
+      prototype.registerHybridMethod("resumeUploadFileByName", &HybridSFtpSpec::resumeUploadFileByName);
+      prototype.registerHybridMethod("resumeUploadFileByNameAsync", &HybridSFtpSpec::resumeUploadFileByNameAsync);
+      prototype.registerHybridMethod("setCreateDt", &HybridSFtpSpec::setCreateDt);
+      prototype.registerHybridMethod("setCreateDtAsync", &HybridSFtpSpec::setCreateDtAsync);
+      prototype.registerHybridMethod("setCreateTimeStr", &HybridSFtpSpec::setCreateTimeStr);
+      prototype.registerHybridMethod("setCreateTimeStrAsync", &HybridSFtpSpec::setCreateTimeStrAsync);
+      prototype.registerHybridMethod("setLastAccessDt", &HybridSFtpSpec::setLastAccessDt);
+      prototype.registerHybridMethod("setLastAccessDtAsync", &HybridSFtpSpec::setLastAccessDtAsync);
+      prototype.registerHybridMethod("setLastAccessTimeStr", &HybridSFtpSpec::setLastAccessTimeStr);
+      prototype.registerHybridMethod("setLastAccessTimeStrAsync", &HybridSFtpSpec::setLastAccessTimeStrAsync);
+      prototype.registerHybridMethod("setLastModifiedDt", &HybridSFtpSpec::setLastModifiedDt);
+      prototype.registerHybridMethod("setLastModifiedDtAsync", &HybridSFtpSpec::setLastModifiedDtAsync);
+      prototype.registerHybridMethod("setLastModifiedTimeStr", &HybridSFtpSpec::setLastModifiedTimeStr);
+      prototype.registerHybridMethod("setLastModifiedTimeStrAsync", &HybridSFtpSpec::setLastModifiedTimeStrAsync);
+      prototype.registerHybridMethod("setOwnerAndGroup", &HybridSFtpSpec::setOwnerAndGroup);
+      prototype.registerHybridMethod("setOwnerAndGroupAsync", &HybridSFtpSpec::setOwnerAndGroupAsync);
+      prototype.registerHybridMethod("setPermissions", &HybridSFtpSpec::setPermissions);
+      prototype.registerHybridMethod("setPermissionsAsync", &HybridSFtpSpec::setPermissionsAsync);
+      prototype.registerHybridMethod("syncTreeDownload", &HybridSFtpSpec::syncTreeDownload);
+      prototype.registerHybridMethod("syncTreeDownloadAsync", &HybridSFtpSpec::syncTreeDownloadAsync);
+      prototype.registerHybridMethod("syncTreeUpload", &HybridSFtpSpec::syncTreeUpload);
+      prototype.registerHybridMethod("syncTreeUploadAsync", &HybridSFtpSpec::syncTreeUploadAsync);
+      prototype.registerHybridMethod("uploadFile", &HybridSFtpSpec::uploadFile);
+      prototype.registerHybridMethod("uploadFileAsync", &HybridSFtpSpec::uploadFileAsync);
+      prototype.registerHybridMethod("uploadFileByName", &HybridSFtpSpec::uploadFileByName);
+      prototype.registerHybridMethod("uploadFileByNameAsync", &HybridSFtpSpec::uploadFileByNameAsync);
+      prototype.registerHybridMethod("writeFileText", &HybridSFtpSpec::writeFileText);
+      prototype.registerHybridMethod("writeFileTextAsync", &HybridSFtpSpec::writeFileTextAsync);
+      prototype.registerHybridMethod("writeFileText32", &HybridSFtpSpec::writeFileText32);
+      prototype.registerHybridMethod("writeFileText32Async", &HybridSFtpSpec::writeFileText32Async);
+      prototype.registerHybridMethod("writeFileText64", &HybridSFtpSpec::writeFileText64);
+      prototype.registerHybridMethod("writeFileText64Async", &HybridSFtpSpec::writeFileText64Async);
+      prototype.registerHybridMethod("writeFileText64s", &HybridSFtpSpec::writeFileText64s);
+      prototype.registerHybridMethod("writeFileText64sAsync", &HybridSFtpSpec::writeFileText64sAsync);
+      prototype.registerHybridMethod("uploadSb", &HybridSFtpSpec::uploadSb);
+      prototype.registerHybridMethod("uploadSbAsync", &HybridSFtpSpec::uploadSbAsync);
+      prototype.registerHybridMethod("uploadBd", &HybridSFtpSpec::uploadBd);
+      prototype.registerHybridMethod("uploadBdAsync", &HybridSFtpSpec::uploadBdAsync);
+      prototype.registerHybridMethod("downloadBd", &HybridSFtpSpec::downloadBd);
+      prototype.registerHybridMethod("downloadBdAsync", &HybridSFtpSpec::downloadBdAsync);
+      prototype.registerHybridMethod("downloadSb", &HybridSFtpSpec::downloadSb);
+      prototype.registerHybridMethod("downloadSbAsync", &HybridSFtpSpec::downloadSbAsync);
+      prototype.registerHybridMethod("sendIgnore", &HybridSFtpSpec::sendIgnore);
+      prototype.registerHybridMethod("sendIgnoreAsync", &HybridSFtpSpec::sendIgnoreAsync);
+      prototype.registerHybridMethod("fileExists", &HybridSFtpSpec::fileExists);
+      prototype.registerHybridMethod("fileExistsAsync", &HybridSFtpSpec::fileExistsAsync);
+      prototype.registerHybridMethod("authenticateSecPw", &HybridSFtpSpec::authenticateSecPw);
+      prototype.registerHybridMethod("authenticateSecPwAsync", &HybridSFtpSpec::authenticateSecPwAsync);
+      prototype.registerHybridMethod("authenticateSecPwPk", &HybridSFtpSpec::authenticateSecPwPk);
+      prototype.registerHybridMethod("authenticateSecPwPkAsync", &HybridSFtpSpec::authenticateSecPwPkAsync);
+      prototype.registerHybridMethod("symLink", &HybridSFtpSpec::symLink);
+      prototype.registerHybridMethod("symLinkAsync", &HybridSFtpSpec::symLinkAsync);
+      prototype.registerHybridMethod("hardLink", &HybridSFtpSpec::hardLink);
+      prototype.registerHybridMethod("hardLinkAsync", &HybridSFtpSpec::hardLinkAsync);
+      prototype.registerHybridMethod("fsync", &HybridSFtpSpec::fsync);
+      prototype.registerHybridMethod("fsyncAsync", &HybridSFtpSpec::fsyncAsync);
+      prototype.registerHybridMethod("readLink", &HybridSFtpSpec::readLink);
+      prototype.registerHybridMethod("readLinkAsync", &HybridSFtpSpec::readLinkAsync);
+      prototype.registerHybridMethod("writeFileBd", &HybridSFtpSpec::writeFileBd);
+      prototype.registerHybridMethod("writeFileBdAsync", &HybridSFtpSpec::writeFileBdAsync);
+      prototype.registerHybridMethod("readFileBd", &HybridSFtpSpec::readFileBd);
+      prototype.registerHybridMethod("readFileBdAsync", &HybridSFtpSpec::readFileBdAsync);
+      prototype.registerHybridMethod("startKeyboardAuth", &HybridSFtpSpec::startKeyboardAuth);
+      prototype.registerHybridMethod("startKeyboardAuthAsync", &HybridSFtpSpec::startKeyboardAuthAsync);
+      prototype.registerHybridMethod("continueKeyboardAuth", &HybridSFtpSpec::continueKeyboardAuth);
+      prototype.registerHybridMethod("continueKeyboardAuthAsync", &HybridSFtpSpec::continueKeyboardAuthAsync);
+      prototype.registerHybridMethod("getHostKeyFP", &HybridSFtpSpec::getHostKeyFP);
+      prototype.registerHybridMethod("setAllowedAlgorithms", &HybridSFtpSpec::setAllowedAlgorithms);
+      prototype.registerHybridMethod("getSyncedFiles", &HybridSFtpSpec::getSyncedFiles);
+      prototype.registerHybridMethod("getLastJsonData", &HybridSFtpSpec::getLastJsonData);
+      prototype.registerHybridMethod("readDirListing", &HybridSFtpSpec::readDirListing);
+      prototype.registerHybridMethod("readDirListingAsync", &HybridSFtpSpec::readDirListingAsync);
+      prototype.registerHybridMethod("abort", &HybridSFtpSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat