@gtkx/ffi 0.10.5 → 0.11.1

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

@@ -1,17 +1,18 @@
 import { Ref } from "@gtkx/native";
 import { NativeObject } from "../../native/base.js";
-import { FileAttributeType, FileCopyFlags, FileCreateFlags, FileMonitorFlags, FileQueryInfoFlags, FileType } from "./enums.js";
+import { DriveStartFlags, FileAttributeType, FileCopyFlags, FileCreateFlags, FileMonitorFlags, FileQueryInfoFlags, FileType, MountMountFlags, MountUnmountFlags } from "./enums.js";
 import { FileAttributeInfoList } from "./file-attribute-info-list.js";
 import { AppInfo } from "./app-info.js";
 import { AsyncResult } from "./async-result.js";
+import { Mount } from "./mount.js";
 import { Cancellable } from "./cancellable.js";
 import { FileEnumerator } from "./file-enumerator.js";
 import { FileInfo } from "./file-info.js";
 import { FileInputStream } from "./file-input-stream.js";
-import { FileIOStream } from "./file-iostream.js";
+import { FileIOStream } from "./file-io-stream.js";
 import { FileMonitor } from "./file-monitor.js";
 import { FileOutputStream } from "./file-output-stream.js";
-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";
 /**
@@ -27,16 +28,16 @@ import * as GObject from "../gobject/index.js";
  * - {@link Gio.File.new_for_path} if you have a path.
  * - {@link Gio.File.new_for_uri} if you have a URI.
  * - {@link Gio.File.new_for_commandline_arg} or
- * {@link Gio.File.new_for_commandline_arg_and_cwd} for a command line
- * argument.
+ *   {@link Gio.File.new_for_commandline_arg_and_cwd} for a command line
+ *   argument.
  * - {@link Gio.File.new_tmp} to create a temporary file from a template.
  * - {@link Gio.File.new_tmp_async} to asynchronously create a temporary file.
  * - {@link Gio.File.new_tmp_dir_async} to asynchronously create a temporary
- * directory.
+ *   directory.
  * - {@link Gio.File.parse_name} from a UTF-8 string gotten from
- * {@link Gio.File.get_parse_name}.
+ *   {@link Gio.File.get_parse_name}.
  * - {@link Gio.File.new_build_filename} or {@link Gio.File.new_build_filenamev}
- * to create a file from path elements.
+ *   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
@@ -94,7 +95,7 @@ import * as GObject from "../gobject/index.js";
  *
  * - {@link Gio.File.mount_mountable} to mount a mountable file.
  * - {@link Gio.File.unmount_mountable_with_operation} to unmount a mountable
- * file.
+ *   file.
  * - {@link Gio.File.eject_mountable_with_operation} to eject a mountable file.
  *
  * ## Entity Tags
@@ -128,14 +129,22 @@ export declare class File extends NativeObject {
      * %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): FileOutputStream;
+    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.
+     */
+    appendToAsync(flags: FileCreateFlags, ioPriority: number, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
     /**
      * Finishes an asynchronous file append operation started with
      * g_file_append_to_async().
-     * @param res - #GAsyncResult
      */
     appendToFinish(res: AsyncResult): FileOutputStream;
     /**
@@ -148,21 +157,13 @@ export declare class File extends NativeObject {
      * 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): string;
+    buildAttributeListForCopy(flags: FileCopyFlags, cancellable?: Cancellable | null): string;
     /**
      * Version of {@link Gio.File.copy_async} using closures instead of callbacks for
      * easier binding in other languages.
-     * @param destination - destination {@link Gio.File}
-     * @param flags - set of {@link Gio.FileCopyFlags}
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional {@link Gio.Cancellable} object,
-     * @param progressCallbackClosure - {@link GObject.Closure} to invoke with progress
-     * @param readyCallbackClosure - {@link GObject.Closure} to invoke when the request is satisfied
      */
-    copyAsyncWithClosures(destination: File, flags: FileCopyFlags, ioPriority: number, readyCallbackClosure: GObject.Closure, cancellable?: Cancellable, progressCallbackClosure?: GObject.Closure): void;
+    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`.
      *
@@ -172,15 +173,9 @@ export declare class File extends NativeObject {
      * 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): boolean;
-    /**
-     * Finishes copying the file started with g_file_copy_async().
-     * @param res - a #GAsyncResult
      */
+    copyAttributes(destination: File, flags: FileCopyFlags, cancellable?: Cancellable | null): boolean;
+    /** Finishes copying the file started with g_file_copy_async(). */
     copyFinish(res: AsyncResult): boolean;
     /**
      * Creates a new file and returns an output stream for writing to it.
@@ -202,14 +197,23 @@ export declare class File extends NativeObject {
      * 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): FileOutputStream;
+    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.
+     */
+    createAsync(flags: FileCreateFlags, ioPriority: number, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
     /**
      * Finishes an asynchronous file create operation started with
      * g_file_create_async().
-     * @param res - a #GAsyncResult
      */
     createFinish(res: AsyncResult): FileOutputStream;
     /**
@@ -236,14 +240,23 @@ export declare class File extends NativeObject {
      * 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): FileIOStream;
+    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.
+     */
+    createReadwriteAsync(flags: FileCreateFlags, ioPriority: number, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
     /**
      * Finishes an asynchronous file create operation started with
      * g_file_create_readwrite_async().
-     * @param res - a #GAsyncResult
      */
     createReadwriteFinish(res: AsyncResult): FileIOStream;
     /**
@@ -256,25 +269,27 @@ export declare class File extends NativeObject {
      * |[
      * 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);
-     * }
+     *     !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): boolean;
+    delete(cancellable?: Cancellable | null): boolean;
     /**
-     * Finishes deleting a file started with g_file_delete_async().
-     * @param result - a #GAsyncResult
+     * 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().
      */
+    deleteAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
+    /** Finishes deleting a file started with g_file_delete_async(). */
     deleteFinish(result: AsyncResult): boolean;
     /**
      * Duplicates a #GFile handle. This operation does not duplicate
@@ -289,16 +304,36 @@ export declare class File extends NativeObject {
      * 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.
+     */
+    ejectMountable(flags: MountUnmountFlags, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | 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.
+     */
+    ejectMountableWithOperation(flags: MountUnmountFlags, mountOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
     /**
      * Finishes an asynchronous eject operation started by
      * g_file_eject_mountable_with_operation().
-     * @param result - a #GAsyncResult
      */
     ejectMountableWithOperationFinish(result: AsyncResult): boolean;
     /**
@@ -327,15 +362,24 @@ export declare class File extends NativeObject {
      * 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): FileEnumerator;
+    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.
+     */
+    enumerateChildrenAsync(attributes: string, flags: FileQueryInfoFlags, ioPriority: number, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
     /**
      * Finishes an async enumerate children operation.
      * See g_file_enumerate_children_async().
-     * @param res - a #GAsyncResult
      */
     enumerateChildrenFinish(res: AsyncResult): FileEnumerator;
     /**
@@ -346,7 +390,6 @@ export declare class File extends NativeObject {
      * aliasing.
      *
      * This call does no blocking I/O.
-     * @param file2 - the second #GFile
      */
     equal(file2: File): boolean;
     /**
@@ -359,13 +402,22 @@ export declare class File extends NativeObject {
      * 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): Mount;
+    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.
+     */
+    findEnclosingMountAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
     /**
      * Finishes an asynchronous find mount request.
      * See g_file_find_enclosing_mount_async().
-     * @param res - a #GAsyncResult
      */
     findEnclosingMountFinish(res: AsyncResult): Mount;
     /**
@@ -392,7 +444,6 @@ export declare class File extends NativeObject {
      * 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;
     /**
@@ -404,7 +455,6 @@ export declare class File extends NativeObject {
      * 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;
     /**
@@ -443,7 +493,6 @@ export declare class File extends NativeObject {
      * Gets the path for `descendant` relative to `parent`.
      *
      * This call does no blocking I/O.
-     * @param descendant - input #GFile
      */
     getRelativePath(descendant: File): string | null;
     /**
@@ -472,9 +521,8 @@ export declare class File extends NativeObject {
      * 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): boolean;
+    hasParent(parent?: File | null): boolean;
     /**
      * Checks whether `file` has the prefix specified by `prefix`.
      *
@@ -490,14 +538,12 @@ export declare class File extends NativeObject {
      * 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;
     /**
@@ -532,10 +578,21 @@ export declare class File extends NativeObject {
      * 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, etagOut?: Ref<string>): GLib.Bytes;
+    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.
+     */
+    loadBytesAsync(cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
     /**
      * Completes an asynchronous request to g_file_load_bytes_async().
      *
@@ -546,10 +603,8 @@ export declare class File extends NativeObject {
      * 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>): GLib.Bytes;
+    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`.
@@ -559,36 +614,40 @@ export declare class File extends NativeObject {
      * 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, length?: Ref<number>, etagOut?: Ref<string>): boolean;
+    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.
+     */
+    loadContentsAsync(cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | 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>, etagOut?: Ref<string>): boolean;
+    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>, etagOut?: Ref<string>): boolean;
+    loadPartialContentsFinish(res: AsyncResult, contents: Ref<number[]>, length?: Ref<number> | null, etagOut?: Ref<string> | null): boolean;
     /**
      * Creates a directory.
      *
@@ -608,13 +667,13 @@ export declare class File extends NativeObject {
      * 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): boolean;
+    makeDirectory(cancellable?: Cancellable | null): boolean;
+    /** Asynchronously creates a directory. */
+    makeDirectoryAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
     /**
      * Finishes an asynchronous directory creation, started with
      * g_file_make_directory_async().
-     * @param result - a #GAsyncResult
      */
     makeDirectoryFinish(result: AsyncResult): boolean;
     /**
@@ -631,9 +690,8 @@ export declare class File extends NativeObject {
      * 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): boolean;
+    makeDirectoryWithParents(cancellable?: Cancellable | null): boolean;
     /**
      * Creates a symbolic link named `file` which contains the string
      * `symlink_value`.
@@ -641,26 +699,24 @@ export declare class File extends NativeObject {
      * 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): boolean;
+    makeSymbolicLink(symlinkValue: string, cancellable?: Cancellable | null): boolean;
+    /**
+     * Asynchronously creates a symbolic link named `file` which contains the
+     * string `symlink_value`.
+     */
+    makeSymbolicLinkAsync(symlinkValue: string, ioPriority: number, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
     /**
      * Finishes an asynchronous symbolic link creation, started with
      * g_file_make_symbolic_link_async().
-     * @param result - a #GAsyncResult
      */
     makeSymbolicLinkFinish(result: AsyncResult): 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>, numDirs?: Ref<number>, numFiles?: Ref<number>): boolean;
+    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.
@@ -668,10 +724,8 @@ export declare class File extends NativeObject {
      * 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): FileMonitor;
+    monitor(flags: FileMonitorFlags, cancellable?: Cancellable | null): FileMonitor;
     /**
      * Obtains a directory monitor for the given file.
      * This may fail if directory monitoring is not supported.
@@ -685,10 +739,8 @@ export declare class File extends NativeObject {
      * 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): FileMonitor;
+    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.
@@ -704,38 +756,52 @@ export declare class File extends NativeObject {
      * 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): FileMonitor;
+    monitorFile(flags: FileMonitorFlags, cancellable?: Cancellable | null): FileMonitor;
     /**
-     * Finishes a mount operation started by g_file_mount_enclosing_volume().
-     * @param result - a #GAsyncResult
+     * 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.
      */
+    mountEnclosingVolume(flags: MountMountFlags, mountOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
+    /** Finishes a mount operation started by g_file_mount_enclosing_volume(). */
     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.
+     */
+    mountMountable(flags: MountMountFlags, mountOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | 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;
     /**
      * Version of {@link Gio.File.move_async} using closures instead of callbacks for
      * easier binding in other languages.
-     * @param destination - destination {@link Gio.File}
-     * @param flags - set of {@link Gio.FileCopyFlags}
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional {@link Gio.Cancellable} object,
-     * @param progressCallbackClosure - {@link GObject.Closure} to invoke with progress
-     * @param readyCallbackClosure - {@link GObject.Closure} to invoke when the request is satisfied
      */
-    moveAsyncWithClosures(destination: File, flags: FileCopyFlags, ioPriority: number, readyCallbackClosure: GObject.Closure, cancellable?: Cancellable, progressCallbackClosure?: GObject.Closure): void;
+    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;
     /**
@@ -755,13 +821,22 @@ export declare class File extends NativeObject {
      * 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): FileIOStream;
+    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.
+     */
+    openReadwriteAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
     /**
      * Finishes an asynchronous file read operation started with
      * g_file_open_readwrite_async().
-     * @param res - a #GAsyncResult
      */
     openReadwriteFinish(res: AsyncResult): FileIOStream;
     /**
@@ -774,12 +849,23 @@ export declare class File extends NativeObject {
      * 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.
+     */
+    pollMountable(cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | 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;
     /**
@@ -789,13 +875,11 @@ export declare class File extends NativeObject {
      * 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): AppInfo;
-    /**
-     * Finishes a g_file_query_default_handler_async() operation.
-     * @param result - a #GAsyncResult
      */
+    queryDefaultHandler(cancellable?: Cancellable | null): AppInfo;
+    /** Async version of g_file_query_default_handler(). */
+    queryDefaultHandlerAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
+    /** Finishes a g_file_query_default_handler_async() operation. */
     queryDefaultHandlerFinish(result: AsyncResult): AppInfo;
     /**
      * Utility function to check if a particular file exists.
@@ -823,19 +907,16 @@ export declare class File extends NativeObject {
      * 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): boolean;
+    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): FileType;
+    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.
@@ -862,14 +943,25 @@ export declare class File extends NativeObject {
      * 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): FileInfo;
+    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.
+     */
+    queryFilesystemInfoAsync(attributes: string, ioPriority: number, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
     /**
      * Finishes an asynchronous filesystem info query.
      * See g_file_query_filesystem_info_async().
-     * @param res - a #GAsyncResult
      */
     queryFilesystemInfoFinish(res: AsyncResult): FileInfo;
     /**
@@ -891,8 +983,8 @@ export declare class File extends NativeObject {
      * `attributes`, they will always be set in the returned {@link Gio.FileInfo},
      * even if the user doesn’t have permissions to access the file:
      *
-     * - {@link Gio.FILE_ATTRIBUTE_STANDARD_NAME}
-     * - {@link Gio.FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME}
+     *  - {@link Gio.FILE_ATTRIBUTE_STANDARD_NAME}
+     *  - {@link 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
@@ -916,15 +1008,23 @@ export declare class File extends NativeObject {
      * If the file does not exist, the {@link 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): FileInfo;
+    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.
+     */
+    queryInfoAsync(attributes: string, flags: FileQueryInfoFlags, ioPriority: number, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
     /**
      * Finishes an asynchronous file info query.
      * See g_file_query_info_async().
-     * @param res - a #GAsyncResult
      */
     queryInfoFinish(res: AsyncResult): FileInfo;
     /**
@@ -938,9 +1038,8 @@ export declare class File extends NativeObject {
      * 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): FileAttributeInfoList;
+    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
@@ -949,9 +1048,8 @@ export declare class File extends NativeObject {
      * 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): FileAttributeInfoList;
+    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.
@@ -964,13 +1062,22 @@ export declare class File extends NativeObject {
      * 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): FileInputStream;
+    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.
+     */
+    readAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
     /**
      * Finishes an asynchronous file read operation started with
      * g_file_read_async().
-     * @param res - a #GAsyncResult
      */
     readFinish(res: AsyncResult): FileInputStream;
     /**
@@ -1015,12 +1122,20 @@ export declare class File extends NativeObject {
      * %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, cancellable?: Cancellable): FileOutputStream;
+    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.
+     */
+    replaceAsync(makeBackup: boolean, flags: FileCreateFlags, ioPriority: number, etag?: string | null, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
     /**
      * Replaces the contents of `file` with `contents` of `length` bytes.
      *
@@ -1038,27 +1153,50 @@ export declare class File extends NativeObject {
      *
      * 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, newEtag?: Ref<string>, cancellable?: Cancellable): boolean;
+    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.
+     */
+    replaceContentsAsync(contents: number[], length: number, makeBackup: boolean, flags: FileCreateFlags, etag?: string | null, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | 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().
+     */
+    replaceContentsBytesAsync(contents: GLib.Bytes, makeBackup: boolean, flags: FileCreateFlags, etag?: string | null, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | 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>): boolean;
+    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;
     /**
@@ -1072,16 +1210,24 @@ export declare class File extends NativeObject {
      * 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, cancellable?: Cancellable): FileIOStream;
+    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.
+     */
+    replaceReadwriteAsync(makeBackup: boolean, flags: FileCreateFlags, ioPriority: number, etag?: string | null, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
     /**
      * Finishes an asynchronous file replace operation started with
      * g_file_replace_readwrite_async().
-     * @param res - a #GAsyncResult
      */
     replaceReadwriteFinish(res: AsyncResult): FileIOStream;
     /**
@@ -1091,7 +1237,6 @@ export declare class File extends NativeObject {
      *
      * 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;
     /**
@@ -1103,13 +1248,8 @@ export declare class File extends NativeObject {
      * 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, cancellable?: Cancellable): boolean;
+    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,
@@ -1118,12 +1258,8 @@ export declare class File extends NativeObject {
      * 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): boolean;
+    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.
@@ -1131,12 +1267,8 @@ export declare class File extends NativeObject {
      * 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): boolean;
+    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.
@@ -1144,12 +1276,8 @@ export declare class File extends NativeObject {
      * 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): boolean;
+    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.
@@ -1157,12 +1285,8 @@ export declare class File extends NativeObject {
      * 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): boolean;
+    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.
@@ -1170,12 +1294,8 @@ export declare class File extends NativeObject {
      * 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): boolean;
+    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.
@@ -1183,17 +1303,20 @@ export declare class File extends NativeObject {
      * 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): boolean;
+    setAttributeUint64(attribute: string, value: number, flags: FileQueryInfoFlags, cancellable?: Cancellable | null): boolean;
     /**
-     * Finishes setting an attribute started in g_file_set_attributes_async().
-     * @param result - a #GAsyncResult
-     * @param info - a #GFileInfo
+     * 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.
      */
+    setAttributesAsync(info: FileInfo, flags: FileQueryInfoFlags, ioPriority: number, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
+    /** Finishes setting an attribute started in g_file_set_attributes_async(). */
     setAttributesFinish(result: AsyncResult, info: Ref<FileInfo>): boolean;
     /**
      * Tries to set all attributes in the #GFileInfo on the target
@@ -1208,11 +1331,8 @@ export declare class File extends NativeObject {
      * 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): boolean;
+    setAttributesFromInfo(info: FileInfo, flags: FileQueryInfoFlags, cancellable?: Cancellable | null): boolean;
     /**
      * Renames `file` to the specified display name.
      *
@@ -1229,30 +1349,62 @@ export declare class File extends NativeObject {
      * 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): File;
+    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.
+     */
+    setDisplayNameAsync(displayName: string, ioPriority: number, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | 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.
+     */
+    startMountable(flags: DriveStartFlags, startOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | 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.
+     */
+    stopMountable(flags: MountUnmountFlags, mountOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | 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;
     /**
@@ -1276,30 +1428,52 @@ export declare class File extends NativeObject {
      * 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): boolean;
+    trash(cancellable?: Cancellable | null): boolean;
+    /** Asynchronously sends `file` to the Trash location, if possible. */
+    trashAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | 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.
+     */
+    unmountMountable(flags: MountUnmountFlags, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | 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.
+     */
+    unmountMountableWithOperation(flags: MountUnmountFlags, mountOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | 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;
 }