@chilkat/react-native 11.6.1

package/src/specs/SFtp.nitro.ts

@@ -0,0 +1,3138 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+import type { HybridObject } from 'react-native-nitro-modules'
+import type { BinData } from './BinData.nitro'
+import type { CkDateTime } from './CkDateTime.nitro'
+import type { JsonObject } from './JsonObject.nitro'
+import type { SFtpDir } from './SFtpDir.nitro'
+import type { SecureString } from './SecureString.nitro'
+import type { Ssh } from './Ssh.nitro'
+import type { SshKey } from './SshKey.nitro'
+import type { StringBuilder } from './StringBuilder.nitro'
+import type { StringTable } from './StringTable.nitro'
+
+/**
+ * Transfer, list, manage, and synchronize files over SFTP.
+ *
+ * `SFtp` is Chilkat's main class for secure file transfer
+ * over SSH. It provides SSH connection and authentication, SFTP subsystem
+ * initialization, uploads, downloads, directory listings, remote file
+ * management, file attributes, handle-based file access, recursive
+ * synchronization, bandwidth throttling, proxy support, host key
+ * fingerprinting, SSH algorithm controls, and detailed diagnostics.
+ *
+ * **SSH + SFTP setup**
+ *
+ * Connect to an SSH server, authenticate with password or key-based
+ * credentials, then initialize the SFTP subsystem before file operations.
+ *
+ * **Upload and download**
+ *
+ * Transfer files using simple path-based APIs, in-memory data, streams,
+ * or handle-based methods when lower-level control is needed.
+ *
+ * **Directory and file management**
+ *
+ * List directories, create and remove folders, rename files, delete files,
+ * inspect attributes, and work with remote paths.
+ *
+ * **Sync-tree operations**
+ *
+ * Upload or download directory trees and synchronize local and remote
+ * folder structures.
+ *
+ * **Security controls**
+ *
+ * Verify host keys, control accepted SSH algorithms, use private keys,
+ * and configure proxy or network settings when required.
+ *
+ * **Diagnostics and reliability**
+ *
+ * Use detailed error text, session logs, progress callbacks, bandwidth
+ * limits, and timeout settings to troubleshoot real-world server behavior.
+ *
+ * **Common pattern:**
+ * Connect, authenticate, initialize SFTP, perform file operations using remote
+ * paths or handles, close any open handles, and disconnect. Use handle-based
+ * APIs for precise control, and synchronization methods for recursive folder
+ * transfers.
+ *
+ * For an extended overview, see
+ * [SFtp Class Overview](https://www.chilkatsoft.com/sftp_class_overview.asp).
+ *
+ * Each `SFtp` instance owns a native Chilkat object. It is released when the JavaScript object is
+ * garbage collected, or immediately by `dispose()`; any use after `dispose()` throws.
+ * Create one with `new SFtp()`.
+ *
+ * Methods that can take a while (network, files, compression, key generation) also have an
+ * `...Async` form returning a `Promise`; it runs on a native worker thread so the UI keeps
+ * rendering. While such a call is pending, every other call on this object throws, except
+ * {@link SFtp.abort} and assigning {@link SFtp.onPercentDone} / {@link SFtp.onProgressInfo}.
+ */
+export interface SFtp extends HybridObject<{ ios: 'c++', android: 'c++' }> {
+  // ---- Properties ----
+
+  /**
+   * Provides HTML-formatted information about the last called method or property. If a method call
+   * fails or behaves unexpectedly, check this property for details. Note that information is
+   * available regardless of the method call's success.
+   *
+   * This property is read-only.
+   */
+  readonly lastErrorHtml: string
+
+  /**
+   * Provides plain text information about the last called method or property. If a method call
+   * fails or behaves unexpectedly, check this property for details. Note that information is
+   * available regardless of the method call's success.
+   *
+   * This property is read-only.
+   */
+  readonly lastErrorText: string
+
+  /**
+   * Provides XML-formatted information about the last called method or property. If a method call
+   * fails or behaves unexpectedly, check this property for details. Note that information is
+   * available regardless of the method call's success.
+   *
+   * This property is read-only.
+   */
+  readonly lastErrorXml: string
+
+  /**
+   * Version of the component/library, such as "10.1.0"
+   *
+   * This property is read-only.
+   */
+  readonly version: string
+
+  /**
+   * If set to a file path, this property logs the LastErrorText of each Chilkat method or property
+   * call to the specified file. This logging helps identify the context and history of Chilkat
+   * calls leading up to any crash or hang, aiding in debugging.
+   *
+   * Enabling the VerboseLogging property provides more detailed information.
+   *
+   * This property is mainly used for debugging rare instances where a Chilkat method call causes a
+   * hang or crash, which should generally not happen.
+   *
+   * Possible causes of hangs include:
+   *
+   * - A timeout property set to 0, indicating an infinite timeout.
+   *
+   * - A hang occurring within an event callback in the application code.
+   *
+   * - An internal bug in the Chilkat code causing the hang.
+   */
+  debugLogFilePath: string
+
+  /**
+   * If set to `true`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may
+   * contain more verbose information. The default value is `false`. Verbose logging should only be
+   * used for debugging. The potentially large quantity of logged information may adversely affect
+   * peformance.
+   */
+  verboseLogging: boolean
+
+  /**
+   * Indicates the success or failure of the most recent method call: `true` means success, `false`
+   * means failure. This property remains unchanged by property setters or getters. This method is
+   * present to address challenges in checking for null or Nothing returns in certain programming
+   * languages. Note: This property does not apply to methods that return integer values or to
+   * boolean-returning methods where the boolean does not indicate success or failure.
+   */
+  lastMethodSuccess: boolean
+
+  /**
+   * Contains the result code from the most recent call to {@link SFtp.authenticatePw}, {@link
+   * SFtp.authenticatePk}, {@link SFtp.authenticatePwPk}, or a corresponding secure-string
+   * authentication method.
+   *
+   * ValueMeaning
+   *
+   * | `1` | | Transport failure: communication was lost, or a network read or write failed or timed
+   * out. |
+   *
+   * | `2` | | Invalid private key: the key format, key type, or key contents are not suitable for
+   * public-key authentication. |
+   *
+   * | `3` |  | No mutually supported authentication method is available. |
+   *
+   * | `4` |  | SSH authentication protocol error: an unexpected or invalid message was received. |
+   *
+   * | `5` |  | The server rejected the supplied password or private key. |
+   *
+   * | `6` |  | The SSH session is already authenticated. |
+   *
+   * | `7` |  | The server requires a password change. See {@link SFtp.passwordChangeRequested}. |
+   *
+   * Read this property immediately after an authentication method fails. Also inspect
+   * `LastErrorText` for detailed diagnostics.
+   *
+   * **Lifetime:** A later successful authentication does not necessarily reset this value. Consult
+   * it only immediately after an authentication method returns `false`; do not use an older value
+   * to describe the current session.
+   *
+   * This property is read-only.
+   */
+  readonly authFailReason: number
+
+  /**
+   * Specifies the approximate maximum download rate, in bytes per second. The default is `0`, which
+   * disables download throttling.
+   *
+   * Bandwidth throttling is approximate. Actual throughput can vary because of network latency, SSH
+   * framing, buffering, and server behavior.
+   */
+  bandwidthThrottleDown: number
+
+  /**
+   * Specifies the approximate maximum upload rate, in bytes per second. The default is `0`, which
+   * disables upload throttling.
+   *
+   * Bandwidth throttling is approximate. Actual throughput can vary because of network latency, SSH
+   * framing, buffering, and server behavior.
+   */
+  bandwidthThrottleUp: number
+
+  /**
+   * Specifies the SSH client-identification string sent when a connection is established. The
+   * default begins with `SSH-2.0-Chilkat_` followed by the Chilkat version, for example
+   * `SSH-2.0-Chilkat_11.6.0`.
+   *
+   * The value should begin with `SSH-2.0-`. A server may disconnect if the identification string is
+   * invalid.
+   */
+  clientIdentifier: string
+
+  /**
+   * **This property is normally left unset.** Set it only on a multihomed computer when the
+   * application must bind the outgoing connection to a specific local network interface.
+   *
+   * Specify a numeric IPv4 or IPv6 address, not a hostname. When the property is empty, the
+   * operating system automatically chooses the local address.
+   */
+  clientIpAddress: string
+
+  /**
+   * Specifies the maximum number of milliseconds allowed for the remote endpoint to accept the TCP
+   * connection.
+   *
+   * This setting covers TCP connection establishment. After the socket is connected, receive and
+   * transfer inactivity are governed by {@link SFtp.idleTimeoutMs} and method-specific timeouts.
+   */
+  connectTimeoutMs: number
+
+  /**
+   * Contains the RFC 4253 reason code from the most recent SSH `DISCONNECT` message received from
+   * the server. A value of `0` means no server-provided disconnect code is available.
+   *
+   * CodeSymbolic name
+   *
+   * | `1` |  | `SSH_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT` |
+   *
+   * | `2` |  | `SSH_DISCONNECT_PROTOCOL_ERROR` |
+   *
+   * | `3` |  | `SSH_DISCONNECT_KEY_EXCHANGE_FAILED` |
+   *
+   * | `4` |  | `SSH_DISCONNECT_RESERVED` |
+   *
+   * | `5` |  | `SSH_DISCONNECT_MAC_ERROR` |
+   *
+   * | `6` |  | `SSH_DISCONNECT_COMPRESSION_ERROR` |
+   *
+   * | `7` |  | `SSH_DISCONNECT_SERVICE_NOT_AVAILABLE` |
+   *
+   * | `8` |  | `SSH_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED` |
+   *
+   * | `9` |  | `SSH_DISCONNECT_HOST_KEY_NOT_VERIFIABLE` |
+   *
+   * | `10` |  | `SSH_DISCONNECT_CONNECTION_LOST` |
+   *
+   * | `11` |  | `SSH_DISCONNECT_BY_APPLICATION` |
+   *
+   * | `12` |  | `SSH_DISCONNECT_TOO_MANY_CONNECTIONS` |
+   *
+   * | `13` |  | `SSH_DISCONNECT_AUTH_CANCELLED_BY_USER` |
+   *
+   * | `14` |  | `SSH_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE` |
+   *
+   * | `15` |  | `SSH_DISCONNECT_ILLEGAL_USER_NAME` |
+   *
+   * See {@link SFtp.disconnectReason} for the server-provided descriptive text.
+   *
+   * This property is read-only.
+   */
+  readonly disconnectCode: number
+
+  /**
+   * Contains the descriptive text sent with the most recent server SSH `DISCONNECT` message. See
+   * {@link SFtp.disconnectCode} for the corresponding RFC 4253 reason code.
+   *
+   * The text is supplied by the server and can be empty or generic. An ordinary TCP loss or a local
+   * disconnect does not necessarily produce an SSH disconnect reason.
+   *
+   * This property is read-only.
+   */
+  readonly disconnectReason: string
+
+  /**
+   * Controls whether Chilkat caches remote file sizes and attributes requested by {@link
+   * SFtp.getFileSize32}, {@link SFtp.getFileSize64}, {@link SFtp.getFileSizeStr}, {@link
+   * SFtp.getFileCreateTimeStr}, {@link SFtp.getFileLastAccessStr}, {@link
+   * SFtp.getFileLastModifiedStr}, {@link SFtp.getFileOwner}, {@link SFtp.getFileGroup}, {@link
+   * SFtp.getFilePermissions}. The default is `false`.
+   *
+   * When enabled, requesting one attribute by filename causes the complete attribute set for that
+   * file to be cached. Later attribute requests for the same filename can be satisfied without
+   * another server round trip.
+   *
+   * Caching applies only when a remote path is used, not when an open handle is used. Call {@link
+   * SFtp.clearCache} when remote metadata may have changed.
+   */
+  enableCache: boolean
+
+  /**
+   * Controls whether SSH compression may be negotiated. The default is `false`.
+   *
+   * Some older servers advertise compression but fail when it is enabled. If the server disconnects
+   * during or immediately after connection or authentication, try leaving this property `false`.
+   */
+  enableCompression: boolean
+
+  /**
+   * Specifies the character encoding used for SFTP filenames. During {@link SFtp.initializeSftp},
+   * Chilkat automatically sets this property when the server supplies a `filename-charset`
+   * extension.
+   *
+   * When the property is empty, incoming and outgoing filenames use UTF-8. Otherwise, Chilkat uses
+   * the specified charset, such as `utf-8`, `iso-8859-1`, or `windows-1252`.
+   *
+   * Use an explicit charset only when required by the server. UTF-8 is the normal SFTP filename
+   * encoding.
+   */
+  filenameCharset: string
+
+  /**
+   * Restricts SSH cipher negotiation to a single cipher. Leave this property empty to use Chilkat's
+   * normal preference order. For broader algorithm control, use {@link SFtp.setAllowedAlgorithms}.
+   *
+   * Cipher nameFamily
+   *
+   * | `chacha20-poly1305@openssh.com` |  | ChaCha20-Poly1305 authenticated encryption |
+   *
+   * | `aes128-ctr, aes192-ctr, aes256-ctr` |  | AES in CTR mode |
+   *
+   * | `aes128-cbc, aes192-cbc, aes256-cbc` |  | AES in CBC mode |
+   *
+   * | `aes128-gcm@openssh.com, aes256-gcm@openssh.com` |  | AES-GCM authenticated encryption |
+   *
+   * | `twofish128-cbc, twofish256-cbc` |  | Twofish in CBC mode |
+   *
+   * | `blowfish-cbc` |  | Blowfish in CBC mode |
+   *
+   * If the server does not support the selected cipher, {@link SFtp.connect} fails.
+   */
+  forceCipher: string
+
+  /**
+   * Controls SFTP protocol-version negotiation. The default is `true`, which forces use of SFTP v3
+   * even when the server supports a newer version.
+   *
+   * Set this property to `false` before {@link SFtp.initializeSftp} when the application needs
+   * features introduced in SFTP v4, v5, or v6. After initialization, read {@link
+   * SFtp.protocolVersion} to determine the negotiated version.
+   */
+  forceV3: boolean
+
+  /**
+   * Specifies the interval, in milliseconds, between `AbortCheck` event callbacks during operations
+   * that support progress events. The default is `0`, which disables periodic callbacks.
+   */
+  heartbeatMs: number
+
+  /**
+   * Specifies the preferred host-key algorithm used during SSH connection establishment. The
+   * default is `DSS`; set it to `RSA` only when required for compatibility with a particular
+   * server.
+   *
+   * Normally this property should be left unchanged.
+   */
+  hostKeyAlg: string
+
+  /**
+   * Contains the connected server's host-key fingerprint in Chilkat's legacy MD5 format. The value
+   * is set after a successful SSH connection.
+   *
+   * ```
+   * ssh-rsa 2048 68:ff:d1:4e:6c:ff:d7:b0:d6:58:73:85:07:bc:2e:d5
+   * ssh-ed25519 256 c8:73:22:c7:82:aa:09:f1:1c:4e:99:8a:a0:62:a7:87
+   * ```
+   *
+   * For new applications, use {@link SFtp.getHostKeyFP} with `SHA256`. Compare the fingerprint with
+   * a value obtained from a trusted source before sending credentials.
+   *
+   * The value is cleared by {@link SFtp.disconnect}. Obtain and validate it while the SSH
+   * connection is active.
+   *
+   * This property is read-only.
+   */
+  readonly hostKeyFingerprint: string
+
+  /**
+   * Specifies the authentication method used by an HTTP proxy. Matching is case-insensitive.
+   *
+   * ValueBehavior
+   *
+   * | \*empty\* |  | Automatically negotiate a supported method. |
+   *
+   * | `Basic` |  | Use HTTP Basic authentication. |
+   *
+   * | `NTLM` |  | Use NTLM authentication. |
+   */
+  httpProxyAuthMethod: string
+
+  /**
+   * Specifies the optional Windows domain used for NTLM authentication with an HTTP proxy. This
+   * property is ignored for Basic authentication.
+   */
+  httpProxyDomain: string
+
+  /**
+   * Specifies the hostname or numeric IP address of an HTTP proxy used to establish the SSH
+   * connection.
+   *
+   * Set this property together with {@link SFtp.httpProxyPort}. A configured SOCKS proxy takes
+   * precedence when {@link SFtp.socksVersion} is `4` or `5`.
+   */
+  httpProxyHostname: string
+
+  /**
+   * Specifies the password used to authenticate with an HTTP proxy.
+   */
+  httpProxyPassword: string
+
+  /**
+   * Specifies the HTTP proxy port. Common values include `8080` and `3128`.
+   *
+   * The proxy is used when {@link SFtp.httpProxyHostname} is nonempty, this property is nonzero,
+   * and {@link SFtp.socksVersion} is `0`.
+   */
+  httpProxyPort: number
+
+  /**
+   * Specifies the username used to authenticate with an HTTP proxy.
+   */
+  httpProxyUsername: string
+
+  /**
+   * Specifies the maximum period, in milliseconds, during which an SFTP operation may make no
+   * progress while sending or receiving data. The default is `30000` (30 seconds).
+   *
+   * Set this property to `0` to allow an operation to wait indefinitely.
+   */
+  idleTimeoutMs: number
+
+  /**
+   * Controls whether `ReadDir` and {@link SFtp.readDirListing} include the special `.` and `..`
+   * directory entries. The default is `false`.
+   *
+   * This property controls only the special directory entries `.` and `..`. It does not exclude
+   * ordinary hidden filenames such as `.gitignore` or `.profile`.
+   */
+  includeDotDirs: boolean
+
+  /**
+   * Contains the RFC 4254 channel-open failure code when {@link SFtp.initializeSftp} cannot open
+   * the SFTP session channel. The initial value is `0`.
+   *
+   * CodeSymbolic name
+   *
+   * | `1` |  | `SSH_OPEN_ADMINISTRATIVELY_PROHIBITED` |
+   *
+   * | `2` |  | `SSH_OPEN_CONNECT_FAILED` |
+   *
+   * | `3` |  | `SSH_OPEN_UNKNOWN_CHANNEL_TYPE` |
+   *
+   * | `4` |  | `SSH_OPEN_RESOURCE_SHORTAGE` |
+   *
+   * This property is read-only.
+   */
+  readonly initializeFailCode: number
+
+  /**
+   * Contains the descriptive text associated with {@link SFtp.initializeFailCode} when {@link
+   * SFtp.initializeSftp} cannot open the SFTP session channel. The text is supplied by the server
+   * and may be empty or generic.
+   *
+   * This property is read-only.
+   */
+  readonly initializeFailReason: string
+
+  /**
+   * Returns `true` when Chilkat's last known state indicates that the underlying SSH transport is
+   * connected. This means {@link SFtp.connect} succeeded; it does not mean authentication or {@link
+   * SFtp.initializeSftp} has completed.
+   *
+   * This property is passive and does not perform network I/O. A silent network failure or a peer
+   * close may remain undetected until an operation reads from or writes to the socket.
+   *
+   * To actively test whether the connection is still writable, call {@link SFtp.sendIgnore} and
+   * check its return value. The server does not reply to an SSH `IGNORE` message.
+   *
+   * This property is read-only.
+   */
+  readonly isConnected: boolean
+
+  /**
+   * Controls whether SSH and SFTP protocol traffic is accumulated in {@link SFtp.sessionLog}. The
+   * default is `false`.
+   *
+   * Session logging is intended for diagnostics and grows as activity continues. Disable it when no
+   * longer needed and treat the resulting log as potentially sensitive.
+   */
+  keepSessionLog: boolean
+
+  /**
+   * Specifies the maximum packet length used by the underlying SSH transport. The default is
+   * `32768` bytes.
+   *
+   * Normally this property should remain unchanged.
+   */
+  maxPacketSize: number
+
+  /**
+   * Indicates that the server rejected password authentication because the account password must be
+   * changed. This property is set by {@link SFtp.authenticatePw} and {@link SFtp.authenticatePwPk}.
+   *
+   * When `true`, call the authentication method again and pass the old and new passwords in this
+   * form:
+   *
+   * ```
+   * |oldPassword|newPassword|
+   * ```
+   *
+   * This property is read-only.
+   */
+  readonly passwordChangeRequested: boolean
+
+  /**
+   * Specifies the value representing 100% completion in `PercentDone` event callbacks. The default
+   * is `100`.
+   *
+   * For example, a scale of `1000` provides 0.1% granularity, so a callback value of `453`
+   * represents 45.3% complete. Values are clamped to the range `10` through `100000`.
+   *
+   * This property applies only in environments that support event callbacks and only to operations
+   * for which progress can be measured.
+   */
+  percentDoneScale: number
+
+  /**
+   * Controls the preferred address family when DNS resolution returns both IPv4 and IPv6 addresses.
+   * The default is `false`, which prefers IPv4. Set it to `true` to prefer IPv6.
+   */
+  preferIpv6: boolean
+
+  /**
+   * Controls whether path-based upload and download methods preserve source timestamps on the
+   * destination. The default is `false`.
+   *
+   * Last-modified time is preserved when supported by the negotiated SFTP version and destination
+   * filesystem. SFTP v3 represents these times with whole-second precision and does not provide a
+   * creation-time attribute; creation-time preservation requires a later protocol version and
+   * server support.
+   *
+   * This property does not apply to low-level transfers performed by opening a remote handle,
+   * reading or writing the data, and then closing the handle.
+   */
+  preserveDate: boolean
+
+  /**
+   * Contains the SFTP protocol version negotiated by {@link SFtp.initializeSftp}, normally a value
+   * from `3` through `6`.
+   *
+   * Chilkat and the server exchange their highest supported versions, and the session uses the
+   * lower compatible version. Features unavailable in older versions are identified throughout this
+   * reference documentation.
+   *
+   * The initial value is `0`. After a successful initialization, the negotiated value can remain
+   * populated after {@link SFtp.disconnect} and during a later connection before SFTP is
+   * initialized again. Do not use this property alone to determine whether an SFTP channel is
+   * currently open.
+   *
+   * This property is read-only.
+   */
+  readonly protocolVersion: number
+
+  /**
+   * Specifies a semicolon-separated list of filename patterns. When nonempty, `ReadDir` and {@link
+   * SFtp.readDirListing} include only entries matching at least one pattern.
+   *
+   * - `*` matches zero or more characters.
+   *
+   * - Matching is case-insensitive.
+   *
+   * - `?` and bracket expressions such as `[0-9]` are not wildcard operators.
+   *
+   * - Surrounding whitespace and empty entries between semicolons are ignored.
+   *
+   * ```
+   * *.xml; *.txt; *.csv
+   * ```
+   */
+  readDirMustMatch: string
+
+  /**
+   * Specifies a semicolon-separated list of filename patterns. When nonempty, `ReadDir` and {@link
+   * SFtp.readDirListing} exclude entries matching any pattern. Exclusion is applied after {@link
+   * SFtp.readDirMustMatch}.
+   *
+   * - `*` matches zero or more characters.
+   *
+   * - Matching is case-insensitive.
+   *
+   * - `?` and bracket expressions such as `[0-9]` are not wildcard operators.
+   *
+   * - Surrounding whitespace and empty entries between semicolons are ignored.
+   *
+   * ```
+   * *.tmp; *.bak; *.log
+   * ```
+   */
+  readDirMustNotMatch: string
+
+  /**
+   * Contains the in-memory SSH/SFTP protocol log. Enable logging by setting {@link
+   * SFtp.keepSessionLog} to `true`.
+   *
+   * This property contains log text, not a file path. Call {@link SFtp.clearSessionLog} to clear
+   * it.
+   *
+   * This property is read-only.
+   */
+  readonly sessionLog: string
+
+  /**
+   * Specifies the socket receive-buffer size. The default is `4194304` bytes. Normally this
+   * property should remain unchanged.
+   *
+   * When download throughput is unexpectedly low, testing a larger value may help. Values should
+   * generally be multiples of `4096`.
+   */
+  soRcvBuf: number
+
+  /**
+   * Specifies the socket send-buffer size. The default is `262144` bytes. Normally this property
+   * should remain unchanged.
+   *
+   * When upload throughput is unexpectedly low, testing values such as `524288` or `1048576` may
+   * help. Values should generally be multiples of `4096`.
+   */
+  soSndBuf: number
+
+  /**
+   * Specifies the SOCKS proxy hostname or IPv4 address. This property is used only when {@link
+   * SFtp.socksVersion} is `4` or `5`.
+   */
+  socksHostname: string
+
+  /**
+   * Specifies the SOCKS5 password when username/password authentication is required. SOCKS4 does
+   * not use a password, so this property is ignored when {@link SFtp.socksVersion} is `4`.
+   */
+  socksPassword: string
+
+  /**
+   * Specifies the SOCKS proxy port. The default is `1080`. This property is used only when {@link
+   * SFtp.socksVersion} is `4` or `5`.
+   */
+  socksPort: number
+
+  /**
+   * Specifies the SOCKS proxy username. For SOCKS4 it is sent as the user ID; for SOCKS5 it is used
+   * with {@link SFtp.socksPassword} for username/password authentication.
+   */
+  socksUsername: string
+
+  /**
+   * Selects whether and how a SOCKS proxy is used.
+   *
+   * ValueBehavior
+   *
+   * | `0` |  | Do not use a SOCKS proxy. This is the default. |
+   *
+   * | `4` |  | Connect through a SOCKS4 proxy. |
+   *
+   * | `5` |  | Connect through a SOCKS5 proxy. |
+   */
+  socksVersion: number
+
+  /**
+   * Specifies a semicolon-separated list of wildcard filename patterns. {@link SFtp.syncTreeUpload}
+   * and {@link SFtp.syncTreeDownload} transfer only files matching at least one pattern.
+   *
+   * This filter applies to filenames, not directory names encountered while recursively traversing
+   * a tree.
+   *
+   * ```
+   * *.xml;*.txt;*.csv
+   * ```
+   *
+   * Use `*` to match zero or more characters. Separate multiple patterns with semicolons.
+   */
+  syncMustMatch: string
+
+  /**
+   * Specifies a semicolon-separated list of wildcard filename patterns. {@link SFtp.syncTreeUpload}
+   * and {@link SFtp.syncTreeDownload} skip files matching any pattern.
+   *
+   * This filter applies to filenames, not directory names encountered while recursively traversing
+   * a tree.
+   *
+   * ```
+   * *.tmp;*.bak;*.log
+   * ```
+   *
+   * Use `*` to match zero or more characters. Separate multiple patterns with semicolons.
+   */
+  syncMustNotMatch: string
+
+  /**
+   * Controls the `TCP_NODELAY` socket option. The default is `false`. Set it to `true` to disable
+   * the Nagle algorithm and reduce delays when many small packets are sent.
+   */
+  tcpNoDelay: boolean
+
+  /**
+   * Specifies the chunk size, in bytes, used by {@link SFtp.uploadFile} and {@link
+   * SFtp.uploadFileByName}. The default is `32000`.
+   *
+   * If an upload fails because the local operating system aborts the connection, try a smaller
+   * value such as `4096`. Smaller chunks can reduce throughput.
+   */
+  uploadChunkSize: number
+
+  /**
+   * Controls the time zone used by date/time getters. When `true`, returned values are expressed in
+   * UTC. When `false` (the default), returned values are converted to the local time zone.
+   *
+   * ```
+   * UtcMode = _FALSE_: Fri, 21 Nov 1997 09:55:06 -0600
+   * UtcMode = _TRUE_:  Fri, 21 Nov 1997 15:55:06 GMT
+   * ```
+   */
+  utcMode: boolean
+
+  /**
+   * Set to `true` to request that the currently running Chilkat operation abort. Both synchronous
+   * and asynchronous operations can be canceled; a synchronous call may be interrupted by setting
+   * this property from another thread.
+   *
+   * When the abort is observed, the current method returns failure and Chilkat resets this property
+   * to `false`. If no method is running, it is reset when the next method begins.
+   */
+  abortCurrent: boolean
+
+  /**
+   * Specifies comma-separated directives that modify {@link SFtp.syncTreeUpload} or {@link
+   * SFtp.syncTreeDownload}. The default is an empty string.
+   *
+   * DirectiveEffect
+   *
+   * | `UploadIgnoreLocalOpenFailures` | | During upload synchronization, skip local files that
+   * cannot be opened, such as files held with exclusive access by another process. |
+   */
+  syncDirectives: string
+
+  /**
+   * Contains the current transfer byte count for an upload or download in progress. An application
+   * can read this property while an asynchronous transfer is running.
+   *
+   * For {@link SFtp.syncTreeUpload} and {@link SFtp.syncTreeDownload}, the value is cumulative
+   * across all files processed by the operation. Use {@link SFtp.xferByteCount64} when a 64-bit
+   * count is required.
+   *
+   * This property is read-only.
+   */
+  readonly xferByteCount: number
+
+  /**
+   * Contains the current 64-bit transfer byte count for an upload or download in progress. An
+   * application can read this property while an asynchronous transfer is running.
+   *
+   * For {@link SFtp.syncTreeUpload} and {@link SFtp.syncTreeDownload}, the value is cumulative
+   * across all files processed by the operation.
+   *
+   * This property is read-only.
+   *
+   * A 64-bit integer in Chilkat; JavaScript numbers are exact up to 2^53.
+   */
+  readonly xferByteCount64: number
+
+  /**
+   * Contains the SSH server-identification string received during connection establishment. For
+   * example:
+   *
+   * ```
+   * SSH-2.0-OpenSSH_8.9p1 Ubuntu-3ubuntu0.16
+   * ```
+   *
+   * The last received identifier can remain populated after {@link SFtp.disconnect}. Use {@link
+   * SFtp.isConnected} to determine whether the SSH transport is currently connected.
+   *
+   * This property is read-only.
+   */
+  readonly serverIdentifier: string
+
+  /**
+   * Provides comma-separated compatibility, security, and synchronization options for uncommon
+   * scenarios. The default is an empty string and is appropriate for most applications.
+   *
+   * KeywordEffect
+   *
+   * | `ForceUserAuthRsaSha1` | | Force legacy `ssh-rsa`/SHA-1 signatures for RSA user
+   * authentication. Set before connecting. |
+   *
+   * | `ProtectFromVpn` |  | On Android, bypass an installed or active VPN. |
+   *
+   * | `NoSyncDownloadEmptyFiles` | | Prevent empty files from being downloaded by
+   * `SyncTreeDownload`. |
+   *
+   * | `no-weak-mac-algs` | | Remove weaker SHA-1, MD5, and RIPEMD-160 MAC algorithms from the
+   * offered list. |
+   *
+   * | `+ssh-hmac-etm` | | Re-enable OpenSSH Encrypt-then-MAC algorithms disabled by default as a
+   * Terrapin mitigation. |
+   *
+   * | `+chacha20-poly1305@openssh.com` | | Re-enable `chacha20-poly1305@openssh.com`, disabled by
+   * default as a Terrapin mitigation. |
+   */
+  uncommonOptions: string
+
+  /**
+   * Specifies a semicolon-separated list of wildcard directory-name patterns. {@link
+   * SFtp.syncTreeUpload} and {@link SFtp.syncTreeDownload} enter only directories matching at least
+   * one pattern.
+   *
+   * ```
+   * xml;txt;data_*
+   * ```
+   *
+   * Use `*` to match zero or more characters. Separate multiple patterns with semicolons.
+   */
+  syncMustMatchDir: string
+
+  /**
+   * Specifies a semicolon-separated list of wildcard directory-name patterns. {@link
+   * SFtp.syncTreeUpload} and {@link SFtp.syncTreeDownload} skip directories matching any pattern.
+   *
+   * ```
+   * temp;cache;archive_*
+   * ```
+   *
+   * Use `*` to match zero or more characters. Separate multiple patterns with semicolons.
+   */
+  syncMustNotMatchDir: string
+
+  /**
+   * Controls whether {@link SFtp.syncTreeDownload} creates empty remote directories locally. The
+   * default is `true`.
+   *
+   * When `false`, a local directory is created only when it is needed to contain a downloaded file.
+   *
+   * When `true`, an empty remote directory is created locally even when no file beneath it is
+   * downloaded.
+   */
+  syncCreateAllLocalDirs: boolean
+
+  /**
+   * Contains the numeric code from the most recently received SFTP `SSH_FXP_STATUS` response. This
+   * is not necessarily the status of the most recently called method. Methods that return a handle,
+   * attributes, or data can complete without receiving a new status response, leaving an older
+   * value unchanged. A successful method can therefore leave a previous nonzero status code in this
+   * property.
+   *
+   * CodeSymbolic name
+   *
+   * | `0` |  | `SSH_FX_OK` |
+   *
+   * | `1` |  | `SSH_FX_EOF` |
+   *
+   * | `2` |  | `SSH_FX_NO_SUCH_FILE` |
+   *
+   * | `3` |  | `SSH_FX_PERMISSION_DENIED` |
+   *
+   * | `4` |  | `SSH_FX_FAILURE` |
+   *
+   * | `5` |  | `SSH_FX_BAD_MESSAGE` |
+   *
+   * | `6` |  | `SSH_FX_NO_CONNECTION` |
+   *
+   * | `7` |  | `SSH_FX_CONNECTION_LOST` |
+   *
+   * | `8` |  | `SSH_FX_OP_UNSUPPORTED` |
+   *
+   * | `9` |  | `SSH_FX_INVALID_HANDLE` |
+   *
+   * | `10` |  | `SSH_FX_NO_SUCH_PATH` |
+   *
+   * | `11` |  | `SSH_FX_FILE_ALREADY_EXISTS` |
+   *
+   * | `12` |  | `SSH_FX_WRITE_PROTECT` |
+   *
+   * | `13` |  | `SSH_FX_NO_MEDIA` |
+   *
+   * | `14` |  | `SSH_FX_NO_SPACE_ON_FILESYSTEM` |
+   *
+   * | `15` |  | `SSH_FX_QUOTA_EXCEEDED` |
+   *
+   * | `16` |  | `SSH_FX_UNKNOWN_PRINCIPAL` |
+   *
+   * | `17` |  | `SSH_FX_LOCK_CONFLICT` |
+   *
+   * | `18` |  | `SSH_FX_DIR_NOT_EMPTY` |
+   *
+   * | `19` |  | `SSH_FX_NOT_A_DIRECTORY` |
+   *
+   * | `20` |  | `SSH_FX_INVALID_FILENAME` |
+   *
+   * | `21` |  | `SSH_FX_LINK_LOOP` |
+   *
+   * | `22` |  | `SSH_FX_CANNOT_DELETE` |
+   *
+   * | `23` |  | `SSH_FX_INVALID_PARAMETER` |
+   *
+   * | `24` |  | `SSH_FX_FILE_IS_A_DIRECTORY` |
+   *
+   * | `25` |  | `SSH_FX_BYTE_RANGE_LOCK_CONFLICT` |
+   *
+   * | `26` |  | `SSH_FX_BYTE_RANGE_LOCK_REFUSED` |
+   *
+   * | `27` |  | `SSH_FX_DELETE_PENDING` |
+   *
+   * | `28` |  | `SSH_FX_FILE_CORRUPT` |
+   *
+   * | `29` |  | `SSH_FX_OWNER_INVALID` |
+   *
+   * | `30` |  | `SSH_FX_GROUP_INVALID` |
+   *
+   * | `31` |  | `SSH_FX_NO_MATCHING_BYTE_RANGE_LOCK` |
+   *
+   * See {@link SFtp.lastStatusMessage} for the server-provided message text.
+   *
+   * Use each method's documented return value as the primary success test. Read this property
+   * immediately after a relevant SFTP failure when the server status provides additional detail.
+   *
+   * This property is read-only.
+   */
+  readonly lastStatusCode: number
+
+  /**
+   * Contains the message text from the most recently received SFTP `SSH_FXP_STATUS` response. The
+   * wording is server-dependent.
+   *
+   * This property can remain unchanged across later successful methods that do not receive a new
+   * status response. See {@link SFtp.lastStatusCode} for the numeric code.
+   *
+   * This property is read-only.
+   */
+  readonly lastStatusMessage: string
+
+  /**
+   * Contains a user-authentication banner received from the server. Check this property after
+   * {@link SFtp.startKeyboardAuth} or another authentication attempt and display it to the user
+   * when appropriate.
+   *
+   * When no banner is available, the property returns an empty string.
+   */
+  userAuthBanner: string
+
+  /**
+   * Enables automatic resolution of secret specification strings from secure operating-system
+   * storage. The default is `false`.
+   *
+   * When `true`, supported password properties and authentication methods may receive a value
+   * beginning with `!!` instead of a literal credential. Chilkat resolves the secret from Windows
+   * Credential Manager on Windows or Apple Keychain on macOS.
+   *
+   * Secret specification format:
+   *
+   * ```
+   * !![appName|]service[|domain]|username
+   * ```
+   *
+   * This feature applies to {@link SFtp.httpProxyPassword}, {@link SFtp.socksPassword}, {@link
+   * SFtp.authenticatePw}, and {@link SFtp.authenticatePwPk}.
+   */
+  enableSecrets: boolean
+
+  // ---- Methods ----
+
+  /**
+   * Authenticates the connected SSH session using public-key authentication. `username` identifies
+   * the server account, and `privateKey` must contain the corresponding private key. The matching
+   * public key must already be authorized for that account on the server.
+   *
+   * Call {@link SFtp.connect} first. After a failure, inspect {@link SFtp.authFailReason} and
+   * `LastErrorText`.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.authenticatePkAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  authenticatePk(username: string, privateKey: SshKey): void
+
+  /**
+   * Asynchronous form of {@link SFtp.authenticatePk}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  authenticatePkAsync(username: string, privateKey: SshKey): Promise<void>
+
+  /**
+   * Authenticates the connected SSH session using `login` and `password`.
+   *
+   * ```
+   * 1. Connect
+   * 2. AuthenticatePw or AuthenticatePk
+   * 3. InitializeSftp
+   * ```
+   *
+   * If the server requests a password change, see {@link SFtp.passwordChangeRequested}. After a
+   * failure, inspect {@link SFtp.authFailReason} and `LastErrorText`.
+   *
+   * A rejected password does not necessarily close the SSH connection. The application may retry
+   * authentication on the same connected session. After a later success, an older {@link
+   * SFtp.authFailReason} value can remain populated.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.authenticatePwAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  authenticatePw(login: string, password: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.authenticatePw}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  authenticatePwAsync(login: string, password: string): Promise<void>
+
+  /**
+   * Authenticates with a server that requires both a password and a private key. `username`
+   * identifies the account, `password` supplies the password, and `privateKey` supplies the private
+   * key.
+   *
+   * Most servers require either password or public-key authentication rather than both. After a
+   * failure, inspect {@link SFtp.authFailReason} and `LastErrorText`.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.authenticatePwPkAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  authenticatePwPk(username: string, password: string, privateKey: SshKey): void
+
+  /**
+   * Asynchronous form of {@link SFtp.authenticatePwPk}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  authenticatePwPkAsync(username: string, password: string, privateKey: SshKey): Promise<void>
+
+  /**
+   * Clears the internal remote file-attribute cache used when {@link SFtp.enableCache} is `true`.
+   */
+  clearCache(): void
+
+  /**
+   * Clears the in-memory text stored in {@link SFtp.sessionLog}.
+   */
+  clearSessionLog(): void
+
+  /**
+   * Closes the remote file or directory handle specified by `handle`. The handle must have been
+   * returned by {@link SFtp.openFile} or {@link SFtp.openDir}.
+   *
+   * Handles are specific to one initialized SFTP session. Close each handle exactly once. Closing
+   * an empty, invalid, or already-closed handle returns `false`. A handle must never be reused
+   * after disconnecting or replacing the connection.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.closeHandleAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  closeHandle(handle: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.closeHandle}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  closeHandleAsync(handle: string): Promise<void>
+
+  /**
+   * Establishes an SSH connection to `domainName` on TCP port `port`. The host may be a DNS name or
+   * numeric IPv4 or IPv6 address; SSH servers commonly listen on port `22`.
+   *
+   * A successful connection establishes the SSH transport only. Next call an authentication method,
+   * then call {@link SFtp.initializeSftp}.
+   *
+   * ```
+   * 1. Connect
+   * 2. AuthenticatePw, AuthenticatePk, or another authentication method
+   * 3. InitializeSftp
+   * 4. Perform SFTP operations
+   * ```
+   *
+   * **Supported negotiation algorithms include:**
+   *
+   * CategoryAlgorithms
+   *
+   * | Host key | | `ssh-ed25519`, `rsa-sha2-256`, `rsa-sha2-512`, `ecdsa-sha2-nistp256`,
+   * `ecdsa-sha2-nistp384`, `ecdsa-sha2-nistp521`, `ssh-rsa`, `ssh-dss` |
+   *
+   * | Key exchange | | `curve25519-sha256`, `curve25519-sha256@libssh.org`, NIST ECDH,
+   * Diffie-Hellman group 1/14/16/18, and group-exchange SHA-1/SHA-256 |
+   *
+   * | Ciphers | | AES CTR/CBC/GCM, Twofish CBC, Blowfish CBC, and optionally
+   * `chacha20-poly1305@openssh.com` |
+   *
+   * | MAC |  | SHA-2, SHA-1, RIPEMD-160, MD5, and optionally OpenSSH Encrypt-then-MAC variants |
+   *
+   * | Compression |  | `none`, `zlib`, and `zlib@openssh.com` |
+   *
+   * Connection failures can occur before SSH negotiation because of firewalls, endpoint security,
+   * routing, network ACLs, proxy configuration, or server policy.
+   *
+   * **Calling while connected:** A new successful `Connect` replaces the existing SSH connection.
+   * The previous SFTP subsystem and all handles from it are no longer usable. Authenticate and call
+   * {@link SFtp.initializeSftp} for the new connection.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.connectAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  connect(domainName: string, port: number): void
+
+  /**
+   * Asynchronous form of {@link SFtp.connect}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  connectAsync(domainName: string, port: number): Promise<void>
+
+  /**
+   * Connects to `hostname` on `port` through the already connected and authenticated `Ssh` object
+   * in `sshConn`.
+   *
+   * ```
+   * application  →  first SSH server  →  destination SSH/SFTP server
+   * ```
+   *
+   * After this method succeeds, authenticate separately with the destination server and call
+   * `InitializeSftp`. All destination traffic is carried through the first SSH connection.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.connectThroughSshAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  connectThroughSsh(sshConn: Ssh, hostname: string, port: number): void
+
+  /**
+   * Asynchronous form of {@link SFtp.connectThroughSsh}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  connectThroughSshAsync(sshConn: Ssh, hostname: string, port: number): Promise<void>
+
+  /**
+   * Copies supported timestamps and attributes from the local file at `localFilename` to the remote
+   * item identified by `remoteFilename`.
+   *
+   * Set `isHandle` to `true` when `remoteFilename` contains an open SFTP handle; otherwise set it
+   * to `false` for a remote path.
+   *
+   * Negotiated SFTP versionAttributes copied
+   *
+   * | SFTP v3 and earlier |  | Last-modified time and last-access time |
+   *
+   * | SFTP v4 and v5 |  | Last-modified time, last-access time, and creation time |
+   *
+   * | SFTP v6 and later | | The preceding timestamps plus read-only, hidden, archive, compressed,
+   * and encrypted flags |
+   *
+   * The remote server and filesystem determine whether all requested attributes can be applied.
+   * Last-access time may change when the server accesses the file, and compressed or encrypted
+   * flags may not have the same effect on every server.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.copyFileAttrAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  copyFileAttr(localFilename: string, remoteFilename: string, isHandle: boolean): void
+
+  /**
+   * Asynchronous form of {@link SFtp.copyFileAttr}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  copyFileAttrAsync(localFilename: string, remoteFilename: string, isHandle: boolean): Promise<void>
+
+  /**
+   * Creates the remote directory specified by `path`. Parent directories are not necessarily
+   * created automatically.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.createDirAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  createDir(path: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.createDir}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  createDirAsync(path: string): Promise<void>
+
+  /**
+   * Closes the current SSH/SFTP connection. All remote file and directory handles from that session
+   * become invalid and must not be reused.
+   *
+   * The object remains reusable. A later session must call {@link SFtp.connect}, authenticate
+   * again, and call {@link SFtp.initializeSftp} before performing SFTP operations.
+   *
+   * Some properties retain values from the previous session after disconnect, including the
+   * negotiated protocol version, server identifier, and last SFTP status. Treat these as historical
+   * values rather than evidence of a live session.
+   */
+  disconnect(): void
+
+  /**
+   * Streams the remote file identified by `handle` to the local filesystem path `toFilename`. The
+   * handle must have been returned by {@link SFtp.openFile}.
+   *
+   * The transfer is streamed and is not limited by available memory. Close the remote handle when
+   * the download is complete.
+   *
+   * This method downloads the entire remote file beginning at byte offset `0`. It does not begin at
+   * the handle's current sequential read position.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.downloadFileAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  downloadFile(handle: string, toFilename: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.downloadFile}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  downloadFileAsync(handle: string, toFilename: string): Promise<void>
+
+  /**
+   * Downloads the remote file at `remoteFilePath` to the local filesystem path `localFilePath`.
+   *
+   * When {@link SFtp.preserveDate} is `true`, Chilkat preserves the remote file's last-modified
+   * time.
+   *
+   * An absolute remote path begins with `/` and is relative to the server filesystem root. A
+   * relative path is interpreted relative to the authenticated user's home directory.
+   *
+   * If the local destination file exists, it is truncated before the download.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.downloadFileByNameAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  downloadFileByName(remoteFilePath: string, localFilePath: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.downloadFileByName}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  downloadFileByNameAsync(remoteFilePath: string, localFilePath: string): Promise<void>
+
+  /**
+   * Returns `true` when the most recent read for `handle` received the SFTP end-of-file status.
+   *
+   * Reading exactly through the final byte does not set EOF immediately. The next read returns
+   * successfully with zero bytes, sets {@link SFtp.lastStatusCode} to `SSH_FX_EOF`, and causes this
+   * method to return `true`.
+   *
+   * An empty, malformed, or already-closed handle can also cause this method to return `true`. Use
+   * {@link SFtp.lastReadFailed} and the read method's result to distinguish a normal EOF from a
+   * handle or read failure.
+   */
+  eof(handle: string): boolean
+
+  /**
+   * Returns the remote file's creation date and time. `pathOrHandle` may contain a remote path or a
+   * handle returned by {@link SFtp.openFile}. Set `bIsHandle` to `true` for a handle and `false`
+   * for a path.
+   *
+   * When `bFollowLinks` is `true`, the server follows a symbolic link and returns metadata for its
+   * target.
+   *
+   * SFTP v3 and earlier do not provide a file creation time.
+   *
+   * The result is an RFC 822 formatted string, for example `Fri, 21 Nov 1997 09:55:06 -0600`.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.getFileCreateTimeStrAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  getFileCreateTimeStr(pathOrHandle: string, bFollowLinks: boolean, bIsHandle: boolean): string
+
+  /**
+   * Asynchronous form of {@link SFtp.getFileCreateTimeStr}: the same call on a native worker
+   * thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  getFileCreateTimeStrAsync(pathOrHandle: string, bFollowLinks: boolean, bIsHandle: boolean): Promise<string>
+
+  /**
+   * Returns the remote file's group ownership. `pathOrHandle` may contain a remote path or a handle
+   * returned by {@link SFtp.openFile}. Set `bIsHandle` to `true` for a handle and `false` for a
+   * path.
+   *
+   * When `bFollowLinks` is `true`, the server follows a symbolic link and returns metadata for its
+   * target.
+   *
+   * With SFTP v3 and earlier, the result is the decimal numeric GID because textual group names are
+   * not supported.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.getFileGroupAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  getFileGroup(pathOrHandle: string, bFollowLinks: boolean, bIsHandle: boolean): string
+
+  /**
+   * Asynchronous form of {@link SFtp.getFileGroup}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  getFileGroupAsync(pathOrHandle: string, bFollowLinks: boolean, bIsHandle: boolean): Promise<string>
+
+  /**
+   * Returns the remote file's last-access date and time. `pathOrHandle` may contain a remote path
+   * or a handle returned by {@link SFtp.openFile}. Set `bIsHandle` to `true` for a handle and
+   * `false` for a path.
+   *
+   * When `bFollowLinks` is `true`, the server follows a symbolic link and returns metadata for its
+   * target.
+   *
+   * The result is an RFC 822 formatted string, for example `Fri, 21 Nov 1997 09:55:06 -0600`.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.getFileLastAccessStrAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  getFileLastAccessStr(pathOrHandle: string, bFollowLinks: boolean, bIsHandle: boolean): string
+
+  /**
+   * Asynchronous form of {@link SFtp.getFileLastAccessStr}: the same call on a native worker
+   * thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  getFileLastAccessStrAsync(pathOrHandle: string, bFollowLinks: boolean, bIsHandle: boolean): Promise<string>
+
+  /**
+   * Returns the remote file's last-modified date and time. `pathOrHandle` may contain a remote path
+   * or a handle returned by {@link SFtp.openFile}. Set `bIsHandle` to `true` for a handle and
+   * `false` for a path.
+   *
+   * When `bFollowLinks` is `true`, the server follows a symbolic link and returns metadata for its
+   * target.
+   *
+   * The result is an RFC 822 formatted string, for example `Fri, 21 Nov 1997 09:55:06 -0600`.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.getFileLastModifiedStrAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  getFileLastModifiedStr(pathOrHandle: string, bFollowLinks: boolean, bIsHandle: boolean): string
+
+  /**
+   * Asynchronous form of {@link SFtp.getFileLastModifiedStr}: the same call on a native worker
+   * thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  getFileLastModifiedStrAsync(pathOrHandle: string, bFollowLinks: boolean, bIsHandle: boolean): Promise<string>
+
+  /**
+   * Returns the remote file's owner. `pathOrHandle` may contain a remote path or a handle returned
+   * by {@link SFtp.openFile}. Set `bIsHandle` to `true` for a handle and `false` for a path.
+   *
+   * When `bFollowLinks` is `true`, the server follows a symbolic link and returns metadata for its
+   * target.
+   *
+   * With SFTP v3 and earlier, the result is the decimal numeric UID because textual owner names are
+   * not supported.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.getFileOwnerAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  getFileOwner(pathOrHandle: string, bFollowLinks: boolean, bIsHandle: boolean): string
+
+  /**
+   * Asynchronous form of {@link SFtp.getFileOwner}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  getFileOwnerAsync(pathOrHandle: string, bFollowLinks: boolean, bIsHandle: boolean): Promise<string>
+
+  /**
+   * Returns the remote item's complete POSIX mode value. `pathOrHandle` may contain a remote path
+   * or a handle returned by {@link SFtp.openFile}. Set `bIsHandle` to `true` for a handle and
+   * `false` for a path. When `bFollowLinks` is `true`, the server follows a symbolic link and
+   * returns metadata for its target.
+   *
+   * The returned integer includes both the file-type bits and permission bits. For example:
+   *
+   * ```
+   * Regular file, mode 0664: octal 0100664, decimal 33204
+   * Regular file, mode 0600: octal 0100600, decimal 33152
+   * Regular file, mode 0644: octal 0100644, decimal 33188
+   * ```
+   *
+   * Mask with octal `07777` to obtain permission and special bits, or `0777` for only the
+   * traditional owner/group/other read, write, and execute bits. See {@link SFtp.setPermissions} to
+   * change the permissions.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.getFilePermissionsAsync}.
+   */
+  getFilePermissions(pathOrHandle: string, bFollowLinks: boolean, bIsHandle: boolean): number
+
+  /**
+   * Asynchronous form of {@link SFtp.getFilePermissions}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   */
+  getFilePermissionsAsync(pathOrHandle: string, bFollowLinks: boolean, bIsHandle: boolean): Promise<number>
+
+  /**
+   * Returns the remote file's size in bytes as a 32-bit integer. `pathOrHandle` may contain a
+   * remote path or a handle returned by {@link SFtp.openFile}. Set `bIsHandle` to `true` for a
+   * handle and `false` for a path.
+   *
+   * When `bFollowLinks` is `true`, the server follows a symbolic link and returns metadata for its
+   * target.
+   *
+   * Returns `-1` when the size cannot be represented as a 32-bit integer. Use `GetFileSize64` or
+   * `GetFileSizeStr` for large files.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.getFileSize32Async}.
+   */
+  getFileSize32(pathOrHandle: string, bFollowLinks: boolean, bIsHandle: boolean): number
+
+  /**
+   * Asynchronous form of {@link SFtp.getFileSize32}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   */
+  getFileSize32Async(pathOrHandle: string, bFollowLinks: boolean, bIsHandle: boolean): Promise<number>
+
+  /**
+   * Returns the remote file's size in bytes as a 64-bit integer. `pathOrHandle` may contain a
+   * remote path or a handle returned by {@link SFtp.openFile}. Set `bIsHandle` to `true` for a
+   * handle and `false` for a path.
+   *
+   * When `bFollowLinks` is `true`, the server follows a symbolic link and returns metadata for its
+   * target.
+   *
+   * 64-bit integers are passed as JavaScript numbers (exact up to 2^53).
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.getFileSize64Async}.
+   */
+  getFileSize64(pathOrHandle: string, bFollowLinks: boolean, bIsHandle: boolean): number
+
+  /**
+   * Asynchronous form of {@link SFtp.getFileSize64}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   */
+  getFileSize64Async(pathOrHandle: string, bFollowLinks: boolean, bIsHandle: boolean): Promise<number>
+
+  /**
+   * Returns the remote file's size in bytes as a decimal string. `pathOrHandle` may contain a
+   * remote path or a handle returned by {@link SFtp.openFile}. Set `bIsHandle` to `true` for a
+   * handle and `false` for a path.
+   *
+   * When `bFollowLinks` is `true`, the server follows a symbolic link and returns metadata for its
+   * target.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.getFileSizeStrAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  getFileSizeStr(pathOrHandle: string, bFollowLinks: boolean, bIsHandle: boolean): string
+
+  /**
+   * Asynchronous form of {@link SFtp.getFileSizeStr}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  getFileSizeStrAsync(pathOrHandle: string, bFollowLinks: boolean, bIsHandle: boolean): Promise<string>
+
+  /**
+   * Opens the SFTP subsystem and negotiates the SFTP protocol version. Call this method after
+   * connecting and authenticating.
+   *
+   * ```
+   * 1. Connect
+   * 2. AuthenticatePw, AuthenticatePk, or another authentication method
+   * 3. InitializeSftp
+   * ```
+   *
+   * After success, read {@link SFtp.protocolVersion} to determine the negotiated SFTP version.
+   *
+   * If opening the SFTP channel fails, inspect {@link SFtp.initializeFailCode}, {@link
+   * SFtp.initializeFailReason}, and `LastErrorText`.
+   *
+   * Call this method only once for a given SSH connection. A second call on the same connection
+   * returns `false`. After disconnecting or replacing the connection, authenticate the new
+   * connection and call this method again.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.initializeSftpAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  initializeSftp(): void
+
+  /**
+   * Asynchronous form of {@link SFtp.initializeSftp}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  initializeSftpAsync(): Promise<void>
+
+  /**
+   * Returns `true` if the most recent read associated with `handle` failed; otherwise returns
+   * `false`.
+   *
+   * A normal end-of-file is not a read failure: the EOF read succeeds, returns zero bytes, and this
+   * method returns `false`. For an empty, malformed, or already-closed handle, this method returns
+   * `true`.
+   */
+  lastReadFailed(handle: string): boolean
+
+  /**
+   * Returns the number of bytes received by the most recent read associated with `handle`.
+   *
+   * The initial value for a newly opened handle is `0`. A normal EOF read and a failed read report
+   * `0`.
+   */
+  lastReadNumBytes(handle: string): number
+
+  /**
+   * Opens the remote directory specified by `path` and returns a handle for reading its entries.
+   *
+   * ```
+   * handle = OpenDir(path)
+   * ReadDirListing(handle, dirObj)
+   * CloseHandle(handle)
+   * ```
+   *
+   * Remote paths use `/` as the separator. A path beginning with `/` is absolute; a relative path
+   * is interpreted relative to the authenticated user's home directory. An empty path refers to
+   * that default directory.
+   *
+   * This method does not change a working directory. SFTP is not FTP and has no persistent
+   * current-directory command.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.openDirAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  openDir(path: string): string
+
+  /**
+   * Asynchronous form of {@link SFtp.openDir}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  openDirAsync(path: string): Promise<string>
+
+  /**
+   * Opens or creates the remote file at `remotePath` and returns a handle for subsequent read or
+   * write operations. Close the handle with `CloseHandle` when finished.
+   *
+   * `access` must be `readOnly`, `writeOnly`, or `readWrite`.
+   *
+   * `createDisposition` is a comma-separated list. It must contain exactly one primary disposition:
+   *
+   * Primary dispositionBehavior
+   *
+   * | `createNew` |  | Create a new file; fail if it already exists. |
+   *
+   * | `createTruncate` |  | Create a new file, or open and truncate an existing file. |
+   *
+   * | `openExisting` |  | Open an existing file; fail if it does not exist. |
+   *
+   * | `openOrCreate` |  | Open the file if it exists, otherwise create it. |
+   *
+   * | `truncateExisting` |  | Open and truncate an existing file; fail if it does not exist. |
+   *
+   * Additional optional keywords are:
+   *
+   * OptionBehavior
+   *
+   * | `appendData` |  | Write at the end of the file. Appends are not guaranteed to be atomic. |
+   *
+   * | `appendDataAtomic` | | Append atomically so concurrent appenders do not collide. SFTP v5 or
+   * later. |
+   *
+   * | `textMode` | | Request server text-mode processing and canonical newline conversion. SFTP v5
+   * or later. |
+   *
+   * | `blockRead` |  | Request exclusive read access. SFTP v5 or later. |
+   *
+   * | `blockWrite` |  | Request exclusive write access. SFTP v5 or later. |
+   *
+   * | `blockDelete` |  | Prevent deletion while the handle is open. SFTP v5 or later. |
+   *
+   * | `blockAdvisory` |  | Make the requested block modes advisory. SFTP v5 or later. |
+   *
+   * | `noFollow` |  | Fail if the final path component is a symbolic link. SFTP v5 or later. |
+   *
+   * | `deleteOnClose` |  | Request deletion when the last handle is closed. SFTP v5 or later. |
+   *
+   * | `accessAuditAlarmInfo` | | Request privileges needed to read or write AUDIT or ALARM ACL
+   * entries. SFTP v5 or later. |
+   *
+   * | `accessBackup` | | Request backup/restore privileges that may bypass normal access checks.
+   * SFTP v5 or later. |
+   *
+   * | `backupStream` |  | Read or write a server-specific backup stream. SFTP v5 or later. |
+   *
+   * Options marked SFTP v5 or later require {@link SFtp.forceV3} to be `false` and a negotiated
+   * {@link SFtp.protocolVersion} of at least `5`.
+   *
+   * An absolute remote path begins with `/`. A relative path is interpreted from the authenticated
+   * user's home directory. Some servers require a filename in the home directory to be written as
+   * `./filename`.
+   *
+   * **Use only documented values:** Some servers or Chilkat versions may tolerate an unknown access
+   * value, an unknown option, or conflicting primary dispositions, but the resulting behavior is
+   * unspecified. Supply one documented access value and exactly one primary disposition.
+   *
+   * `appendData` forces writes to the end of the file, including explicit-offset writes. By itself
+   * it opens an existing file but does not create a missing file; combine it with an appropriate
+   * primary disposition when creation is required. Options defined for SFTP v5 or later must not be
+   * assumed to take effect when an older version is negotiated, even if the open request succeeds.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.openFileAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  openFile(remotePath: string, access: string, createDisposition: string): string
+
+  /**
+   * Asynchronous form of {@link SFtp.openFile}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  openFileAsync(remotePath: string, access: string, createDisposition: string): Promise<string>
+
+  /**
+   * Reads up to `numBytes` bytes from the current position of `handle`, decodes the bytes using
+   * `charset`, and returns the resulting text.
+   *
+   * See [Supported Charsets](https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp).
+   *
+   * The requested size is measured in bytes, not characters. With a multibyte encoding such as
+   * UTF-8 or Shift_JIS, the final character can be split across calls. For robust streaming, read
+   * raw bytes and decode with application-maintained state.
+   *
+   * **Multibyte boundaries:** Chilkat does not retain an incomplete multibyte character between
+   * calls. If `numBytes` ends in the middle of a UTF-8 sequence, the first returned string ends
+   * with the incomplete bytes and the next call begins with the remaining bytes. Choose byte counts
+   * that end on character boundaries, or read bytes and perform streaming decoding in the
+   * application.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.readFileTextAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  readFileText(handle: string, numBytes: number, charset: string): string
+
+  /**
+   * Asynchronous form of {@link SFtp.readFileText}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  readFileTextAsync(handle: string, numBytes: number, charset: string): Promise<string>
+
+  /**
+   * Reads up to `numBytes` bytes from `handle` at the 32-bit byte `offset`, decodes the bytes using
+   * `charset`, and returns the resulting text.
+   *
+   * See [Supported Charsets](https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp).
+   *
+   * The requested size is measured in bytes, not characters. With a multibyte encoding such as
+   * UTF-8 or Shift_JIS, the final character can be split across calls. For robust streaming, read
+   * raw bytes and decode with application-maintained state.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.readFileText32Async}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  readFileText32(handle: string, offset: number, numBytes: number, charset: string): string
+
+  /**
+   * Asynchronous form of {@link SFtp.readFileText32}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  readFileText32Async(handle: string, offset: number, numBytes: number, charset: string): Promise<string>
+
+  /**
+   * Reads up to `numBytes` bytes from `handle` at the 64-bit byte `offset`, decodes the bytes using
+   * `charset`, and returns the resulting text.
+   *
+   * See [Supported Charsets](https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp).
+   *
+   * The requested size is measured in bytes, not characters. With a multibyte encoding such as
+   * UTF-8 or Shift_JIS, the final character can be split across calls. For robust streaming, read
+   * raw bytes and decode with application-maintained state.
+   *
+   * 64-bit integers are passed as JavaScript numbers (exact up to 2^53).
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.readFileText64Async}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  readFileText64(handle: string, offset: number, numBytes: number, charset: string): string
+
+  /**
+   * Asynchronous form of {@link SFtp.readFileText64}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  readFileText64Async(handle: string, offset: number, numBytes: number, charset: string): Promise<string>
+
+  /**
+   * Reads up to `numBytes` bytes from `handle` at the byte offset supplied as decimal string
+   * `offset`, decodes the bytes using `charset`, and returns the resulting text.
+   *
+   * See [Supported Charsets](https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp).
+   *
+   * The requested size is measured in bytes, not characters. With a multibyte encoding, the final
+   * character can be split across calls.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.readFileText64sAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  readFileText64s(handle: string, offset: string, numBytes: number, charset: string): string
+
+  /**
+   * Asynchronous form of {@link SFtp.readFileText64s}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  readFileText64sAsync(handle: string, offset: string, numBytes: number, charset: string): Promise<string>
+
+  /**
+   * Asks the server to canonicalize `originalPath` and returns the resulting absolute remote path.
+   *
+   * For SFTP v5 or later, `composePath` may optionally modify or extend the original path; pass an
+   * empty string when no composition is needed. If `composePath` is absolute, it replaces
+   * `originalPath`.
+   *
+   * SFTP v3 and v4 do not support path composition. On those versions, `composePath` is ignored and
+   * the method canonicalizes only `originalPath`.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.realPathAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  realPath(originalPath: string, composePath: string): string
+
+  /**
+   * Asynchronous form of {@link SFtp.realPath}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  realPathAsync(originalPath: string, composePath: string): Promise<string>
+
+  /**
+   * Deletes the remote directory specified by `path`.
+   *
+   * Most SFTP servers require the directory to be empty before it can be removed.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.removeDirAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  removeDir(path: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.removeDir}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  removeDirAsync(path: string): Promise<void>
+
+  /**
+   * Deletes the remote file specified by `filename`.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.removeFileAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  removeFile(filename: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.removeFile}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  removeFileAsync(filename: string): Promise<void>
+
+  /**
+   * Renames or moves a remote file or directory from `oldPath` to `newPath`.
+   *
+   * ```
+   * oldPath: someDirA/filename
+   * newPath: someDirB/abc/xyz/filename
+   * ```
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.renameFileOrDirAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  renameFileOrDir(oldPath: string, newPath: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.renameFileOrDir}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  renameFileOrDirAsync(oldPath: string, newPath: string): Promise<void>
+
+  /**
+   * Resumes downloading `remoteFilePath` to the local filesystem path `localFilePath`. Chilkat uses
+   * only the existing local file size as the remote starting offset.
+   *
+   * - If the local file is missing or empty, a normal download is performed.
+   *
+   * - If it is smaller, the remaining remote bytes are appended after the existing local length.
+   *
+   * - If it is the same size or larger, the method treats the download as complete and does not
+   *   truncate or verify the local content.
+   *
+   * **Important:** The existing local bytes are not compared with the remote source. Before
+   * resuming, the application must ensure that the local file is the correct prefix of the remote
+   * file.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.resumeDownloadFileByNameAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  resumeDownloadFileByName(remoteFilePath: string, localFilePath: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.resumeDownloadFileByName}: the same call on a native worker
+   * thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  resumeDownloadFileByNameAsync(remoteFilePath: string, localFilePath: string): Promise<void>
+
+  /**
+   * Resumes uploading the local file at `localFilePath` to `remoteFilePath`. Chilkat uses only the
+   * existing remote file size as the local starting offset.
+   *
+   * - If the remote file is missing or empty, a normal upload is performed.
+   *
+   * - If it is smaller, the remaining local bytes are appended after the existing remote length.
+   *
+   * - If it is the same size or larger, the method treats the upload as complete and does not
+   *   truncate or verify the remote content.
+   *
+   * **Important:** The existing remote bytes are not compared with the local source. Before
+   * resuming, the application must ensure that the remote file is the correct prefix of the local
+   * file.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.resumeUploadFileByNameAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  resumeUploadFileByName(remoteFilePath: string, localFilePath: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.resumeUploadFileByName}: the same call on a native worker
+   * thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  resumeUploadFileByNameAsync(remoteFilePath: string, localFilePath: string): Promise<void>
+
+  /**
+   * Sets the remote file's creation date and time. `pathOrHandle` may contain a remote path or an
+   * open handle. Set `isHandle` to `true` for a handle and `false` for a path.
+   *
+   * SFTP v3 and earlier do not support setting creation time.
+   *
+   * `createDateTime` supplies the new value.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.setCreateDtAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  setCreateDt(pathOrHandle: string, isHandle: boolean, createDateTime: CkDateTime): void
+
+  /**
+   * Asynchronous form of {@link SFtp.setCreateDt}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  setCreateDtAsync(pathOrHandle: string, isHandle: boolean, createDateTime: CkDateTime): Promise<void>
+
+  /**
+   * Sets the remote file's creation date and time. `pathOrHandle` may contain a remote path or an
+   * open handle. Set `bIsHandle` to `true` for a handle and `false` for a path.
+   *
+   * Pass the value in `dateTimeStr` as an RFC 822 formatted string, for example `Fri, 21 Nov 1997
+   * 09:55:06 -0600`.
+   *
+   * SFTP v3 and earlier do not support setting creation time.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.setCreateTimeStrAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  setCreateTimeStr(pathOrHandle: string, bIsHandle: boolean, dateTimeStr: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.setCreateTimeStr}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  setCreateTimeStrAsync(pathOrHandle: string, bIsHandle: boolean, dateTimeStr: string): Promise<void>
+
+  /**
+   * Sets the remote file's last-access date and time. `pathOrHandle` may contain a remote path or
+   * an open handle. Set `isHandle` to `true` for a handle and `false` for a path.
+   *
+   * `accessDateTime` supplies the new value.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.setLastAccessDtAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  setLastAccessDt(pathOrHandle: string, isHandle: boolean, accessDateTime: CkDateTime): void
+
+  /**
+   * Asynchronous form of {@link SFtp.setLastAccessDt}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  setLastAccessDtAsync(pathOrHandle: string, isHandle: boolean, accessDateTime: CkDateTime): Promise<void>
+
+  /**
+   * Sets the remote file's last-access date and time. `pathOrHandle` may contain a remote path or
+   * an open handle. Set `bIsHandle` to `true` for a handle and `false` for a path.
+   *
+   * Pass the value in `dateTimeStr` as an RFC 822 formatted string, for example `Fri, 21 Nov 1997
+   * 09:55:06 -0600`.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.setLastAccessTimeStrAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  setLastAccessTimeStr(pathOrHandle: string, bIsHandle: boolean, dateTimeStr: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.setLastAccessTimeStr}: the same call on a native worker
+   * thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  setLastAccessTimeStrAsync(pathOrHandle: string, bIsHandle: boolean, dateTimeStr: string): Promise<void>
+
+  /**
+   * Sets the remote file's last-modified date and time. `pathOrHandle` may contain a remote path or
+   * an open handle. Set `isHandle` to `true` for a handle and `false` for a path.
+   *
+   * `modifiedDateTime` supplies the new value.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.setLastModifiedDtAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  setLastModifiedDt(pathOrHandle: string, isHandle: boolean, modifiedDateTime: CkDateTime): void
+
+  /**
+   * Asynchronous form of {@link SFtp.setLastModifiedDt}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  setLastModifiedDtAsync(pathOrHandle: string, isHandle: boolean, modifiedDateTime: CkDateTime): Promise<void>
+
+  /**
+   * Sets the remote file's last-modified date and time. `pathOrHandle` may contain a remote path or
+   * an open handle. Set `bIsHandle` to `true` for a handle and `false` for a path.
+   *
+   * Pass the value in `dateTimeStr` as an RFC 822 formatted string, for example `Fri, 21 Nov 1997
+   * 09:55:06 -0600`.
+   *
+   * When SFTP v3 is negotiated, the stored timestamp has whole-second precision.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.setLastModifiedTimeStrAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  setLastModifiedTimeStr(pathOrHandle: string, bIsHandle: boolean, dateTimeStr: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.setLastModifiedTimeStr}: the same call on a native worker
+   * thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  setLastModifiedTimeStrAsync(pathOrHandle: string, bIsHandle: boolean, dateTimeStr: string): Promise<void>
+
+  /**
+   * Sets the owner and group of the remote item identified by `pathOrHandle`. Set `isHandle` to
+   * `true` for an open handle and `false` for a remote path.
+   *
+   * `owner` and `group` supply the new textual owner and group values.
+   *
+   * SFTP v3 and earlier do not support textual owner and group names.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.setOwnerAndGroupAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  setOwnerAndGroup(pathOrHandle: string, isHandle: boolean, owner: string, group: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.setOwnerAndGroup}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  setOwnerAndGroupAsync(pathOrHandle: string, isHandle: boolean, owner: string, group: string): Promise<void>
+
+  /**
+   * Sets the POSIX permission bits for the remote item identified by `pathOrHandle`. Set `isHandle`
+   * to `true` for an open handle and `false` for a remote path.
+   *
+   * Pass the permission bits, not the file-type bits. In languages supporting octal integer
+   * literals, common values include `0600`, `0644`, and `0755`. Their decimal equivalents are
+   * `384`, `420`, and `493`.
+   *
+   * After setting permissions, {@link SFtp.getFilePermissions} returns the complete mode, including
+   * the file-type bits. For example, setting `0644` on a regular file can subsequently return
+   * `0100644`.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.setPermissionsAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  setPermissions(pathOrHandle: string, isHandle: boolean, permissions: number): void
+
+  /**
+   * Asynchronous form of {@link SFtp.setPermissions}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  setPermissionsAsync(pathOrHandle: string, isHandle: boolean, permissions: number): Promise<void>
+
+  /**
+   * Synchronizes files from the remote directory `remoteRoot` to the local filesystem directory
+   * `localRoot`.
+   *
+   * ModeBehavior
+   *
+   * | `0` |  | Download all files. |
+   *
+   * | `1` |  | Download files that do not exist locally. |
+   *
+   * | `2` |  | Download files that are newer remotely or missing locally. |
+   *
+   * | `3` |  | Download only files that are newer remotely; do not download missing local files. |
+   *
+   * | `5` |  | Download files that are missing locally or differ in size. |
+   *
+   * | `6` |  | Mode 5 plus files that are newer remotely. |
+   *
+   * | `99` |  | Do not download; delete remote files that do not exist locally. |
+   *
+   * Set `recurse` to `true` to descend into subdirectories. An absolute remote path begins with
+   * `/`; a relative path is interpreted from the authenticated user's home directory.
+   *
+   * Use {@link SFtp.getSyncedFiles} after the operation to retrieve the relative paths that were
+   * downloaded or created.
+   *
+   * With {@link SFtp.syncCreateAllLocalDirs} set to `true`, mode `0` creates empty remote
+   * directories locally. Mode `1` downloads only missing local files and preserves existing local
+   * files. Mode `99` deletes files from the remote tree that are absent locally; it does not delete
+   * extra local files.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.syncTreeDownloadAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  syncTreeDownload(remoteRoot: string, localRoot: string, mode: number, recurse: boolean): void
+
+  /**
+   * Asynchronous form of {@link SFtp.syncTreeDownload}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  syncTreeDownloadAsync(remoteRoot: string, localRoot: string, mode: number, recurse: boolean): Promise<void>
+
+  /**
+   * Synchronizes files from the local filesystem directory `localBaseDir` to the remote directory
+   * `remoteBaseDir`.
+   *
+   * ModeBehavior
+   *
+   * | `0` |  | Upload all files. |
+   *
+   * | `1` |  | Upload files that do not exist remotely. |
+   *
+   * | `2` |  | Upload files that are newer locally or missing remotely. |
+   *
+   * | `3` |  | Upload only files that are newer locally; do not upload missing remote files. |
+   *
+   * | `4` |  | Upload files that are missing remotely or differ in size. |
+   *
+   * | `5` |  | Mode 4 plus files that are newer locally. |
+   *
+   * Set `bRecurse` to `true` to descend into subdirectories. An absolute remote path begins with
+   * `/`; a relative path is interpreted from the authenticated user's home directory.
+   *
+   * Use {@link SFtp.getSyncedFiles} after the operation to retrieve the relative paths that were
+   * uploaded.
+   *
+   * Mode `0` also creates empty remote directories. Mode `1` uploads only missing files and does
+   * not replace an existing remote file merely because the local file is newer; use mode `2` for
+   * missing-or-newer behavior. The filename and directory filters are applied during recursive
+   * traversal.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.syncTreeUploadAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  syncTreeUpload(localBaseDir: string, remoteBaseDir: string, mode: number, bRecurse: boolean): void
+
+  /**
+   * Asynchronous form of {@link SFtp.syncTreeUpload}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  syncTreeUploadAsync(localBaseDir: string, remoteBaseDir: string, mode: number, bRecurse: boolean): Promise<void>
+
+  /**
+   * Streams the local filesystem file at `fromLocalFilePath` to the remote file identified by
+   * `handle`. The handle must have been returned by {@link SFtp.openFile}.
+   *
+   * Close the remote handle when the upload is complete.
+   *
+   * The upload begins at the handle's current sequential write position. Existing bytes before that
+   * position are preserved unless the file was truncated when opened.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.uploadFileAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  uploadFile(handle: string, fromLocalFilePath: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.uploadFile}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  uploadFileAsync(handle: string, fromLocalFilePath: string): Promise<void>
+
+  /**
+   * Uploads the local filesystem file at `localFilePath` to `remoteFilePath`.
+   *
+   * When {@link SFtp.preserveDate} is `true`, Chilkat preserves the local file's last-modified time
+   * on the remote file.
+   *
+   * An absolute remote path begins with `/` and is relative to the server filesystem root. A
+   * relative path is interpreted relative to the authenticated user's home directory.
+   *
+   * If the destination exists, it is truncated before the upload. A zero-byte local file creates or
+   * truncates the remote file to zero bytes. Missing remote parent directories are not created
+   * automatically.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.uploadFileByNameAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  uploadFileByName(remoteFilePath: string, localFilePath: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.uploadFileByName}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  uploadFileByNameAsync(remoteFilePath: string, localFilePath: string): Promise<void>
+
+  /**
+   * Encodes `textData` using `charset` and writes the resulting bytes at the current sequential
+   * write position for `handle`.
+   *
+   * The position is maintained by Chilkat for the handle. Opening an existing file with
+   * `openOrCreate` positions sequential writes at the current end of the file. An explicit-offset
+   * write can change the position used by the next sequential write. When the file was opened with
+   * `appendData`, writes are forced to the end.
+   *
+   * See [Supported Charsets](https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp).
+   *
+   * No byte-order mark or line ending is added unless it is present in the supplied text or
+   * produced by the selected encoding.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.writeFileTextAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  writeFileText(handle: string, charset: string, textData: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.writeFileText}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  writeFileTextAsync(handle: string, charset: string, textData: string): Promise<void>
+
+  /**
+   * Encodes `textData` using `charset` and writes the resulting bytes to `handle` at the 32-bit
+   * byte offset `offset32`.
+   *
+   * After a successful explicit-offset write, the next sequential write begins immediately after
+   * the bytes written by this call. If the file was opened with `appendData`, the server appends
+   * and the explicit offset does not control placement.
+   *
+   * See [Supported Charsets](https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp).
+   *
+   * `offset32` must be nonnegative. A negative value can be interpreted as a very large unsigned
+   * offset. Writing beyond end-of-file can create a sparse file; whether the gap is sparse is
+   * determined by the server filesystem.
+   *
+   * No byte-order mark or line ending is added unless it is present in the supplied text or
+   * produced by the selected encoding.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.writeFileText32Async}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  writeFileText32(handle: string, offset32: number, charset: string, textData: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.writeFileText32}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  writeFileText32Async(handle: string, offset32: number, charset: string, textData: string): Promise<void>
+
+  /**
+   * Encodes `textData` using `charset` and writes the resulting bytes to `handle` at the 64-bit
+   * byte offset `offset64`.
+   *
+   * See [Supported Charsets](https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp).
+   *
+   * No byte-order mark or line ending is added unless it is present in the supplied text or
+   * produced by the selected encoding.
+   *
+   * 64-bit integers are passed as JavaScript numbers (exact up to 2^53).
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.writeFileText64Async}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  writeFileText64(handle: string, offset64: number, charset: string, textData: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.writeFileText64}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  writeFileText64Async(handle: string, offset64: number, charset: string, textData: string): Promise<void>
+
+  /**
+   * Encodes `textData` using `charset` and writes the resulting bytes to `handle` at the byte
+   * offset supplied as decimal string `offset64`.
+   *
+   * See [Supported Charsets](https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp).
+   *
+   * No byte-order mark or line ending is added unless it is present in the supplied text or
+   * produced by the selected encoding.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.writeFileText64sAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  writeFileText64s(handle: string, offset64: string, charset: string, textData: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.writeFileText64s}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  writeFileText64sAsync(handle: string, offset64: string, charset: string, textData: string): Promise<void>
+
+  /**
+   * Encodes the text in `sb` using `charset` and uploads it to `remoteFilePath`.
+   *
+   * Set `includeBom` to `true` to prepend a byte-order mark when the selected encoding supports
+   * one.
+   *
+   * If the destination exists, it is truncated before the text is uploaded. For `utf-8`, setting
+   * `includeBom` to `true` prepends the three bytes `EF BB BF`; setting it to `false` omits them.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.uploadSbAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  uploadSb(sb: StringBuilder, remoteFilePath: string, charset: string, includeBom: boolean): void
+
+  /**
+   * Asynchronous form of {@link SFtp.uploadSb}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  uploadSbAsync(sb: StringBuilder, remoteFilePath: string, charset: string, includeBom: boolean): Promise<void>
+
+  /**
+   * Uploads all bytes in `binData` to the remote file at `remoteFilePath`.
+   *
+   * If the destination exists, it is truncated before the bytes are uploaded.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.uploadBdAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  uploadBd(binData: BinData, remoteFilePath: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.uploadBd}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  uploadBdAsync(binData: BinData, remoteFilePath: string): Promise<void>
+
+  /**
+   * Downloads the remote file at `remoteFilePath` and appends its bytes to `binData`.
+   *
+   * Existing data in `binData` is preserved. Clear it first when replacement rather than append
+   * behavior is required.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.downloadBdAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  downloadBd(remoteFilePath: string, binData: BinData): void
+
+  /**
+   * Asynchronous form of {@link SFtp.downloadBd}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  downloadBdAsync(remoteFilePath: string, binData: BinData): Promise<void>
+
+  /**
+   * Downloads the remote file at `remoteFilePath`, decodes it using `charset`, and appends the text
+   * to `sb`.
+   *
+   * Existing text in `sb` is preserved. Clear it first when replacement rather than append behavior
+   * is required.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.downloadSbAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  downloadSb(remoteFilePath: string, charset: string, sb: StringBuilder): void
+
+  /**
+   * Asynchronous form of {@link SFtp.downloadSb}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  downloadSbAsync(remoteFilePath: string, charset: string, sb: StringBuilder): Promise<void>
+
+  /**
+   * Sends an SSH `IGNORE` message. No SFTP file handle or channel is required.
+   *
+   * The server does not send a reply, but a successful send helps verify that the SSH connection is
+   * still writable.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.sendIgnoreAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  sendIgnore(): void
+
+  /**
+   * Asynchronous form of {@link SFtp.sendIgnore}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  sendIgnoreAsync(): Promise<void>
+
+  /**
+   * Checks the remote item at `remotePath`. When `followLinks` is `true`, a symbolic link is
+   * followed and the target type is returned.
+   *
+   * Return valueMeaning
+   *
+   * | `-1` |  | Unable to determine the result. Inspect `LastErrorText`. |
+   *
+   * | `0` |  | The path does not exist. |
+   *
+   * | `1` |  | A regular file exists. |
+   *
+   * | `2` |  | A directory exists. |
+   *
+   * | `3` |  | A symbolic link exists. This is possible only when `followLinks` is `false`. |
+   *
+   * | `4` |  | A special filesystem entry exists. |
+   *
+   * | `5` |  | An entry of unknown type exists. |
+   *
+   * | `6` |  | A socket exists. |
+   *
+   * | `7` |  | A character device exists. |
+   *
+   * | `8` |  | A block device exists. |
+   *
+   * | `9` |  | A FIFO exists. |
+   *
+   * Positive values correspond to SFTP filesystem entry types. Some types are platform-dependent.
+   *
+   * For a dangling symbolic link, `followLinks = _FALSE_` returns `3` for the link itself, while
+   * `followLinks = _TRUE_` returns `0` because the target does not exist.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.fileExistsAsync}.
+   */
+  fileExists(remotePath: string, followLinks: boolean): number
+
+  /**
+   * Asynchronous form of {@link SFtp.fileExists}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   */
+  fileExistsAsync(remotePath: string, followLinks: boolean): Promise<number>
+
+  /**
+   * Works like {@link SFtp.authenticatePw}, but receives `login` and `password` in `SecureString`
+   * objects.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.authenticateSecPwAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  authenticateSecPw(login: SecureString, password: SecureString): void
+
+  /**
+   * Asynchronous form of {@link SFtp.authenticateSecPw}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  authenticateSecPwAsync(login: SecureString, password: SecureString): Promise<void>
+
+  /**
+   * Works like {@link SFtp.authenticatePwPk}, but receives `username` and `password` in
+   * `SecureString` objects. `privateKey` supplies the private key.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.authenticateSecPwPkAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  authenticateSecPwPk(username: SecureString, password: SecureString, privateKey: SshKey): void
+
+  /**
+   * Asynchronous form of {@link SFtp.authenticateSecPwPk}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  authenticateSecPwPkAsync(username: SecureString, password: SecureString, privateKey: SshKey): Promise<void>
+
+  /**
+   * Creates a symbolic link on the server. `oldPath` identifies the link target and `newPath`
+   * identifies the new symbolic-link path.
+   *
+   * The server's SFTP implementation determines path interpretation and whether symbolic links are
+   * permitted.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.symLinkAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  symLink(oldPath: string, newPath: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.symLink}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  symLinkAsync(oldPath: string, newPath: string): Promise<void>
+
+  /**
+   * Creates a hard link from `newPath` to the existing remote file at `oldPath`.
+   *
+   * This method uses the OpenSSH `hardlink@openssh.com` extension and succeeds only when the server
+   * supports that extension.
+   *
+   * A successful hard link refers to the same underlying file. Modifying the existing file through
+   * either path changes the content observed through the other path.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.hardLinkAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  hardLink(oldPath: string, newPath: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.hardLink}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  hardLinkAsync(oldPath: string, newPath: string): Promise<void>
+
+  /**
+   * Requests that the server flush pending data for the open file identified by `handle` to stable
+   * storage.
+   *
+   * This method uses the OpenSSH `fsync@openssh.com` extension and succeeds only when the server
+   * supports that extension.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.fsyncAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  fsync(handle: string): void
+
+  /**
+   * Asynchronous form of {@link SFtp.fsync}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  fsyncAsync(handle: string): Promise<void>
+
+  /**
+   * Returns the target path stored in the symbolic link at remote `path`.
+   *
+   * The returned value is the target string stored in the link. It is not automatically
+   * canonicalized and can be relative, absolute, or refer to a nonexistent target.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.readLinkAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  readLink(path: string): string
+
+  /**
+   * Asynchronous form of {@link SFtp.readLink}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  readLinkAsync(path: string): Promise<string>
+
+  /**
+   * Appends all bytes in `bd` to the remote file identified by `handle`. The handle must have been
+   * returned by {@link SFtp.openFile}.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.writeFileBdAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  writeFileBd(handle: string, bd: BinData): void
+
+  /**
+   * Asynchronous form of {@link SFtp.writeFileBd}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  writeFileBdAsync(handle: string, bd: BinData): Promise<void>
+
+  /**
+   * Reads up to `numBytes` bytes from the current position of the remote file identified by
+   * `handle` and appends them to `bd`. The handle must have been returned by {@link SFtp.openFile}.
+   *
+   * Fewer bytes can be read when end-of-file is reached. Repeat the call until `Eof(handle)`
+   * returns `true` to read the entire file incrementally.
+   *
+   * This method shares the handle's sequential read position with `ReadFileBytes` and {@link
+   * SFtp.readFileText}. Existing bytes in `bd` are preserved.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.readFileBdAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  readFileBd(handle: string, numBytes: number, bd: BinData): void
+
+  /**
+   * Asynchronous form of {@link SFtp.readFileBd}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  readFileBdAsync(handle: string, numBytes: number, bd: BinData): Promise<void>
+
+  /**
+   * Begins keyboard-interactive authentication for `login` and returns XML describing the server's
+   * prompts.
+   *
+   * ```
+   * <infoRequest numPrompts="N">
+   *   <name>name_string</name>
+   *   <instruction>instruction_string</instruction>
+   *   <prompt1 echo="1_or_0">prompt_string</prompt1>
+   *   ...
+   *   <promptN echo="1_or_0">prompt_string</promptN>
+   * </infoRequest>
+   * ```
+   *
+   * The `echo` attribute indicates whether the response may be displayed while entered. A value of
+   * `0` normally identifies secret input such as a password.
+   *
+   * If authentication immediately succeeds or fails, the result has one of these forms:
+   *
+   * ```
+   * <success>success message</success>
+   *
+   * <error>error message</error>
+   * ```
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.startKeyboardAuthAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  startKeyboardAuth(login: string): string
+
+  /**
+   * Asynchronous form of {@link SFtp.startKeyboardAuth}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  startKeyboardAuthAsync(login: string): Promise<string>
+
+  /**
+   * Continues keyboard-interactive authentication by submitting `response` for the prompts returned
+   * by {@link SFtp.startKeyboardAuth}.
+   *
+   * For a single prompt, pass the response text directly. For multiple prompts, pass XML in this
+   * form:
+   *
+   * ```
+   * <response>
+   *   <response1>response to first prompt</response1>
+   *   <response2>response to second prompt</response2>
+   *   ...
+   * </response>
+   * ```
+   *
+   * The returned XML indicates authentication success, authentication failure, or another
+   * `infoRequest` containing additional prompts.
+   *
+   * ```
+   * <success>success message</success>
+   *
+   * <error>error message</error>
+   * ```
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.continueKeyboardAuthAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  continueKeyboardAuth(response: string): string
+
+  /**
+   * Asynchronous form of {@link SFtp.continueKeyboardAuth}: the same call on a native worker
+   * thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  continueKeyboardAuthAsync(response: string): Promise<string>
+
+  /**
+   * Returns the connected server's host-key fingerprint using `hashAlg`. Common choices include
+   * `SHA256`, `SHA384`, `SHA512`, `SHA1`, and `MD5`.
+   *
+   * includeKeyTypeincludeHashNameExample format
+   *
+   * | `true` |  | `true` |  | `ssh-rsa SHA256:L7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...` |
+   *
+   * | `true` |  | `false` |  | `ssh-rsa L7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...` |
+   *
+   * | `false` |  | `true` |  | `SHA256:L7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...` |
+   *
+   * | `false` |  | `false` |  | `L7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...` |
+   *
+   * For server identity verification, compare a SHA-256 fingerprint with a value obtained from a
+   * trusted source before sending credentials.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  getHostKeyFP(hashAlg: string, includeKeyType: boolean, includeHashName: boolean): string
+
+  /**
+   * Configures the exact set of SSH algorithms permitted for subsequent connections using the
+   * settings in `json`.
+   *
+   * Call this method before `Connect`. The connection fails when no mutually supported algorithm
+   * remains in a required category.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  setAllowedAlgorithms(json: JsonObject): void
+
+  /**
+   * Appends to `strTab` the relative paths processed by the most recent {@link SFtp.syncTreeUpload}
+   * or {@link SFtp.syncTreeDownload} operation.
+   *
+   * For downloads, entries can include local directories that were created. Directory paths end
+   * with `/` so they can be distinguished from file paths.
+   *
+   * Existing entries in `strTab` are preserved.
+   *
+   * Clear `strTab` first when only the latest synchronization results are wanted. Downloaded
+   * directory entries are reported with a trailing `/`; uploaded directory entries are reported
+   * without one.
+   */
+  getSyncedFiles(strTab: StringTable): void
+
+  /**
+   * Populates `json` with supplemental details produced by the most recent method when such details
+   * are available. Many methods do not produce additional JSON information.
+   */
+  getLastJsonData(json: JsonObject): void
+
+  /**
+   * Reads all remaining directory entries from `handle`, which must have been returned by {@link
+   * SFtp.openDir}, and stores them in `dirObj`. Entries are returned in server order; Chilkat does
+   * not sort the listing.
+   *
+   * After end-of-directory has been reached, another call on the same handle returns `true`, adds
+   * no entries, and sets {@link SFtp.lastStatusCode} to `SSH_FX_EOF`.
+   *
+   * This method does not clear `dirObj`. Use a new or cleared `SFtpDir` object when an empty result
+   * must replace an earlier listing. Close the directory handle when finished.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link SFtp.readDirListingAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  readDirListing(handle: string, dirObj: SFtpDir): void
+
+  /**
+   * Asynchronous form of {@link SFtp.readDirListing}: the same call on a native worker thread,
+   * settling on the JavaScript thread. While it is pending, other calls on this object throw,
+   * except {@link SFtp.abort} (which cancels it) and the {@link SFtp.onPercentDone} /
+   * {@link SFtp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link SFtp.lastErrorText}.
+   */
+  readDirListingAsync(handle: string, dirObj: SFtpDir): Promise<void>
+
+  // ---- Events (ReactNativeGen_DESIGN.md §6) ----
+
+  /**
+   * Called with the percent completed (0..100) while a long-running method runs, when Chilkat
+   * can measure progress. Runs on the JavaScript thread, so it is only useful with the
+   * `...Async` methods (during a synchronous call the thread is busy and the events arrive
+   * after it returns). Assign `undefined` to remove.
+   */
+  onPercentDone?: (pctDone: number) => void
+
+  /**
+   * Called with a name/value pair of progress information while a long-running method runs
+   * (what is reported depends on the class and method). Runs on the JavaScript thread; see
+   * {@link SFtp.onPercentDone}. Assign `undefined` to remove.
+   */
+  onProgressInfo?: (name: string, value: string) => void
+
+  /**
+   * Requests that the pending `...Async` call on this object stop at its next progress check.
+   * The promise then rejects with Chilkat's abort error. Chilkat checks at least every
+   * `heartbeatMs` milliseconds on the classes that have that property, so set it (e.g. 250)
+   * for a responsive cancel. Harmless when nothing is pending.
+   */
+  abort(): void
+}