@gtkx/ffi 0.1.44 → 0.1.46

package/dist/generated/gio/file.d.ts

@@ -14,137 +14,1952 @@ import { Mount } from "./mount.js";
 import { MountOperation } from "./mount-operation.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * `GFile` is a high level abstraction for manipulating files on a
+ * virtual file system. `GFile`s are lightweight, immutable objects
+ * that do no I/O upon creation. It is necessary to understand that
+ * `GFile` objects do not represent files, merely an identifier for a
+ * file. All file content I/O is implemented as streaming operations
+ * (see [class@Gio.InputStream] and [class@Gio.OutputStream]).
+ *
+ * To construct a `GFile`, you can use:
+ *
+ * - [func@Gio.File.new_for_path] if you have a path.
+ * - [func@Gio.File.new_for_uri] if you have a URI.
+ * - [func@Gio.File.new_for_commandline_arg] or
+ * [func@Gio.File.new_for_commandline_arg_and_cwd] for a command line
+ * argument.
+ * - [func@Gio.File.new_tmp] to create a temporary file from a template.
+ * - [func@Gio.File.new_tmp_async] to asynchronously create a temporary file.
+ * - [func@Gio.File.new_tmp_dir_async] to asynchronously create a temporary
+ * directory.
+ * - [func@Gio.File.parse_name] from a UTF-8 string gotten from
+ * [method@Gio.File.get_parse_name].
+ * - [func@Gio.File.new_build_filename] or [func@Gio.File.new_build_filenamev]
+ * to create a file from path elements.
+ *
+ * One way to think of a `GFile` is as an abstraction of a pathname. For
+ * normal files the system pathname is what is stored internally, but as
+ * `GFile`s are extensible it could also be something else that corresponds
+ * to a pathname in a userspace implementation of a filesystem.
+ *
+ * `GFile`s make up hierarchies of directories and files that correspond to
+ * the files on a filesystem. You can move through the file system with
+ * `GFile` using [method@Gio.File.get_parent] to get an identifier for the
+ * parent directory, [method@Gio.File.get_child] to get a child within a
+ * directory, and [method@Gio.File.resolve_relative_path] to resolve a relative
+ * path between two `GFile`s. There can be multiple hierarchies, so you may not
+ * end up at the same root if you repeatedly call [method@Gio.File.get_parent]
+ * on two different files.
+ *
+ * All `GFile`s have a basename (get with [method@Gio.File.get_basename]). These
+ * names are byte strings that are used to identify the file on the filesystem
+ * (relative to its parent directory) and there is no guarantees that they
+ * have any particular charset encoding or even make any sense at all. If
+ * you want to use filenames in a user interface you should use the display
+ * name that you can get by requesting the
+ * `G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME` attribute with
+ * [method@Gio.File.query_info]. This is guaranteed to be in UTF-8 and can be
+ * used in a user interface. But always store the real basename or the `GFile`
+ * to use to actually access the file, because there is no way to go from a
+ * display name to the actual name.
+ *
+ * Using `GFile` as an identifier has the same weaknesses as using a path
+ * in that there may be multiple aliases for the same file. For instance,
+ * hard or soft links may cause two different `GFile`s to refer to the same
+ * file. Other possible causes for aliases are: case insensitive filesystems,
+ * short and long names on FAT/NTFS, or bind mounts in Linux. If you want to
+ * check if two `GFile`s point to the same file you can query for the
+ * `G_FILE_ATTRIBUTE_ID_FILE` attribute. Note that `GFile` does some trivial
+ * canonicalization of pathnames passed in, so that trivial differences in
+ * the path string used at creation (duplicated slashes, slash at end of
+ * path, `.` or `..` path segments, etc) does not create different `GFile`s.
+ *
+ * Many `GFile` operations have both synchronous and asynchronous versions
+ * to suit your application. Asynchronous versions of synchronous functions
+ * simply have `_async()` appended to their function names. The asynchronous
+ * I/O functions call a [callback@Gio.AsyncReadyCallback] which is then used to
+ * finalize the operation, producing a [iface@Gio.AsyncResult] which is then
+ * passed to the function’s matching `_finish()` operation.
+ *
+ * It is highly recommended to use asynchronous calls when running within a
+ * shared main loop, such as in the main thread of an application. This avoids
+ * I/O operations blocking other sources on the main loop from being dispatched.
+ * Synchronous I/O operations should be performed from worker threads. See the
+ * introduction to asynchronous programming section
+ * for more.
+ *
+ * Some `GFile` operations almost always take a noticeable amount of time, and
+ * so do not have synchronous analogs. Notable cases include:
+ *
+ * - [method@Gio.File.mount_mountable] to mount a mountable file.
+ * - [method@Gio.File.unmount_mountable_with_operation] to unmount a mountable
+ * file.
+ * - [method@Gio.File.eject_mountable_with_operation] to eject a mountable file.
+ *
+ * ## Entity Tags
+ *
+ * One notable feature of `GFile`s are entity tags, or ‘etags’ for
+ * short. Entity tags are somewhat like a more abstract version of the
+ * traditional mtime, and can be used to quickly determine if the file
+ * has been modified from the version on the file system. See the
+ * HTTP 1.1
+ * specification
+ * for HTTP `ETag` headers, which are a very similar concept.
+ */
 export declare class File {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): File;
+    /**
+     * Gets an output stream for appending data to the file.
+     * If the file doesn't already exist it is created.
+     *
+     * By default files created are generally readable by everyone,
+     * but if you pass %G_FILE_CREATE_PRIVATE in `flags` the file
+     * will be made readable only to the current user, to the level that
+     * is supported on the target filesystem.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled
+     * by triggering the cancellable object from another thread. If the
+     * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+     * returned.
+     *
+     * Some file systems don't allow all file names, and may return an
+     * %G_IO_ERROR_INVALID_FILENAME error. If the file is a directory the
+     * %G_IO_ERROR_IS_DIRECTORY error will be returned. Other errors are
+     * possible too, and depend on what kind of filesystem the file is on.
+     * @param flags - a set of #GFileCreateFlags
+     * @param cancellable - optional #GCancellable object,
+     */
     appendTo(flags: FileCreateFlags, cancellable?: Cancellable | null): FileOutputStream;
+    /**
+     * Asynchronously opens `file` for appending.
+     *
+     * For more details, see g_file_append_to() which is
+     * the synchronous version of this call.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_file_append_to_finish() to get the result
+     * of the operation.
+     * @param flags - a set of #GFileCreateFlags
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     appendToAsync(flags: FileCreateFlags, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an asynchronous file append operation started with
+     * g_file_append_to_async().
+     * @param res - #GAsyncResult
+     */
     appendToFinish(res: AsyncResult): FileOutputStream;
+    /**
+     * Prepares the file attribute query string for copying to @file.
+     *
+     * This function prepares an attribute query string to be
+     * passed to g_file_query_info() to get a list of attributes
+     * normally copied with the file (see g_file_copy_attributes()
+     * for the detailed description). This function is used by the
+     * implementation of g_file_copy_attributes() and is useful
+     * when one needs to query and set the attributes in two
+     * stages (e.g., for recursive move of a directory).
+     * @param flags - a set of #GFileCopyFlags
+     * @param cancellable - optional #GCancellable object,
+     */
     buildAttributeListForCopy(flags: FileCopyFlags, cancellable?: Cancellable | null): string;
+    /**
+     * Copies the file `source` to the location specified by @destination.
+     * Can not handle recursive copies of directories.
+     *
+     * If the flag %G_FILE_COPY_OVERWRITE is specified an already
+     * existing `destination` file is overwritten.
+     *
+     * If the flag %G_FILE_COPY_NOFOLLOW_SYMLINKS is specified then symlinks
+     * will be copied as symlinks, otherwise the target of the
+     * `source` symlink will be copied.
+     *
+     * If the flag %G_FILE_COPY_ALL_METADATA is specified then all the metadata
+     * that is possible to copy is copied, not just the default subset (which,
+     * for instance, does not include the owner, see #GFileInfo).
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     *
+     * If `progress_callback` is not %NULL, then the operation can be monitored
+     * by setting this to a #GFileProgressCallback function.
+     * `progress_callback_data` will be passed to this function. It is guaranteed
+     * that this callback will be called after all data has been transferred with
+     * the total number of bytes copied during the operation.
+     *
+     * If the `source` file does not exist, then the %G_IO_ERROR_NOT_FOUND error
+     * is returned, independent on the status of the @destination.
+     *
+     * If %G_FILE_COPY_OVERWRITE is not specified and the target exists, then
+     * the error %G_IO_ERROR_EXISTS is returned.
+     *
+     * If trying to overwrite a file over a directory, the %G_IO_ERROR_IS_DIRECTORY
+     * error is returned. If trying to overwrite a directory with a directory the
+     * %G_IO_ERROR_WOULD_MERGE error is returned.
+     *
+     * If the source is a directory and the target does not exist, or
+     * %G_FILE_COPY_OVERWRITE is specified and the target is a file, then the
+     * %G_IO_ERROR_WOULD_RECURSE error is returned.
+     *
+     * If you are interested in copying the #GFile object itself (not the on-disk
+     * file), see g_file_dup().
+     * @param destination - destination #GFile
+     * @param flags - set of #GFileCopyFlags
+     * @param cancellable - optional #GCancellable object,
+     * @param progressCallback - function to callback with
+     * @param progressCallbackData - user data to pass to @progress_callback
+     */
     copy(destination: File, flags: FileCopyFlags, cancellable?: Cancellable | null, progressCallback?: (...args: unknown[]) => unknown | null, progressCallbackData?: number | null): boolean;
+    /**
+     * Copies the file `source` to the location specified by `destination` asynchronously. For details of the behaviour, see g_file_copy().
+     *
+     * If `progress_callback` is not %NULL, then that function that will be called
+     * just like in g_file_copy(). The callback will run in the default main context
+     * of the thread calling g_file_copy_async() — the same context as `callback` is
+     * run in.
+     *
+     * When the operation is finished, `callback` will be called. You can then call
+     * g_file_copy_finish() to get the result of the operation.
+     * @param destination - destination #GFile
+     * @param flags - set of #GFileCopyFlags
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object,
+     * @param progressCallback - function to callback with progress information, or %NULL if
+     * @param progressCallbackData - user data to pass to @progress_callback
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback
+     */
     copyAsync(destination: File, flags: FileCopyFlags, ioPriority: number, cancellable?: Cancellable | null, progressCallback?: (...args: unknown[]) => unknown | null, progressCallbackData?: number | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Version of [method@Gio.File.copy_async] using closures instead of callbacks for
+     * easier binding in other languages.
+     * @param destination - destination [type@Gio.File]
+     * @param flags - set of [flags@Gio.FileCopyFlags]
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional [class@Gio.Cancellable] object,
+     * @param progressCallbackClosure - [type@GObject.Closure] to invoke with progress
+     * @param readyCallbackClosure - [type@GObject.Closure] to invoke when the request is satisfied
+     */
     copyAsyncWithClosures(destination: File, flags: FileCopyFlags, ioPriority: number, readyCallbackClosure: GObject.Closure, cancellable?: Cancellable | null, progressCallbackClosure?: GObject.Closure | null): void;
+    /**
+     * Copies the file attributes from `source` to @destination.
+     *
+     * Normally only a subset of the file attributes are copied,
+     * those that are copies in a normal file copy operation
+     * (which for instance does not include e.g. owner). However
+     * if %G_FILE_COPY_ALL_METADATA is specified in @flags, then
+     * all the metadata that is possible to copy is copied. This
+     * is useful when implementing move by copy + delete source.
+     * @param destination - a #GFile to copy attributes to
+     * @param flags - a set of #GFileCopyFlags
+     * @param cancellable - optional #GCancellable object,
+     */
     copyAttributes(destination: File, flags: FileCopyFlags, cancellable?: Cancellable | null): boolean;
+    /**
+     * Finishes copying the file started with g_file_copy_async().
+     * @param res - a #GAsyncResult
+     */
     copyFinish(res: AsyncResult): boolean;
+    /**
+     * Creates a new file and returns an output stream for writing to it.
+     * The file must not already exist.
+     *
+     * By default files created are generally readable by everyone,
+     * but if you pass %G_FILE_CREATE_PRIVATE in `flags` the file
+     * will be made readable only to the current user, to the level
+     * that is supported on the target filesystem.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled
+     * by triggering the cancellable object from another thread. If the
+     * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+     * returned.
+     *
+     * If a file or directory with this name already exists the
+     * %G_IO_ERROR_EXISTS error will be returned. Some file systems don't
+     * allow all file names, and may return an %G_IO_ERROR_INVALID_FILENAME
+     * error, and if the name is to long %G_IO_ERROR_FILENAME_TOO_LONG will
+     * be returned. Other errors are possible too, and depend on what kind
+     * of filesystem the file is on.
+     * @param flags - a set of #GFileCreateFlags
+     * @param cancellable - optional #GCancellable object,
+     */
     create(flags: FileCreateFlags, cancellable?: Cancellable | null): FileOutputStream;
+    /**
+     * Asynchronously creates a new file and returns an output stream
+     * for writing to it. The file must not already exist.
+     *
+     * For more details, see g_file_create() which is
+     * the synchronous version of this call.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_file_create_finish() to get the result
+     * of the operation.
+     * @param flags - a set of #GFileCreateFlags
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     createAsync(flags: FileCreateFlags, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an asynchronous file create operation started with
+     * g_file_create_async().
+     * @param res - a #GAsyncResult
+     */
     createFinish(res: AsyncResult): FileOutputStream;
+    /**
+     * Creates a new file and returns a stream for reading and
+     * writing to it. The file must not already exist.
+     *
+     * By default files created are generally readable by everyone,
+     * but if you pass %G_FILE_CREATE_PRIVATE in `flags` the file
+     * will be made readable only to the current user, to the level
+     * that is supported on the target filesystem.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled
+     * by triggering the cancellable object from another thread. If the
+     * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+     * returned.
+     *
+     * If a file or directory with this name already exists, the
+     * %G_IO_ERROR_EXISTS error will be returned. Some file systems don't
+     * allow all file names, and may return an %G_IO_ERROR_INVALID_FILENAME
+     * error, and if the name is too long, %G_IO_ERROR_FILENAME_TOO_LONG
+     * will be returned. Other errors are possible too, and depend on what
+     * kind of filesystem the file is on.
+     *
+     * Note that in many non-local file cases read and write streams are
+     * not supported, so make sure you really need to do read and write
+     * streaming, rather than just opening for reading or writing.
+     * @param flags - a set of #GFileCreateFlags
+     * @param cancellable - optional #GCancellable object,
+     */
     createReadwrite(flags: FileCreateFlags, cancellable?: Cancellable | null): FileIOStream;
+    /**
+     * Asynchronously creates a new file and returns a stream
+     * for reading and writing to it. The file must not already exist.
+     *
+     * For more details, see g_file_create_readwrite() which is
+     * the synchronous version of this call.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_file_create_readwrite_finish() to get
+     * the result of the operation.
+     * @param flags - a set of #GFileCreateFlags
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     createReadwriteAsync(flags: FileCreateFlags, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an asynchronous file create operation started with
+     * g_file_create_readwrite_async().
+     * @param res - a #GAsyncResult
+     */
     createReadwriteFinish(res: AsyncResult): FileIOStream;
+    /**
+     * Deletes a file. If the `file` is a directory, it will only be
+     * deleted if it is empty. This has the same semantics as g_unlink().
+     *
+     * If `file` doesn’t exist, %G_IO_ERROR_NOT_FOUND will be returned. This allows
+     * for deletion to be implemented avoiding
+     * [time-of-check to time-of-use races](https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use):
+     * |[
+     * g_autoptr(GError) local_error = NULL;
+     * if (!g_file_delete (my_file, my_cancellable, &local_error) &&
+     * !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+     * {
+     * // deletion failed for some reason other than the file not existing:
+     * // so report the error
+     * g_warning ("Failed to delete %s: %s",
+     * g_file_peek_path (my_file), local_error->message);
+     * }
+     * ]|
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param cancellable - optional #GCancellable object,
+     */
     delete(cancellable?: Cancellable | null): boolean;
+    /**
+     * Asynchronously delete a file. If the `file` is a directory, it will
+     * only be deleted if it is empty.  This has the same semantics as
+     * g_unlink().
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback to call
+     * @param userData - the data to pass to callback function
+     */
     deleteAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes deleting a file started with g_file_delete_async().
+     * @param result - a #GAsyncResult
+     */
     deleteFinish(result: AsyncResult): boolean;
+    /**
+     * Duplicates a #GFile handle. This operation does not duplicate
+     * the actual file or directory represented by the #GFile; see
+     * g_file_copy() if attempting to copy a file.
+     *
+     * g_file_dup() is useful when a second handle is needed to the same underlying
+     * file, for use in a separate thread (#GFile is not thread-safe). For use
+     * within the same thread, use g_object_ref() to increment the existing object’s
+     * reference count.
+     *
+     * This call does no blocking I/O.
+     */
     dup(): File;
+    /**
+     * Starts an asynchronous eject on a mountable.
+     * When this operation has completed, `callback` will be called with
+     * `user_user` data, and the operation can be finalized with
+     * g_file_eject_mountable_finish().
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param flags - flags affecting the operation
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     ejectMountable(flags: MountUnmountFlags, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an asynchronous eject operation started by
+     * g_file_eject_mountable().
+     * @param result - a #GAsyncResult
+     */
     ejectMountableFinish(result: AsyncResult): boolean;
+    /**
+     * Starts an asynchronous eject on a mountable.
+     * When this operation has completed, `callback` will be called with
+     * `user_user` data, and the operation can be finalized with
+     * g_file_eject_mountable_with_operation_finish().
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param flags - flags affecting the operation
+     * @param mountOperation - a #GMountOperation,
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     ejectMountableWithOperation(flags: MountUnmountFlags, mountOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an asynchronous eject operation started by
+     * g_file_eject_mountable_with_operation().
+     * @param result - a #GAsyncResult
+     */
     ejectMountableWithOperationFinish(result: AsyncResult): boolean;
+    /**
+     * Gets the requested information about the files in a directory.
+     * The result is a #GFileEnumerator object that will give out
+     * #GFileInfo objects for all the files in the directory.
+     *
+     * The `attributes` value is a string that specifies the file
+     * attributes that should be gathered. It is not an error if
+     * it's not possible to read a particular requested attribute
+     * from a file - it just won't be set. `attributes` should
+     * be a comma-separated list of attributes or attribute wildcards.
+     * The wildcard "*" means all attributes, and a wildcard like
+     * "standard::*" means all attributes in the standard namespace.
+     * An example attribute query be "standard::*,owner::user".
+     * The standard attributes are available as defines, like
+     * %G_FILE_ATTRIBUTE_STANDARD_NAME. %G_FILE_ATTRIBUTE_STANDARD_NAME should
+     * always be specified if you plan to call g_file_enumerator_get_child() or
+     * g_file_enumerator_iterate() on the returned enumerator.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled
+     * by triggering the cancellable object from another thread. If the
+     * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+     * returned.
+     *
+     * If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will
+     * be returned. If the file is not a directory, the %G_IO_ERROR_NOT_DIRECTORY
+     * error will be returned. Other errors are possible too.
+     * @param attributes - an attribute query string
+     * @param flags - a set of #GFileQueryInfoFlags
+     * @param cancellable - optional #GCancellable object,
+     */
     enumerateChildren(attributes: string, flags: FileQueryInfoFlags, cancellable?: Cancellable | null): FileEnumerator;
+    /**
+     * Asynchronously gets the requested information about the files
+     * in a directory. The result is a #GFileEnumerator object that will
+     * give out #GFileInfo objects for all the files in the directory.
+     *
+     * For more details, see g_file_enumerate_children() which is
+     * the synchronous version of this call.
+     *
+     * When the operation is finished, `callback` will be called. You can
+     * then call g_file_enumerate_children_finish() to get the result of
+     * the operation.
+     * @param attributes - an attribute query string
+     * @param flags - a set of #GFileQueryInfoFlags
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     enumerateChildrenAsync(attributes: string, flags: FileQueryInfoFlags, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an async enumerate children operation.
+     * See g_file_enumerate_children_async().
+     * @param res - a #GAsyncResult
+     */
     enumerateChildrenFinish(res: AsyncResult): FileEnumerator;
+    /**
+     * Checks if the two given #GFiles refer to the same file.
+     *
+     * Note that two #GFiles that differ can still refer to the same
+     * file on the filesystem due to various forms of filename
+     * aliasing.
+     *
+     * This call does no blocking I/O.
+     * @param file2 - the second #GFile
+     */
     equal(file2: File): boolean;
+    /**
+     * Gets a #GMount for the #GFile.
+     *
+     * #GMount is returned only for user interesting locations, see
+     * #GVolumeMonitor. If the #GFileIface for `file` does not have a #mount,
+     * `error` will be set to %G_IO_ERROR_NOT_FOUND and %NULL #will be returned.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param cancellable - optional #GCancellable object,
+     */
     findEnclosingMount(cancellable?: Cancellable | null): Mount;
+    /**
+     * Asynchronously gets the mount for the file.
+     *
+     * For more details, see g_file_find_enclosing_mount() which is
+     * the synchronous version of this call.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_file_find_enclosing_mount_finish() to
+     * get the result of the operation.
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     findEnclosingMountAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an asynchronous find mount request.
+     * See g_file_find_enclosing_mount_async().
+     * @param res - a #GAsyncResult
+     */
     findEnclosingMountFinish(res: AsyncResult): Mount;
+    /**
+     * Gets the base name (the last component of the path) for a given #GFile.
+     *
+     * If called for the top level of a system (such as the filesystem root
+     * or a uri like sftp://host/) it will return a single directory separator
+     * (and on Windows, possibly a drive letter).
+     *
+     * The base name is a byte string (not UTF-8). It has no defined encoding
+     * or rules other than it may not contain zero bytes.  If you want to use
+     * filenames in a user interface you should use the display name that you
+     * can get by requesting the %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME
+     * attribute with g_file_query_info().
+     *
+     * This call does no blocking I/O.
+     */
     getBasename(): string | null;
+    /**
+     * Gets a child of `file` with basename equal to @name.
+     *
+     * Note that the file with that specific name might not exist, but
+     * you can still have a #GFile that points to it. You can use this
+     * for instance to create that file.
+     *
+     * This call does no blocking I/O.
+     * @param name - string containing the child's basename
+     */
     getChild(name: string): File;
+    /**
+     * Gets the child of `file` for a given `display_name` (i.e. a UTF-8
+     * version of the name). If this function fails, it returns %NULL
+     * and `error` will be set. This is very useful when constructing a
+     * #GFile for a new file and the user entered the filename in the
+     * user interface, for instance when you select a directory and
+     * type a filename in the file selector.
+     *
+     * This call does no blocking I/O.
+     * @param displayName - string to a possible child
+     */
     getChildForDisplayName(displayName: string): File;
+    /**
+     * Gets the parent directory for the @file.
+     * If the `file` represents the root directory of the
+     * file system, then %NULL will be returned.
+     *
+     * This call does no blocking I/O.
+     */
     getParent(): File | null;
+    /**
+     * Gets the parse name of the @file.
+     * A parse name is a UTF-8 string that describes the
+     * file such that one can get the #GFile back using
+     * g_file_parse_name().
+     *
+     * This is generally used to show the #GFile as a nice
+     * full-pathname kind of string in a user interface,
+     * like in a location entry.
+     *
+     * For local files with names that can safely be converted
+     * to UTF-8 the pathname is used, otherwise the IRI is used
+     * (a form of URI that allows UTF-8 characters unescaped).
+     *
+     * This call does no blocking I/O.
+     */
     getParseName(): string;
+    /**
+     * Gets the local pathname for #GFile, if one exists. If non-%NULL, this is
+     * guaranteed to be an absolute, canonical path. It might contain symlinks.
+     *
+     * This call does no blocking I/O.
+     */
     getPath(): string | null;
+    /**
+     * Gets the path for `descendant` relative to @parent.
+     *
+     * This call does no blocking I/O.
+     * @param descendant - input #GFile
+     */
     getRelativePath(descendant: File): string | null;
+    /**
+     * Gets the URI for the @file.
+     *
+     * This call does no blocking I/O.
+     */
     getUri(): string;
+    /**
+     * Gets the URI scheme for a #GFile.
+     * RFC 3986 decodes the scheme as:
+     * |[
+     * URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
+     * ]|
+     * Common schemes include "file", "http", "ftp", etc.
+     *
+     * The scheme can be different from the one used to construct the #GFile,
+     * in that it might be replaced with one that is logically equivalent to the #GFile.
+     *
+     * This call does no blocking I/O.
+     */
     getUriScheme(): string | null;
+    /**
+     * Checks if `file` has a parent, and optionally, if it is @parent.
+     *
+     * If `parent` is %NULL then this function returns %TRUE if `file` has any
+     * parent at all.  If `parent` is non-%NULL then %TRUE is only returned
+     * if `file` is an immediate child of @parent.
+     * @param parent - the parent to check for, or %NULL
+     */
     hasParent(parent?: File | null): boolean;
+    /**
+     * Checks whether `file` has the prefix specified by @prefix.
+     *
+     * In other words, if the names of initial elements of @file's
+     * pathname match @prefix. Only full pathname elements are matched,
+     * so a path like /foo is not considered a prefix of /foobar, only
+     * of /foo/bar.
+     *
+     * A #GFile is not a prefix of itself. If you want to check for
+     * equality, use g_file_equal().
+     *
+     * This call does no I/O, as it works purely on names. As such it can
+     * sometimes return %FALSE even if `file` is inside a `prefix` (from a
+     * filesystem point of view), because the prefix of `file` is an alias
+     * of @prefix.
+     * @param prefix - input #GFile
+     */
     hasPrefix(prefix: File): boolean;
+    /**
+     * Checks to see if a #GFile has a given URI scheme.
+     *
+     * This call does no blocking I/O.
+     * @param uriScheme - a string containing a URI scheme
+     */
     hasUriScheme(uriScheme: string): boolean;
+    /**
+     * Creates a hash value for a #GFile.
+     *
+     * This call does no blocking I/O.
+     */
     hash(): number;
+    /**
+     * Checks to see if a file is native to the platform.
+     *
+     * A native file is one expressed in the platform-native filename format,
+     * e.g. "C:\Windows" or "/usr/bin/". This does not mean the file is local,
+     * as it might be on a locally mounted remote filesystem.
+     *
+     * On some systems non-native files may be available using the native
+     * filesystem via a userspace filesystem (FUSE), in these cases this call
+     * will return %FALSE, but g_file_get_path() will still return a native path.
+     *
+     * This call does no blocking I/O.
+     */
     isNative(): boolean;
+    /**
+     * Loads the contents of `file` and returns it as #GBytes.
+     *
+     * If `file` is a resource:// based URI, the resulting bytes will reference the
+     * embedded resource instead of a copy. Otherwise, this is equivalent to calling
+     * g_file_load_contents() and g_bytes_new_take().
+     *
+     * For resources, `etag_out` will be set to %NULL.
+     *
+     * The data contained in the resulting #GBytes is always zero-terminated, but
+     * this is not included in the #GBytes length. The resulting #GBytes should be
+     * freed with g_bytes_unref() when no longer in use.
+     * @param cancellable - a #GCancellable or %NULL
+     * @param etagOut - a location to place the current
+     */
     loadBytes(cancellable?: Cancellable | null, etagOut?: Ref<string> | null): GLib.Bytes;
+    /**
+     * Asynchronously loads the contents of `file` as #GBytes.
+     *
+     * If `file` is a resource:// based URI, the resulting bytes will reference the
+     * embedded resource instead of a copy. Otherwise, this is equivalent to calling
+     * g_file_load_contents_async() and g_bytes_new_take().
+     *
+     * `callback` should call g_file_load_bytes_finish() to get the result of this
+     * asynchronous operation.
+     *
+     * See g_file_load_bytes() for more information.
+     * @param cancellable - a #GCancellable or %NULL
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     loadBytesAsync(cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Completes an asynchronous request to g_file_load_bytes_async().
+     *
+     * For resources, `etag_out` will be set to %NULL.
+     *
+     * The data contained in the resulting #GBytes is always zero-terminated, but
+     * this is not included in the #GBytes length. The resulting #GBytes should be
+     * freed with g_bytes_unref() when no longer in use.
+     *
+     * See g_file_load_bytes() for more information.
+     * @param result - a #GAsyncResult provided to the callback
+     * @param etagOut - a location to place the current
+     */
     loadBytesFinish(result: AsyncResult, etagOut?: Ref<string> | null): GLib.Bytes;
+    /**
+     * Loads the content of the file into memory. The data is always
+     * zero-terminated, but this is not included in the resultant @length.
+     * The returned `contents` should be freed with g_free() when no longer
+     * needed.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore
+     * @param contents - a location to place the contents of the file
+     * @param length - a location to place the length of the contents of the file,
+     * @param etagOut - a location to place the current entity tag for the file,
+     */
     loadContents(contents: Ref<number[]>, cancellable?: Cancellable | null, length?: Ref<number> | null, etagOut?: Ref<string> | null): boolean;
+    /**
+     * Starts an asynchronous load of the @file's contents.
+     *
+     * For more details, see g_file_load_contents() which is
+     * the synchronous version of this call.
+     *
+     * When the load operation has completed, `callback` will be called
+     * with `user` data. To finish the operation, call
+     * g_file_load_contents_finish() with the #GAsyncResult returned by
+     * the @callback.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore
+     * @param callback - a #GAsyncReadyCallback to call when the request is satisfied
+     * @param userData - the data to pass to callback function
+     */
     loadContentsAsync(cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an asynchronous load of the @file's contents.
+     * The contents are placed in @contents, and `length` is set to the
+     * size of the `contents` string. The `contents` should be freed with
+     * g_free() when no longer needed. If `etag_out` is present, it will be
+     * set to the new entity tag for the @file.
+     * @param res - a #GAsyncResult
+     * @param contents - a location to place the contents of the file
+     * @param length - a location to place the length of the contents of the file,
+     * @param etagOut - a location to place the current entity tag for the file,
+     */
     loadContentsFinish(res: AsyncResult, contents: Ref<number[]>, length?: Ref<number> | null, etagOut?: Ref<string> | null): boolean;
+    /**
+     * Finishes an asynchronous partial load operation that was started
+     * with g_file_load_partial_contents_async(). The data is always
+     * zero-terminated, but this is not included in the resultant @length.
+     * The returned `contents` should be freed with g_free() when no longer
+     * needed.
+     * @param res - a #GAsyncResult
+     * @param contents - a location to place the contents of the file
+     * @param length - a location to place the length of the contents of the file,
+     * @param etagOut - a location to place the current entity tag for the file,
+     */
     loadPartialContentsFinish(res: AsyncResult, contents: Ref<number[]>, length?: Ref<number> | null, etagOut?: Ref<string> | null): boolean;
+    /**
+     * Creates a directory.
+     *
+     * Note that this will only create a child directory
+     * of the immediate parent directory of the path or URI given by the #GFile.
+     * To recursively create directories, see g_file_make_directory_with_parents().
+     *
+     * This function will fail if the parent directory does not exist, setting
+     * `error` to %G_IO_ERROR_NOT_FOUND. If the file system doesn't support
+     * creating directories, this function will fail, setting `error` to
+     * %G_IO_ERROR_NOT_SUPPORTED. If the directory already exists,
+     * [error@Gio.IOErrorEnum.EXISTS] will be returned.
+     *
+     * For a local #GFile the newly created directory will have the default
+     * (current) ownership and permissions of the current process.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param cancellable - optional #GCancellable object,
+     */
     makeDirectory(cancellable?: Cancellable | null): boolean;
+    /**
+     * Asynchronously creates a directory.
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback to call
+     * @param userData - the data to pass to callback function
+     */
     makeDirectoryAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an asynchronous directory creation, started with
+     * g_file_make_directory_async().
+     * @param result - a #GAsyncResult
+     */
     makeDirectoryFinish(result: AsyncResult): boolean;
+    /**
+     * Creates a directory and any parent directories that may not
+     * exist similar to 'mkdir -p'. If the file system does not support
+     * creating directories, this function will fail, setting `error` to
+     * %G_IO_ERROR_NOT_SUPPORTED. If the directory itself already exists,
+     * this function will fail setting `error` to %G_IO_ERROR_EXISTS, unlike
+     * the similar g_mkdir_with_parents().
+     *
+     * For a local #GFile the newly created directories will have the default
+     * (current) ownership and permissions of the current process.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param cancellable - optional #GCancellable object,
+     */
     makeDirectoryWithParents(cancellable?: Cancellable | null): boolean;
+    /**
+     * Creates a symbolic link named `file` which contains the string
+     * @symlink_value.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param symlinkValue - a string with the path for the target
+     * @param cancellable - optional #GCancellable object,
+     */
     makeSymbolicLink(symlinkValue: string, cancellable?: Cancellable | null): boolean;
+    /**
+     * Asynchronously creates a symbolic link named `file` which contains the
+     * string @symlink_value.
+     * @param symlinkValue - a string with the path for the target
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback to call
+     * @param userData - the data to pass to callback function
+     */
     makeSymbolicLinkAsync(symlinkValue: string, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an asynchronous symbolic link creation, started with
+     * g_file_make_symbolic_link_async().
+     * @param result - a #GAsyncResult
+     */
     makeSymbolicLinkFinish(result: AsyncResult): boolean;
+    /**
+     * Recursively measures the disk usage of @file.
+     *
+     * This is essentially an analog of the 'du' command, but it also
+     * reports the number of directories and non-directory files encountered
+     * (including things like symbolic links).
+     *
+     * By default, errors are only reported against the toplevel file
+     * itself.  Errors found while recursing are silently ignored, unless
+     * %G_FILE_MEASURE_REPORT_ANY_ERROR is given in @flags.
+     *
+     * The returned size, @disk_usage, is in bytes and should be formatted
+     * with g_format_size() in order to get something reasonable for showing
+     * in a user interface.
+     *
+     * `progress_callback` and `progress_data` can be given to request
+     * periodic progress updates while scanning.  See the documentation for
+     * #GFileMeasureProgressCallback for information about when and how the
+     * callback will be invoked.
+     * @param flags - #GFileMeasureFlags
+     * @param cancellable - optional #GCancellable
+     * @param progressCallback - a #GFileMeasureProgressCallback
+     * @param progressData - user_data for @progress_callback
+     * @param diskUsage - the number of bytes of disk space used
+     * @param numDirs - the number of directories encountered
+     * @param numFiles - the number of non-directories encountered
+     */
     measureDiskUsage(flags: FileMeasureFlags, cancellable?: Cancellable | null, progressCallback?: (...args: unknown[]) => unknown | null, progressData?: number | null, diskUsage?: Ref<number> | null, numDirs?: Ref<number> | null, numFiles?: Ref<number> | null): boolean;
+    /**
+     * Collects the results from an earlier call to
+     * g_file_measure_disk_usage_async().  See g_file_measure_disk_usage() for
+     * more information.
+     * @param result - the #GAsyncResult passed to your #GAsyncReadyCallback
+     * @param diskUsage - the number of bytes of disk space used
+     * @param numDirs - the number of directories encountered
+     * @param numFiles - the number of non-directories encountered
+     */
     measureDiskUsageFinish(result: AsyncResult, diskUsage?: Ref<number> | null, numDirs?: Ref<number> | null, numFiles?: Ref<number> | null): boolean;
+    /**
+     * Obtains a file or directory monitor for the given file,
+     * depending on the type of the file.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param flags - a set of #GFileMonitorFlags
+     * @param cancellable - optional #GCancellable object,
+     */
     monitor(flags: FileMonitorFlags, cancellable?: Cancellable | null): FileMonitor;
+    /**
+     * Obtains a directory monitor for the given file.
+     * This may fail if directory monitoring is not supported.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     *
+     * It does not make sense for `flags` to contain
+     * %G_FILE_MONITOR_WATCH_HARD_LINKS, since hard links can not be made to
+     * directories.  It is not possible to monitor all the files in a
+     * directory for changes made via hard links; if you want to do this then
+     * you must register individual watches with g_file_monitor().
+     * @param flags - a set of #GFileMonitorFlags
+     * @param cancellable - optional #GCancellable object,
+     */
     monitorDirectory(flags: FileMonitorFlags, cancellable?: Cancellable | null): FileMonitor;
+    /**
+     * Obtains a file monitor for the given file. If no file notification
+     * mechanism exists, then regular polling of the file is used.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     *
+     * If `flags` contains %G_FILE_MONITOR_WATCH_HARD_LINKS then the monitor
+     * will also attempt to report changes made to the file via another
+     * filename (ie, a hard link). Without this flag, you can only rely on
+     * changes made through the filename contained in `file` to be
+     * reported. Using this flag may result in an increase in resource
+     * usage, and may not have any effect depending on the #GFileMonitor
+     * backend and/or filesystem type.
+     * @param flags - a set of #GFileMonitorFlags
+     * @param cancellable - optional #GCancellable object,
+     */
     monitorFile(flags: FileMonitorFlags, cancellable?: Cancellable | null): FileMonitor;
+    /**
+     * Starts a @mount_operation, mounting the volume that contains
+     * the file @location.
+     *
+     * When this operation has completed, `callback` will be called with
+     * `user_user` data, and the operation can be finalized with
+     * g_file_mount_enclosing_volume_finish().
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param flags - flags affecting the operation
+     * @param mountOperation - a #GMountOperation
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback to call
+     * @param userData - the data to pass to callback function
+     */
     mountEnclosingVolume(flags: MountMountFlags, mountOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes a mount operation started by g_file_mount_enclosing_volume().
+     * @param result - a #GAsyncResult
+     */
     mountEnclosingVolumeFinish(result: AsyncResult): boolean;
+    /**
+     * Mounts a file of type G_FILE_TYPE_MOUNTABLE.
+     * Using @mount_operation, you can request callbacks when, for instance,
+     * passwords are needed during authentication.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_file_mount_mountable_finish() to get
+     * the result of the operation.
+     * @param flags - flags affecting the operation
+     * @param mountOperation - a #GMountOperation,
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     mountMountable(flags: MountMountFlags, mountOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes a mount operation. See g_file_mount_mountable() for details.
+     *
+     * Finish an asynchronous mount operation that was started
+     * with g_file_mount_mountable().
+     * @param result - a #GAsyncResult
+     */
     mountMountableFinish(result: AsyncResult): File;
+    /**
+     * Tries to move the file or directory `source` to the location specified
+     * by @destination. If native move operations are supported then this is
+     * used, otherwise a copy + delete fallback is used. The native
+     * implementation may support moving directories (for instance on moves
+     * inside the same filesystem), but the fallback code does not.
+     *
+     * If the flag %G_FILE_COPY_OVERWRITE is specified an already
+     * existing `destination` file is overwritten.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     *
+     * If `progress_callback` is not %NULL, then the operation can be monitored
+     * by setting this to a #GFileProgressCallback function.
+     * `progress_callback_data` will be passed to this function. It is
+     * guaranteed that this callback will be called after all data has been
+     * transferred with the total number of bytes copied during the operation.
+     *
+     * If the `source` file does not exist, then the %G_IO_ERROR_NOT_FOUND
+     * error is returned, independent on the status of the @destination.
+     *
+     * If %G_FILE_COPY_OVERWRITE is not specified and the target exists,
+     * then the error %G_IO_ERROR_EXISTS is returned.
+     *
+     * If trying to overwrite a file over a directory, the %G_IO_ERROR_IS_DIRECTORY
+     * error is returned. If trying to overwrite a directory with a directory the
+     * %G_IO_ERROR_WOULD_MERGE error is returned.
+     *
+     * If the source is a directory and the target does not exist, or
+     * %G_FILE_COPY_OVERWRITE is specified and the target is a file, then
+     * the %G_IO_ERROR_WOULD_RECURSE error may be returned (if the native
+     * move operation isn't available).
+     * @param destination - #GFile pointing to the destination location
+     * @param flags - set of #GFileCopyFlags
+     * @param cancellable - optional #GCancellable object,
+     * @param progressCallback - #GFileProgressCallback
+     * @param progressCallbackData - gpointer to user data for
+     */
     move(destination: File, flags: FileCopyFlags, cancellable?: Cancellable | null, progressCallback?: (...args: unknown[]) => unknown | null, progressCallbackData?: number | null): boolean;
+    /**
+     * Asynchronously moves a file `source` to the location of @destination. For details of the behaviour, see g_file_move().
+     *
+     * If `progress_callback` is not %NULL, then that function that will be called
+     * just like in g_file_move(). The callback will run in the default main context
+     * of the thread calling g_file_move_async() — the same context as `callback` is
+     * run in.
+     *
+     * When the operation is finished, `callback` will be called. You can then call
+     * g_file_move_finish() to get the result of the operation.
+     * @param destination - #GFile pointing to the destination location
+     * @param flags - set of #GFileCopyFlags
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object,
+     * @param progressCallback - #GFileProgressCallback function for updates
+     * @param progressCallbackData - gpointer to user data for the callback function
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     moveAsync(destination: File, flags: FileCopyFlags, ioPriority: number, cancellable?: Cancellable | null, progressCallback?: (...args: unknown[]) => unknown | null, progressCallbackData?: number | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Version of [method@Gio.File.move_async] using closures instead of callbacks for
+     * easier binding in other languages.
+     * @param destination - destination [type@Gio.File]
+     * @param flags - set of [flags@Gio.FileCopyFlags]
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional [class@Gio.Cancellable] object,
+     * @param progressCallbackClosure - [type@GObject.Closure] to invoke with progress
+     * @param readyCallbackClosure - [type@GObject.Closure] to invoke when the request is satisfied
+     */
     moveAsyncWithClosures(destination: File, flags: FileCopyFlags, ioPriority: number, readyCallbackClosure: GObject.Closure, cancellable?: Cancellable | null, progressCallbackClosure?: GObject.Closure | null): void;
+    /**
+     * Finishes an asynchronous file movement, started with
+     * g_file_move_async().
+     * @param result - a #GAsyncResult
+     */
     moveFinish(result: AsyncResult): boolean;
+    /**
+     * Opens an existing file for reading and writing. The result is
+     * a #GFileIOStream that can be used to read and write the contents
+     * of the file.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled
+     * by triggering the cancellable object from another thread. If the
+     * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+     * returned.
+     *
+     * If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will
+     * be returned. If the file is a directory, the %G_IO_ERROR_IS_DIRECTORY
+     * error will be returned. Other errors are possible too, and depend on
+     * what kind of filesystem the file is on. Note that in many non-local
+     * file cases read and write streams are not supported, so make sure you
+     * really need to do read and write streaming, rather than just opening
+     * for reading or writing.
+     * @param cancellable - a #GCancellable
+     */
     openReadwrite(cancellable?: Cancellable | null): FileIOStream;
+    /**
+     * Asynchronously opens `file` for reading and writing.
+     *
+     * For more details, see g_file_open_readwrite() which is
+     * the synchronous version of this call.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_file_open_readwrite_finish() to get
+     * the result of the operation.
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     openReadwriteAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an asynchronous file read operation started with
+     * g_file_open_readwrite_async().
+     * @param res - a #GAsyncResult
+     */
     openReadwriteFinish(res: AsyncResult): FileIOStream;
+    /**
+     * Exactly like g_file_get_path(), but caches the result via
+     * g_object_set_qdata_full().  This is useful for example in C
+     * applications which mix `g_file_*` APIs with native ones.  It
+     * also avoids an extra duplicated string when possible, so will be
+     * generally more efficient.
+     *
+     * This call does no blocking I/O.
+     */
     peekPath(): string | null;
+    /**
+     * Polls a file of type %G_FILE_TYPE_MOUNTABLE.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_file_mount_mountable_finish() to get
+     * the result of the operation.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore
+     * @param callback - a #GAsyncReadyCallback to call
+     * @param userData - the data to pass to callback function
+     */
     pollMountable(cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes a poll operation. See g_file_poll_mountable() for details.
+     *
+     * Finish an asynchronous poll operation that was polled
+     * with g_file_poll_mountable().
+     * @param result - a #GAsyncResult
+     */
     pollMountableFinish(result: AsyncResult): boolean;
+    /**
+     * Returns the #GAppInfo that is registered as the default
+     * application to handle the file specified by @file.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore
+     */
     queryDefaultHandler(cancellable?: Cancellable | null): AppInfo;
+    /**
+     * Async version of g_file_query_default_handler().
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object, %NULL to ignore
+     * @param callback - a #GAsyncReadyCallback to call when the request is done
+     * @param userData - data to pass to @callback
+     */
     queryDefaultHandlerAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes a g_file_query_default_handler_async() operation.
+     * @param result - a #GAsyncResult
+     */
     queryDefaultHandlerFinish(result: AsyncResult): AppInfo;
+    /**
+     * Utility function to check if a particular file exists.
+     *
+     * The fallback implementation of this API is using [method@Gio.File.query_info]
+     * and therefore may do blocking I/O. To asynchronously query the existence
+     * of a file, use [method@Gio.File.query_info_async].
+     *
+     * Note that in many cases it is [racy to first check for file existence](https://en.wikipedia.org/wiki/Time_of_check_to_time_of_use)
+     * and then execute something based on the outcome of that, because the
+     * file might have been created or removed in between the operations. The
+     * general approach to handling that is to not check, but just do the
+     * operation and handle the errors as they come.
+     *
+     * As an example of race-free checking, take the case of reading a file,
+     * and if it doesn't exist, creating it. There are two racy versions: read
+     * it, and on error create it; and: check if it exists, if not create it.
+     * These can both result in two processes creating the file (with perhaps
+     * a partially written file as the result). The correct approach is to
+     * always try to create the file with g_file_create() which will either
+     * atomically create the file or fail with a %G_IO_ERROR_EXISTS error.
+     *
+     * However, in many cases an existence check is useful in a user interface,
+     * for instance to make a menu item sensitive/insensitive, so that you don't
+     * have to fool users that something is possible and then just show an error
+     * dialog. If you do this, you should make sure to also handle the errors
+     * that can happen due to races when you execute the operation.
+     * @param cancellable - optional #GCancellable object,
+     */
     queryExists(cancellable?: Cancellable | null): boolean;
+    /**
+     * Utility function to inspect the #GFileType of a file. This is
+     * implemented using g_file_query_info() and as such does blocking I/O.
+     *
+     * The primary use case of this method is to check if a file is
+     * a regular file, directory, or symlink.
+     * @param flags - a set of #GFileQueryInfoFlags passed to g_file_query_info()
+     * @param cancellable - optional #GCancellable object,
+     */
     queryFileType(flags: FileQueryInfoFlags, cancellable?: Cancellable | null): FileType;
+    /**
+     * Similar to g_file_query_info(), but obtains information
+     * about the filesystem the `file` is on, rather than the file itself.
+     * For instance the amount of space available and the type of
+     * the filesystem.
+     *
+     * The `attributes` value is a string that specifies the attributes
+     * that should be gathered. It is not an error if it's not possible
+     * to read a particular requested attribute from a file - it just
+     * won't be set. `attributes` should be a comma-separated list of
+     * attributes or attribute wildcards. The wildcard "*" means all
+     * attributes, and a wildcard like "filesystem::*" means all attributes
+     * in the filesystem namespace. The standard namespace for filesystem
+     * attributes is "filesystem". Common attributes of interest are
+     * %G_FILE_ATTRIBUTE_FILESYSTEM_SIZE (the total size of the filesystem
+     * in bytes), %G_FILE_ATTRIBUTE_FILESYSTEM_FREE (number of bytes available),
+     * and %G_FILE_ATTRIBUTE_FILESYSTEM_TYPE (type of the filesystem).
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled
+     * by triggering the cancellable object from another thread. If the
+     * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+     * returned.
+     *
+     * If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will
+     * be returned. Other errors are possible too, and depend on what
+     * kind of filesystem the file is on.
+     * @param attributes - an attribute query string
+     * @param cancellable - optional #GCancellable object,
+     */
     queryFilesystemInfo(attributes: string, cancellable?: Cancellable | null): FileInfo;
+    /**
+     * Asynchronously gets the requested information about the filesystem
+     * that the specified `file` is on. The result is a #GFileInfo object
+     * that contains key-value attributes (such as type or size for the
+     * file).
+     *
+     * For more details, see g_file_query_filesystem_info() which is the
+     * synchronous version of this call.
+     *
+     * When the operation is finished, `callback` will be called. You can
+     * then call g_file_query_info_finish() to get the result of the
+     * operation.
+     * @param attributes - an attribute query string
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     queryFilesystemInfoAsync(attributes: string, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an asynchronous filesystem info query.
+     * See g_file_query_filesystem_info_async().
+     * @param res - a #GAsyncResult
+     */
     queryFilesystemInfoFinish(res: AsyncResult): FileInfo;
+    /**
+     * Gets the requested information about specified @file.
+     *
+     * The result is a [class@Gio.FileInfo] object that contains key-value
+     * attributes (such as the type or size of the file).
+     *
+     * The `attributes` value is a string that specifies the file
+     * attributes that should be gathered. It is not an error if
+     * it’s not possible to read a particular requested attribute
+     * from a file — it just won't be set. In particular this means that if a file
+     * is inaccessible (due to being in a folder with restrictive permissions), for
+     * example, you can expect the returned [class@Gio.FileInfo] to have very few
+     * attributes set. You should check whether an attribute is set using
+     * [method@Gio.FileInfo.has_attribute] before trying to retrieve its value.
+     *
+     * It is guaranteed that if any of the following attributes are listed in
+     * @attributes, they will always be set in the returned [class@Gio.FileInfo],
+     * even if the user doesn’t have permissions to access the file:
+     *
+     * - [const@Gio.FILE_ATTRIBUTE_STANDARD_NAME]
+     * - [const@Gio.FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME]
+     *
+     * `attributes` should be a comma-separated list of attributes or attribute
+     * wildcards. The wildcard `"*"` means all attributes, and a wildcard like
+     * `"standard::*"` means all attributes in the standard namespace.
+     * An example attribute query might be `"standard::*,owner::user"`.
+     * The standard attributes are available as defines, like
+     * [const@Gio.FILE_ATTRIBUTE_STANDARD_NAME].
+     *
+     * If `cancellable` is not `NULL`, then the operation can be cancelled
+     * by triggering the cancellable object from another thread. If the
+     * operation was cancelled, the error [error@Gio.IOErrorEnum.CANCELLED] will be
+     * returned.
+     *
+     * For symlinks, normally the information about the target of the
+     * symlink is returned, rather than information about the symlink
+     * itself. However if you pass [flags@Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS]
+     * in `flags` the information about the symlink itself will be returned.
+     * Also, for symlinks that point to non-existing files the information
+     * about the symlink itself will be returned.
+     *
+     * If the file does not exist, the [error@Gio.IOErrorEnum.NOT_FOUND] error will be
+     * returned. Other errors are possible too, and depend on what kind of
+     * file system the file is on.
+     * @param attributes - an attribute query string
+     * @param flags - flags to affect the query operation
+     * @param cancellable - optional cancellable object
+     */
     queryInfo(attributes: string, flags: FileQueryInfoFlags, cancellable?: Cancellable | null): FileInfo;
+    /**
+     * Asynchronously gets the requested information about specified @file.
+     * The result is a #GFileInfo object that contains key-value attributes
+     * (such as type or size for the file).
+     *
+     * For more details, see g_file_query_info() which is the synchronous
+     * version of this call.
+     *
+     * When the operation is finished, `callback` will be called. You can
+     * then call g_file_query_info_finish() to get the result of the operation.
+     * @param attributes - an attribute query string
+     * @param flags - a set of #GFileQueryInfoFlags
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     queryInfoAsync(attributes: string, flags: FileQueryInfoFlags, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an asynchronous file info query.
+     * See g_file_query_info_async().
+     * @param res - a #GAsyncResult
+     */
     queryInfoFinish(res: AsyncResult): FileInfo;
+    /**
+     * Obtain the list of settable attributes for the file.
+     *
+     * Returns the type and full attribute name of all the attributes
+     * that can be set on this file. This doesn't mean setting it will
+     * always succeed though, you might get an access failure, or some
+     * specific file may not support a specific attribute.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param cancellable - optional #GCancellable object,
+     */
     querySettableAttributes(cancellable?: Cancellable | null): FileAttributeInfoList;
+    /**
+     * Obtain the list of attribute namespaces where new attributes
+     * can be created by a user. An example of this is extended
+     * attributes (in the "xattr" namespace).
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param cancellable - optional #GCancellable object,
+     */
     queryWritableNamespaces(cancellable?: Cancellable | null): FileAttributeInfoList;
+    /**
+     * Opens a file for reading. The result is a #GFileInputStream that
+     * can be used to read the contents of the file.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     *
+     * If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will be
+     * returned. If the file is a directory, the %G_IO_ERROR_IS_DIRECTORY
+     * error will be returned. Other errors are possible too, and depend
+     * on what kind of filesystem the file is on.
+     * @param cancellable - a #GCancellable
+     */
     read(cancellable?: Cancellable | null): FileInputStream;
+    /**
+     * Asynchronously opens `file` for reading.
+     *
+     * For more details, see g_file_read() which is
+     * the synchronous version of this call.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_file_read_finish() to get the result
+     * of the operation.
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     readAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an asynchronous file read operation started with
+     * g_file_read_async().
+     * @param res - a #GAsyncResult
+     */
     readFinish(res: AsyncResult): FileInputStream;
+    /**
+     * Returns an output stream for overwriting the file, possibly
+     * creating a backup copy of the file first. If the file doesn't exist,
+     * it will be created.
+     *
+     * This will try to replace the file in the safest way possible so
+     * that any errors during the writing will not affect an already
+     * existing copy of the file. For instance, for local files it
+     * may write to a temporary file and then atomically rename over
+     * the destination when the stream is closed.
+     *
+     * By default files created are generally readable by everyone,
+     * but if you pass %G_FILE_CREATE_PRIVATE in `flags` the file
+     * will be made readable only to the current user, to the level that
+     * is supported on the target filesystem.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled
+     * by triggering the cancellable object from another thread. If the
+     * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+     * returned.
+     *
+     * If you pass in a non-%NULL `etag` value and `file` already exists, then
+     * this value is compared to the current entity tag of the file, and if
+     * they differ an %G_IO_ERROR_WRONG_ETAG error is returned. This
+     * generally means that the file has been changed since you last read
+     * it. You can get the new etag from g_file_output_stream_get_etag()
+     * after you've finished writing and closed the #GFileOutputStream. When
+     * you load a new file you can use g_file_input_stream_query_info() to
+     * get the etag of the file.
+     *
+     * If `make_backup` is %TRUE, this function will attempt to make a
+     * backup of the current file before overwriting it. If this fails
+     * a %G_IO_ERROR_CANT_CREATE_BACKUP error will be returned. If you
+     * want to replace anyway, try again with `make_backup` set to %FALSE.
+     *
+     * If the file is a directory the %G_IO_ERROR_IS_DIRECTORY error will
+     * be returned, and if the file is some other form of non-regular file
+     * then a %G_IO_ERROR_NOT_REGULAR_FILE error will be returned. Some
+     * file systems don't allow all file names, and may return an
+     * %G_IO_ERROR_INVALID_FILENAME error, and if the name is to long
+     * %G_IO_ERROR_FILENAME_TOO_LONG will be returned. Other errors are
+     * possible too, and depend on what kind of filesystem the file is on.
+     * @param etag - an optional [entity tag](#entity-tags)
+     * @param makeBackup - %TRUE if a backup should be created
+     * @param flags - a set of #GFileCreateFlags
+     * @param cancellable - optional #GCancellable object,
+     */
     replace(makeBackup: boolean, flags: FileCreateFlags, etag?: string | null, cancellable?: Cancellable | null): FileOutputStream;
+    /**
+     * Asynchronously overwrites the file, replacing the contents,
+     * possibly creating a backup copy of the file first.
+     *
+     * For more details, see g_file_replace() which is
+     * the synchronous version of this call.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_file_replace_finish() to get the result
+     * of the operation.
+     * @param etag - an [entity tag](#entity-tags) for the current #GFile,
+     * @param makeBackup - %TRUE if a backup should be created
+     * @param flags - a set of #GFileCreateFlags
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     replaceAsync(makeBackup: boolean, flags: FileCreateFlags, ioPriority: number, etag?: string | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Replaces the contents of `file` with `contents` of `length` bytes.
+     *
+     * If `etag` is specified (not %NULL), any existing file must have that etag,
+     * or the error %G_IO_ERROR_WRONG_ETAG will be returned.
+     *
+     * If `make_backup` is %TRUE, this function will attempt to make a backup
+     * of @file. Internally, it uses g_file_replace(), so will try to replace the
+     * file contents in the safest way possible. For example, atomic renames are
+     * used when replacing local files’ contents.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     *
+     * The returned `new_etag` can be used to verify that the file hasn't
+     * changed the next time it is saved over.
+     * @param contents - a string containing the new contents for @file
+     * @param length - the length of `contents` in bytes
+     * @param etag - the old [entity-tag](#entity-tags) for the document,
+     * @param makeBackup - %TRUE if a backup should be created
+     * @param flags - a set of #GFileCreateFlags
+     * @param newEtag - a location to a new [entity tag](#entity-tags)
+     * @param cancellable - optional #GCancellable object, %NULL to ignore
+     */
     replaceContents(contents: number[], length: number, makeBackup: boolean, flags: FileCreateFlags, etag?: string | null, newEtag?: Ref<string> | null, cancellable?: Cancellable | null): boolean;
+    /**
+     * Starts an asynchronous replacement of `file` with the given
+     * `contents` of `length` bytes. `etag` will replace the document's
+     * current entity tag.
+     *
+     * When this operation has completed, `callback` will be called with
+     * `user_user` data, and the operation can be finalized with
+     * g_file_replace_contents_finish().
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     *
+     * If `make_backup` is %TRUE, this function will attempt to
+     * make a backup of @file.
+     *
+     * Note that no copy of `contents` will be made, so it must stay valid
+     * until `callback` is called. See g_file_replace_contents_bytes_async()
+     * for a #GBytes version that will automatically hold a reference to the
+     * contents (without copying) for the duration of the call.
+     * @param contents - string of contents to replace the file with
+     * @param length - the length of `contents` in bytes
+     * @param etag - a new [entity tag](#entity-tags) for the @file, or %NULL
+     * @param makeBackup - %TRUE if a backup should be created
+     * @param flags - a set of #GFileCreateFlags
+     * @param cancellable - optional #GCancellable object, %NULL to ignore
+     * @param callback - a #GAsyncReadyCallback to call when the request is satisfied
+     * @param userData - the data to pass to callback function
+     */
     replaceContentsAsync(contents: number[], length: number, makeBackup: boolean, flags: FileCreateFlags, etag?: string | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Same as g_file_replace_contents_async() but takes a #GBytes input instead.
+     * This function will keep a ref on `contents` until the operation is done.
+     * Unlike g_file_replace_contents_async() this allows forgetting about the
+     * content without waiting for the callback.
+     *
+     * When this operation has completed, `callback` will be called with
+     * `user_user` data, and the operation can be finalized with
+     * g_file_replace_contents_finish().
+     * @param contents - a #GBytes
+     * @param etag - a new [entity tag](#entity-tags) for the @file, or %NULL
+     * @param makeBackup - %TRUE if a backup should be created
+     * @param flags - a set of #GFileCreateFlags
+     * @param cancellable - optional #GCancellable object, %NULL to ignore
+     * @param callback - a #GAsyncReadyCallback to call when the request is satisfied
+     * @param userData - the data to pass to callback function
+     */
     replaceContentsBytesAsync(contents: GLib.Bytes, makeBackup: boolean, flags: FileCreateFlags, etag?: string | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an asynchronous replace of the given @file. See
+     * g_file_replace_contents_async(). Sets `new_etag` to the new entity
+     * tag for the document, if present.
+     * @param res - a #GAsyncResult
+     * @param newEtag - a location of a new [entity tag](#entity-tags)
+     */
     replaceContentsFinish(res: AsyncResult, newEtag?: Ref<string> | null): boolean;
+    /**
+     * Finishes an asynchronous file replace operation started with
+     * g_file_replace_async().
+     * @param res - a #GAsyncResult
+     */
     replaceFinish(res: AsyncResult): FileOutputStream;
+    /**
+     * Returns an output stream for overwriting the file in readwrite mode,
+     * possibly creating a backup copy of the file first. If the file doesn't
+     * exist, it will be created.
+     *
+     * For details about the behaviour, see g_file_replace() which does the
+     * same thing but returns an output stream only.
+     *
+     * Note that in many non-local file cases read and write streams are not
+     * supported, so make sure you really need to do read and write streaming,
+     * rather than just opening for reading or writing.
+     * @param etag - an optional [entity tag](#entity-tags)
+     * @param makeBackup - %TRUE if a backup should be created
+     * @param flags - a set of #GFileCreateFlags
+     * @param cancellable - optional #GCancellable object,
+     */
     replaceReadwrite(makeBackup: boolean, flags: FileCreateFlags, etag?: string | null, cancellable?: Cancellable | null): FileIOStream;
+    /**
+     * Asynchronously overwrites the file in read-write mode,
+     * replacing the contents, possibly creating a backup copy
+     * of the file first.
+     *
+     * For more details, see g_file_replace_readwrite() which is
+     * the synchronous version of this call.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_file_replace_readwrite_finish() to get
+     * the result of the operation.
+     * @param etag - an [entity tag](#entity-tags) for the current #GFile,
+     * @param makeBackup - %TRUE if a backup should be created
+     * @param flags - a set of #GFileCreateFlags
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     replaceReadwriteAsync(makeBackup: boolean, flags: FileCreateFlags, ioPriority: number, etag?: string | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an asynchronous file replace operation started with
+     * g_file_replace_readwrite_async().
+     * @param res - a #GAsyncResult
+     */
     replaceReadwriteFinish(res: AsyncResult): FileIOStream;
+    /**
+     * Resolves a relative path for `file` to an absolute path.
+     *
+     * This call does no blocking I/O.
+     *
+     * If the `relative_path` is an absolute path name, the resolution
+     * is done absolutely (without taking `file` path as base).
+     * @param relativePath - a given relative path string
+     */
     resolveRelativePath(relativePath: string): File;
+    /**
+     * Sets an attribute in the file with attribute name `attribute` to @value_p.
+     *
+     * Some attributes can be unset by setting `type` to
+     * %G_FILE_ATTRIBUTE_TYPE_INVALID and `value_p` to %NULL.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param attribute - a string containing the attribute's name
+     * @param type - The type of the attribute
+     * @param valueP - a pointer to the value (or the pointer
+     * @param flags - a set of #GFileQueryInfoFlags
+     * @param cancellable - optional #GCancellable object,
+     */
     setAttribute(attribute: string, type: FileAttributeType, flags: FileQueryInfoFlags, valueP?: number | null, cancellable?: Cancellable | null): boolean;
+    /**
+     * Sets `attribute` of type %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING to @value.
+     * If `attribute` is of a different type, this operation will fail,
+     * returning %FALSE.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param attribute - a string containing the attribute's name
+     * @param value - a string containing the attribute's new value
+     * @param flags - a #GFileQueryInfoFlags
+     * @param cancellable - optional #GCancellable object,
+     */
     setAttributeByteString(attribute: string, value: string, flags: FileQueryInfoFlags, cancellable?: Cancellable | null): boolean;
+    /**
+     * Sets `attribute` of type %G_FILE_ATTRIBUTE_TYPE_INT32 to @value.
+     * If `attribute` is of a different type, this operation will fail.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param attribute - a string containing the attribute's name
+     * @param value - a #gint32 containing the attribute's new value
+     * @param flags - a #GFileQueryInfoFlags
+     * @param cancellable - optional #GCancellable object,
+     */
     setAttributeInt32(attribute: string, value: number, flags: FileQueryInfoFlags, cancellable?: Cancellable | null): boolean;
+    /**
+     * Sets `attribute` of type %G_FILE_ATTRIBUTE_TYPE_INT64 to @value.
+     * If `attribute` is of a different type, this operation will fail.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param attribute - a string containing the attribute's name
+     * @param value - a #guint64 containing the attribute's new value
+     * @param flags - a #GFileQueryInfoFlags
+     * @param cancellable - optional #GCancellable object,
+     */
     setAttributeInt64(attribute: string, value: number, flags: FileQueryInfoFlags, cancellable?: Cancellable | null): boolean;
+    /**
+     * Sets `attribute` of type %G_FILE_ATTRIBUTE_TYPE_STRING to @value.
+     * If `attribute` is of a different type, this operation will fail.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param attribute - a string containing the attribute's name
+     * @param value - a string containing the attribute's value
+     * @param flags - #GFileQueryInfoFlags
+     * @param cancellable - optional #GCancellable object,
+     */
     setAttributeString(attribute: string, value: string, flags: FileQueryInfoFlags, cancellable?: Cancellable | null): boolean;
+    /**
+     * Sets `attribute` of type %G_FILE_ATTRIBUTE_TYPE_UINT32 to @value.
+     * If `attribute` is of a different type, this operation will fail.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param attribute - a string containing the attribute's name
+     * @param value - a #guint32 containing the attribute's new value
+     * @param flags - a #GFileQueryInfoFlags
+     * @param cancellable - optional #GCancellable object,
+     */
     setAttributeUint32(attribute: string, value: number, flags: FileQueryInfoFlags, cancellable?: Cancellable | null): boolean;
+    /**
+     * Sets `attribute` of type %G_FILE_ATTRIBUTE_TYPE_UINT64 to @value.
+     * If `attribute` is of a different type, this operation will fail.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param attribute - a string containing the attribute's name
+     * @param value - a #guint64 containing the attribute's new value
+     * @param flags - a #GFileQueryInfoFlags
+     * @param cancellable - optional #GCancellable object,
+     */
     setAttributeUint64(attribute: string, value: number, flags: FileQueryInfoFlags, cancellable?: Cancellable | null): boolean;
+    /**
+     * Asynchronously sets the attributes of `file` with @info.
+     *
+     * For more details, see g_file_set_attributes_from_info(),
+     * which is the synchronous version of this call.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_file_set_attributes_finish() to get
+     * the result of the operation.
+     * @param info - a #GFileInfo
+     * @param flags - a #GFileQueryInfoFlags
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     setAttributesAsync(info: FileInfo, flags: FileQueryInfoFlags, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes setting an attribute started in g_file_set_attributes_async().
+     * @param result - a #GAsyncResult
+     * @param info - a #GFileInfo
+     */
     setAttributesFinish(result: AsyncResult, info: Ref<FileInfo>): boolean;
+    /**
+     * Tries to set all attributes in the #GFileInfo on the target
+     * values, not stopping on the first error.
+     *
+     * If there is any error during this operation then `error` will
+     * be set to the first error. Error on particular fields are flagged
+     * by setting the "status" field in the attribute value to
+     * %G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING, which means you can
+     * also detect further errors.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param info - a #GFileInfo
+     * @param flags - #GFileQueryInfoFlags
+     * @param cancellable - optional #GCancellable object,
+     */
     setAttributesFromInfo(info: FileInfo, flags: FileQueryInfoFlags, cancellable?: Cancellable | null): boolean;
+    /**
+     * Renames `file` to the specified display name.
+     *
+     * The display name is converted from UTF-8 to the correct encoding
+     * for the target filesystem if possible and the `file` is renamed to this.
+     *
+     * If you want to implement a rename operation in the user interface the
+     * edit name (%G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME) should be used as the
+     * initial value in the rename widget, and then the result after editing
+     * should be passed to g_file_set_display_name().
+     *
+     * On success the resulting converted filename is returned.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param displayName - a string
+     * @param cancellable - optional #GCancellable object,
+     */
     setDisplayName(displayName: string, cancellable?: Cancellable | null): File;
+    /**
+     * Asynchronously sets the display name for a given #GFile.
+     *
+     * For more details, see g_file_set_display_name() which is
+     * the synchronous version of this call.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_file_set_display_name_finish() to get
+     * the result of the operation.
+     * @param displayName - a string
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     setDisplayNameAsync(displayName: string, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes setting a display name started with
+     * g_file_set_display_name_async().
+     * @param res - a #GAsyncResult
+     */
     setDisplayNameFinish(res: AsyncResult): File;
+    /**
+     * Starts a file of type %G_FILE_TYPE_MOUNTABLE.
+     * Using @start_operation, you can request callbacks when, for instance,
+     * passwords are needed during authentication.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_file_mount_mountable_finish() to get
+     * the result of the operation.
+     * @param flags - flags affecting the operation
+     * @param startOperation - a #GMountOperation, or %NULL to avoid user interaction
+     * @param cancellable - optional #GCancellable object, %NULL to ignore
+     * @param callback - a #GAsyncReadyCallback to call when the request is satisfied, or %NULL
+     * @param userData - the data to pass to callback function
+     */
     startMountable(flags: DriveStartFlags, startOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes a start operation. See g_file_start_mountable() for details.
+     *
+     * Finish an asynchronous start operation that was started
+     * with g_file_start_mountable().
+     * @param result - a #GAsyncResult
+     */
     startMountableFinish(result: AsyncResult): boolean;
+    /**
+     * Stops a file of type %G_FILE_TYPE_MOUNTABLE.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_file_stop_mountable_finish() to get
+     * the result of the operation.
+     * @param flags - flags affecting the operation
+     * @param mountOperation - a #GMountOperation,
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback to call
+     * @param userData - the data to pass to callback function
+     */
     stopMountable(flags: MountUnmountFlags, mountOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes a stop operation, see g_file_stop_mountable() for details.
+     *
+     * Finish an asynchronous stop operation that was started
+     * with g_file_stop_mountable().
+     * @param result - a #GAsyncResult
+     */
     stopMountableFinish(result: AsyncResult): boolean;
+    /**
+     * Checks if `file` supports thread-default main contexts
+     * (see [method@GLib.MainContext.push_thread_default])
+     * If this returns %FALSE, you cannot perform asynchronous operations on
+     * `file` in a thread that has a thread-default context.
+     */
     supportsThreadContexts(): boolean;
+    /**
+     * Sends `file` to the "Trashcan", if possible. This is similar to
+     * deleting it, but the user can recover it before emptying the trashcan.
+     * Trashing is disabled for system mounts by default (see
+     * g_unix_mount_entry_is_system_internal()), so this call can return the
+     * %G_IO_ERROR_NOT_SUPPORTED error. Since GLib 2.66, the `x-gvfs-notrash` unix
+     * mount option can be used to disable g_file_trash() support for particular
+     * mounts, the %G_IO_ERROR_NOT_SUPPORTED error will be returned in that case.
+     * Since 2.82, the `x-gvfs-trash` unix mount option can be used to enable
+     * g_file_trash() support for particular system mounts.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param cancellable - optional #GCancellable object,
+     */
     trash(cancellable?: Cancellable | null): boolean;
+    /**
+     * Asynchronously sends `file` to the Trash location, if possible.
+     * @param ioPriority - the I/O priority of the request
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback to call
+     * @param userData - the data to pass to callback function
+     */
     trashAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an asynchronous file trashing operation, started with
+     * g_file_trash_async().
+     * @param result - a #GAsyncResult
+     */
     trashFinish(result: AsyncResult): boolean;
+    /**
+     * Unmounts a file of type G_FILE_TYPE_MOUNTABLE.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_file_unmount_mountable_finish() to get
+     * the result of the operation.
+     * @param flags - flags affecting the operation
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     unmountMountable(flags: MountUnmountFlags, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an unmount operation, see g_file_unmount_mountable() for details.
+     *
+     * Finish an asynchronous unmount operation that was started
+     * with g_file_unmount_mountable().
+     * @param result - a #GAsyncResult
+     */
     unmountMountableFinish(result: AsyncResult): boolean;
+    /**
+     * Unmounts a file of type %G_FILE_TYPE_MOUNTABLE.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     *
+     * When the operation is finished, `callback` will be called.
+     * You can then call g_file_unmount_mountable_finish() to get
+     * the result of the operation.
+     * @param flags - flags affecting the operation
+     * @param mountOperation - a #GMountOperation,
+     * @param cancellable - optional #GCancellable object,
+     * @param callback - a #GAsyncReadyCallback
+     * @param userData - the data to pass to callback function
+     */
     unmountMountableWithOperation(flags: MountUnmountFlags, mountOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Finishes an unmount operation,
+     * see g_file_unmount_mountable_with_operation() for details.
+     *
+     * Finish an asynchronous unmount operation that was started
+     * with g_file_unmount_mountable_with_operation().
+     * @param result - a #GAsyncResult
+     */
     unmountMountableWithOperationFinish(result: AsyncResult): boolean;
 }