@girs/gio-2.0 2.76.1-3.2.0 → 2.77.0-3.2.2

package/gio-2.0.d.ts

@@ -2177,6 +2177,9 @@ enum FileMeasureFlags {
      *   sizes.  Normally, the block-size is used, if available, as this is a
      *   more accurate representation of disk space used.
      *   Compare with `du --apparent-size`.
+     *   Since GLib 2.78. and similarly to `du` since GNU Coreutils 9.2, this will
+     *   ignore the sizes of file types other than regular files and links, as the
+     *   sizes of other file types are not specified in a standard way.
      */
     APPARENT_SIZE,
     /**
@@ -4562,6 +4565,16 @@ function dtls_client_connection_new(base_socket: DatagramBased, server_identity:
  * @returns the new   #GDtlsServerConnection, or %NULL on error
  */
 function dtls_server_connection_new(base_socket: DatagramBased, certificate: TlsCertificate | null): DtlsServerConnection
+/**
+ * Constructs a #GFile from a vector of elements using the correct
+ * separator for filenames.
+ * 
+ * Using this function is equivalent to calling g_build_filenamev(),
+ * followed by g_file_new_for_path() on the result.
+ * @param args %NULL-terminated   array of strings containing the path elements.
+ * @returns a new #GFile
+ */
+function file_new_build_filenamev(args: string[]): File
 /**
  * Creates a #GFile with the given argument from the command line.
  * The value of `arg` can be either a URI, an absolute path or a
@@ -6998,6 +7011,34 @@ interface ActionMap {
      * @param action_name the name of the action
      */
     remove_action(action_name: string | null): void
+    /**
+     * Remove actions from a #GActionMap. This is meant as the reverse of
+     * g_action_map_add_action_entries().
+     * 
+     * 
+     * 
+     * ```c
+     * static const GActionEntry entries[] = {
+     *     { "quit",         activate_quit              },
+     *     { "print-string", activate_print_string, "s" }
+     * };
+     * 
+     * void
+     * add_actions (GActionMap *map)
+     * {
+     *   g_action_map_add_action_entries (map, entries, G_N_ELEMENTS (entries), NULL);
+     * }
+     * 
+     * void
+     * remove_actions (GActionMap *map)
+     * {
+     *   g_action_map_remove_action_entries (map, entries, G_N_ELEMENTS (entries));
+     * }
+     * ```
+     * 
+     * @param entries a pointer to           the first item in an array of #GActionEntry structs
+     */
+    remove_action_entries(entries: ActionEntry[]): void
 
     // Own virtual methods of Gio-2.0.Gio.ActionMap
 
@@ -14834,7 +14875,7 @@ interface File {
  * - g_file_new_tmp_async() to asynchronously create a temporary file.
  * - g_file_new_tmp_dir_async() to asynchronously create a temporary directory.
  * - g_file_parse_name() from a UTF-8 string gotten from g_file_get_parse_name().
- * - g_file_new_build_filename() to create a file from path elements.
+ * - g_file_new_build_filename() or g_file_new_build_filenamev() to create a file from path elements.
  * 
  * One way to think of a #GFile is as an abstraction of a pathname. For
  * normal files the system pathname is what is stored internally, but as
@@ -14915,6 +14956,16 @@ class File extends GObject.Object {
 
     constructor(config?: File.ConstructorProperties) 
     _init(config?: File.ConstructorProperties): void
+    /**
+     * Constructs a #GFile from a vector of elements using the correct
+     * separator for filenames.
+     * 
+     * Using this function is equivalent to calling g_build_filenamev(),
+     * followed by g_file_new_for_path() on the result.
+     * @param args %NULL-terminated   array of strings containing the path elements.
+     * @returns a new #GFile
+     */
+    static new_build_filenamev(args: string[]): File
     /**
      * Creates a #GFile with the given argument from the command line.
      * The value of `arg` can be either a URI, an absolute path or a
@@ -16709,6 +16760,9 @@ interface PollableInputStream extends InputStream {
      * the stream may not actually be readable even after the source
      * triggers, so you should use g_pollable_input_stream_read_nonblocking()
      * rather than g_input_stream_read() from the callback.
+     * 
+     * The behaviour of this method is undefined if
+     * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
      * @param cancellable a #GCancellable, or %NULL
      * @returns a new #GSource
      */
@@ -16722,6 +16776,9 @@ interface PollableInputStream extends InputStream {
      * non-blocking behavior, you should always use
      * g_pollable_input_stream_read_nonblocking(), which will return a
      * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+     * 
+     * The behaviour of this method is undefined if
+     * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
      * @returns %TRUE if @stream is readable, %FALSE if not. If an error   has occurred on @stream, this will result in   g_pollable_input_stream_is_readable() returning %TRUE, and the   next attempt to read will return the error.
      */
     is_readable(): boolean
@@ -16737,6 +16794,9 @@ interface PollableInputStream extends InputStream {
      * if `cancellable` has already been cancelled when you call, which
      * may happen if you call this method after a source triggers due
      * to having been cancelled.
+     * 
+     * The behaviour of this method is undefined if
+     * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
      * @param cancellable a #GCancellable, or %NULL
      * @returns the number of bytes read, or -1 on error (including   %G_IO_ERROR_WOULD_BLOCK).
      */
@@ -16765,6 +16825,9 @@ interface PollableInputStream extends InputStream {
      * the stream may not actually be readable even after the source
      * triggers, so you should use g_pollable_input_stream_read_nonblocking()
      * rather than g_input_stream_read() from the callback.
+     * 
+     * The behaviour of this method is undefined if
+     * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
      * @virtual 
      * @param cancellable a #GCancellable, or %NULL
      * @returns a new #GSource
@@ -16779,6 +16842,9 @@ interface PollableInputStream extends InputStream {
      * non-blocking behavior, you should always use
      * g_pollable_input_stream_read_nonblocking(), which will return a
      * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+     * 
+     * The behaviour of this method is undefined if
+     * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
      * @virtual 
      * @returns %TRUE if @stream is readable, %FALSE if not. If an error   has occurred on @stream, this will result in   g_pollable_input_stream_is_readable() returning %TRUE, and the   next attempt to read will return the error.
      */
@@ -16795,6 +16861,9 @@ interface PollableInputStream extends InputStream {
      * if `cancellable` has already been cancelled when you call, which
      * may happen if you call this method after a source triggers due
      * to having been cancelled.
+     * 
+     * The behaviour of this method is undefined if
+     * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
      * @virtual 
      * @returns the number of bytes read, or -1 on error (including   %G_IO_ERROR_WOULD_BLOCK).
      */
@@ -16813,6 +16882,11 @@ interface PollableInputStream extends InputStream {
  * can be polled for readiness to read. This can be used when
  * interfacing with a non-GIO API that expects
  * UNIX-file-descriptor-style asynchronous I/O rather than GIO-style.
+ * 
+ * Some classes may implement #GPollableInputStream but have only certain
+ * instances of that class be pollable. If g_pollable_input_stream_can_poll()
+ * returns %FALSE, then the behavior of other #GPollableInputStream methods is
+ * undefined.
  * @interface 
  */
 class PollableInputStream extends GObject.Object {
@@ -16861,6 +16935,9 @@ interface PollableOutputStream extends OutputStream {
      * the stream may not actually be writable even after the source
      * triggers, so you should use g_pollable_output_stream_write_nonblocking()
      * rather than g_output_stream_write() from the callback.
+     * 
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
      * @param cancellable a #GCancellable, or %NULL
      * @returns a new #GSource
      */
@@ -16874,6 +16951,9 @@ interface PollableOutputStream extends OutputStream {
      * non-blocking behavior, you should always use
      * g_pollable_output_stream_write_nonblocking(), which will return a
      * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+     * 
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
      * @returns %TRUE if @stream is writable, %FALSE if not. If an error   has occurred on @stream, this will result in   g_pollable_output_stream_is_writable() returning %TRUE, and the   next attempt to write will return the error.
      */
     is_writable(): boolean
@@ -16893,6 +16973,9 @@ interface PollableOutputStream extends OutputStream {
      * Also note that if %G_IO_ERROR_WOULD_BLOCK is returned some underlying
      * transports like D/TLS require that you re-send the same `buffer` and
      * `count` in the next write call.
+     * 
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
      * @param buffer a buffer to write     data from
      * @param cancellable a #GCancellable, or %NULL
      * @returns the number of bytes written, or -1 on error (including   %G_IO_ERROR_WOULD_BLOCK).
@@ -16915,6 +16998,9 @@ interface PollableOutputStream extends OutputStream {
      * Also note that if %G_POLLABLE_RETURN_WOULD_BLOCK is returned some underlying
      * transports like D/TLS require that you re-send the same `vectors` and
      * `n_vectors` in the next write call.
+     * 
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
      * @param vectors the buffer containing the #GOutputVectors to write.
      * @param cancellable a #GCancellable, or %NULL
      * @returns %@G_POLLABLE_RETURN_OK on success, %G_POLLABLE_RETURN_WOULD_BLOCK if the stream is not currently writable (and @error is *not* set), or %G_POLLABLE_RETURN_FAILED if there was an error in which case @error will be set.
@@ -16944,6 +17030,9 @@ interface PollableOutputStream extends OutputStream {
      * the stream may not actually be writable even after the source
      * triggers, so you should use g_pollable_output_stream_write_nonblocking()
      * rather than g_output_stream_write() from the callback.
+     * 
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
      * @virtual 
      * @param cancellable a #GCancellable, or %NULL
      * @returns a new #GSource
@@ -16958,6 +17047,9 @@ interface PollableOutputStream extends OutputStream {
      * non-blocking behavior, you should always use
      * g_pollable_output_stream_write_nonblocking(), which will return a
      * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+     * 
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
      * @virtual 
      * @returns %TRUE if @stream is writable, %FALSE if not. If an error   has occurred on @stream, this will result in   g_pollable_output_stream_is_writable() returning %TRUE, and the   next attempt to write will return the error.
      */
@@ -16978,6 +17070,9 @@ interface PollableOutputStream extends OutputStream {
      * Also note that if %G_IO_ERROR_WOULD_BLOCK is returned some underlying
      * transports like D/TLS require that you re-send the same `buffer` and
      * `count` in the next write call.
+     * 
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
      * @virtual 
      * @param buffer a buffer to write     data from
      * @returns the number of bytes written, or -1 on error (including   %G_IO_ERROR_WOULD_BLOCK).
@@ -17000,6 +17095,9 @@ interface PollableOutputStream extends OutputStream {
      * Also note that if %G_POLLABLE_RETURN_WOULD_BLOCK is returned some underlying
      * transports like D/TLS require that you re-send the same `vectors` and
      * `n_vectors` in the next write call.
+     * 
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
      * @virtual 
      * @param vectors the buffer containing the #GOutputVectors to write.
      * @returns %@G_POLLABLE_RETURN_OK on success, %G_POLLABLE_RETURN_WOULD_BLOCK if the stream is not currently writable (and @error is *not* set), or %G_POLLABLE_RETURN_FAILED if there was an error in which case @error will be set.
@@ -17019,6 +17117,11 @@ interface PollableOutputStream extends OutputStream {
  * can be polled for readiness to write. This can be used when
  * interfacing with a non-GIO API that expects
  * UNIX-file-descriptor-style asynchronous I/O rather than GIO-style.
+ * 
+ * Some classes may implement #GPollableOutputStream but have only certain
+ * instances of that class be pollable. If g_pollable_output_stream_can_poll()
+ * returns %FALSE, then the behavior of other #GPollableOutputStream methods is
+ * undefined.
  * @interface 
  */
 class PollableOutputStream extends GObject.Object {
@@ -19091,19 +19194,34 @@ interface AppInfoMonitor {
 
 /**
  * #GAppInfoMonitor is a very simple object used for monitoring the app
- * info database for changes (ie: newly installed or removed
- * applications).
+ * info database for changes (newly installed or removed applications).
  * 
  * Call g_app_info_monitor_get() to get a #GAppInfoMonitor and connect
- * to the "changed" signal.
+ * to the #GAppInfoMonitor::changed signal. The signal will be emitted once when
+ * the app info database changes, and will not be emitted again until after the
+ * next call to g_app_info_get_all() or another `g_app_info_*()` function. This
+ * is because monitoring the app info database for changes is expensive.
+ * 
+ * The following functions will re-arm the #GAppInfoMonitor::changed signal so
+ * it can be emitted again:
+ *  - g_app_info_get_all()
+ *  - g_app_info_get_all_for_type()
+ *  - g_app_info_get_default_for_type()
+ *  - g_app_info_get_fallback_for_type()
+ *  - g_app_info_get_recommended_for_type()
+ *  - g_desktop_app_info_get_implementations()
+ *  - g_desktop_app_info_new()
+ *  - g_desktop_app_info_new_from_filename()
+ *  - g_desktop_app_info_new_from_keyfile()
+ *  - g_desktop_app_info_search()
  * 
  * In the usual case, applications should try to make note of the change
  * (doing things like invalidating caches) but not act on it.  In
  * particular, applications should avoid making calls to #GAppInfo APIs
  * in response to the change signal, deferring these until the time that
- * the data is actually required.  The exception to this case is when
+ * the updated data is actually required.  The exception to this case is when
  * application information is actually being displayed on the screen
- * (eg: during a search or when the list of all applications is shown).
+ * (for example, during a search or when the list of all applications is shown).
  * The reason for this is that changes to the list of installed
  * applications often come in groups (like during system updates) and
  * rescanning the list on every change is pointless and expensive.
@@ -19128,6 +19246,10 @@ class AppInfoMonitor extends GObject.Object {
      * thread-default main context whenever the list of installed
      * applications (as reported by g_app_info_get_all()) may have changed.
      * 
+     * The #GAppInfoMonitor::changed signal will only be emitted once until
+     * g_app_info_get_all() (or another `g_app_info_*()` function) is called. Doing
+     * so will re-arm the signal ready to notify about the next change.
+     * 
      * You must only call g_object_unref() on the return value from under
      * the same main context as you created it.
      * @returns a reference to a #GAppInfoMonitor
@@ -19640,7 +19762,7 @@ interface Application extends ActionGroup, ActionMap {
      * Increases the use count of `application`.
      * 
      * Use this function to indicate that the application has a reason to
-     * continue to run.  For example, g_application_hold() is called by GTK+
+     * continue to run.  For example, g_application_hold() is called by GTK
      * when a toplevel window is on the screen.
      * 
      * To cancel the hold, call g_application_release().
@@ -20181,6 +20303,10 @@ interface Application extends ActionGroup, ActionMap {
  * conveniently access them remotely. GIO provides a #GDBusMenuModel wrapper
  * for remote access to exported #GMenuModels.
  * 
+ * Note: Due to the fact that actions are exported on the session bus,
+ * using `maybe` parameters is not supported, since D-Bus does not support
+ * `maybe` types.
+ * 
  * There is a number of different entry points into a GApplication:
  * 
  * - via 'Activate' (i.e. just starting the application)
@@ -26335,9 +26461,10 @@ interface DebugControllerDBus extends DebugController, Initable {
  * #GDebugController:debug-enabled and, by default, g_log_get_debug_enabled().
  * default.
  * 
- * By default, all processes will be able to call `SetDebugEnabled()`. If this
- * process is privileged, or might expose sensitive information in its debug
- * output, you may want to restrict the ability to enable debug output to
+ * By default, no processes are allowed to call `SetDebugEnabled()` unless a
+ * #GDebugControllerDBus::authorize signal handler is installed. This is because
+ * the process may be privileged, or might expose sensitive information in its
+ * debug output. You may want to restrict the ability to enable debug output to
  * privileged users or processes.
  * 
  * One option is to install a D-Bus security policy which restricts access to
@@ -27163,22 +27290,69 @@ interface FileEnumerator {
     next_file(cancellable: Cancellable | null): FileInfo | null
     /**
      * Request information for a number of files from the enumerator asynchronously.
-     * When all i/o for the operation is finished the `callback` will be called with
+     * When all I/O for the operation is finished the `callback` will be called with
      * the requested information.
      * 
      * See the documentation of #GFileEnumerator for information about the
      * order of returned files.
      * 
-     * The callback can be called with less than `num_files` files in case of error
-     * or at the end of the enumerator. In case of a partial error the callback will
-     * be called with any succeeding items and no error, and on the next request the
-     * error will be reported. If a request is cancelled the callback will be called
-     * with %G_IO_ERROR_CANCELLED.
+     * Once the end of the enumerator is reached, or if an error occurs, the
+     * `callback` will be called with an empty list. In this case, the previous call
+     * to g_file_enumerator_next_files_async() will typically have returned fewer
+     * than `num_files` items.
+     * 
+     * If a request is cancelled the callback will be called with
+     * %G_IO_ERROR_CANCELLED.
+     * 
+     * This leads to the following pseudo-code usage:
+     * 
+     * ```
+     * g_autoptr(GFile) dir = get_directory ();
+     * g_autoptr(GFileEnumerator) enumerator = NULL;
+     * g_autolist(GFileInfo) files = NULL;
+     * g_autoptr(GError) local_error = NULL;
+     * 
+     * enumerator = yield g_file_enumerate_children_async (dir,
+     *                                                     G_FILE_ATTRIBUTE_STANDARD_NAME ","
+     *                                                     G_FILE_ATTRIBUTE_STANDARD_TYPE,
+     *                                                     G_FILE_QUERY_INFO_NONE,
+     *                                                     G_PRIORITY_DEFAULT,
+     *                                                     cancellable,
+     *                                                     …,
+     *                                                     &local_error);
+     * if (enumerator == NULL)
+     *   g_error ("Error enumerating: %s", local_error->message);
+     * 
+     * // Loop until no files are returned, either because the end of the enumerator
+     * // has been reached, or an error was returned.
+     * do
+     *   {
+     *     files = yield g_file_enumerator_next_files_async (enumerator,
+     *                                                       5,  // number of files to request
+     *                                                       G_PRIORITY_DEFAULT,
+     *                                                       cancellable,
+     *                                                       …,
+     *                                                       &local_error);
+     * 
+     *     // Process the returned files, but don’t assume that exactly 5 were returned.
+     *     for (GList *l = files; l != NULL; l = l->next)
+     *       {
+     *         GFileInfo *info = l->data;
+     *         handle_file_info (info);
+     *       }
+     *   }
+     * while (files != NULL);
+     * 
+     * if (local_error != NULL &&
+     *     !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+     *   g_error ("Error while enumerating: %s", local_error->message);
+     * ```
+     * 
      * 
      * During an async request no other sync and async calls are allowed, and will
      * result in %G_IO_ERROR_PENDING errors.
      * 
-     * Any outstanding i/o request with higher priority (lower numerical value) will
+     * Any outstanding I/O request with higher priority (lower numerical value) will
      * be executed before an outstanding request with lower priority. Default
      * priority is %G_PRIORITY_DEFAULT.
      * @param num_files the number of file info objects to request
@@ -27194,22 +27368,69 @@ interface FileEnumerator {
      * Promisified version of {@link next_files_async}
      * 
      * Request information for a number of files from the enumerator asynchronously.
-     * When all i/o for the operation is finished the `callback` will be called with
+     * When all I/O for the operation is finished the `callback` will be called with
      * the requested information.
      * 
      * See the documentation of #GFileEnumerator for information about the
      * order of returned files.
      * 
-     * The callback can be called with less than `num_files` files in case of error
-     * or at the end of the enumerator. In case of a partial error the callback will
-     * be called with any succeeding items and no error, and on the next request the
-     * error will be reported. If a request is cancelled the callback will be called
-     * with %G_IO_ERROR_CANCELLED.
+     * Once the end of the enumerator is reached, or if an error occurs, the
+     * `callback` will be called with an empty list. In this case, the previous call
+     * to g_file_enumerator_next_files_async() will typically have returned fewer
+     * than `num_files` items.
+     * 
+     * If a request is cancelled the callback will be called with
+     * %G_IO_ERROR_CANCELLED.
+     * 
+     * This leads to the following pseudo-code usage:
+     * 
+     * ```
+     * g_autoptr(GFile) dir = get_directory ();
+     * g_autoptr(GFileEnumerator) enumerator = NULL;
+     * g_autolist(GFileInfo) files = NULL;
+     * g_autoptr(GError) local_error = NULL;
+     * 
+     * enumerator = yield g_file_enumerate_children_async (dir,
+     *                                                     G_FILE_ATTRIBUTE_STANDARD_NAME ","
+     *                                                     G_FILE_ATTRIBUTE_STANDARD_TYPE,
+     *                                                     G_FILE_QUERY_INFO_NONE,
+     *                                                     G_PRIORITY_DEFAULT,
+     *                                                     cancellable,
+     *                                                     …,
+     *                                                     &local_error);
+     * if (enumerator == NULL)
+     *   g_error ("Error enumerating: %s", local_error->message);
+     * 
+     * // Loop until no files are returned, either because the end of the enumerator
+     * // has been reached, or an error was returned.
+     * do
+     *   {
+     *     files = yield g_file_enumerator_next_files_async (enumerator,
+     *                                                       5,  // number of files to request
+     *                                                       G_PRIORITY_DEFAULT,
+     *                                                       cancellable,
+     *                                                       …,
+     *                                                       &local_error);
+     * 
+     *     // Process the returned files, but don’t assume that exactly 5 were returned.
+     *     for (GList *l = files; l != NULL; l = l->next)
+     *       {
+     *         GFileInfo *info = l->data;
+     *         handle_file_info (info);
+     *       }
+     *   }
+     * while (files != NULL);
+     * 
+     * if (local_error != NULL &&
+     *     !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+     *   g_error ("Error while enumerating: %s", local_error->message);
+     * ```
+     * 
      * 
      * During an async request no other sync and async calls are allowed, and will
      * result in %G_IO_ERROR_PENDING errors.
      * 
-     * Any outstanding i/o request with higher priority (lower numerical value) will
+     * Any outstanding I/O request with higher priority (lower numerical value) will
      * be executed before an outstanding request with lower priority. Default
      * priority is %G_PRIORITY_DEFAULT.
      * @param num_files the number of file info objects to request
@@ -27281,22 +27502,69 @@ interface FileEnumerator {
     vfunc_next_file(cancellable: Cancellable | null): FileInfo | null
     /**
      * Request information for a number of files from the enumerator asynchronously.
-     * When all i/o for the operation is finished the `callback` will be called with
+     * When all I/O for the operation is finished the `callback` will be called with
      * the requested information.
      * 
      * See the documentation of #GFileEnumerator for information about the
      * order of returned files.
      * 
-     * The callback can be called with less than `num_files` files in case of error
-     * or at the end of the enumerator. In case of a partial error the callback will
-     * be called with any succeeding items and no error, and on the next request the
-     * error will be reported. If a request is cancelled the callback will be called
-     * with %G_IO_ERROR_CANCELLED.
+     * Once the end of the enumerator is reached, or if an error occurs, the
+     * `callback` will be called with an empty list. In this case, the previous call
+     * to g_file_enumerator_next_files_async() will typically have returned fewer
+     * than `num_files` items.
+     * 
+     * If a request is cancelled the callback will be called with
+     * %G_IO_ERROR_CANCELLED.
+     * 
+     * This leads to the following pseudo-code usage:
+     * 
+     * ```
+     * g_autoptr(GFile) dir = get_directory ();
+     * g_autoptr(GFileEnumerator) enumerator = NULL;
+     * g_autolist(GFileInfo) files = NULL;
+     * g_autoptr(GError) local_error = NULL;
+     * 
+     * enumerator = yield g_file_enumerate_children_async (dir,
+     *                                                     G_FILE_ATTRIBUTE_STANDARD_NAME ","
+     *                                                     G_FILE_ATTRIBUTE_STANDARD_TYPE,
+     *                                                     G_FILE_QUERY_INFO_NONE,
+     *                                                     G_PRIORITY_DEFAULT,
+     *                                                     cancellable,
+     *                                                     …,
+     *                                                     &local_error);
+     * if (enumerator == NULL)
+     *   g_error ("Error enumerating: %s", local_error->message);
+     * 
+     * // Loop until no files are returned, either because the end of the enumerator
+     * // has been reached, or an error was returned.
+     * do
+     *   {
+     *     files = yield g_file_enumerator_next_files_async (enumerator,
+     *                                                       5,  // number of files to request
+     *                                                       G_PRIORITY_DEFAULT,
+     *                                                       cancellable,
+     *                                                       …,
+     *                                                       &local_error);
+     * 
+     *     // Process the returned files, but don’t assume that exactly 5 were returned.
+     *     for (GList *l = files; l != NULL; l = l->next)
+     *       {
+     *         GFileInfo *info = l->data;
+     *         handle_file_info (info);
+     *       }
+     *   }
+     * while (files != NULL);
+     * 
+     * if (local_error != NULL &&
+     *     !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+     *   g_error ("Error while enumerating: %s", local_error->message);
+     * ```
+     * 
      * 
      * During an async request no other sync and async calls are allowed, and will
      * result in %G_IO_ERROR_PENDING errors.
      * 
-     * Any outstanding i/o request with higher priority (lower numerical value) will
+     * Any outstanding I/O request with higher priority (lower numerical value) will
      * be executed before an outstanding request with lower priority. Default
      * priority is %G_PRIORITY_DEFAULT.
      * @virtual 
@@ -28161,7 +28429,7 @@ interface FileInfo {
      * to the given symlink target.
      * @param symlink_target a static string containing a path to a symlink target.
      */
-    set_symlink_target(symlink_target: string | null): void
+    set_symlink_target(symlink_target: string): void
     /**
      * Unsets a mask set by g_file_info_set_attribute_mask(), if one
      * is set.
@@ -30469,7 +30737,7 @@ interface InputStream {
  * streaming APIs.
  * 
  * All of these functions have async variants too.
- * @interface 
+ * @class 
  */
 class InputStream extends GObject.Object {
 
@@ -33970,7 +34238,7 @@ interface OutputStream {
  * streaming APIs.
  * 
  * All of these functions have async variants too.
- * @interface 
+ * @class 
  */
 class OutputStream extends GObject.Object {
 
@@ -34810,12 +35078,44 @@ module Resolver {
     // Constructor properties interface
 
     interface ConstructorProperties extends GObject.Object.ConstructorProperties {
+
+        // Own constructor properties of Gio-2.0.Gio.Resolver
+
+        /**
+         * The timeout applied to all resolver lookups, in milliseconds.
+         * 
+         * This may be changed through the lifetime of the #GResolver. The new value
+         * will apply to any lookups started after the change, but not to any
+         * already-ongoing lookups.
+         * 
+         * If this is `0`, no timeout is applied to lookups.
+         * 
+         * No timeout was applied to lookups before this property was added in
+         * GLib 2.78.
+         */
+        timeout?: number | null
     }
 
 }
 
 interface Resolver {
 
+    // Own properties of Gio-2.0.Gio.Resolver
+
+    /**
+     * The timeout applied to all resolver lookups, in milliseconds.
+     * 
+     * This may be changed through the lifetime of the #GResolver. The new value
+     * will apply to any lookups started after the change, but not to any
+     * already-ongoing lookups.
+     * 
+     * If this is `0`, no timeout is applied to lookups.
+     * 
+     * No timeout was applied to lookups before this property was added in
+     * GLib 2.78.
+     */
+    timeout: number
+
     // Own fields of Gio-2.0.Gio.Resolver
 
     parent_instance: GObject.Object
@@ -34823,6 +35123,11 @@ interface Resolver {
 
     // Owm methods of Gio-2.0.Gio.Resolver
 
+    /**
+     * Get the timeout applied to all resolver lookups. See #GResolver:timeout.
+     * @returns the resolver timeout, in milliseconds, or `0` for no timeout
+     */
+    get_timeout(): number
     /**
      * Synchronously reverse-resolves `address` to determine its
      * associated hostname.
@@ -35125,6 +35430,11 @@ interface Resolver {
      * itself as the default resolver for all later code to use.
      */
     set_default(): void
+    /**
+     * Set the timeout applied to all resolver lookups. See #GResolver:timeout.
+     * @param timeout_ms timeout in milliseconds, or `0` for no timeouts
+     */
+    set_timeout(timeout_ms: number): void
 
     // Own virtual methods of Gio-2.0.Gio.Resolver
 
@@ -35321,6 +35631,9 @@ interface Resolver {
 
     // Class property signals of Gio-2.0.Gio.Resolver
 
+    connect(sigName: "notify::timeout", callback: (($obj: Resolver, pspec: GObject.ParamSpec) => void)): number
+    connect_after(sigName: "notify::timeout", callback: (($obj: Resolver, pspec: GObject.ParamSpec) => void)): number
+    emit(sigName: "notify::timeout", ...args: any[]): void
     connect(sigName: string, callback: (...args: any[]) => void): number
     connect_after(sigName: string, callback: (...args: any[]) => void): number
     emit(sigName: string, ...args: any[]): void
@@ -35336,6 +35649,10 @@ interface Resolver {
  * #GNetworkAddress and #GNetworkService provide wrappers around
  * #GResolver functionality that also implement #GSocketConnectable,
  * making it easy to connect to a remote host/service.
+ * 
+ * The default resolver (see g_resolver_get_default()) has a timeout of 30s set
+ * on it since GLib 2.78. Earlier versions of GLib did not support resolver
+ * timeouts.
  * @class 
  */
 class Resolver extends GObject.Object {
@@ -41652,6 +41969,13 @@ interface Task extends AsyncResult {
      * do this. If you have a very large number of tasks to run (several tens of
      * tasks), but don't want them to all run at once, you should only queue a
      * limited number of them (around ten) at a time.
+     * 
+     * Be aware that if your task depends on other tasks to complete, use of this
+     * function could lead to a livelock if the other tasks also use this function
+     * and enough of them (around 10) execute in a dependency chain, as that will
+     * exhaust the thread pool. If this situation is possible, consider using a
+     * separate worker thread or thread pool explicitly, rather than using
+     * g_task_run_in_thread().
      * @param task_func a #GTaskThreadFunc
      */
     run_in_thread(task_func: TaskThreadFunc): void
@@ -45414,7 +45738,7 @@ interface TlsInteraction {
  * initialization function. Any interactions not implemented will return
  * %G_TLS_INTERACTION_UNHANDLED. If a derived class implements an async method,
  * it must also implement the corresponding finish method.
- * @class 
+ * @interface 
  */
 class TlsInteraction extends GObject.Object {