@gtkx/ffi 0.10.0 → 0.10.2

package/dist/generated/gio/memory-output-stream.js

@@ -4,6 +4,7 @@ import { getNativeObject } from "../../native/object.js";
 import { isInstantiating, setInstantiating } from "../../native/base.js";
 import { registerNativeClass } from "../../registry.js";
 import * as GLib from "../glib/index.js";
+import * as GObject from "../gobject/index.js";
 import { OutputStream } from "./output-stream.js";
 /**
  * `GMemoryOutputStream` is a class for using arbitrary
@@ -12,6 +13,12 @@ import { OutputStream } from "./output-stream.js";
  * As of GLib 2.34, `GMemoryOutputStream` trivially implements
  * {@link Gio.PollableOutputStream}: it always polls as ready.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class MemoryOutputStream extends OutputStream {
     static glibTypeName = "GMemoryOutputStream";
     static objectType = "gobject";
@@ -463,13 +470,25 @@ export class MemoryOutputStream extends OutputStream {
         return result;
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
             const callbackArgs = args.slice(1);
-            const result = handler(self, ...callbackArgs);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
             return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [

package/dist/generated/gio/menu-attribute-iter.d.ts

@@ -1,10 +1,6 @@
 import { Ref } from "@gtkx/native";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
-/**
- * #GMenuAttributeIter is an opaque structure type.  You must access it
- * using the functions below.
- */
 export declare class MenuAttributeIter extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gio/menu-attribute-iter.js

@@ -7,6 +7,12 @@ import * as GObject from "../gobject/index.js";
  * #GMenuAttributeIter is an opaque structure type.  You must access it
  * using the functions below.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class MenuAttributeIter extends GObject.GObject {
     static glibTypeName = "GMenuAttributeIter";
     static objectType = "gobject";
@@ -98,13 +104,25 @@ export class MenuAttributeIter extends GObject.GObject {
         ], { type: "boolean" });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
             const callbackArgs = args.slice(1);
-            const result = handler(self, ...callbackArgs);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
             return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [

package/dist/generated/gio/menu-item.d.ts

@@ -2,10 +2,6 @@ import { Icon } from "./icon.js";
 import { MenuModel } from "./menu-model.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
-/**
- * #GMenuItem is an opaque structure type.  You must access it using the
- * functions below.
- */
 export declare class MenuItem extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gio/menu-item.js

@@ -8,6 +8,12 @@ import * as GObject from "../gobject/index.js";
  * #GMenuItem is an opaque structure type.  You must access it using the
  * functions below.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class MenuItem extends GObject.GObject {
     static glibTypeName = "GMenuItem";
     static objectType = "gobject";
@@ -472,13 +478,25 @@ export class MenuItem extends GObject.GObject {
         ], { type: "undefined" });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
             const callbackArgs = args.slice(1);
-            const result = handler(self, ...callbackArgs);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
             return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [

package/dist/generated/gio/menu-link-iter.d.ts

@@ -1,10 +1,6 @@
 import { Ref } from "@gtkx/native";
 import { MenuModel } from "./menu-model.js";
 import * as GObject from "../gobject/index.js";
-/**
- * #GMenuLinkIter is an opaque structure type.  You must access it using
- * the functions below.
- */
 export declare class MenuLinkIter extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gio/menu-link-iter.js

@@ -6,6 +6,12 @@ import * as GObject from "../gobject/index.js";
  * #GMenuLinkIter is an opaque structure type.  You must access it using
  * the functions below.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class MenuLinkIter extends GObject.GObject {
     static glibTypeName = "GMenuLinkIter";
     static objectType = "gobject";
@@ -97,13 +103,25 @@ export class MenuLinkIter extends GObject.GObject {
         ], { type: "boolean" });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
             const callbackArgs = args.slice(1);
-            const result = handler(self, ...callbackArgs);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
             return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [

package/dist/generated/gio/menu-model.js

@@ -130,6 +130,10 @@ const SIGNAL_META = {
         ],
         returnType: { type: "undefined" },
     },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class MenuModel extends GObject.GObject {
     static glibTypeName = "GMenuModel";
@@ -330,6 +334,9 @@ export class MenuModel extends GObject.GObject {
                 if (t?.type === "gobject" && callbackArgs[i] != null) {
                     return getNativeObject(callbackArgs[i]);
                 }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
                 return callbackArgs[i];
             });
             const result = handler(self, ...wrapped);

package/dist/generated/gio/menu.js

@@ -2,6 +2,7 @@ import { call } from "../../batch.js";
 import { getNativeObject } from "../../native/object.js";
 import { isInstantiating, setInstantiating } from "../../native/base.js";
 import { registerNativeClass } from "../../registry.js";
+import * as GObject from "../gobject/index.js";
 import { MenuModel } from "./menu-model.js";
 /**
  * `GMenu` is a simple implementation of {@link Gio.MenuModel}.
@@ -22,6 +23,10 @@ const SIGNAL_META = {
         ],
         returnType: { type: "undefined" },
     },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class Menu extends MenuModel {
     static glibTypeName = "GMenu";
@@ -422,6 +427,9 @@ export class Menu extends MenuModel {
                 if (t?.type === "gobject" && callbackArgs[i] != null) {
                     return getNativeObject(callbackArgs[i]);
                 }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
                 return callbackArgs[i];
             });
             const result = handler(self, ...wrapped);

package/dist/generated/gio/mount-operation.js

@@ -71,6 +71,10 @@ const SIGNAL_META = {
         ],
         returnType: { type: "undefined" },
     },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class MountOperation extends GObject.GObject {
     static glibTypeName = "GMountOperation";
@@ -373,6 +377,9 @@ export class MountOperation extends GObject.GObject {
                 if (t?.type === "gobject" && callbackArgs[i] != null) {
                     return getNativeObject(callbackArgs[i]);
                 }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
                 if (t?.type === "boxed" && callbackArgs[i] != null) {
                     const cls = getNativeClass(t.innerType);
                     return cls ? getNativeObject(callbackArgs[i], cls) : callbackArgs[i];

package/dist/generated/gio/native-socket-address.d.ts

@@ -1,11 +1,5 @@
 import * as GObject from "../gobject/index.js";
 import { SocketAddress } from "./socket-address.js";
-/**
- * A socket address of some unknown native type.
- *
- * This corresponds to a general `struct sockaddr` of a type not otherwise
- * handled by GLib.
- */
 export declare class NativeSocketAddress extends SocketAddress {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gio/native-socket-address.js

@@ -2,6 +2,7 @@ import { call } from "../../batch.js";
 import { getNativeObject } from "../../native/object.js";
 import { isInstantiating, setInstantiating } from "../../native/base.js";
 import { registerNativeClass } from "../../registry.js";
+import * as GObject from "../gobject/index.js";
 import { SocketAddress } from "./socket-address.js";
 /**
  * A socket address of some unknown native type.
@@ -9,6 +10,12 @@ import { SocketAddress } from "./socket-address.js";
  * This corresponds to a general `struct sockaddr` of a type not otherwise
  * handled by GLib.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class NativeSocketAddress extends SocketAddress {
     static glibTypeName = "GNativeSocketAddress";
     static objectType = "gobject";
@@ -41,13 +48,25 @@ export class NativeSocketAddress extends SocketAddress {
         }
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
             const callbackArgs = args.slice(1);
-            const result = handler(self, ...callbackArgs);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
             return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [

package/dist/generated/gio/native-volume-monitor.js

@@ -1,6 +1,7 @@
 import { call } from "../../batch.js";
 import { getNativeObject } from "../../native/object.js";
 import { registerNativeClass } from "../../registry.js";
+import * as GObject from "../gobject/index.js";
 import { VolumeMonitor } from "./volume-monitor.js";
 const SIGNAL_META = {
     "drive-changed": {
@@ -51,6 +52,10 @@ const SIGNAL_META = {
         params: [{ type: "gobject", borrowed: true }],
         returnType: { type: "undefined" },
     },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class NativeVolumeMonitor extends VolumeMonitor {
     static glibTypeName = "GNativeVolumeMonitor";
@@ -72,6 +77,9 @@ export class NativeVolumeMonitor extends VolumeMonitor {
                 if (t?.type === "gobject" && callbackArgs[i] != null) {
                     return getNativeObject(callbackArgs[i]);
                 }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
                 return callbackArgs[i];
             });
             const result = handler(self, ...wrapped);

package/dist/generated/gio/network-address.d.ts

@@ -1,17 +1,5 @@
 import { SocketAddressEnumerator } from "./socket-address-enumerator.js";
 import * as GObject from "../gobject/index.js";
-/**
- * `GNetworkAddress` provides an easy way to resolve a hostname and
- * then attempt to connect to that host, handling the possibility of
- * multiple IP addresses and multiple address families.
- *
- * The enumeration results of resolved addresses *may* be cached as long
- * as this object is kept alive which may have unexpected results if
- * alive for too long.
- *
- * See {@link Gio.SocketConnectable} for an example of using the connectable
- * interface.
- */
 export declare class NetworkAddress extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gio/network-address.js

@@ -16,6 +16,12 @@ import * as GObject from "../gobject/index.js";
  * See {@link Gio.SocketConnectable} for an example of using the connectable
  * interface.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class NetworkAddress extends GObject.GObject {
     static glibTypeName = "GNetworkAddress";
     static objectType = "gobject";
@@ -250,13 +256,25 @@ export class NetworkAddress extends GObject.GObject {
         ], { type: "string" });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
             const callbackArgs = args.slice(1);
-            const result = handler(self, ...callbackArgs);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
             return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [

package/dist/generated/gio/network-service.d.ts

@@ -1,16 +1,5 @@
 import { SocketAddressEnumerator } from "./socket-address-enumerator.js";
 import * as GObject from "../gobject/index.js";
-/**
- * Like {@link Gio.NetworkAddress} does with hostnames, `GNetworkService`
- * provides an easy way to resolve a SRV record, and then attempt to
- * connect to one of the hosts that implements that service, handling
- * service priority/weighting, multiple IP addresses, and multiple
- * address families.
- *
- * See {@link Gio.SrvTarget} for more information about SRV records, and see
- * {@link Gio.SocketConnectable} for an example of using the connectable
- * interface.
- */
 export declare class NetworkService extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gio/network-service.js

@@ -14,6 +14,12 @@ import * as GObject from "../gobject/index.js";
  * {@link Gio.SocketConnectable} for an example of using the connectable
  * interface.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class NetworkService extends GObject.GObject {
     static glibTypeName = "GNetworkService";
     static objectType = "gobject";
@@ -162,13 +168,25 @@ export class NetworkService extends GObject.GObject {
         ], { type: "string" });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
             const callbackArgs = args.slice(1);
-            const result = handler(self, ...callbackArgs);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
             return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [

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

@@ -2,53 +2,6 @@ import { NotificationPriority } from "./enums.js";
 import { Icon } from "./icon.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
-/**
- * `GNotification` is a mechanism for creating a notification to be shown
- * to the user — typically as a pop-up notification presented by the
- * desktop environment shell.
- *
- * The key difference between `GNotification` and other similar APIs is
- * that, if supported by the desktop environment, notifications sent
- * with `GNotification` will persist after the application has exited,
- * and even across system reboots.
- *
- * Since the user may click on a notification while the application is
- * not running, applications using `GNotification` should be able to be
- * started as a D-Bus service, using {@link Gio.Application}.
- *
- * In order for `GNotification` to work, the application must have installed
- * a `.desktop` file. For example:
- * ```
- * [Desktop Entry]
- * Name=Test Application
- * Comment=Description of what Test Application does
- * Exec=gnome-test-application
- * Icon=org.gnome.TestApplication
- * Terminal=false
- * Type=Application
- * Categories=GNOME;GTK;TestApplication Category;
- * StartupNotify=true
- * DBusActivatable=true
- * X-GNOME-UsesNotifications=true
- * ```
- *
- * The `X-GNOME-UsesNotifications` key indicates to GNOME Control Center
- * that this application uses notifications, so it can be listed in the
- * Control Center’s ‘Notifications’ panel.
- *
- * The `.desktop` file must be named as `org.gnome.TestApplication.desktop`,
- * where `org.gnome.TestApplication` is the ID passed to
- * {@link Gio.Application.new}.
- *
- * User interaction with a notification (either the default action, or
- * buttons) must be associated with actions on the application (ie:
- * `app.` actions).  It is not possible to route user interaction
- * through the notification itself, because the object will not exist if
- * the application is autostarted as a result of a notification being
- * clicked.
- *
- * A notification can be sent with {@link Gio.Application.send_notification}.
- */
 export declare class Notification extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gio/notification.js

@@ -50,6 +50,12 @@ import * as GObject from "../gobject/index.js";
  *
  * A notification can be sent with {@link Gio.Application.send_notification}.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class Notification extends GObject.GObject {
     static glibTypeName = "GNotification";
     static objectType = "gobject";
@@ -300,13 +306,25 @@ export class Notification extends GObject.GObject {
         ], { type: "undefined" });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
             const callbackArgs = args.slice(1);
-            const result = handler(self, ...callbackArgs);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
             return result;
         };
         return call("libgio-2.0.so.0", "g_signal_connect_closure", [

package/dist/generated/gio/output-stream.d.ts

@@ -5,25 +5,6 @@ import { Cancellable } from "./cancellable.js";
 import { InputStream } from "./input-stream.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
-/**
- * `GOutputStream` is a base class for implementing streaming output.
- *
- * It has functions to write to a stream ({@link Gio.OutputStream.write}),
- * to close a stream ({@link Gio.OutputStream.close}) and to flush pending
- * writes ({@link Gio.OutputStream.flush}).
- *
- * To copy the content of an input stream to an output stream without
- * manually handling the reads and writes, use {@link Gio.OutputStream.splice}.
- *
- * See the documentation for {@link Gio.IOStream} for details of thread safety
- * of streaming APIs.
- *
- * All of these functions have async variants too.
- *
- * All classes derived from `GOutputStream` *should* implement synchronous
- * writing, splicing, flushing and closing streams, but *may* implement
- * asynchronous versions.
- */
 export declare class OutputStream extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";