@gtkx/ffi 0.7.0 → 0.9.0

package/dist/generated/gio/file.js

@@ -1,6 +1,10 @@
-import { call, NativeError, getObject, getBoxed, getInterface, } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { NativeError } from "../../native-error.js";
+import { getObject, getBoxed, getInterface } from "../../native.js";
+import { FileAttributeInfoList } from "./file-attribute-info-list.js";
 import { AppInfo } from "./app-info.js";
 import { Mount } from "./mount.js";
+import * as GLib from "../glib/index.js";
 /**
  * `GFile` is a high level abstraction for manipulating files on a
  * virtual file system. `GFile`s are lightweight, immutable objects
@@ -157,52 +161,6 @@ export class File {
         }
         return getObject(ptr);
     }
-    /**
-     * 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, ioPriority, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_append_to_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes an asynchronous file append operation started with
      * g_file_append_to_async().
@@ -282,164 +240,6 @@ export class File {
         }
         return result;
     }
-    /**
-     * 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, flags, cancellable, progressCallback, progressCallbackData) {
-        const error = { value: null };
-        const result = call("libgio-2.0.so.0", "g_file_copy", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: destination?.id ?? destination,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: progressCallback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: progressCallbackData,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "boolean" });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        return result;
-    }
-    /**
-     * 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, flags, ioPriority, cancellable, progressCallback, progressCallbackData, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_copy_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: destination?.id ?? destination,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: progressCallback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: progressCallbackData,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Version of [method@Gio.File.copy_async] using closures instead of callbacks for
      * easier binding in other languages.
@@ -632,53 +432,6 @@ export class File {
         }
         return getObject(ptr);
     }
-    /**
-     * 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, ioPriority, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_create_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes an asynchronous file create operation started with
      * g_file_create_async().
@@ -772,53 +525,6 @@ export class File {
         }
         return getObject(ptr);
     }
-    /**
-     * 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, ioPriority, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_create_readwrite_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes an asynchronous file create operation started with
      * g_file_create_readwrite_async().
@@ -905,42 +611,6 @@ export class File {
         }
         return result;
     }
-    /**
-     * 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, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_delete_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes deleting a file started with g_file_delete_async().
      * @param result - a #GAsyncResult
@@ -994,47 +664,6 @@ export class File {
         ], { type: "gobject", borrowed: true });
         return getInterface(ptr, 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, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_eject_mountable", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes an asynchronous eject operation started by
      * g_file_eject_mountable().
@@ -1068,53 +697,6 @@ export class File {
         }
         return _result;
     }
-    /**
-     * 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, mountOperation, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_eject_mountable_with_operation", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: mountOperation?.id ?? mountOperation,
-                optional: true,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes an asynchronous eject operation started by
      * g_file_eject_mountable_with_operation().
@@ -1215,59 +797,6 @@ export class File {
         }
         return getObject(ptr);
     }
-    /**
-     * 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, flags, ioPriority, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_enumerate_children_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "string" },
-                value: attributes,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes an async enumerate children operation.
      * See g_file_enumerate_children_async().
@@ -1364,47 +893,6 @@ export class File {
         }
         return getInterface(ptr, 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, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_find_enclosing_mount_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes an asynchronous find mount request.
      * See g_file_find_enclosing_mount_async().
@@ -1785,45 +1273,7 @@ export class File {
         if (error.value !== null) {
             throw new NativeError(error.value);
         }
-        return getBoxed(ptr, "GBytes");
-    }
-    /**
-     * 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, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_load_bytes_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
+        return getBoxed(ptr, GLib.Bytes);
     }
     /**
      * Completes an asynchronous request to g_file_load_bytes_async().
@@ -1874,7 +1324,7 @@ export class File {
         if (error.value !== null) {
             throw new NativeError(error.value);
         }
-        return getBoxed(ptr, "GBytes");
+        return getBoxed(ptr, GLib.Bytes);
     }
     /**
      * Loads the content of the file into memory. The data is always
@@ -1942,47 +1392,6 @@ export class File {
         }
         return result;
     }
-    /**
-     * 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, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_load_contents_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes an asynchronous load of the @file's contents.
      * The contents are placed in @contents, and `length` is set to the
@@ -2157,40 +1566,6 @@ export class File {
         }
         return result;
     }
-    /**
-     * 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, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_make_directory_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes an asynchronous directory creation, started with
      * g_file_make_directory_async().
@@ -2312,46 +1687,6 @@ export class File {
         }
         return result;
     }
-    /**
-     * 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, ioPriority, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_make_symbolic_link_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "string" },
-                value: symlinkValue,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes an asynchronous symbolic link creation, started with
      * g_file_make_symbolic_link_async().
@@ -2386,57 +1721,24 @@ export class File {
         return _result;
     }
     /**
-     * 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
+     * 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
      */
-    measureDiskUsage(flags, cancellable, progressCallback, progressData, diskUsage, numDirs, numFiles) {
+    measureDiskUsageFinish(result, diskUsage, numDirs, numFiles) {
         const error = { value: null };
-        const result = call("libgio-2.0.so.0", "g_file_measure_disk_usage", [
+        const _result = call("libgio-2.0.so.0", "g_file_measure_disk_usage_finish", [
             {
                 type: { type: "gobject" },
                 value: this.id,
             },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
             {
                 type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: progressCallback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: progressData,
-                optional: true,
+                value: result?.id ?? result,
             },
             {
                 type: {
@@ -2477,82 +1779,21 @@ export class File {
         if (error.value !== null) {
             throw new NativeError(error.value);
         }
-        return result;
+        return _result;
     }
     /**
-     * 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
+     * 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,
      */
-    measureDiskUsageFinish(result, diskUsage, numDirs, numFiles) {
+    monitor(flags, cancellable) {
         const error = { value: null };
-        const _result = call("libgio-2.0.so.0", "g_file_measure_disk_usage_finish", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: result?.id ?? result,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: true },
-                },
-                value: diskUsage,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: true },
-                },
-                value: numDirs,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: true },
-                },
-                value: numFiles,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "boolean" });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        return _result;
-    }
-    /**
-     * 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, cancellable) {
-        const error = { value: null };
-        const ptr = call("libgio-2.0.so.0", "g_file_monitor", [
+        const ptr = call("libgio-2.0.so.0", "g_file_monitor", [
             {
                 type: { type: "gobject" },
                 value: this.id,
@@ -2683,55 +1924,6 @@ export class File {
         }
         return getObject(ptr);
     }
-    /**
-     * 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, mountOperation, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_mount_enclosing_volume", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: mountOperation?.id ?? mountOperation,
-                optional: true,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes a mount operation started by g_file_mount_enclosing_volume().
      * @param result - a #GAsyncResult
@@ -2764,56 +1956,6 @@ export class File {
         }
         return _result;
     }
-    /**
-     * 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, mountOperation, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_mount_mountable", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: mountOperation?.id ?? mountOperation,
-                optional: true,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes a mount operation. See g_file_mount_mountable() for details.
      *
@@ -2849,157 +1991,6 @@ export class File {
         }
         return getInterface(ptr, 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, flags, cancellable, progressCallback, progressCallbackData) {
-        const error = { value: null };
-        const result = call("libgio-2.0.so.0", "g_file_move", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: destination?.id ?? destination,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: progressCallback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: progressCallbackData,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "boolean" });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        return result;
-    }
-    /**
-     * 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, flags, ioPriority, cancellable, progressCallback, progressCallbackData, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_move_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: destination?.id ?? destination,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: progressCallback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: progressCallbackData,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Version of [method@Gio.File.move_async] using closures instead of callbacks for
      * easier binding in other languages.
@@ -3135,47 +2126,6 @@ export class File {
         }
         return getObject(ptr);
     }
-    /**
-     * 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, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_open_readwrite_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes an asynchronous file read operation started with
      * g_file_open_readwrite_async().
@@ -3226,43 +2176,6 @@ export class File {
             },
         ], { type: "string", borrowed: true });
     }
-    /**
-     * 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, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_poll_mountable", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes a poll operation. See g_file_poll_mountable() for details.
      *
@@ -3336,40 +2249,6 @@ export class File {
         }
         return getInterface(ptr, 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, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_query_default_handler_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes a g_file_query_default_handler_async() operation.
      * @param result - a #GAsyncResult
@@ -3531,55 +2410,6 @@ export class File {
         }
         return getObject(ptr);
     }
-    /**
-     * 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, ioPriority, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_query_filesystem_info_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "string" },
-                value: attributes,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes an asynchronous filesystem info query.
      * See g_file_query_filesystem_info_async().
@@ -3652,71 +2482,18 @@ export class File {
      * 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, flags, cancellable) {
-        const error = { value: null };
-        const ptr = call("libgio-2.0.so.0", "g_file_query_info", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "string" },
-                value: attributes,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "gobject", borrowed: true });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        return getObject(ptr);
-    }
-    /**
-     * 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.
+     * about the symlink itself will be returned.
      *
-     * 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.
+     * 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 - 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
+     * @param flags - flags to affect the query operation
+     * @param cancellable - optional cancellable object
      */
-    queryInfoAsync(attributes, flags, ioPriority, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_query_info_async", [
+    queryInfo(attributes, flags, cancellable) {
+        const error = { value: null };
+        const ptr = call("libgio-2.0.so.0", "g_file_query_info", [
             {
                 type: { type: "gobject" },
                 value: this.id,
@@ -3729,26 +2506,27 @@ export class File {
                 type: { type: "int", size: 32, unsigned: false },
                 value: flags,
             },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
             {
                 type: { type: "gobject", borrowed: true },
                 value: cancellable?.id ?? cancellable,
                 optional: true,
             },
             {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GError",
+                        lib: "libglib-2.0.so.0",
+                    },
+                },
+                value: error,
             },
-        ], { type: "undefined" });
+        ], { type: "gobject", borrowed: true });
+        if (error.value !== null) {
+            throw new NativeError(error.value);
+        }
+        return getObject(ptr);
     }
     /**
      * Finishes an asynchronous file info query.
@@ -3828,7 +2606,7 @@ export class File {
         if (error.value !== null) {
             throw new NativeError(error.value);
         }
-        return getBoxed(ptr, "GFileAttributeInfoList");
+        return getBoxed(ptr, FileAttributeInfoList);
     }
     /**
      * Obtain the list of attribute namespaces where new attributes
@@ -3872,7 +2650,7 @@ export class File {
         if (error.value !== null) {
             throw new NativeError(error.value);
         }
-        return getBoxed(ptr, "GFileAttributeInfoList");
+        return getBoxed(ptr, FileAttributeInfoList);
     }
     /**
      * Opens a file for reading. The result is a #GFileInputStream that
@@ -3917,47 +2695,6 @@ export class File {
         }
         return getObject(ptr);
     }
-    /**
-     * 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, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_read_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes an asynchronous file read operation started with
      * g_file_read_async().
@@ -4080,64 +2817,6 @@ export class File {
         }
         return getObject(ptr);
     }
-    /**
-     * 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, flags, ioPriority, etag, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_replace_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "string" },
-                value: etag,
-                optional: true,
-            },
-            {
-                type: { type: "boolean" },
-                value: makeBackup,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Replaces the contents of `file` with `contents` of `length` bytes.
      *
@@ -4221,144 +2900,6 @@ export class File {
         }
         return result;
     }
-    /**
-     * 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, length, makeBackup, flags, etag, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_replace_contents_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: {
-                    type: "array",
-                    itemType: { type: "int", size: 8, unsigned: true },
-                },
-                value: contents,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: length,
-            },
-            {
-                type: { type: "string" },
-                value: etag,
-                optional: true,
-            },
-            {
-                type: { type: "boolean" },
-                value: makeBackup,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
-    /**
-     * 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, makeBackup, flags, etag, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_replace_contents_bytes_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GBytes",
-                    lib: "libgio-2.0.so.0",
-                },
-                value: contents?.id ?? contents,
-            },
-            {
-                type: { type: "string" },
-                value: etag,
-                optional: true,
-            },
-            {
-                type: { type: "boolean" },
-                value: makeBackup,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes an asynchronous replace of the given @file. See
      * g_file_replace_contents_async(). Sets `new_etag` to the new entity
@@ -4448,69 +2989,9 @@ export class File {
      * @param flags - a set of #GFileCreateFlags
      * @param cancellable - optional #GCancellable object,
      */
-    replaceReadwrite(makeBackup, flags, etag, cancellable) {
-        const error = { value: null };
-        const ptr = call("libgio-2.0.so.0", "g_file_replace_readwrite", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "string" },
-                value: etag,
-                optional: true,
-            },
-            {
-                type: { type: "boolean" },
-                value: makeBackup,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "gobject", borrowed: true });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        return getObject(ptr);
-    }
-    /**
-     * 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, flags, ioPriority, etag, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_replace_readwrite_async", [
+    replaceReadwrite(makeBackup, flags, etag, cancellable) {
+        const error = { value: null };
+        const ptr = call("libgio-2.0.so.0", "g_file_replace_readwrite", [
             {
                 type: { type: "gobject" },
                 value: this.id,
@@ -4528,26 +3009,27 @@ export class File {
                 type: { type: "int", size: 32, unsigned: false },
                 value: flags,
             },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
             {
                 type: { type: "gobject", borrowed: true },
                 value: cancellable?.id ?? cancellable,
                 optional: true,
             },
             {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GError",
+                        lib: "libglib-2.0.so.0",
+                    },
+                },
+                value: error,
             },
-        ], { type: "undefined" });
+        ], { type: "gobject", borrowed: true });
+        if (error.value !== null) {
+            throw new NativeError(error.value);
+        }
+        return getObject(ptr);
     }
     /**
      * Finishes an asynchronous file replace operation started with
@@ -4984,57 +3466,6 @@ export class File {
         }
         return result;
     }
-    /**
-     * 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, flags, ioPriority, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_set_attributes_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: info?.id ?? info,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes setting an attribute started in g_file_set_attributes_async().
      * @param result - a #GAsyncResult
@@ -5179,52 +3610,6 @@ export class File {
         }
         return getInterface(ptr, 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, ioPriority, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_set_display_name_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "string" },
-                value: displayName,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes setting a display name started with
      * g_file_set_display_name_async().
@@ -5258,56 +3643,6 @@ export class File {
         }
         return getInterface(ptr, 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, startOperation, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_start_mountable", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: startOperation?.id ?? startOperation,
-                optional: true,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes a start operation. See g_file_start_mountable() for details.
      *
@@ -5343,54 +3678,6 @@ export class File {
         }
         return _result;
     }
-    /**
-     * 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, mountOperation, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_stop_mountable", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: mountOperation?.id ?? mountOperation,
-                optional: true,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes a stop operation, see g_file_stop_mountable() for details.
      *
@@ -5485,40 +3772,6 @@ export class File {
         }
         return result;
     }
-    /**
-     * 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, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_trash_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes an asynchronous file trashing operation, started with
      * g_file_trash_async().
@@ -5552,48 +3805,6 @@ export class File {
         }
         return _result;
     }
-    /**
-     * 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, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_unmount_mountable", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes an unmount operation, see g_file_unmount_mountable() for details.
      *
@@ -5629,54 +3840,6 @@ export class File {
         }
         return _result;
     }
-    /**
-     * 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, mountOperation, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_file_unmount_mountable_with_operation", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: mountOperation?.id ?? mountOperation,
-                optional: true,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes an unmount operation,
      * see g_file_unmount_mountable_with_operation() for details.