@gtkx/ffi 0.7.0 → 0.9.0

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

@@ -1,5 +1,5 @@
 import { Ref } from "@gtkx/native";
-import { DriveStartFlags, FileAttributeType, FileCopyFlags, FileCreateFlags, FileMeasureFlags, FileMonitorFlags, FileQueryInfoFlags, FileType, MountMountFlags, MountUnmountFlags } from "./enums.js";
+import { FileAttributeType, FileCopyFlags, FileCreateFlags, FileMonitorFlags, FileQueryInfoFlags, FileType } from "./enums.js";
 import { FileAttributeInfoList } from "./file-attribute-info-list.js";
 import { AppInfo } from "./app-info.js";
 import { AsyncResult } from "./async-result.js";
@@ -11,7 +11,6 @@ import { FileIOStream } from "./file-iostream.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";
 /**
@@ -134,22 +133,6 @@ export declare class File {
      * @param cancellable - optional #GCancellable object,
      */
     appendTo(flags: FileCreateFlags, cancellable?: Cancellable | null): FileOutputStream;
-    /**
-     * Asynchronously opens `file` for appending.
-     *
-     * For more details, see g_file_append_to() which is
-     * the synchronous version of this call.
-     *
-     * When the operation is finished, `callback` will be called.
-     * You can then call g_file_append_to_finish() to get the result
-     * of the operation.
-     * @param flags - a set of #GFileCreateFlags
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    appendToAsync(flags: FileCreateFlags, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes an asynchronous file append operation started with
      * g_file_append_to_async().
@@ -170,74 +153,6 @@ export declare class File {
      * @param cancellable - optional #GCancellable object,
      */
     buildAttributeListForCopy(flags: FileCopyFlags, cancellable?: Cancellable | null): string;
-    /**
-     * Copies the file `source` to the location specified by @destination.
-     * Can not handle recursive copies of directories.
-     *
-     * If the flag %G_FILE_COPY_OVERWRITE is specified an already
-     * existing `destination` file is overwritten.
-     *
-     * If the flag %G_FILE_COPY_NOFOLLOW_SYMLINKS is specified then symlinks
-     * will be copied as symlinks, otherwise the target of the
-     * `source` symlink will be copied.
-     *
-     * If the flag %G_FILE_COPY_ALL_METADATA is specified then all the metadata
-     * that is possible to copy is copied, not just the default subset (which,
-     * for instance, does not include the owner, see #GFileInfo).
-     *
-     * If `cancellable` is not %NULL, then the operation can be cancelled by
-     * triggering the cancellable object from another thread. If the operation
-     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
-     *
-     * If `progress_callback` is not %NULL, then the operation can be monitored
-     * by setting this to a #GFileProgressCallback function.
-     * `progress_callback_data` will be passed to this function. It is guaranteed
-     * that this callback will be called after all data has been transferred with
-     * the total number of bytes copied during the operation.
-     *
-     * If the `source` file does not exist, then the %G_IO_ERROR_NOT_FOUND error
-     * is returned, independent on the status of the @destination.
-     *
-     * If %G_FILE_COPY_OVERWRITE is not specified and the target exists, then
-     * the error %G_IO_ERROR_EXISTS is returned.
-     *
-     * If trying to overwrite a file over a directory, the %G_IO_ERROR_IS_DIRECTORY
-     * error is returned. If trying to overwrite a directory with a directory the
-     * %G_IO_ERROR_WOULD_MERGE error is returned.
-     *
-     * If the source is a directory and the target does not exist, or
-     * %G_FILE_COPY_OVERWRITE is specified and the target is a file, then the
-     * %G_IO_ERROR_WOULD_RECURSE error is returned.
-     *
-     * If you are interested in copying the #GFile object itself (not the on-disk
-     * file), see g_file_dup().
-     * @param destination - destination #GFile
-     * @param flags - set of #GFileCopyFlags
-     * @param cancellable - optional #GCancellable object,
-     * @param progressCallback - function to callback with
-     * @param progressCallbackData - user data to pass to @progress_callback
-     */
-    copy(destination: File, flags: FileCopyFlags, cancellable?: Cancellable | null, progressCallback?: (...args: unknown[]) => unknown | null, progressCallbackData?: number | null): boolean;
-    /**
-     * Copies the file `source` to the location specified by `destination` asynchronously. For details of the behaviour, see g_file_copy().
-     *
-     * If `progress_callback` is not %NULL, then that function that will be called
-     * just like in g_file_copy(). The callback will run in the default main context
-     * of the thread calling g_file_copy_async() — the same context as `callback` is
-     * run in.
-     *
-     * When the operation is finished, `callback` will be called. You can then call
-     * g_file_copy_finish() to get the result of the operation.
-     * @param destination - destination #GFile
-     * @param flags - set of #GFileCopyFlags
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional #GCancellable object,
-     * @param progressCallback - function to callback with progress information, or %NULL if
-     * @param progressCallbackData - user data to pass to @progress_callback
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback
-     */
-    copyAsync(destination: File, flags: FileCopyFlags, ioPriority: number, cancellable?: Cancellable | null, progressCallback?: (...args: unknown[]) => unknown | null, progressCallbackData?: number | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Version of [method@Gio.File.copy_async] using closures instead of callbacks for
      * easier binding in other languages.
@@ -292,23 +207,6 @@ export declare class File {
      * @param cancellable - optional #GCancellable object,
      */
     create(flags: FileCreateFlags, cancellable?: Cancellable | null): FileOutputStream;
-    /**
-     * Asynchronously creates a new file and returns an output stream
-     * for writing to it. The file must not already exist.
-     *
-     * For more details, see g_file_create() which is
-     * the synchronous version of this call.
-     *
-     * When the operation is finished, `callback` will be called.
-     * You can then call g_file_create_finish() to get the result
-     * of the operation.
-     * @param flags - a set of #GFileCreateFlags
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    createAsync(flags: FileCreateFlags, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes an asynchronous file create operation started with
      * g_file_create_async().
@@ -343,23 +241,6 @@ export declare class File {
      * @param cancellable - optional #GCancellable object,
      */
     createReadwrite(flags: FileCreateFlags, cancellable?: Cancellable | null): FileIOStream;
-    /**
-     * Asynchronously creates a new file and returns a stream
-     * for reading and writing to it. The file must not already exist.
-     *
-     * For more details, see g_file_create_readwrite() which is
-     * the synchronous version of this call.
-     *
-     * When the operation is finished, `callback` will be called.
-     * You can then call g_file_create_readwrite_finish() to get
-     * the result of the operation.
-     * @param flags - a set of #GFileCreateFlags
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    createReadwriteAsync(flags: FileCreateFlags, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes an asynchronous file create operation started with
      * g_file_create_readwrite_async().
@@ -391,16 +272,6 @@ export declare class File {
      * @param cancellable - optional #GCancellable object,
      */
     delete(cancellable?: Cancellable | null): boolean;
-    /**
-     * Asynchronously delete a file. If the `file` is a directory, it will
-     * only be deleted if it is empty.  This has the same semantics as
-     * g_unlink().
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback to call
-     * @param userData - the data to pass to callback function
-     */
-    deleteAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes deleting a file started with g_file_delete_async().
      * @param result - a #GAsyncResult
@@ -419,43 +290,12 @@ export declare class File {
      * This call does no blocking I/O.
      */
     dup(): File;
-    /**
-     * Starts an asynchronous eject on a mountable.
-     * When this operation has completed, `callback` will be called with
-     * `user_user` data, and the operation can be finalized with
-     * g_file_eject_mountable_finish().
-     *
-     * If `cancellable` is not %NULL, then the operation can be cancelled by
-     * triggering the cancellable object from another thread. If the operation
-     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
-     * @param flags - flags affecting the operation
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    ejectMountable(flags: MountUnmountFlags, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes an asynchronous eject operation started by
      * g_file_eject_mountable().
      * @param result - a #GAsyncResult
      */
     ejectMountableFinish(result: AsyncResult): boolean;
-    /**
-     * Starts an asynchronous eject on a mountable.
-     * When this operation has completed, `callback` will be called with
-     * `user_user` data, and the operation can be finalized with
-     * g_file_eject_mountable_with_operation_finish().
-     *
-     * If `cancellable` is not %NULL, then the operation can be cancelled by
-     * triggering the cancellable object from another thread. If the operation
-     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
-     * @param flags - flags affecting the operation
-     * @param mountOperation - a #GMountOperation,
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    ejectMountableWithOperation(flags: MountUnmountFlags, mountOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes an asynchronous eject operation started by
      * g_file_eject_mountable_with_operation().
@@ -493,25 +333,6 @@ export declare class File {
      * @param cancellable - optional #GCancellable object,
      */
     enumerateChildren(attributes: string, flags: FileQueryInfoFlags, cancellable?: Cancellable | null): FileEnumerator;
-    /**
-     * Asynchronously gets the requested information about the files
-     * in a directory. The result is a #GFileEnumerator object that will
-     * give out #GFileInfo objects for all the files in the directory.
-     *
-     * For more details, see g_file_enumerate_children() which is
-     * the synchronous version of this call.
-     *
-     * When the operation is finished, `callback` will be called. You can
-     * then call g_file_enumerate_children_finish() to get the result of
-     * the operation.
-     * @param attributes - an attribute query string
-     * @param flags - a set of #GFileQueryInfoFlags
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    enumerateChildrenAsync(attributes: string, flags: FileQueryInfoFlags, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes an async enumerate children operation.
      * See g_file_enumerate_children_async().
@@ -542,21 +363,6 @@ export declare class File {
      * @param cancellable - optional #GCancellable object,
      */
     findEnclosingMount(cancellable?: Cancellable | null): Mount;
-    /**
-     * Asynchronously gets the mount for the file.
-     *
-     * For more details, see g_file_find_enclosing_mount() which is
-     * the synchronous version of this call.
-     *
-     * When the operation is finished, `callback` will be called.
-     * You can then call g_file_find_enclosing_mount_finish() to
-     * get the result of the operation.
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    findEnclosingMountAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes an asynchronous find mount request.
      * See g_file_find_enclosing_mount_async().
@@ -731,22 +537,6 @@ export declare class File {
      * @param etagOut - a location to place the current
      */
     loadBytes(cancellable?: Cancellable | null, etagOut?: Ref<string> | null): GLib.Bytes;
-    /**
-     * Asynchronously loads the contents of `file` as #GBytes.
-     *
-     * If `file` is a resource:// based URI, the resulting bytes will reference the
-     * embedded resource instead of a copy. Otherwise, this is equivalent to calling
-     * g_file_load_contents_async() and g_bytes_new_take().
-     *
-     * `callback` should call g_file_load_bytes_finish() to get the result of this
-     * asynchronous operation.
-     *
-     * See g_file_load_bytes() for more information.
-     * @param cancellable - a #GCancellable or %NULL
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    loadBytesAsync(cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Completes an asynchronous request to g_file_load_bytes_async().
      *
@@ -776,25 +566,6 @@ export declare class File {
      * @param etagOut - a location to place the current entity tag for the file,
      */
     loadContents(contents: Ref<number[]>, cancellable?: Cancellable | null, length?: Ref<number> | null, etagOut?: Ref<string> | null): boolean;
-    /**
-     * Starts an asynchronous load of the @file's contents.
-     *
-     * For more details, see g_file_load_contents() which is
-     * the synchronous version of this call.
-     *
-     * When the load operation has completed, `callback` will be called
-     * with `user` data. To finish the operation, call
-     * g_file_load_contents_finish() with the #GAsyncResult returned by
-     * the @callback.
-     *
-     * If `cancellable` is not %NULL, then the operation can be cancelled by
-     * triggering the cancellable object from another thread. If the operation
-     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
-     * @param cancellable - optional #GCancellable object, %NULL to ignore
-     * @param callback - a #GAsyncReadyCallback to call when the request is satisfied
-     * @param userData - the data to pass to callback function
-     */
-    loadContentsAsync(cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes an asynchronous load of the @file's contents.
      * The contents are placed in @contents, and `length` is set to the
@@ -841,14 +612,6 @@ export declare class File {
      * @param cancellable - optional #GCancellable object,
      */
     makeDirectory(cancellable?: Cancellable | null): boolean;
-    /**
-     * Asynchronously creates a directory.
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback to call
-     * @param userData - the data to pass to callback function
-     */
-    makeDirectoryAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes an asynchronous directory creation, started with
      * g_file_make_directory_async().
@@ -883,50 +646,12 @@ export declare class File {
      * @param cancellable - optional #GCancellable object,
      */
     makeSymbolicLink(symlinkValue: string, cancellable?: Cancellable | null): boolean;
-    /**
-     * Asynchronously creates a symbolic link named `file` which contains the
-     * string @symlink_value.
-     * @param symlinkValue - a string with the path for the target
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback to call
-     * @param userData - the data to pass to callback function
-     */
-    makeSymbolicLinkAsync(symlinkValue: string, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes an asynchronous symbolic link creation, started with
      * g_file_make_symbolic_link_async().
      * @param result - a #GAsyncResult
      */
     makeSymbolicLinkFinish(result: AsyncResult): boolean;
-    /**
-     * Recursively measures the disk usage of @file.
-     *
-     * This is essentially an analog of the 'du' command, but it also
-     * reports the number of directories and non-directory files encountered
-     * (including things like symbolic links).
-     *
-     * By default, errors are only reported against the toplevel file
-     * itself.  Errors found while recursing are silently ignored, unless
-     * %G_FILE_MEASURE_REPORT_ANY_ERROR is given in @flags.
-     *
-     * The returned size, @disk_usage, is in bytes and should be formatted
-     * with g_format_size() in order to get something reasonable for showing
-     * in a user interface.
-     *
-     * `progress_callback` and `progress_data` can be given to request
-     * periodic progress updates while scanning.  See the documentation for
-     * #GFileMeasureProgressCallback for information about when and how the
-     * callback will be invoked.
-     * @param flags - #GFileMeasureFlags
-     * @param cancellable - optional #GCancellable
-     * @param progressCallback - a #GFileMeasureProgressCallback
-     * @param progressData - user_data for @progress_callback
-     * @param diskUsage - the number of bytes of disk space used
-     * @param numDirs - the number of directories encountered
-     * @param numFiles - the number of non-directories encountered
-     */
-    measureDiskUsage(flags: FileMeasureFlags, cancellable?: Cancellable | null, progressCallback?: (...args: unknown[]) => unknown | null, progressData?: number | null, diskUsage?: Ref<number> | null, numDirs?: Ref<number> | null, numFiles?: Ref<number> | null): boolean;
     /**
      * Collects the results from an earlier call to
      * g_file_measure_disk_usage_async().  See g_file_measure_disk_usage() for
@@ -984,48 +709,11 @@ export declare class File {
      * @param cancellable - optional #GCancellable object,
      */
     monitorFile(flags: FileMonitorFlags, cancellable?: Cancellable | null): FileMonitor;
-    /**
-     * Starts a @mount_operation, mounting the volume that contains
-     * the file @location.
-     *
-     * When this operation has completed, `callback` will be called with
-     * `user_user` data, and the operation can be finalized with
-     * g_file_mount_enclosing_volume_finish().
-     *
-     * If `cancellable` is not %NULL, then the operation can be cancelled by
-     * triggering the cancellable object from another thread. If the operation
-     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
-     * @param flags - flags affecting the operation
-     * @param mountOperation - a #GMountOperation
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback to call
-     * @param userData - the data to pass to callback function
-     */
-    mountEnclosingVolume(flags: MountMountFlags, mountOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes a mount operation started by g_file_mount_enclosing_volume().
      * @param result - a #GAsyncResult
      */
     mountEnclosingVolumeFinish(result: AsyncResult): boolean;
-    /**
-     * Mounts a file of type G_FILE_TYPE_MOUNTABLE.
-     * Using @mount_operation, you can request callbacks when, for instance,
-     * passwords are needed during authentication.
-     *
-     * If `cancellable` is not %NULL, then the operation can be cancelled by
-     * triggering the cancellable object from another thread. If the operation
-     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
-     *
-     * When the operation is finished, `callback` will be called.
-     * You can then call g_file_mount_mountable_finish() to get
-     * the result of the operation.
-     * @param flags - flags affecting the operation
-     * @param mountOperation - a #GMountOperation,
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    mountMountable(flags: MountMountFlags, mountOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes a mount operation. See g_file_mount_mountable() for details.
      *
@@ -1034,67 +722,6 @@ export declare class File {
      * @param result - a #GAsyncResult
      */
     mountMountableFinish(result: AsyncResult): File;
-    /**
-     * Tries to move the file or directory `source` to the location specified
-     * by @destination. If native move operations are supported then this is
-     * used, otherwise a copy + delete fallback is used. The native
-     * implementation may support moving directories (for instance on moves
-     * inside the same filesystem), but the fallback code does not.
-     *
-     * If the flag %G_FILE_COPY_OVERWRITE is specified an already
-     * existing `destination` file is overwritten.
-     *
-     * If `cancellable` is not %NULL, then the operation can be cancelled by
-     * triggering the cancellable object from another thread. If the operation
-     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
-     *
-     * If `progress_callback` is not %NULL, then the operation can be monitored
-     * by setting this to a #GFileProgressCallback function.
-     * `progress_callback_data` will be passed to this function. It is
-     * guaranteed that this callback will be called after all data has been
-     * transferred with the total number of bytes copied during the operation.
-     *
-     * If the `source` file does not exist, then the %G_IO_ERROR_NOT_FOUND
-     * error is returned, independent on the status of the @destination.
-     *
-     * If %G_FILE_COPY_OVERWRITE is not specified and the target exists,
-     * then the error %G_IO_ERROR_EXISTS is returned.
-     *
-     * If trying to overwrite a file over a directory, the %G_IO_ERROR_IS_DIRECTORY
-     * error is returned. If trying to overwrite a directory with a directory the
-     * %G_IO_ERROR_WOULD_MERGE error is returned.
-     *
-     * If the source is a directory and the target does not exist, or
-     * %G_FILE_COPY_OVERWRITE is specified and the target is a file, then
-     * the %G_IO_ERROR_WOULD_RECURSE error may be returned (if the native
-     * move operation isn't available).
-     * @param destination - #GFile pointing to the destination location
-     * @param flags - set of #GFileCopyFlags
-     * @param cancellable - optional #GCancellable object,
-     * @param progressCallback - #GFileProgressCallback
-     * @param progressCallbackData - gpointer to user data for
-     */
-    move(destination: File, flags: FileCopyFlags, cancellable?: Cancellable | null, progressCallback?: (...args: unknown[]) => unknown | null, progressCallbackData?: number | null): boolean;
-    /**
-     * Asynchronously moves a file `source` to the location of @destination. For details of the behaviour, see g_file_move().
-     *
-     * If `progress_callback` is not %NULL, then that function that will be called
-     * just like in g_file_move(). The callback will run in the default main context
-     * of the thread calling g_file_move_async() — the same context as `callback` is
-     * run in.
-     *
-     * When the operation is finished, `callback` will be called. You can then call
-     * g_file_move_finish() to get the result of the operation.
-     * @param destination - #GFile pointing to the destination location
-     * @param flags - set of #GFileCopyFlags
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional #GCancellable object,
-     * @param progressCallback - #GFileProgressCallback function for updates
-     * @param progressCallbackData - gpointer to user data for the callback function
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    moveAsync(destination: File, flags: FileCopyFlags, ioPriority: number, cancellable?: Cancellable | null, progressCallback?: (...args: unknown[]) => unknown | null, progressCallbackData?: number | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Version of [method@Gio.File.move_async] using closures instead of callbacks for
      * easier binding in other languages.
@@ -1132,21 +759,6 @@ export declare class File {
      * @param cancellable - a #GCancellable
      */
     openReadwrite(cancellable?: Cancellable | null): FileIOStream;
-    /**
-     * Asynchronously opens `file` for reading and writing.
-     *
-     * For more details, see g_file_open_readwrite() which is
-     * the synchronous version of this call.
-     *
-     * When the operation is finished, `callback` will be called.
-     * You can then call g_file_open_readwrite_finish() to get
-     * the result of the operation.
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    openReadwriteAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes an asynchronous file read operation started with
      * g_file_open_readwrite_async().
@@ -1163,21 +775,6 @@ export declare class File {
      * This call does no blocking I/O.
      */
     peekPath(): string | null;
-    /**
-     * Polls a file of type %G_FILE_TYPE_MOUNTABLE.
-     *
-     * If `cancellable` is not %NULL, then the operation can be cancelled by
-     * triggering the cancellable object from another thread. If the operation
-     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
-     *
-     * When the operation is finished, `callback` will be called.
-     * You can then call g_file_mount_mountable_finish() to get
-     * the result of the operation.
-     * @param cancellable - optional #GCancellable object, %NULL to ignore
-     * @param callback - a #GAsyncReadyCallback to call
-     * @param userData - the data to pass to callback function
-     */
-    pollMountable(cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes a poll operation. See g_file_poll_mountable() for details.
      *
@@ -1196,14 +793,6 @@ export declare class File {
      * @param cancellable - optional #GCancellable object, %NULL to ignore
      */
     queryDefaultHandler(cancellable?: Cancellable | null): AppInfo;
-    /**
-     * Async version of g_file_query_default_handler().
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional #GCancellable object, %NULL to ignore
-     * @param callback - a #GAsyncReadyCallback to call when the request is done
-     * @param userData - data to pass to @callback
-     */
-    queryDefaultHandlerAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes a g_file_query_default_handler_async() operation.
      * @param result - a #GAsyncResult
@@ -1278,25 +867,6 @@ export declare class File {
      * @param cancellable - optional #GCancellable object,
      */
     queryFilesystemInfo(attributes: string, cancellable?: Cancellable | null): FileInfo;
-    /**
-     * Asynchronously gets the requested information about the filesystem
-     * that the specified `file` is on. The result is a #GFileInfo object
-     * that contains key-value attributes (such as type or size for the
-     * file).
-     *
-     * For more details, see g_file_query_filesystem_info() which is the
-     * synchronous version of this call.
-     *
-     * When the operation is finished, `callback` will be called. You can
-     * then call g_file_query_info_finish() to get the result of the
-     * operation.
-     * @param attributes - an attribute query string
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    queryFilesystemInfoAsync(attributes: string, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes an asynchronous filesystem info query.
      * See g_file_query_filesystem_info_async().
@@ -1352,24 +922,6 @@ export declare class File {
      * @param cancellable - optional cancellable object
      */
     queryInfo(attributes: string, flags: FileQueryInfoFlags, cancellable?: Cancellable | null): FileInfo;
-    /**
-     * Asynchronously gets the requested information about specified @file.
-     * The result is a #GFileInfo object that contains key-value attributes
-     * (such as type or size for the file).
-     *
-     * For more details, see g_file_query_info() which is the synchronous
-     * version of this call.
-     *
-     * When the operation is finished, `callback` will be called. You can
-     * then call g_file_query_info_finish() to get the result of the operation.
-     * @param attributes - an attribute query string
-     * @param flags - a set of #GFileQueryInfoFlags
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    queryInfoAsync(attributes: string, flags: FileQueryInfoFlags, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes an asynchronous file info query.
      * See g_file_query_info_async().
@@ -1416,21 +968,6 @@ export declare class File {
      * @param cancellable - a #GCancellable
      */
     read(cancellable?: Cancellable | null): FileInputStream;
-    /**
-     * Asynchronously opens `file` for reading.
-     *
-     * For more details, see g_file_read() which is
-     * the synchronous version of this call.
-     *
-     * When the operation is finished, `callback` will be called.
-     * You can then call g_file_read_finish() to get the result
-     * of the operation.
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    readAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes an asynchronous file read operation started with
      * g_file_read_async().
@@ -1485,25 +1022,6 @@ export declare class File {
      * @param cancellable - optional #GCancellable object,
      */
     replace(makeBackup: boolean, flags: FileCreateFlags, etag?: string | null, cancellable?: Cancellable | null): FileOutputStream;
-    /**
-     * Asynchronously overwrites the file, replacing the contents,
-     * possibly creating a backup copy of the file first.
-     *
-     * For more details, see g_file_replace() which is
-     * the synchronous version of this call.
-     *
-     * When the operation is finished, `callback` will be called.
-     * You can then call g_file_replace_finish() to get the result
-     * of the operation.
-     * @param etag - an [entity tag](#entity-tags) for the current #GFile,
-     * @param makeBackup - %TRUE if a backup should be created
-     * @param flags - a set of #GFileCreateFlags
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    replaceAsync(makeBackup: boolean, flags: FileCreateFlags, ioPriority: number, etag?: string | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Replaces the contents of `file` with `contents` of `length` bytes.
      *
@@ -1530,54 +1048,6 @@ export declare class File {
      * @param cancellable - optional #GCancellable object, %NULL to ignore
      */
     replaceContents(contents: number[], length: number, makeBackup: boolean, flags: FileCreateFlags, etag?: string | null, newEtag?: Ref<string> | null, cancellable?: Cancellable | null): boolean;
-    /**
-     * Starts an asynchronous replacement of `file` with the given
-     * `contents` of `length` bytes. `etag` will replace the document's
-     * current entity tag.
-     *
-     * When this operation has completed, `callback` will be called with
-     * `user_user` data, and the operation can be finalized with
-     * g_file_replace_contents_finish().
-     *
-     * If `cancellable` is not %NULL, then the operation can be cancelled by
-     * triggering the cancellable object from another thread. If the operation
-     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
-     *
-     * If `make_backup` is %TRUE, this function will attempt to
-     * make a backup of @file.
-     *
-     * Note that no copy of `contents` will be made, so it must stay valid
-     * until `callback` is called. See g_file_replace_contents_bytes_async()
-     * for a #GBytes version that will automatically hold a reference to the
-     * contents (without copying) for the duration of the call.
-     * @param contents - string of contents to replace the file with
-     * @param length - the length of `contents` in bytes
-     * @param etag - a new [entity tag](#entity-tags) for the @file, or %NULL
-     * @param makeBackup - %TRUE if a backup should be created
-     * @param flags - a set of #GFileCreateFlags
-     * @param cancellable - optional #GCancellable object, %NULL to ignore
-     * @param callback - a #GAsyncReadyCallback to call when the request is satisfied
-     * @param userData - the data to pass to callback function
-     */
-    replaceContentsAsync(contents: number[], length: number, makeBackup: boolean, flags: FileCreateFlags, etag?: string | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
-    /**
-     * Same as g_file_replace_contents_async() but takes a #GBytes input instead.
-     * This function will keep a ref on `contents` until the operation is done.
-     * Unlike g_file_replace_contents_async() this allows forgetting about the
-     * content without waiting for the callback.
-     *
-     * When this operation has completed, `callback` will be called with
-     * `user_user` data, and the operation can be finalized with
-     * g_file_replace_contents_finish().
-     * @param contents - a #GBytes
-     * @param etag - a new [entity tag](#entity-tags) for the @file, or %NULL
-     * @param makeBackup - %TRUE if a backup should be created
-     * @param flags - a set of #GFileCreateFlags
-     * @param cancellable - optional #GCancellable object, %NULL to ignore
-     * @param callback - a #GAsyncReadyCallback to call when the request is satisfied
-     * @param userData - the data to pass to callback function
-     */
-    replaceContentsBytesAsync(contents: GLib.Bytes, makeBackup: boolean, flags: FileCreateFlags, etag?: string | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes an asynchronous replace of the given @file. See
      * g_file_replace_contents_async(). Sets `new_etag` to the new entity
@@ -1609,26 +1079,6 @@ export declare class File {
      * @param cancellable - optional #GCancellable object,
      */
     replaceReadwrite(makeBackup: boolean, flags: FileCreateFlags, etag?: string | null, cancellable?: Cancellable | null): FileIOStream;
-    /**
-     * Asynchronously overwrites the file in read-write mode,
-     * replacing the contents, possibly creating a backup copy
-     * of the file first.
-     *
-     * For more details, see g_file_replace_readwrite() which is
-     * the synchronous version of this call.
-     *
-     * When the operation is finished, `callback` will be called.
-     * You can then call g_file_replace_readwrite_finish() to get
-     * the result of the operation.
-     * @param etag - an [entity tag](#entity-tags) for the current #GFile,
-     * @param makeBackup - %TRUE if a backup should be created
-     * @param flags - a set of #GFileCreateFlags
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    replaceReadwriteAsync(makeBackup: boolean, flags: FileCreateFlags, ioPriority: number, etag?: string | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes an asynchronous file replace operation started with
      * g_file_replace_readwrite_async().
@@ -1740,23 +1190,6 @@ export declare class File {
      * @param cancellable - optional #GCancellable object,
      */
     setAttributeUint64(attribute: string, value: number, flags: FileQueryInfoFlags, cancellable?: Cancellable | null): boolean;
-    /**
-     * Asynchronously sets the attributes of `file` with @info.
-     *
-     * For more details, see g_file_set_attributes_from_info(),
-     * which is the synchronous version of this call.
-     *
-     * When the operation is finished, `callback` will be called.
-     * You can then call g_file_set_attributes_finish() to get
-     * the result of the operation.
-     * @param info - a #GFileInfo
-     * @param flags - a #GFileQueryInfoFlags
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    setAttributesAsync(info: FileInfo, flags: FileQueryInfoFlags, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes setting an attribute started in g_file_set_attributes_async().
      * @param result - a #GAsyncResult
@@ -1801,47 +1234,12 @@ export declare class File {
      * @param cancellable - optional #GCancellable object,
      */
     setDisplayName(displayName: string, cancellable?: Cancellable | null): File;
-    /**
-     * Asynchronously sets the display name for a given #GFile.
-     *
-     * For more details, see g_file_set_display_name() which is
-     * the synchronous version of this call.
-     *
-     * When the operation is finished, `callback` will be called.
-     * You can then call g_file_set_display_name_finish() to get
-     * the result of the operation.
-     * @param displayName - a string
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    setDisplayNameAsync(displayName: string, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes setting a display name started with
      * g_file_set_display_name_async().
      * @param res - a #GAsyncResult
      */
     setDisplayNameFinish(res: AsyncResult): File;
-    /**
-     * Starts a file of type %G_FILE_TYPE_MOUNTABLE.
-     * Using @start_operation, you can request callbacks when, for instance,
-     * passwords are needed during authentication.
-     *
-     * If `cancellable` is not %NULL, then the operation can be cancelled by
-     * triggering the cancellable object from another thread. If the operation
-     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
-     *
-     * When the operation is finished, `callback` will be called.
-     * You can then call g_file_mount_mountable_finish() to get
-     * the result of the operation.
-     * @param flags - flags affecting the operation
-     * @param startOperation - a #GMountOperation, or %NULL to avoid user interaction
-     * @param cancellable - optional #GCancellable object, %NULL to ignore
-     * @param callback - a #GAsyncReadyCallback to call when the request is satisfied, or %NULL
-     * @param userData - the data to pass to callback function
-     */
-    startMountable(flags: DriveStartFlags, startOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes a start operation. See g_file_start_mountable() for details.
      *
@@ -1850,23 +1248,6 @@ export declare class File {
      * @param result - a #GAsyncResult
      */
     startMountableFinish(result: AsyncResult): boolean;
-    /**
-     * Stops a file of type %G_FILE_TYPE_MOUNTABLE.
-     *
-     * If `cancellable` is not %NULL, then the operation can be cancelled by
-     * triggering the cancellable object from another thread. If the operation
-     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
-     *
-     * When the operation is finished, `callback` will be called.
-     * You can then call g_file_stop_mountable_finish() to get
-     * the result of the operation.
-     * @param flags - flags affecting the operation
-     * @param mountOperation - a #GMountOperation,
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback to call
-     * @param userData - the data to pass to callback function
-     */
-    stopMountable(flags: MountUnmountFlags, mountOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes a stop operation, see g_file_stop_mountable() for details.
      *
@@ -1899,36 +1280,12 @@ export declare class File {
      * @param cancellable - optional #GCancellable object,
      */
     trash(cancellable?: Cancellable | null): boolean;
-    /**
-     * Asynchronously sends `file` to the Trash location, if possible.
-     * @param ioPriority - the I/O priority of the request
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback to call
-     * @param userData - the data to pass to callback function
-     */
-    trashAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes an asynchronous file trashing operation, started with
      * g_file_trash_async().
      * @param result - a #GAsyncResult
      */
     trashFinish(result: AsyncResult): boolean;
-    /**
-     * Unmounts a file of type G_FILE_TYPE_MOUNTABLE.
-     *
-     * If `cancellable` is not %NULL, then the operation can be cancelled by
-     * triggering the cancellable object from another thread. If the operation
-     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
-     *
-     * When the operation is finished, `callback` will be called.
-     * You can then call g_file_unmount_mountable_finish() to get
-     * the result of the operation.
-     * @param flags - flags affecting the operation
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    unmountMountable(flags: MountUnmountFlags, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes an unmount operation, see g_file_unmount_mountable() for details.
      *
@@ -1937,23 +1294,6 @@ export declare class File {
      * @param result - a #GAsyncResult
      */
     unmountMountableFinish(result: AsyncResult): boolean;
-    /**
-     * Unmounts a file of type %G_FILE_TYPE_MOUNTABLE.
-     *
-     * If `cancellable` is not %NULL, then the operation can be cancelled by
-     * triggering the cancellable object from another thread. If the operation
-     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
-     *
-     * When the operation is finished, `callback` will be called.
-     * You can then call g_file_unmount_mountable_finish() to get
-     * the result of the operation.
-     * @param flags - flags affecting the operation
-     * @param mountOperation - a #GMountOperation,
-     * @param cancellable - optional #GCancellable object,
-     * @param callback - a #GAsyncReadyCallback
-     * @param userData - the data to pass to callback function
-     */
-    unmountMountableWithOperation(flags: MountUnmountFlags, mountOperation?: MountOperation | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes an unmount operation,
      * see g_file_unmount_mountable_with_operation() for details.