@gtkx/ffi 0.7.0 → 0.9.0

package/dist/generated/gio/dbus-object-manager-client.js

@@ -1,4 +1,7 @@
-import { call, NativeError, getObject, getInterface, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { NativeError } from "../../native-error.js";
+import { getObject, getInterface, isInstantiating, setInstantiating, } from "../../native.js";
+import { registerType } from "../../registry.js";
 import { DBusInterface } from "./dbus-interface.js";
 import { DBusObject } from "./dbus-object.js";
 import { DBusObjectProxy } from "./dbus-object-proxy.js";
@@ -165,291 +168,6 @@ export class DBusObjectManagerClient extends GObject.GObject {
         }
         return getObject(ptr);
     }
-    /**
-     * Like g_dbus_object_manager_client_new_sync() but takes a #GBusType instead
-     * of a #GDBusConnection.
-     *
-     * This is a synchronous failable constructor - the calling thread is
-     * blocked until a reply is received. See g_dbus_object_manager_client_new_for_bus()
-     * for the asynchronous version.
-     * @param busType - A #GBusType.
-     * @param flags - Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
-     * @param name - The owner of the control object (unique or well-known name).
-     * @param objectPath - The object path of the control object.
-     * @param getProxyTypeFunc - A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
-     * @param getProxyTypeUserData - User data to pass to @get_proxy_type_func.
-     * @param getProxyTypeDestroyNotify - Free function for `get_proxy_type_user_data` or %NULL.
-     * @param cancellable - A #GCancellable or %NULL
-     */
-    static objectManagerClientNewForBusSync(busType, flags, name, objectPath, getProxyTypeFunc, getProxyTypeUserData, getProxyTypeDestroyNotify, cancellable) {
-        const error = { value: null };
-        const ptr = call("libgio-2.0.so.0", "g_dbus_object_manager_client_new_for_bus_sync", [
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: busType,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "string" },
-                value: name,
-            },
-            {
-                type: { type: "string" },
-                value: objectPath,
-            },
-            {
-                type: { type: "callback" },
-                value: getProxyTypeFunc,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: getProxyTypeUserData,
-                optional: true,
-            },
-            {
-                type: { type: "callback", trampoline: "destroy" },
-                value: getProxyTypeDestroyNotify,
-                optional: true,
-            },
-            {
-                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: false });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        return getObject(ptr);
-    }
-    /**
-     * Creates a new #GDBusObjectManagerClient object.
-     *
-     * This is a synchronous failable constructor - the calling thread is
-     * blocked until a reply is received. See g_dbus_object_manager_client_new()
-     * for the asynchronous version.
-     * @param connection - A #GDBusConnection.
-     * @param flags - Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
-     * @param name - The owner of the control object (unique or well-known name), or %NULL when not using a message bus connection.
-     * @param objectPath - The object path of the control object.
-     * @param getProxyTypeFunc - A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
-     * @param getProxyTypeUserData - User data to pass to @get_proxy_type_func.
-     * @param getProxyTypeDestroyNotify - Free function for `get_proxy_type_user_data` or %NULL.
-     * @param cancellable - A #GCancellable or %NULL
-     */
-    static objectManagerClientNewSync(connection, flags, objectPath, name, getProxyTypeFunc, getProxyTypeUserData, getProxyTypeDestroyNotify, cancellable) {
-        const error = { value: null };
-        const ptr = call("libgio-2.0.so.0", "g_dbus_object_manager_client_new_sync", [
-            {
-                type: { type: "gobject", borrowed: true },
-                value: connection?.id ?? connection,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "string" },
-                value: name,
-                optional: true,
-            },
-            {
-                type: { type: "string" },
-                value: objectPath,
-            },
-            {
-                type: { type: "callback" },
-                value: getProxyTypeFunc,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: getProxyTypeUserData,
-                optional: true,
-            },
-            {
-                type: { type: "callback", trampoline: "destroy" },
-                value: getProxyTypeDestroyNotify,
-                optional: true,
-            },
-            {
-                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: false });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        return getObject(ptr);
-    }
-    /**
-     * Asynchronously creates a new #GDBusObjectManagerClient object.
-     *
-     * This is an asynchronous failable constructor. When the result is
-     * ready, `callback` will be invoked in the thread-default main context
-     * (see [method@GLib.MainContext.push_thread_default])
-     * of the thread you are calling this method from. You can then call
-     * g_dbus_object_manager_client_new_finish() to get the result. See
-     * g_dbus_object_manager_client_new_sync() for the synchronous version.
-     * @param connection - A #GDBusConnection.
-     * @param flags - Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
-     * @param name - The owner of the control object (unique or well-known name).
-     * @param objectPath - The object path of the control object.
-     * @param getProxyTypeFunc - A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
-     * @param getProxyTypeUserData - User data to pass to @get_proxy_type_func.
-     * @param getProxyTypeDestroyNotify - Free function for `get_proxy_type_user_data` or %NULL.
-     * @param cancellable - A #GCancellable or %NULL
-     * @param callback - A #GAsyncReadyCallback to call when the request is satisfied.
-     * @param userData - The data to pass to @callback.
-     */
-    static _new(connection, flags, name, objectPath, getProxyTypeFunc, getProxyTypeUserData, getProxyTypeDestroyNotify, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_dbus_object_manager_client_new", [
-            {
-                type: { type: "gobject", borrowed: true },
-                value: connection?.id ?? connection,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "string" },
-                value: name,
-            },
-            {
-                type: { type: "string" },
-                value: objectPath,
-            },
-            {
-                type: { type: "callback" },
-                value: getProxyTypeFunc,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: getProxyTypeUserData,
-                optional: true,
-            },
-            {
-                type: { type: "callback", trampoline: "destroy" },
-                value: getProxyTypeDestroyNotify,
-                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" });
-    }
-    /**
-     * Like g_dbus_object_manager_client_new() but takes a #GBusType instead of a
-     * #GDBusConnection.
-     *
-     * This is an asynchronous failable constructor. When the result is
-     * ready, `callback` will be invoked in the thread-default main context
-     * (see [method@GLib.MainContext.push_thread_default])
-     * of the thread you are calling this method from. You can
-     * then call g_dbus_object_manager_client_new_for_bus_finish() to get the result. See
-     * g_dbus_object_manager_client_new_for_bus_sync() for the synchronous version.
-     * @param busType - A #GBusType.
-     * @param flags - Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
-     * @param name - The owner of the control object (unique or well-known name).
-     * @param objectPath - The object path of the control object.
-     * @param getProxyTypeFunc - A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
-     * @param getProxyTypeUserData - User data to pass to @get_proxy_type_func.
-     * @param getProxyTypeDestroyNotify - Free function for `get_proxy_type_user_data` or %NULL.
-     * @param cancellable - A #GCancellable or %NULL
-     * @param callback - A #GAsyncReadyCallback to call when the request is satisfied.
-     * @param userData - The data to pass to @callback.
-     */
-    static newForBus(busType, flags, name, objectPath, getProxyTypeFunc, getProxyTypeUserData, getProxyTypeDestroyNotify, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_dbus_object_manager_client_new_for_bus", [
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: busType,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "string" },
-                value: name,
-            },
-            {
-                type: { type: "string" },
-                value: objectPath,
-            },
-            {
-                type: { type: "callback" },
-                value: getProxyTypeFunc,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: getProxyTypeUserData,
-                optional: true,
-            },
-            {
-                type: { type: "callback", trampoline: "destroy" },
-                value: getProxyTypeDestroyNotify,
-                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" });
-    }
     /**
      * Gets the #GDBusConnection used by @manager.
      */
@@ -499,75 +217,6 @@ export class DBusObjectManagerClient extends GObject.GObject {
             },
         ], { type: "string" });
     }
-    /**
-     * Starts asynchronous initialization of the object implementing the
-     * interface. This must be done before any real use of the object after
-     * initial construction. If the object also implements #GInitable you can
-     * optionally call g_initable_init() instead.
-     *
-     * This method is intended for language bindings. If writing in C,
-     * g_async_initable_new_async() should typically be used instead.
-     *
-     * When the initialization is finished, `callback` will be called. You can
-     * then call g_async_initable_init_finish() to get the result of the
-     * initialization.
-     *
-     * Implementations may also support cancellation. If `cancellable` is not
-     * %NULL, then initialization 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 `cancellable` is not %NULL, and
-     * the object doesn't support cancellable initialization, the error
-     * %G_IO_ERROR_NOT_SUPPORTED will be returned.
-     *
-     * As with #GInitable, if the object is not initialized, or initialization
-     * returns with an error, then all operations on the object except
-     * g_object_ref() and g_object_unref() are considered to be invalid, and
-     * have undefined behaviour. They will often fail with g_critical() or
-     * g_warning(), but this must not be relied on.
-     *
-     * Callers should not assume that a class which implements #GAsyncInitable can
-     * be initialized multiple times; for more information, see g_initable_init().
-     * If a class explicitly supports being initialized multiple times,
-     * implementation requires yielding all subsequent calls to init_async() on the
-     * results of the first call.
-     *
-     * For classes that also support the #GInitable interface, the default
-     * implementation of this method will run the g_initable_init() function
-     * in a thread, so if you want to support asynchronous initialization via
-     * threads, just implement the #GAsyncInitable interface without overriding
-     * any interface methods.
-     * @param ioPriority - the I/O priority of the operation
-     * @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
-     */
-    initAsync(ioPriority, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_async_initable_init_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 asynchronous initialization and returns the result.
      * See g_async_initable_init_async().

package/dist/generated/gio/dbus-object-manager-server.js

@@ -1,4 +1,6 @@
-import { call, getObject, getInterface, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { getObject, getInterface, isInstantiating, setInstantiating, } from "../../native.js";
+import { registerType } from "../../registry.js";
 import { DBusInterface } from "./dbus-interface.js";
 import { DBusObject } from "./dbus-object.js";
 import * as GObject from "../gobject/index.js";

package/dist/generated/gio/dbus-object-manager.js

@@ -1,4 +1,5 @@
-import { call, getObject, getInterface } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { getObject, getInterface } from "../../native.js";
 import { DBusInterface } from "./dbus-interface.js";
 import { DBusObject } from "./dbus-object.js";
 /**

package/dist/generated/gio/dbus-object-proxy.js

@@ -1,4 +1,6 @@
-import { call, getObject, getInterface, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { getObject, getInterface, isInstantiating, setInstantiating, } from "../../native.js";
+import { registerType } from "../../registry.js";
 import { DBusInterface } from "./dbus-interface.js";
 import * as GObject from "../gobject/index.js";
 /**

package/dist/generated/gio/dbus-object-skeleton.js

@@ -1,4 +1,6 @@
-import { call, getObject, getInterface, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { getObject, getInterface, isInstantiating, setInstantiating, } from "../../native.js";
+import { registerType } from "../../registry.js";
 import { DBusInterface } from "./dbus-interface.js";
 import { DBusInterfaceSkeleton } from "./dbus-interface-skeleton.js";
 import { DBusMethodInvocation } from "./dbus-method-invocation.js";

package/dist/generated/gio/dbus-object.js

@@ -1,4 +1,5 @@
-import { call, getObject, getInterface } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { getObject, getInterface } from "../../native.js";
 import { DBusInterface } from "./dbus-interface.js";
 /**
  * The `GDBusObject` type is the base type for D-Bus objects on both

package/dist/generated/gio/dbus-property-info.d.ts

@@ -9,6 +9,7 @@ export declare class DBusPropertyInfo {
     id: unknown;
     constructor(init?: DBusPropertyInfoInit);
     protected createPtr(init: DBusPropertyInfoInit): unknown;
+    static fromPtr(ptr: unknown): DBusPropertyInfo;
     /**
      * If `info` is statically allocated does nothing. Otherwise increases
      * the reference count.

package/dist/generated/gio/dbus-property-info.js

@@ -1,5 +1,7 @@
 import { alloc, read, write } from "@gtkx/native";
-import { call, getBoxed, registerType } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { getBoxed } from "../../native.js";
+import { registerType } from "../../registry.js";
 /** Information about a D-Bus property on a D-Bus interface. */
 export class DBusPropertyInfo {
     static glibTypeName = "GDBusPropertyInfo";
@@ -13,6 +15,11 @@ export class DBusPropertyInfo {
             write(ptr, { type: "int", size: 32, unsigned: false }, 0, init.refCount);
         return ptr;
     }
+    static fromPtr(ptr) {
+        const instance = Object.create(DBusPropertyInfo.prototype);
+        instance.id = ptr;
+        return instance;
+    }
     /**
      * If `info` is statically allocated does nothing. Otherwise increases
      * the reference count.
@@ -34,7 +41,7 @@ export class DBusPropertyInfo {
             innerType: "GDBusPropertyInfo",
             lib: "libgio-2.0.so.0",
         });
-        return getBoxed(ptr, "GDBusPropertyInfo");
+        return getBoxed(ptr, DBusPropertyInfo);
     }
     /**
      * If `info` is statically allocated, does nothing. Otherwise decreases

package/dist/generated/gio/dbus-proxy.d.ts

@@ -65,112 +65,6 @@ export declare class DBusProxy extends GObject.GObject {
      * @param cancellable - A #GCancellable or %NULL.
      */
     static proxyNewSync(connection: DBusConnection, flags: DBusProxyFlags, objectPath: string, interfaceName: string, info?: DBusInterfaceInfo | null, name?: string | null, cancellable?: Cancellable | null): DBusProxy;
-    /**
-     * Creates a proxy for accessing `interface_name` on the remote object
-     * at `object_path` owned by `name` at `connection` and asynchronously
-     * loads D-Bus properties unless the
-     * %G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES flag is used. Connect to
-     * the #GDBusProxy::g-properties-changed signal to get notified about
-     * property changes.
-     *
-     * If the %G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS flag is not set, also sets up
-     * match rules for signals. Connect to the #GDBusProxy::g-signal signal
-     * to handle signals from the remote object.
-     *
-     * If both %G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES and
-     * %G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS are set, this constructor is
-     * guaranteed to complete immediately without blocking.
-     *
-     * If `name` is a well-known name and the
-     * %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START and %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION
-     * flags aren't set and no name owner currently exists, the message bus
-     * will be requested to launch a name owner for the name.
-     *
-     * This is a failable asynchronous constructor - when the proxy is
-     * ready, `callback` will be invoked and you can use
-     * g_dbus_proxy_new_finish() to get the result.
-     *
-     * See g_dbus_proxy_new_sync() and for a synchronous version of this constructor.
-     *
-     * #GDBusProxy is used in this [example][class@Gio.DBusProxy#a-watch-proxy-example].
-     * @param connection - A #GDBusConnection.
-     * @param flags - Flags used when constructing the proxy.
-     * @param info - A #GDBusInterfaceInfo specifying the minimal interface that `proxy` conforms to or %NULL.
-     * @param name - A bus name (well-known or unique) or %NULL if `connection` is not a message bus connection.
-     * @param objectPath - An object path.
-     * @param interfaceName - A D-Bus interface name.
-     * @param cancellable - A #GCancellable or %NULL.
-     * @param callback - Callback function to invoke when the proxy is ready.
-     * @param userData - User data to pass to @callback.
-     */
-    static _new(connection: DBusConnection, flags: DBusProxyFlags, objectPath: string, interfaceName: string, info?: DBusInterfaceInfo | null, name?: string | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
-    /**
-     * Like g_dbus_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
-     *
-     * #GDBusProxy is used in this [example][class@Gio.DBusProxy#a-watch-proxy-example].
-     * @param busType - A #GBusType.
-     * @param flags - Flags used when constructing the proxy.
-     * @param info - A #GDBusInterfaceInfo specifying the minimal interface that `proxy` conforms to or %NULL.
-     * @param name - A bus name (well-known or unique).
-     * @param objectPath - An object path.
-     * @param interfaceName - A D-Bus interface name.
-     * @param cancellable - A #GCancellable or %NULL.
-     * @param callback - Callback function to invoke when the proxy is ready.
-     * @param userData - User data to pass to @callback.
-     */
-    static newForBus(busType: BusType, flags: DBusProxyFlags, name: string, objectPath: string, interfaceName: string, info?: DBusInterfaceInfo | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
-    /**
-     * Asynchronously invokes the `method_name` method on @proxy.
-     *
-     * If `method_name` contains any dots, then `name` is split into interface and
-     * method name parts. This allows using `proxy` for invoking methods on
-     * other interfaces.
-     *
-     * If the #GDBusConnection associated with `proxy` is closed then
-     * the operation will fail with %G_IO_ERROR_CLOSED. If
-     * `cancellable` is canceled, the operation will fail with
-     * %G_IO_ERROR_CANCELLED. If `parameters` contains a value not
-     * compatible with the D-Bus protocol, the operation fails with
-     * %G_IO_ERROR_INVALID_ARGUMENT.
-     *
-     * If the `parameters` #GVariant is floating, it is consumed. This allows
-     * convenient 'inline' use of g_variant_new(), e.g.:
-     * |[<!-- language="C" -->
-     * g_dbus_proxy_call (proxy,
-     * "TwoStrings",
-     * g_variant_new ("(ss)",
-     * "Thing One",
-     * "Thing Two"),
-     * G_DBUS_CALL_FLAGS_NONE,
-     * -1,
-     * NULL,
-     * (GAsyncReadyCallback) two_strings_done,
-     * &data);
-     * ]|
-     *
-     * If `proxy` has an expected interface (see
-     * #GDBusProxy:g-interface-info) and `method_name` is referenced by it,
-     * then the return value is checked against the return type.
-     *
-     * This is an asynchronous method. When the operation is finished,
-     * `callback` will be invoked in the thread-default main context
-     * (see [method@GLib.MainContext.push_thread_default])
-     * of the thread you are calling this method from.
-     * You can then call g_dbus_proxy_call_finish() to get the result of
-     * the operation. See g_dbus_proxy_call_sync() for the synchronous
-     * version of this method.
-     *
-     * If `callback` is %NULL then the D-Bus method call message will be sent with
-     * the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.
-     * @param methodName - Name of method to invoke.
-     * @param parameters - A #GVariant tuple with parameters for the signal or %NULL if not passing parameters.
-     * @param flags - Flags from the #GDBusCallFlags enumeration.
-     * @param timeoutMsec - The timeout in milliseconds (with %G_MAXINT meaning
-     * @param cancellable - A #GCancellable or %NULL.
-     * @param callback - A #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't
-     * @param userData - The data to pass to @callback.
-     */
-    call(methodName: string, flags: DBusCallFlags, timeoutMsec: number, parameters?: GLib.Variant | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes an operation started with g_dbus_proxy_call().
      * @param res - A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_proxy_call().
@@ -218,20 +112,6 @@ export declare class DBusProxy extends GObject.GObject {
      * @param cancellable - A #GCancellable or %NULL.
      */
     callSync(methodName: string, flags: DBusCallFlags, timeoutMsec: number, parameters?: GLib.Variant | null, cancellable?: Cancellable | null): GLib.Variant;
-    /**
-     * Like g_dbus_proxy_call() but also takes a #GUnixFDList object.
-     *
-     * This method is only available on UNIX.
-     * @param methodName - Name of method to invoke.
-     * @param parameters - A #GVariant tuple with parameters for the signal or %NULL if not passing parameters.
-     * @param flags - Flags from the #GDBusCallFlags enumeration.
-     * @param timeoutMsec - The timeout in milliseconds (with %G_MAXINT meaning
-     * @param fdList - A #GUnixFDList or %NULL.
-     * @param cancellable - A #GCancellable or %NULL.
-     * @param callback - A #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't
-     * @param userData - The data to pass to @callback.
-     */
-    callWithUnixFdList(methodName: string, flags: DBusCallFlags, timeoutMsec: number, parameters?: GLib.Variant | null, fdList?: UnixFDList | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes an operation started with g_dbus_proxy_call_with_unix_fd_list().
      * @param outFdList - Return location for a #GUnixFDList or %NULL.
@@ -363,49 +243,6 @@ export declare class DBusProxy extends GObject.GObject {
      * @param info - Minimum interface this proxy conforms to
      */
     setInterfaceInfo(info?: DBusInterfaceInfo | null): void;
-    /**
-     * Starts asynchronous initialization of the object implementing the
-     * interface. This must be done before any real use of the object after
-     * initial construction. If the object also implements #GInitable you can
-     * optionally call g_initable_init() instead.
-     *
-     * This method is intended for language bindings. If writing in C,
-     * g_async_initable_new_async() should typically be used instead.
-     *
-     * When the initialization is finished, `callback` will be called. You can
-     * then call g_async_initable_init_finish() to get the result of the
-     * initialization.
-     *
-     * Implementations may also support cancellation. If `cancellable` is not
-     * %NULL, then initialization 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 `cancellable` is not %NULL, and
-     * the object doesn't support cancellable initialization, the error
-     * %G_IO_ERROR_NOT_SUPPORTED will be returned.
-     *
-     * As with #GInitable, if the object is not initialized, or initialization
-     * returns with an error, then all operations on the object except
-     * g_object_ref() and g_object_unref() are considered to be invalid, and
-     * have undefined behaviour. They will often fail with g_critical() or
-     * g_warning(), but this must not be relied on.
-     *
-     * Callers should not assume that a class which implements #GAsyncInitable can
-     * be initialized multiple times; for more information, see g_initable_init().
-     * If a class explicitly supports being initialized multiple times,
-     * implementation requires yielding all subsequent calls to init_async() on the
-     * results of the first call.
-     *
-     * For classes that also support the #GInitable interface, the default
-     * implementation of this method will run the g_initable_init() function
-     * in a thread, so if you want to support asynchronous initialization via
-     * threads, just implement the #GAsyncInitable interface without overriding
-     * any interface methods.
-     * @param ioPriority - the I/O priority of the operation
-     * @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
-     */
-    initAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     /**
      * Finishes asynchronous initialization and returns the result.
      * See g_async_initable_init_async().