@chilkat/react-native 11.6.1

package/src/specs/Scp.nitro.ts

@@ -0,0 +1,708 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+import type { HybridObject } from 'react-native-nitro-modules'
+import type { BinData } from './BinData.nitro'
+import type { Ssh } from './Ssh.nitro'
+
+/**
+ * Transfer files, text, and binary data over SCP using an existing SSH connection.
+ *
+ * `Scp` is the Chilkat class for SCP file transfer over an
+ * already-established `Chilkat.Ssh` connection. It supports
+ * local-file upload and download, in-memory binary transfer, encoded binary
+ * transfer, text transfer with explicit character sets, `BinData`
+ * transfer, directory-tree synchronization, sync filtering, remote UNIX
+ * permission overrides, environment variables, progress scaling, abort support,
+ * and asynchronous task integration.
+ *
+ * **Uses an SSH connection**
+ *
+ * Attach `Scp` to an authenticated `Chilkat.Ssh`
+ * session rather than opening a separate network connection.
+ *
+ * **Upload and download files**
+ *
+ * Transfer local files to remote paths or download remote files to the
+ * local filesystem using SCP.
+ *
+ * **Memory-based transfers**
+ *
+ * Upload or download binary data, encoded data, text, or
+ * `Chilkat.BinData` without requiring temporary files.
+ *
+ * **Directory synchronization**
+ *
+ * Synchronize directory trees and use filtering options to include or
+ * exclude selected files.
+ *
+ * **Remote file options**
+ *
+ * Set remote UNIX permissions, pass environment variables, and control
+ * transfer-related behavior required by the remote server.
+ *
+ * **Progress and async support**
+ *
+ * Monitor progress, scale progress percentages, abort active transfers, and
+ * run supported operations as asynchronous tasks.
+ *
+ * **Common pattern:**
+ * Connect and authenticate with `Chilkat.Ssh`, initialize
+ * `Scp` with that SSH connection, then upload, download, or
+ * synchronize the desired files or in-memory data. Use `Scp` for
+ * SCP-style transfers over SSH; use `Chilkat.SFtp` when the remote
+ * server expects the SFTP protocol instead.
+ *
+ * For an extended overview, see
+ * [Scp Class Overview](https://www.chilkatsoft.com/scp_class_overview.asp).
+ *
+ * Each `Scp` 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 Scp()`.
+ *
+ * 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 Scp.abort} and assigning {@link Scp.onPercentDone} / {@link Scp.onProgressInfo}.
+ */
+export interface Scp 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
+
+  /**
+   * Set to `true` to request cancellation of the method currently executing on this object.
+   * Long-running network and file-transfer operations check this property periodically; a method
+   * that completes quickly may finish before the request is observed.
+   *
+   * Both synchronous and asynchronous operations can be cancelled. To cancel a synchronous call,
+   * set this property from another thread on the same `Scp` object. Chilkat resets the property to
+   * `false` after the cancellation is processed. If no method is running, a previously set value is
+   * cleared when the next method begins.
+   *
+   * **Cooperative cancellation:** This property requests an abort; it does not forcibly terminate a
+   * thread. Use the method return value, `LastMethodSuccess` where applicable, and `LastErrorText`
+   * to determine the final outcome.
+   */
+  abortCurrent: boolean
+
+  /**
+   * Specifies the interval, in milliseconds, between `AbortCheck` event callbacks during supported
+   * long-running operations. The callback allows the application to report activity or request
+   * cancellation before the operation completes.
+   *
+   * The default value is `0`, which disables periodic `AbortCheck` callbacks.
+   *
+   * **Event-callback setting:** This property is useful only in programming environments that
+   * support Chilkat event callbacks. It is not an SSH keep-alive interval and does not change
+   * connection or read timeouts.
+   */
+  heartbeatMs: number
+
+  /**
+   * Specifies the value that represents 100% completion in `PercentDone` event callbacks. The
+   * default is `100`, which reports progress in whole-percent units. For example, when the scale is
+   * `1000`, a callback value of `453` represents 45.3% completion.
+   *
+   * The value is limited to the range `10` through `100000`. Increasing the scale provides finer
+   * numeric granularity for operations whose progress can be measured.
+   *
+   * **Event-callback setting:** This property applies only in programming environments that support
+   * Chilkat event callbacks. A larger scale changes the meaning and possible granularity of
+   * callback values; it does not guarantee that every intermediate value will be reported.
+   */
+  percentDoneScale: number
+
+  /**
+   * Specifies a semicolon-separated list of wildcard patterns for filenames that are eligible for
+   * transfer by {@link Scp.syncTreeUpload} and {@link Scp.syncTreeDownload}. A file is considered
+   * only when its filename matches at least one pattern.
+   *
+   * For example, `*.xml;*.txt;*.csv` limits synchronization to XML, text, and CSV files. The
+   * default empty string imposes no include restriction.
+   *
+   * **Pattern scope:** Patterns are matched against the final filename, not the full local or
+   * remote path. Directory traversal is controlled separately by {@link Scp.syncMustMatchDir} and
+   * {@link Scp.syncMustNotMatchDir}.
+   */
+  syncMustMatch: string
+
+  /**
+   * Specifies a semicolon-separated list of wildcard patterns for directory names that may be
+   * traversed by {@link Scp.syncTreeUpload} and {@link Scp.syncTreeDownload}. When this property is
+   * nonempty, synchronization descends only into directories whose names match at least one
+   * pattern.
+   *
+   * For example, `a*;b*;c*` permits traversal into directories whose names begin with `a`, `b`, or
+   * `c`. The default empty string permits traversal into all directories, subject to {@link
+   * Scp.syncMustNotMatchDir}.
+   *
+   * **Pattern scope:** Each pattern is matched against the directory name itself, not its complete
+   * path. This property affects traversal; it does not directly select individual files.
+   */
+  syncMustMatchDir: string
+
+  /**
+   * Specifies a semicolon-separated list of wildcard patterns for filenames that must be skipped by
+   * {@link Scp.syncTreeUpload} and {@link Scp.syncTreeDownload}.
+   *
+   * For example, `*.tmp;*.bak;*.log` excludes temporary, backup, and log files. The default empty
+   * string excludes no files.
+   *
+   * **Pattern scope:** Patterns are matched against the final filename, not the full path. Use
+   * {@link Scp.syncMustNotMatchDir} to prevent synchronization from entering selected directories
+   * and their subtrees.
+   */
+  syncMustNotMatch: string
+
+  /**
+   * Specifies a semicolon-separated list of wildcard patterns for directory names that must not be
+   * traversed by {@link Scp.syncTreeUpload} and {@link Scp.syncTreeDownload}. A matching directory
+   * and everything below it are skipped.
+   *
+   * For example, `temp*;cache*;.git` prevents traversal into temporary, cache, and Git metadata
+   * directories. The default empty string excludes no directories.
+   *
+   * **Pattern scope:** Each pattern is matched against the directory name itself, not its complete
+   * path. This setting is especially useful during recursive synchronization because excluding a
+   * directory avoids scanning its entire subtree.
+   */
+  syncMustNotMatchDir: string
+
+  /**
+   * Contains the local paths of the files transferred by the most recent call to {@link
+   * Scp.syncTreeUpload} or {@link Scp.syncTreeDownload}. Paths are listed one per line.
+   *
+   * - After an upload, each line is the full local path of a source file that was uploaded.
+   *
+   * - After a download, each line is the full local path of a destination file that was downloaded.
+   *
+   * **Local paths only:** This property reports local filesystem paths, not remote paths. It lists
+   * files actually transferred by the last synchronization operation, rather than every file
+   * examined during comparison.
+   */
+  syncedFiles: string
+
+  /**
+   * Specifies an octal UNIX permission mode to apply to files uploaded by SCP, overriding the
+   * permissions derived from the local source file. For example, set this property to `0644` to
+   * grant read/write permission to the owner and read-only permission to the group and others.
+   *
+   * The default is the empty string, which causes the uploaded file's remote permissions to be
+   * based on the local file's permissions.
+   *
+   * **UNIX permission notation:** Supply the mode as a string containing octal digits, such as
+   * `0600`, `0644`, or `0755`. The remote SSH account must still have permission to create or
+   * replace the file, and server-side policy may restrict the final mode.
+   */
+  unixPermOverride: string
+
+  /**
+   * Provides a comma-separated list of specialized compatibility options. The default is the empty
+   * string, which is appropriate for normal SCP transfers.
+   *
+   * KeywordBehavior
+   *
+   * | `FilenameOnly` | | Uses only the filename, rather than the complete target path, in the
+   * remote `scp -t` command. This option exists for compatibility with systems such as certain
+   * LANCOM routers. |
+   *
+   * | `ProtectFromVpn` | | On Android, attempts to route the SCP connection outside an installed or
+   * active VPN. |
+   *
+   * **Leave empty unless needed:** These options alter uncommon platform or server compatibility
+   * behavior. Enable a keyword only when a Chilkat example, release note, or support response
+   * identifies it as necessary for the target environment.
+   */
+  uncommonOptions: string
+
+  /**
+   * Specifies environment variables to send for each SCP upload or download. Set the property to a
+   * JSON object whose member names are environment-variable names and whose values are strings.
+   *
+   * ```
+   * {
+   *   "LCS_PASSWORD": "myPassword",
+   *   "SOME_ENV_VAR": "some_value"
+   * }
+   * ```
+   *
+   * **Server policy controls acceptance:** SCP transfers run through SSH channels. The SSH server
+   * may accept, reject, or ignore requested environment variables according to its configuration.
+   * Do not assume that setting this property guarantees that the remote SCP process receives every
+   * variable.
+   *
+   * **Sensitive values:** Environment variables can contain secrets, but they are not a substitute
+   * for SSH authentication. Avoid exposing sensitive values in application logs or diagnostic
+   * output.
+   */
+  sendEnv: string
+
+  // ---- Methods ----
+
+  /**
+   * Downloads the file at `remotePath` and returns its bytes encoded as text using the binary
+   * encoding named by `encoding`, such as `base64` or `hex`.
+   *
+   * An absolute remote path begins with `/`. A relative path is interpreted relative to the
+   * authenticated SSH user's home directory.
+   *
+   * **Binary encoding versus charset:** `encoding` selects a text representation of arbitrary
+   * bytes; it is not a character set and does not decode the remote file as text. Use {@link
+   * Scp.downloadString} when the remote file contains text that must be decoded with a charset.
+   *
+   * **Memory use:** The complete file and its encoded representation are held in memory. Encodings
+   * such as Base64 also increase the amount of data returned.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Scp.downloadBinaryEncodedAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Scp.lastErrorText}.
+   */
+  downloadBinaryEncoded(remotePath: string, encoding: string): string
+
+  /**
+   * Asynchronous form of {@link Scp.downloadBinaryEncoded}: 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 Scp.abort} (which cancels it) and the {@link Scp.onPercentDone} /
+   * {@link Scp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Scp.lastErrorText}.
+   */
+  downloadBinaryEncodedAsync(remotePath: string, encoding: string): Promise<string>
+
+  /**
+   * Downloads the file at `remotePath` from the SSH server and writes its bytes to the local
+   * filesystem path in `localPath`.
+   *
+   * An absolute remote path begins with `/`. A relative remote path is interpreted relative to the
+   * authenticated SSH user's home directory. The application must have permission to create or
+   * replace the local destination file.
+   *
+   * **Streaming transfer:** This method is the preferred download method for large files because
+   * the data is written to disk rather than returned as one in-memory byte array or string.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Scp.downloadFileAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Scp.lastErrorText}.
+   */
+  downloadFile(remotePath: string, localPath: string): void
+
+  /**
+   * Asynchronous form of {@link Scp.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 Scp.abort} (which cancels it) and the {@link Scp.onPercentDone} /
+   * {@link Scp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Scp.lastErrorText}.
+   */
+  downloadFileAsync(remotePath: string, localPath: string): Promise<void>
+
+  /**
+   * Downloads the file at `remotePath`, decodes its bytes using the character encoding named by
+   * `charset`, and returns the resulting text.
+   *
+   * An absolute remote path begins with `/`. A relative path is interpreted relative to the
+   * authenticated SSH user's home directory.
+   *
+   * **Charset matters:** `charset` describes how the remote file’s bytes represent characters, for
+   * example `utf-8`, `windows-1252`, or `iso-8859-1`. Using the wrong charset can produce incorrect
+   * characters. Use a binary download method for files that are not text.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Scp.downloadStringAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Scp.lastErrorText}.
+   */
+  downloadString(remotePath: string, charset: string): string
+
+  /**
+   * Asynchronous form of {@link Scp.downloadString}: 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 Scp.abort} (which cancels it) and the {@link Scp.onPercentDone} /
+   * {@link Scp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Scp.lastErrorText}.
+   */
+  downloadStringAsync(remotePath: string, charset: string): Promise<string>
+
+  /**
+   * Synchronizes files from the remote directory tree rooted at `remoteRoot` to the local directory
+   * rooted at `localRoot`. `bRecurse` controls recursion: set it to `true` to descend into
+   * subdirectories, or `false` to process only files directly in the root directory.
+   *
+   * An absolute remote root begins with `/`; a relative remote root is interpreted relative to the
+   * authenticated SSH user's home directory. A relative local root is interpreted relative to the
+   * application's current working directory.
+   *
+   * ModeFiles transferred
+   *
+   * | `0` |  | Download every eligible file. |
+   *
+   * | `1` |  | Download files that do not already exist locally. |
+   *
+   * | `2` | | Download files that are missing locally or whose remote last-modified time is newer
+   * than the local file. |
+   *
+   * | `3` | | Download only files whose remote last-modified time is newer. A remote file that has
+   * no local counterpart is not downloaded. |
+   *
+   * | `5` |  | Download files that are missing locally or whose size differs from the local file. |
+   *
+   * | `6` | | Download files that are missing locally, differ in size, or have a newer remote
+   * last-modified time. |
+   *
+   * The filename and directory filters in {@link Scp.syncMustMatch}, {@link Scp.syncMustNotMatch},
+   * {@link Scp.syncMustMatchDir}, and {@link Scp.syncMustNotMatchDir} are applied during traversal.
+   * After completion, {@link Scp.syncedFiles} lists the full local paths of files actually
+   * downloaded.
+   *
+   * **Timestamp-based modes:** Modes `2`, `3`, and `6` compare last-modified times. Incorrect
+   * server timestamps or clock differences between systems can affect which file is considered
+   * newer.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Scp.syncTreeDownloadAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Scp.lastErrorText}.
+   */
+  syncTreeDownload(remoteRoot: string, localRoot: string, mode: number, bRecurse: boolean): void
+
+  /**
+   * Asynchronous form of {@link Scp.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 Scp.abort} (which cancels it) and the {@link Scp.onPercentDone} /
+   * {@link Scp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Scp.lastErrorText}.
+   */
+  syncTreeDownloadAsync(remoteRoot: string, localRoot: string, mode: number, bRecurse: boolean): Promise<void>
+
+  /**
+   * Synchronizes files from the local directory tree rooted at `localBaseDir` to the remote
+   * directory rooted at `remoteBaseDir`. `bRecurse` controls recursion: set it to `true` to descend
+   * into subdirectories, or `false` to process only files directly in the local base directory.
+   *
+   * A relative local base directory is interpreted relative to the application's current working
+   * directory. An absolute remote base directory begins with `/`; a relative remote base directory
+   * is interpreted relative to the authenticated SSH user's home directory.
+   *
+   * ModeFiles transferred
+   *
+   * | `0` |  | Upload every eligible file. |
+   *
+   * | `1` |  | Upload files that do not already exist on the remote server. |
+   *
+   * | `2` | | Upload files that are missing remotely or whose local last-modified time is newer
+   * than the remote file. |
+   *
+   * | `3` | | Upload only files whose local last-modified time is newer. A local file that has no
+   * remote counterpart is not uploaded. |
+   *
+   * | `4` |  | Upload files that are missing remotely or whose size differs from the remote file. |
+   *
+   * | `5` | | Upload files that are missing remotely, differ in size, or have a newer local
+   * last-modified time. |
+   *
+   * The filename and directory filters in {@link Scp.syncMustMatch}, {@link Scp.syncMustNotMatch},
+   * {@link Scp.syncMustMatchDir}, and {@link Scp.syncMustNotMatchDir} are applied during traversal.
+   * After completion, {@link Scp.syncedFiles} lists the full local paths of files actually
+   * uploaded.
+   *
+   * **Timestamp-based modes:** Modes `2`, `3`, and `5` compare last-modified times. Incorrect
+   * server timestamps or clock differences between systems can affect which file is considered
+   * newer.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Scp.syncTreeUploadAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Scp.lastErrorText}.
+   */
+  syncTreeUpload(localBaseDir: string, remoteBaseDir: string, mode: number, bRecurse: boolean): void
+
+  /**
+   * Asynchronous form of {@link Scp.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 Scp.abort} (which cancels it) and the {@link Scp.onPercentDone} /
+   * {@link Scp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Scp.lastErrorText}.
+   */
+  syncTreeUploadAsync(localBaseDir: string, remoteBaseDir: string, mode: number, bRecurse: boolean): Promise<void>
+
+  /**
+   * Decodes the text in `encodedData` using the binary encoding named by `encoding`, then uploads
+   * the resulting bytes to the remote file at `remotePath`. Typical encoding names include `base64`
+   * and `hex`.
+   *
+   * An absolute remote path begins with `/`. A relative path is interpreted relative to the
+   * authenticated SSH user's home directory. The remote parent directory must already exist.
+   *
+   * **The encoded text is not uploaded literally:** For example, when `encoding` is `base64`,
+   * Chilkat Base64-decodes `encodedData` and transfers the decoded binary bytes. This method is for
+   * encoded binary representations, not character-set conversion.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Scp.uploadBinaryEncodedAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Scp.lastErrorText}.
+   */
+  uploadBinaryEncoded(remotePath: string, encodedData: string, encoding: string): void
+
+  /**
+   * Asynchronous form of {@link Scp.uploadBinaryEncoded}: 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 Scp.abort} (which cancels it) and the {@link Scp.onPercentDone} /
+   * {@link Scp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Scp.lastErrorText}.
+   */
+  uploadBinaryEncodedAsync(remotePath: string, encodedData: string, encoding: string): Promise<void>
+
+  /**
+   * Uploads the local filesystem file at `localPath` to the remote path in `remotePath`. The file
+   * is transferred as raw bytes.
+   *
+   * An absolute remote path begins with `/`. A relative remote path is interpreted relative to the
+   * authenticated SSH user's home directory. The remote parent directory must already exist, and
+   * the SSH account must have permission to create or replace the destination file.
+   *
+   * Remote permissions are normally derived from the local file. Set {@link Scp.unixPermOverride}
+   * when a specific remote UNIX mode is required.
+   *
+   * **SCP is not FTP:** There is no ASCII or binary transfer mode. `UploadFile` copies the file
+   * bytes without line-ending or character-set conversion.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Scp.uploadFileAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Scp.lastErrorText}.
+   */
+  uploadFile(localPath: string, remotePath: string): void
+
+  /**
+   * Asynchronous form of {@link Scp.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 Scp.abort} (which cancels it) and the {@link Scp.onPercentDone} /
+   * {@link Scp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Scp.lastErrorText}.
+   */
+  uploadFileAsync(localPath: string, remotePath: string): Promise<void>
+
+  /**
+   * Encodes the text in `textData` using the character encoding named by `charset`, then uploads
+   * the resulting bytes to the remote file at `remotePath`.
+   *
+   * An absolute remote path begins with `/`. A relative path is interpreted relative to the
+   * authenticated SSH user's home directory. The remote parent directory must already exist.
+   *
+   * **Text encoding:** `charset` controls how characters are converted to bytes, for example
+   * `utf-8`, `windows-1252`, or `iso-8859-1`. SCP itself has no text mode; any line-ending
+   * characters already present in `textData` are encoded and transferred as part of the text.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Scp.uploadStringAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Scp.lastErrorText}.
+   */
+  uploadString(remotePath: string, textData: string, charset: string): void
+
+  /**
+   * Asynchronous form of {@link Scp.uploadString}: 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 Scp.abort} (which cancels it) and the {@link Scp.onPercentDone} /
+   * {@link Scp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Scp.lastErrorText}.
+   */
+  uploadStringAsync(remotePath: string, textData: string, charset: string): Promise<void>
+
+  /**
+   * Associates this `Scp` object with the connected and authenticated `Ssh` object in
+   * `sshConnection`. Subsequent SCP operations use that existing SSH session rather than opening a
+   * separate network connection.
+   *
+   * Connection, proxy, timeout, host-key verification, algorithm, logging, and other
+   * transport-related settings belong to the `Ssh` object and therefore apply to the SCP operations
+   * performed through it. Keep the SSH object connected and available for as long as the `Scp`
+   * object is using it.
+   *
+   * **SCP and SFTP are different protocols:** `Scp` performs SCP-style transfers over SSH and
+   * requires compatible SCP support on the remote system. Use `Chilkat.SFtp` when the server
+   * expects the SSH File Transfer Protocol subsystem or when directory listing and remote
+   * file-management features are needed.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Scp.lastErrorText}.
+   */
+  useSsh(sshConnection: Ssh): void
+
+  /**
+   * Downloads the file at `remotePath` and appends its exact bytes to the existing contents of the
+   * `BinData` object in `bd`.
+   *
+   * An absolute remote path begins with `/`. A relative path is interpreted relative to the
+   * authenticated SSH user's home directory.
+   *
+   * **Append behavior:** This method does not clear `bd` before downloading. Clear the `BinData`
+   * object first when the downloaded file should replace, rather than follow, its current contents.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Scp.downloadBdAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Scp.lastErrorText}.
+   */
+  downloadBd(remotePath: string, bd: BinData): void
+
+  /**
+   * Asynchronous form of {@link Scp.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 Scp.abort} (which cancels it) and the {@link Scp.onPercentDone} /
+   * {@link Scp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Scp.lastErrorText}.
+   */
+  downloadBdAsync(remotePath: string, bd: BinData): Promise<void>
+
+  /**
+   * Uploads all bytes currently contained in the `BinData` object in `bd` to the remote file at
+   * `remotePath`. The data is transferred without character decoding or other transformation.
+   *
+   * An absolute remote path begins with `/`. A relative path is interpreted relative to the
+   * authenticated SSH user's home directory. The remote parent directory must already exist.
+   *
+   * **Source object:** The upload reads the current contents of `bd` and does not remove or modify
+   * those bytes.
+   *
+   * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
+   * {@link Scp.uploadBdAsync}.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Scp.lastErrorText}.
+   */
+  uploadBd(remotePath: string, bd: BinData): void
+
+  /**
+   * Asynchronous form of {@link Scp.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 Scp.abort} (which cancels it) and the {@link Scp.onPercentDone} /
+   * {@link Scp.onProgressInfo} callbacks, which report progress while it runs.
+   *
+   * The promise rejects with an Error if the call fails; the full log is in
+   * {@link Scp.lastErrorText}.
+   */
+  uploadBdAsync(remotePath: string, bd: BinData): 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 Scp.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
+}