@chilkat/react-native 11.6.1

package/src/specs/FileAccess.nitro.ts

@@ -0,0 +1,836 @@
+// 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 { StringBuilder } from './StringBuilder.nitro'
+
+/**
+ * Read, write, compare, copy, split, inspect, and manage files and paths.
+ *
+ * `FileAccess` provides general-purpose file-system
+ * utilities for applications that need direct control over files, directories,
+ * paths, timestamps, and low-level file operations. It can read, write, append,
+ * seek, compare, copy, rename, delete, split, reassemble, and inspect files,
+ * and also includes helpers for directory operations, path parsing, symbolic
+ * links, temporary filenames, block-based reading, fragment scanning, text
+ * replacement, and open-file access.
+ *
+ * **Read and write files**
+ *
+ * Load or save text and binary files, append data, replace file contents,
+ * and work with explicit character encodings when needed.
+ *
+ * **File management**
+ *
+ * Copy, rename, delete, compare, split, reassemble, and inspect files using
+ * straightforward file-system utility methods.
+ *
+ * **Directories and paths**
+ *
+ * Create, remove, check, and work with directories, and use path helpers to
+ * extract filenames, extensions, directory names, and related path parts.
+ *
+ * **Open-file operations**
+ *
+ * Open files for lower-level reading or writing, seek within files, read
+ * blocks, and process large files without loading everything at once.
+ *
+ * **Timestamps and metadata**
+ *
+ * Get or set file times, inspect sizes and existence, and use metadata
+ * helpers when coordinating file processing workflows.
+ *
+ * **Special file utilities**
+ *
+ * Generate temporary filenames, work with symbolic links, scan for byte
+ * fragments, and perform text replacement in files.
+ *
+ * **Common pattern:**
+ * Use `FileAccess` for local file-system tasks that are outside the
+ * scope of a specific protocol class. It is especially useful for preparing
+ * files before upload, saving downloaded data, comparing or splitting files,
+ * reading large files in blocks, manipulating paths, or performing small
+ * filesystem operations without using platform-specific APIs.
+ *
+ * For an extended overview, see
+ * [FileAccess Class Overview](https://www.chilkatsoft.com/fileaccess_class_overview.asp).
+ *
+ * Each `FileAccess` 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 FileAccess()`.
+ */
+export interface FileAccess 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
+
+  /**
+   * Returns the current working directory of the calling process. Relative file and directory paths
+   * are resolved against this process-wide working directory.
+   *
+   * **Process-wide setting:** The working directory belongs to the process, not to an individual
+   * `FileAccess` object. Changing it can therefore affect relative-path behavior elsewhere in the
+   * application.
+   *
+   * This property is read-only.
+   */
+  readonly currentDir: string
+
+  /**
+   * Returns `true` when the currently open file is positioned at end-of-file; otherwise returns
+   * `false`.
+   *
+   * **Open-file state:** This property applies to the file opened by `OpenForRead`, `OpenForWrite`,
+   * `OpenForReadWrite`, `OpenForAppend`, or `FileOpen`.
+   *
+   * This property is read-only.
+   */
+  readonly endOfFile: boolean
+
+  /**
+   * Provides the detailed open-error code from the most recent call to `FileOpen`, `OpenForRead`,
+   * `OpenForWrite`, `OpenForReadWrite`, or `OpenForAppend`.
+   *
+   * CodeMeaning
+   *
+   * | `0` |  | Success; no open error. |
+   *
+   * | `1` |  | Access denied. |
+   *
+   * | `2` |  | File not found. |
+   *
+   * | `3` |  | General, non-specific open error. |
+   *
+   * | `4` |  | File already exists. |
+   *
+   * | `5` |  | The path refers to a directory and the requested access involves writing. |
+   *
+   * | `6` |  | Too many symbolic links were encountered while resolving the path. |
+   *
+   * | `7` |  | The process already has the maximum number of files open. |
+   *
+   * | `8` |  | The pathname is too long. |
+   *
+   * | `9` |  | The system-wide limit on open files has been reached. |
+   *
+   * | `10` | | The pathname refers to a device special file for which no corresponding device
+   * exists. |
+   *
+   * | `11` |  | Insufficient kernel memory was available. |
+   *
+   * | `12` |  | A file was to be created, but the containing device has no space available. |
+   *
+   * | `13` |  | A pathname component expected to be a directory is not a directory. |
+   *
+   * | `14` | | The regular file is too large to be opened because of an operating-system
+   * limitation. |
+   *
+   * | `15` |  | The path is on a read-only filesystem and write access was requested. |
+   *
+   * **Use with FileOpenErrorMsg:** `FileOpenError` is useful for programmatic handling;
+   * `FileOpenErrorMsg` provides the corresponding human-readable message.
+   *
+   * This property is read-only.
+   */
+  readonly fileOpenError: number
+
+  /**
+   * Returns the human-readable message corresponding to `FileOpenError` for the most recent
+   * file-open attempt.
+   *
+   * This property is read-only.
+   */
+  readonly fileOpenErrorMsg: string
+
+  /**
+   * **Windows only.** If `true`, `OpenForAppend`, `OpenForRead`, `OpenForReadWrite`, and
+   * `OpenForWrite` request exclusive access to the file. Other processes are prevented from opening
+   * the file until `FileClose` releases the handle. The default is `false`.
+   *
+   * **File sharing:** Windows file sharing is established when the file handle is opened. Set this
+   * property before calling an `OpenFor*` method.
+   */
+  lockFileOnOpen: boolean
+
+  // ---- Methods ----
+
+  /**
+   * Appends `text` to the currently open file after converting the string to the legacy ANSI
+   * character encoding used by Chilkat for the platform.
+   *
+   * **Character encoding:** Use `AppendText` or `AppendSb` when an explicit encoding such as
+   * `utf-8` is preferred.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  appendAnsi(text: string): void
+
+  /**
+   * Appends `str` to the currently open file after encoding the text with the character set named
+   * by `charset`, such as `utf-8` or `iso-8859-1`.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  appendText(str: string, charset: string): void
+
+  /**
+   * Appends the UTF-16 little-endian byte-order mark to the currently open file. The two bytes
+   * written are `FF FE`.
+   *
+   * **BOM placement:** A BOM normally belongs at the beginning of a text file. This method appends
+   * bytes at the current write position, so call it before writing text when creating a new
+   * UTF-16LE file.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  appendUnicodeBOM(): void
+
+  /**
+   * Appends the UTF-8 byte-order mark to the currently open file. The three bytes written are `EF
+   * BB BF`.
+   *
+   * **UTF-8 BOM:** A UTF-8 BOM is optional. Some software uses it as an encoding signature, while
+   * other software expects BOM-less UTF-8.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  appendUtf8BOM(): void
+
+  /**
+   * Ensures that the directory portion of `filePath` exists. Any missing parent directories are
+   * created; the final path component is treated as a filename and is not created as a directory.
+   *
+   * **Difference from DirEnsureExists:** Use `DirAutoCreate` when you have a file path. Use
+   * `DirEnsureExists` when the argument itself is a directory path.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  dirAutoCreate(filePath: string): void
+
+  /**
+   * Creates the directory specified by `dirPath`. Parent directories must already exist; use
+   * `DirEnsureExists` when missing parent directories should also be created.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  dirCreate(dirPath: string): void
+
+  /**
+   * Deletes the directory specified by `dirPath`. The directory must be empty; use `TreeDelete` to
+   * recursively delete a directory and its contents.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  dirDelete(dirPath: string): void
+
+  /**
+   * Ensures that the complete directory path `dirPath` exists, creating missing directories along
+   * the path as needed.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  dirEnsureExists(dirPath: string): void
+
+  /**
+   * Closes the currently open file and releases its operating-system file handle. Any exclusive
+   * lock obtained through `LockFileOnOpen` is released at this time.
+   */
+  fileClose(): void
+
+  /**
+   * Compares `filePath1` and `filePath2` byte-for-byte and returns `true` only when their contents
+   * are identical. File sizes are compared first; when sizes match, the files are compared
+   * incrementally rather than being loaded entirely into memory.
+   *
+   * **Binary comparison:** The comparison is byte-oriented. Text encodings, line-ending
+   * conventions, and Unicode normalization are not interpreted or normalized.
+   */
+  fileContentsEqual(filePath1: string, filePath2: string): boolean
+
+  /**
+   * Copies `existingFilepath` to `newFilepath`. If `failIfExists` is `true` and the destination
+   * already exists, the copy fails instead of overwriting it.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  fileCopy(existingFilepath: string, newFilepath: string, failIfExists: boolean): void
+
+  /**
+   * Deletes the file specified by `filePath`.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  fileDelete(filePath: string): void
+
+  /**
+   * Returns `true` if `filePath` exists; otherwise returns `false`. Use `FileExists3` when the
+   * application must distinguish "does not exist" from "could not determine because of an error."
+   */
+  fileExists(filePath: string): boolean
+
+  /**
+   * Checks whether `path` exists and returns a three-state result: `1` if it exists, `0` if it does
+   * not exist, and `-1` if Chilkat could not determine the result because of permissions or another
+   * filesystem error.
+   */
+  fileExists3(path: string): number
+
+  /**
+   * **Windows-specific low-level open.** Opens `filePath` using arguments modeled after the Win32
+   * `CreateFile` API. For portable code, prefer `OpenForRead`, `OpenForWrite`, `OpenForReadWrite`,
+   * or `OpenForAppend`.
+   *
+   * CategoryCommon values
+   *
+   * | Access |  | `GENERIC_READ = 0x80000000`, `GENERIC_WRITE = 0x40000000` |
+   *
+   * | Sharing |  | `FILE_SHARE_READ = 0x1`, `FILE_SHARE_WRITE = 0x2` |
+   *
+   * | Disposition | | `CREATE_NEW=1`, `CREATE_ALWAYS=2`, `OPEN_EXISTING=3`, `OPEN_ALWAYS=4`,
+   * `TRUNCATE_EXISTING=5` |
+   *
+   * **Open failures:** When this method fails, inspect `FileOpenError` and `FileOpenErrorMsg` for
+   * the reason.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  fileOpen(filePath: string, accessMode: number, shareMode: number, createDisposition: number, attributes: number): void
+
+  /**
+   * Renames or moves `existingFilepath` to `newFilepath` using the local filesystem.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  fileRename(existingFilepath: string, newFilepath: string): void
+
+  /**
+   * Moves the current file position by `offset` bytes relative to `origin`.
+   *
+   * | `0` |  | Offset from the beginning of the file. |
+   *
+   * | `1` |  | Offset from the current file position. |
+   *
+   * | `2` |  | Offset from end-of-file; negative offsets are commonly used. |
+   *
+   * **Random access:** Seeking changes where the next read or write occurs; it does not itself
+   * read, write, or resize the file.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  fileSeek(offset: number, origin: number): void
+
+  /**
+   * Returns the file size in bytes as a signed 32-bit integer, or `-1` on failure.
+   *
+   * **Large files:** A signed 32-bit result cannot represent files larger than approximately 2 GB.
+   * Use `FileSize64` or `FileSizeStr` for large files.
+   */
+  fileSize(filePath: string): number
+
+  /**
+   * Generates a fixed-width decimal block identifier from `index`, padded to `length` characters,
+   * and then encodes those bytes using `encoding` (for example `base64`, `hex`, or `ascii`). This
+   * utility was originally added for block-oriented uploads such as Azure Blob block uploads.
+   *
+   * **Ordering:** Fixed-width decimal identifiers preserve numeric ordering when identifiers are
+   * compared lexically, provided the chosen width is large enough for all indexes.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  genBlockId(index: number, length: number, encoding: string): string
+
+  /**
+   * Returns how many `blockSize`-byte blocks are required to cover the currently open file. A
+   * partial final block counts as one block. Returns `0` for an empty file and `-1` if no file is
+   * open.
+   *
+   * **Calculation:** Conceptually this is `ceil(fileSize / blockSize)` for a non-empty file.
+   */
+  getNumBlocks(blockSize: number): number
+
+  /**
+   * Generates a temporary pathname in `dirPath` using `prefix` and a random alphanumeric suffix, in
+   * the general form `prefix_xxxx.TMP`. The returned pathname is guaranteed not to already exist at
+   * the time it is generated.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  getTempFilename(dirPath: string, prefix: string): string
+
+  /**
+   * Opens `filePath` for writing at end-of-file. The file is created if it does not exist. Existing
+   * content is preserved, and the initial file position is at the end.
+   *
+   * **Open failures:** If the open/create operation fails, inspect `FileOpenError` and
+   * `FileOpenErrorMsg`. On Windows, `LockFileOnOpen` can request exclusive access for this method.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  openForAppend(filePath: string): void
+
+  /**
+   * Opens an existing `filePath` for reading. The file may contain text or binary data and must
+   * already exist.
+   *
+   * **Open failures:** If the open/create operation fails, inspect `FileOpenError` and
+   * `FileOpenErrorMsg`. On Windows, `LockFileOnOpen` can request exclusive access for this method.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  openForRead(filePath: string): void
+
+  /**
+   * Opens `filePath` for both reading and writing. The file is created if necessary. Existing
+   * content is preserved, and the initial file position is at the beginning.
+   *
+   * **Open failures:** If the open/create operation fails, inspect `FileOpenError` and
+   * `FileOpenErrorMsg`. On Windows, `LockFileOnOpen` can request exclusive access for this method.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  openForReadWrite(filePath: string): void
+
+  /**
+   * Opens `filePath` for writing. The file is created if necessary; if it already exists, it is
+   * truncated to zero length when opened.
+   *
+   * **Open failures:** If the open/create operation fails, inspect `FileOpenError` and
+   * `FileOpenErrorMsg`. On Windows, `LockFileOnOpen` can request exclusive access for this method.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  openForWrite(filePath: string): void
+
+  /**
+   * Reads the entire file at `filePath` as binary data and returns an encoded textual
+   * representation. Supported encoding names documented for this method include `base64`, `hex`,
+   * `qp`, and `url`.
+   *
+   * **Encoding is not encryption:** These encodings transform bytes into text; they do not provide
+   * confidentiality.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  readBinaryToEncoded(filePath: string, encoding: string): string
+
+  /**
+   * Reads the entire file at `filePath`, decodes its bytes using `charset`, and returns the
+   * resulting text.
+   *
+   * **Charset matters:** The charset controls byte-to-character conversion. Use the encoding that
+   * actually represents the file; incorrect charset selection can produce incorrect text or
+   * conversion failure.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  readEntireTextFile(filePath: string, charset: string): string
+
+  /**
+   * Reassembles a file previously divided by `SplitFile`. Parts are read from `partsDirPath` using
+   * the supplied `partPrefix` and `partExtension`, and the combined bytes are written to
+   * `reassembledFilename`.
+   *
+   * **Byte-for-byte reconstruction:** Reassembly is a binary operation; no text decoding or newline
+   * conversion is performed.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  reassembleFile(partsDirPath: string, partPrefix: string, partExtension: string, reassembledFilename: string): void
+
+  /**
+   * Reads the file at `filePath` as text using `charset`, replaces occurrences of `existingString`
+   * with `replacementString`, writes the updated text back to the file, and returns the number of
+   * replacements made.
+   *
+   * **Text operation:** This is character-based replacement after decoding the file. It is not
+   * suitable for arbitrary binary files.
+   */
+  replaceStrings(filePath: string, charset: string, existingString: string, replacementString: string): number
+
+  /**
+   * Changes the current working directory of the calling process to `dirPath`.
+   *
+   * **Process-wide effect:** The current directory is normally process-wide, so changing it can
+   * affect relative paths used by other code or threads. Absolute paths avoid that dependency.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  setCurrentDir(dirPath: string): void
+
+  /**
+   * Sets the creation, last-access, and last-modified timestamps for `filePath` from the supplied
+   * `CkDateTime` objects. On filesystems that do not support a creation/birth time, `createTime` is
+   * ignored.
+   *
+   * **Filesystem differences:** Timestamp availability and precision are filesystem- and
+   * operating-system-dependent.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  setFileTimes(filePath: string, createTime: CkDateTime, lastAccessTime: CkDateTime, lastModTime: CkDateTime): void
+
+  /**
+   * Sets the last-modified timestamp of `filePath` from `lastModified`. The precision actually
+   * stored depends on the underlying filesystem.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  setLastModified(filePath: string, lastModified: CkDateTime): void
+
+  /**
+   * Splits `fileToSplit` into sequential binary parts of up to `partSize` bytes and writes them to
+   * `destDir` using `partPrefix` and `partExtension`. Use `ReassembleFile` to reconstruct the
+   * original file.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  splitFile(fileToSplit: string, partPrefix: string, partExtension: string, partSize: number, destDir: string): void
+
+  /**
+   * Recursively deletes the directory tree rooted at `path`, including contained files and
+   * subdirectories.
+   *
+   * **Destructive operation:** This operation is recursive and destructive. Ensure `path`
+   * identifies the intended tree before calling it.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  treeDelete(path: string): void
+
+  /**
+   * Creates or opens `filePath`, encodes `textData` using `charset`, writes the resulting bytes,
+   * and closes the file. Existing file content is replaced. If `includePreamble` is `true`, an
+   * appropriate preamble/BOM is included for encodings such as UTF-8 or UTF-16.
+   *
+   * **BOM terminology:** A BOM is part of the byte representation of the text file; it is not part
+   * of the application string itself.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  writeEntireTextFile(filePath: string, textData: string, charset: string, includedPreamble: boolean): void
+
+  /**
+   * Reads up to `maxNumBytes` bytes from the current file position and appends the bytes to
+   * `binData`. The file position advances by the number of bytes read.
+   *
+   * **Destination behavior:** Existing bytes already present in `binData` are preserved; newly read
+   * bytes are appended.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  fileReadBd(maxNumBytes: number, binData: BinData): void
+
+  /**
+   * Writes bytes from `binData` to the currently open file. `offset` selects the starting byte
+   * within the `BinData`; `numBytes` selects how many bytes to write. Set both to `0` to write the
+   * entire `BinData`, or set `numBytes` to `0` to write all remaining bytes beginning at `offset`.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  fileWriteBd(binData: BinData, offset: number, numBytes: number): void
+
+  /**
+   * Returns the final filename component of `path`, including its extension. If the path ends with
+   * a directory separator, the returned filename is empty.
+   *
+   * ```
+   * GetFileName('C:\mydir\myfile.ext')  ->  'myfile.ext'
+   * GetFileName('C:\mydir\')            ->  ''
+   * ```
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  getFileName(path: string): string
+
+  /**
+   * Returns the directory portion of `path` according to Chilkat path-parsing rules.
+   *
+   * ```
+   * GetDirectoryName('C:\MyDir\MySubDir\myfile.ext')  ->  'C:\MyDir\MySubDir\'
+   * GetDirectoryName('C:\MyDir\MySubDir')             ->  'C:\MyDir\'
+   * GetDirectoryName('C:\')                             ->  'C:\'
+   * ```
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  getDirectoryName(path: string): string
+
+  /**
+   * Returns the filename extension portion of `path`, including the leading period. A period
+   * appearing only in a directory name is not treated as the file extension.
+   *
+   * ```
+   * GetExtension('C:\mydir.old\myfile.ext')  ->  '.ext'
+   * GetExtension('C:\mydir.old\')            ->  ''
+   * ```
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  getExtension(path: string): string
+
+  /**
+   * Returns the final filename component of `path` with its extension removed. If `path` ends with
+   * a directory separator, the returned value is empty.
+   *
+   * ```
+   * GetFileNameWithoutExtension('C:\mydir\myfile.ext')  ->  'myfile'
+   * GetFileNameWithoutExtension('C:\mydir\')            ->  ''
+   * ```
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  getFileNameWithoutExtension(path: string): string
+
+  /**
+   * Appends the text contained in `sb` to the currently open file using the character encoding
+   * specified by `charset`.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  appendSb(sb: StringBuilder, charset: string): void
+
+  /**
+   * Appends all bytes contained in `bd` to the currently open file without text conversion.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  appendBd(bd: BinData): void
+
+  /**
+   * Examines `path` and classifies the filesystem entry.
+   *
+   * | `-1` |  | Unable to determine because of permissions or another error. |
+   *
+   * | `0` |  | Does not exist. |
+   *
+   * | `1` |  | Regular file. |
+   *
+   * | `2` |  | Directory. |
+   *
+   * | `3` |  | Symbolic link. |
+   *
+   * | `4` |  | Windows shortcut. |
+   *
+   * | `99` |  | Another filesystem type. |
+   *
+   * **Future values:** Additional file-type codes may be added in future versions as needed.
+   */
+  fileType(path: string): number
+
+  /**
+   * Returns the resolved target pathname for the symbolic link at `linkPath`. On Windows, this
+   * method also understands Windows shortcut (`.lnk`) files and returns the absolute target path.
+   *
+   * **Link vs. target:** A symbolic link is a filesystem object that refers to another path. A
+   * Windows shortcut is a separate shell-file format; Chilkat supports both here even though they
+   * are different mechanisms.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  symlinkTarget(linkPath: string): string
+
+  /**
+   * Creates a symbolic link at `linkPath` that refers to `targetPath`.
+   *
+   * **Windows note:** A Windows symbolic link is not the same as a Windows shortcut. Windows may
+   * require elevated privileges or an operating-system configuration such as Developer Mode that
+   * permits unprivileged symbolic-link creation, depending on system policy and how the application
+   * is launched.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  symlinkCreate(targetPath: string, linkPath: string): void
+
+  /**
+   * Reads the zero-based block `blockIndex` from the currently open file, using `blockSize` bytes
+   * per block, and appends the bytes to `bd`. A partial final block is appended at its actual
+   * length.
+   *
+   * **Destination behavior:** Existing contents of `bd` are preserved; the block bytes are
+   * appended.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  readBlockBd(blockIndex: number, blockSize: number, bd: BinData): void
+
+  /**
+   * Returns the size of `filePath` in bytes as a decimal string. This avoids the range limitation
+   * of a 32-bit integer return value.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  fileSizeStr(filePath: string): string
+
+  /**
+   * Scans the currently open file for the next text fragment beginning with `beginMarker` and
+   * ending with `endMarker`. The matched fragment, including both markers, is decoded using
+   * `charset` and appended to `sb`. If `startAtBeginning` is `true`, scanning restarts at the
+   * beginning of the file; otherwise it continues after the previously matched fragment.
+   *
+   * | `1` |  | A fragment was found and appended. |
+   *
+   * | `0` |  | No matching fragment was found. |
+   *
+   * | `-1` |  | An error occurred while reading. |
+   */
+  readNextFragment(startAtBeginning: boolean, beginMarker: string, endMarker: string, charset: string, sb: StringBuilder): number
+
+  /**
+   * Truncates the currently open file at the current file position. Bytes at and after that
+   * position are removed, making the current position the new end-of-file.
+   *
+   * **Use with FileSeek:** A common pattern is to seek to the desired new length and then call
+   * `Truncate`.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  truncate(): void
+
+  /**
+   * Writes exactly `szByteData` bytes beginning at `pByteData` to the currently open file at the
+   * current file position.
+   *
+   * **C++ buffer contract:** The caller must supply a valid readable buffer containing at least
+   * `szByteData` bytes.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  fileWrite2(byteData: ArrayBuffer): void
+
+  /**
+   * Returns the size of `filePath` in bytes as a signed 64-bit integer, or `-1` on failure.
+   *
+   * 64-bit integers are passed as JavaScript numbers (exact up to 2^53).
+   */
+  fileSize64(filePath: string): number
+
+  /**
+   * Returns `true` if `dirPath` exists as a directory; otherwise returns `false`.
+   */
+  dirExists(dirPath: string): boolean
+
+  /**
+   * Returns one file timestamp as an ISO 8601 UTC string in the form `YYYY-MM-DDTHH:MM:SSZ`. The
+   * `which` argument selects `0` = last-modified, `1` = last-access, or `2` = creation.
+   *
+   * **Portability:** Creation/birth time is not available on every filesystem. The documented
+   * Chilkat behavior on Linux is to return the last-modified time when creation time is
+   * unavailable.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link FileAccess.lastErrorText}.
+   */
+  getFileTimeStr(path: string, which: number): string
+}