@gtkx/ffi 0.10.5 → 0.11.0

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

@@ -1,5 +1,9 @@
 import { Ref } from "@gtkx/native";
 import { PollableReturn, SocketFamily, SocketProtocol, SocketType } from "./enums.js";
+import { InputMessage } from "./input-message.js";
+import { InputVector } from "./input-vector.js";
+import { OutputMessage } from "./output-message.js";
+import { OutputVector } from "./output-vector.js";
 import { Cancellable } from "./cancellable.js";
 import { Credentials } from "./credentials.js";
 import { InetAddress } from "./inet-address.js";
@@ -8,6 +12,78 @@ import { SocketConnection } from "./socket-connection.js";
 import { SocketControlMessage } from "./socket-control-message.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * A `GSocket` is a low-level networking primitive. It is a more or less
+ * direct mapping of the BSD socket API in a portable GObject based API.
+ * It supports both the UNIX socket implementations and winsock2 on Windows.
+ *
+ * `GSocket` is the platform independent base upon which the higher level
+ * network primitives are based. Applications are not typically meant to
+ * use it directly, but rather through classes like {@link Gio.SocketClient},
+ * {@link Gio.SocketService} and {@link Gio.SocketConnection}. However there may
+ * be cases where direct use of `GSocket` is useful.
+ *
+ * `GSocket` implements the {@link Gio.Initable} interface, so if it is manually
+ * constructed by e.g. {@link GObject.Object.new} you must call
+ * {@link Gio.Initable.init} and check the results before using the object.
+ * This is done automatically in {@link Gio.Socket.new} and
+ * {@link Gio.Socket.new_from_fd}, so these functions can return `NULL`.
+ *
+ * Sockets operate in two general modes, blocking or non-blocking. When
+ * in blocking mode all operations (which don’t take an explicit blocking
+ * parameter) block until the requested operation
+ * is finished or there is an error. In non-blocking mode all calls that
+ * would block return immediately with a `G_IO_ERROR_WOULD_BLOCK` error.
+ * To know when a call would successfully run you can call
+ * {@link Gio.Socket.condition_check}, or {@link Gio.Socket.condition_wait}.
+ * You can also use {@link Gio.Socket.create_source} and attach it to a
+ * {@link GLib.MainContext} to get callbacks when I/O is possible.
+ * Note that all sockets are always set to non blocking mode in the system, and
+ * blocking mode is emulated in `GSocket`.
+ *
+ * When working in non-blocking mode applications should always be able to
+ * handle getting a `G_IO_ERROR_WOULD_BLOCK` error even when some other
+ * function said that I/O was possible. This can easily happen in case
+ * of a race condition in the application, but it can also happen for other
+ * reasons. For instance, on Windows a socket is always seen as writable
+ * until a write returns `G_IO_ERROR_WOULD_BLOCK`.
+ *
+ * `GSocket`s can be either connection oriented or datagram based.
+ * For connection oriented types you must first establish a connection by
+ * either connecting to an address or accepting a connection from another
+ * address. For connectionless socket types the target/source address is
+ * specified or received in each I/O operation.
+ *
+ * All socket file descriptors are set to be close-on-exec.
+ *
+ * Note that creating a `GSocket` causes the signal `SIGPIPE` to be
+ * ignored for the remainder of the program. If you are writing a
+ * command-line utility that uses `GSocket`, you may need to take into
+ * account the fact that your program will not automatically be killed
+ * if it tries to write to `stdout` after it has been closed.
+ *
+ * Like most other APIs in GLib, `GSocket` is not inherently thread safe. To use
+ * a `GSocket` concurrently from multiple threads, you must implement your own
+ * locking.
+ *
+ * ## Nagle’s algorithm
+ *
+ * Since GLib 2.80, `GSocket` will automatically set the `TCP_NODELAY` option on
+ * all `G_SOCKET_TYPE_STREAM` sockets. This disables
+ * [Nagle’s algorithm](https://en.wikipedia.org/wiki/Nagle%27s_algorithm) as it
+ * typically does more harm than good on modern networks.
+ *
+ * If your application needs Nagle’s algorithm enabled, call
+ * {@link Gio.Socket.set_option} after constructing a `GSocket` to enable it:
+ * ```c
+ * socket = g_socket_new (…, G_SOCKET_TYPE_STREAM, …);
+ * if (socket != NULL)
+ *   {
+ *     g_socket_set_option (socket, IPPROTO_TCP, TCP_NODELAY, FALSE, &local_error);
+ *     // handle error if needed
+ *   }
+ * ```
+ */
 export declare class Socket extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";
@@ -25,9 +101,6 @@ export declare class Socket extends GObject.GObject {
      * The protocol id is passed directly to the operating
      * system, so you can use protocols not listed in #GSocketProtocol if you
      * know the protocol number used for it.
-     * @param family - the socket family to use, e.g. %G_SOCKET_FAMILY_IPV4.
-     * @param type - the socket type to use.
-     * @param protocol - the id of the protocol to use, or 0 for default.
      */
     constructor(family: SocketFamily, type: SocketType, protocol: SocketProtocol);
     /**
@@ -44,7 +117,6 @@ export declare class Socket extends GObject.GObject {
      *
      * Since GLib 2.46, it is no longer a fatal error to call this on a non-socket
      * descriptor.  Instead, a GError will be set with code %G_IO_ERROR_FAILED
-     * @param fd - a native socket file descriptor.
      */
     static newFromFd(fd: number): Socket;
     /**
@@ -58,9 +130,8 @@ export declare class Socket extends GObject.GObject {
      * If there are no outstanding connections then the operation will block
      * or return %G_IO_ERROR_WOULD_BLOCK if non-blocking I/O is enabled.
      * To be notified of an incoming connection, wait for the %G_IO_IN condition.
-     * @param cancellable - a %GCancellable or %NULL
      */
-    accept(cancellable?: Cancellable): Socket;
+    accept(cancellable?: Cancellable | null): Socket;
     /**
      * When a socket is created it is attached to an address family, but it
      * doesn't have an address in this family. g_socket_bind() assigns the
@@ -85,8 +156,6 @@ export declare class Socket extends GObject.GObject {
      * same address, and they will all receive all of the multicast and
      * broadcast packets sent to that address. (The behavior of unicast
      * UDP packets to an address with multiple listeners is not defined.)
-     * @param address - a #GSocketAddress specifying the local address.
-     * @param allowReuse - whether to allow reusing this address
      */
     bind(address: SocketAddress, allowReuse: boolean): boolean;
     /**
@@ -145,7 +214,6 @@ export declare class Socket extends GObject.GObject {
      * these conditions will always be set in the output if they are true.
      *
      * This call never blocks.
-     * @param condition - a #GIOCondition mask to check
      */
     conditionCheck(condition: GLib.IOCondition): GLib.IOCondition;
     /**
@@ -165,11 +233,8 @@ export declare class Socket extends GObject.GObject {
      * other GLib APIs, this function actually only has millisecond
      * resolution, and the behavior is undefined if `timeout_us` is not an
      * exact number of milliseconds.
-     * @param condition - a #GIOCondition mask to wait for
-     * @param timeoutUs - the maximum time (in microseconds) to wait, or -1
-     * @param cancellable - a #GCancellable, or %NULL
      */
-    conditionTimedWait(condition: GLib.IOCondition, timeoutUs: number, cancellable?: Cancellable): boolean;
+    conditionTimedWait(condition: GLib.IOCondition, timeoutUs: number, cancellable?: Cancellable | null): boolean;
     /**
      * Waits for `condition` to become true on `socket`. When the condition
      * is met, %TRUE is returned.
@@ -181,10 +246,8 @@ export declare class Socket extends GObject.GObject {
      * %G_IO_ERROR_TIMED_OUT).
      *
      * See also g_socket_condition_timed_wait().
-     * @param condition - a #GIOCondition mask to wait for
-     * @param cancellable - a #GCancellable, or %NULL
      */
-    conditionWait(condition: GLib.IOCondition, cancellable?: Cancellable): boolean;
+    conditionWait(condition: GLib.IOCondition, cancellable?: Cancellable | null): boolean;
     /**
      * Connect the socket to the specified remote address.
      *
@@ -202,10 +265,8 @@ export declare class Socket extends GObject.GObject {
      * and the user can be notified of the connection finishing by waiting
      * for the G_IO_OUT condition. The result of the connection must then be
      * checked with g_socket_check_connect_result().
-     * @param address - a #GSocketAddress specifying the remote address.
-     * @param cancellable - a %GCancellable or %NULL
      */
-    socketConnect(address: SocketAddress, cancellable?: Cancellable): boolean;
+    SocketConnect(address: SocketAddress, cancellable?: Cancellable | null): boolean;
     /**
      * Creates a #GSocketConnection subclass of the right type for
      * `socket`.
@@ -260,9 +321,7 @@ export declare class Socket extends GObject.GObject {
      * g_unix_connection_receive_credentials() functions.
      */
     getCredentials(): Credentials;
-    /**
-     * Gets the socket family of the socket.
-     */
+    /** Gets the socket family of the socket. */
     getFamily(): SocketFamily;
     /**
      * Returns the underlying OS socket object. On unix this
@@ -313,9 +372,6 @@ export declare class Socket extends GObject.GObject {
      * Note that even for socket options that are a single byte in size,
      * `value` is still a pointer to a #gint variable, not a #guchar;
      * g_socket_get_option() will handle the conversion internally.
-     * @param level - the "API level" of the option (eg, `SOL_SOCKET`)
-     * @param optname - the "name" of the option (eg, `SO_BROADCAST`)
-     * @param value - return location for the option value
      */
     getOption(level: number, optname: number, value: Ref<number>): boolean;
     /**
@@ -328,9 +384,7 @@ export declare class Socket extends GObject.GObject {
      * useful for connection oriented sockets that have been connected.
      */
     getRemoteAddress(): SocketAddress;
-    /**
-     * Gets the socket type of the socket.
-     */
+    /** Gets the socket type of the socket. */
     getSocketType(): SocketType;
     /**
      * Gets the timeout setting of the socket. For details on this, see
@@ -342,9 +396,7 @@ export declare class Socket extends GObject.GObject {
      * g_socket_set_ttl() for more details.
      */
     getTtl(): number;
-    /**
-     * Checks whether a socket is closed.
-     */
+    /** Checks whether a socket is closed. */
     isClosed(): boolean;
     /**
      * Check whether the socket is connected. This is only useful for
@@ -371,11 +423,8 @@ export declare class Socket extends GObject.GObject {
      *
      * To bind to a given source-specific multicast address, use
      * g_socket_join_multicast_group_ssm() instead.
-     * @param group - a #GInetAddress specifying the group address to join.
-     * @param sourceSpecific - %TRUE if source-specific multicast should be used
-     * @param iface - Name of the interface to use, or %NULL
      */
-    joinMulticastGroup(group: InetAddress, sourceSpecific: boolean, iface?: string): boolean;
+    joinMulticastGroup(group: InetAddress, sourceSpecific: boolean, iface?: string | null): boolean;
     /**
      * Registers `socket` to receive multicast messages sent to `group`.
      * `socket` must be a %G_SOCKET_TYPE_DATAGRAM socket, and must have
@@ -392,11 +441,8 @@ export declare class Socket extends GObject.GObject {
      * Note that this function can be called multiple times for the same
      * `group` with different `source_specific` in order to receive multicast
      * packets from more than one source.
-     * @param group - a #GInetAddress specifying the group address to join.
-     * @param sourceSpecific - a #GInetAddress specifying the
-     * @param iface - Name of the interface to use, or %NULL
      */
-    joinMulticastGroupSsm(group: InetAddress, sourceSpecific?: InetAddress, iface?: string): boolean;
+    joinMulticastGroupSsm(group: InetAddress, sourceSpecific?: InetAddress | null, iface?: string | null): boolean;
     /**
      * Removes `socket` from the multicast group defined by `group`, `iface`,
      * and `source_specific` (which must all have the same values they had
@@ -407,11 +453,8 @@ export declare class Socket extends GObject.GObject {
      *
      * To unbind to a given source-specific multicast address, use
      * g_socket_leave_multicast_group_ssm() instead.
-     * @param group - a #GInetAddress specifying the group address to leave.
-     * @param sourceSpecific - %TRUE if source-specific multicast was used
-     * @param iface - Interface used
      */
-    leaveMulticastGroup(group: InetAddress, sourceSpecific: boolean, iface?: string): boolean;
+    leaveMulticastGroup(group: InetAddress, sourceSpecific: boolean, iface?: string | null): boolean;
     /**
      * Removes `socket` from the multicast group defined by `group`, `iface`,
      * and `source_specific` (which must all have the same values they had
@@ -419,11 +462,8 @@ export declare class Socket extends GObject.GObject {
      *
      * `socket` remains bound to its address and port, and can still receive
      * unicast messages after calling this.
-     * @param group - a #GInetAddress specifying the group address to leave.
-     * @param sourceSpecific - a #GInetAddress specifying the
-     * @param iface - Name of the interface to use, or %NULL
      */
-    leaveMulticastGroupSsm(group: InetAddress, sourceSpecific?: InetAddress, iface?: string): boolean;
+    leaveMulticastGroupSsm(group: InetAddress, sourceSpecific?: InetAddress | null, iface?: string | null): boolean;
     /**
      * Marks the socket as a server socket, i.e. a socket that is used
      * to accept incoming requests using g_socket_accept().
@@ -459,11 +499,8 @@ export declare class Socket extends GObject.GObject {
      * %G_IO_IN condition.
      *
      * On error -1 is returned and `error` is set accordingly.
-     * @param buffer - a buffer to read data into (which should be at least `size` bytes long).
-     * @param size - the number of bytes you want to read from the socket
-     * @param cancellable - a %GCancellable or %NULL
      */
-    receive(buffer: Ref<number[]>, size: number, cancellable?: Cancellable): number;
+    receive(buffer: Ref<number[]>, size: number, cancellable?: Cancellable | null): number;
     /**
      * Receives data (up to `size` bytes) from a socket.
      *
@@ -474,11 +511,8 @@ export declare class Socket extends GObject.GObject {
      * the connection is closed, or there is an error). Pass `0` to use the default
      * timeout from {@link Gio.Socket.timeout}, or pass a positive number to wait
      * for that many microseconds for data before returning `G_IO_ERROR_TIMED_OUT`.
-     * @param size - the number of bytes you want to read from the socket
-     * @param timeoutUs - the timeout to wait for, in microseconds, or `-1` to block
-     * @param cancellable - a %GCancellable, or `NULL`
      */
-    receiveBytes(size: number, timeoutUs: number, cancellable?: Cancellable): GLib.Bytes;
+    receiveBytes(size: number, timeoutUs: number, cancellable?: Cancellable | null): GLib.Bytes;
     /**
      * Receive data (up to `size` bytes) from a socket.
      *
@@ -494,12 +528,8 @@ export declare class Socket extends GObject.GObject {
      * the connection is closed, or there is an error). Pass `0` to use the default
      * timeout from {@link Gio.Socket.timeout}, or pass a positive number to wait
      * for that many microseconds for data before returning `G_IO_ERROR_TIMED_OUT`.
-     * @param address - return location for a #GSocketAddress
-     * @param size - the number of bytes you want to read from the socket
-     * @param timeoutUs - the timeout to wait for, in microseconds, or `-1` to block
-     * @param cancellable - a #GCancellable, or `NULL`
      */
-    receiveBytesFrom(size: number, timeoutUs: number, address?: Ref<SocketAddress>, cancellable?: Cancellable): GLib.Bytes;
+    receiveBytesFrom(size: number, timeoutUs: number, address?: Ref<SocketAddress> | null, cancellable?: Cancellable | null): GLib.Bytes;
     /**
      * Receive data (up to `size` bytes) from a socket.
      *
@@ -508,12 +538,8 @@ export declare class Socket extends GObject.GObject {
      * `address` is owned by the caller.
      *
      * See g_socket_receive() for additional information.
-     * @param address - a pointer to a #GSocketAddress
-     * @param buffer - a buffer to read data into (which should be at least `size` bytes long).
-     * @param size - the number of bytes you want to read from the socket
-     * @param cancellable - a %GCancellable or %NULL
      */
-    receiveFrom(buffer: Ref<number[]>, size: number, address?: Ref<SocketAddress>, cancellable?: Cancellable): number;
+    receiveFrom(buffer: Ref<number[]>, size: number, address?: Ref<SocketAddress> | null, cancellable?: Cancellable | null): number;
     /**
      * Receive data from a socket.  For receiving multiple messages, see
      * g_socket_receive_messages(); for easier use, see
@@ -574,15 +600,8 @@ export declare class Socket extends GObject.GObject {
      * %G_IO_IN condition.
      *
      * On error -1 is returned and `error` is set accordingly.
-     * @param address - a pointer to a #GSocketAddress
-     * @param vectors - an array of #GInputVector structs
-     * @param numVectors - the number of elements in `vectors`, or -1
-     * @param messages - a pointer
-     * @param numMessages - a pointer which will be filled with the number of
-     * @param flags - a pointer to an int containing #GSocketMsgFlags flags,
-     * @param cancellable - a %GCancellable or %NULL
      */
-    receiveMessage(vectors: number[], numVectors: number, numMessages: Ref<number>, flags: Ref<number>, address?: Ref<SocketAddress>, messages?: Ref<SocketControlMessage[]>, cancellable?: Cancellable): number;
+    receiveMessage(vectors: InputVector[], numVectors: number, numMessages: Ref<number>, flags: Ref<number>, address?: Ref<SocketAddress> | null, messages?: Ref<SocketControlMessage[]> | null, cancellable?: Cancellable | null): number;
     /**
      * Receive multiple data messages from `socket` in one go.  This is the most
      * complicated and fully-featured version of this call. For easier use, see
@@ -632,22 +651,14 @@ export declare class Socket extends GObject.GObject {
      * On error -1 is returned and `error` is set accordingly. An error will only
      * be returned if zero messages could be received; otherwise the number of
      * messages successfully received before the error will be returned.
-     * @param messages - an array of #GInputMessage structs
-     * @param numMessages - the number of elements in `messages`
-     * @param flags - an int containing #GSocketMsgFlags flags for the overall operation,
-     * @param cancellable - a %GCancellable or %NULL
      */
-    receiveMessages(messages: number[], numMessages: number, flags: number, cancellable?: Cancellable): number;
+    receiveMessages(messages: InputMessage[], numMessages: number, flags: number, cancellable?: Cancellable | null): number;
     /**
      * This behaves exactly the same as g_socket_receive(), except that
      * the choice of blocking or non-blocking behavior is determined by
      * the `blocking` argument rather than by `socket`'s properties.
-     * @param buffer - a buffer to read data into (which should be at least `size` bytes long).
-     * @param size - the number of bytes you want to read from the socket
-     * @param blocking - whether to do blocking or non-blocking I/O
-     * @param cancellable - a %GCancellable or %NULL
      */
-    receiveWithBlocking(buffer: Ref<number[]>, size: number, blocking: boolean, cancellable?: Cancellable): number;
+    receiveWithBlocking(buffer: Ref<number[]>, size: number, blocking: boolean, cancellable?: Cancellable | null): number;
     /**
      * Tries to send `size` bytes from `buffer` on the socket. This is
      * mainly used by connection-oriented sockets; it is identical to
@@ -663,11 +674,8 @@ export declare class Socket extends GObject.GObject {
      * very common due to the way the underlying APIs work.)
      *
      * On error -1 is returned and `error` is set accordingly.
-     * @param buffer - the buffer
-     * @param size - the number of bytes to send
-     * @param cancellable - a %GCancellable or %NULL
      */
-    send(buffer: number[], size: number, cancellable?: Cancellable): number;
+    send(buffer: number[], size: number, cancellable?: Cancellable | null): number;
     /**
      * Send data to `address` on `socket`.  For sending multiple messages see
      * g_socket_send_messages(); for easier use, see
@@ -711,15 +719,8 @@ export declare class Socket extends GObject.GObject {
      * function.
      *
      * On error -1 is returned and `error` is set accordingly.
-     * @param address - a #GSocketAddress, or %NULL
-     * @param vectors - an array of #GOutputVector structs
-     * @param numVectors - the number of elements in `vectors`, or -1
-     * @param messages - a pointer to an
-     * @param numMessages - number of elements in `messages`, or -1.
-     * @param flags - an int containing #GSocketMsgFlags flags, which may additionally
-     * @param cancellable - a %GCancellable or %NULL
      */
-    sendMessage(vectors: number[], numVectors: number, numMessages: number, flags: number, address?: SocketAddress, messages?: SocketControlMessage[], cancellable?: Cancellable): number;
+    sendMessage(vectors: OutputVector[], numVectors: number, numMessages: number, flags: number, address?: SocketAddress | null, messages?: SocketControlMessage[] | null, cancellable?: Cancellable | null): number;
     /**
      * This behaves exactly the same as g_socket_send_message(), except that
      * the choice of timeout behavior is determined by the `timeout_us` argument
@@ -728,17 +729,8 @@ export declare class Socket extends GObject.GObject {
      * On error %G_POLLABLE_RETURN_FAILED is returned and `error` is set accordingly, or
      * if the socket is currently not writable %G_POLLABLE_RETURN_WOULD_BLOCK is
      * returned. `bytes_written` will contain 0 in both cases.
-     * @param address - a #GSocketAddress, or %NULL
-     * @param vectors - an array of #GOutputVector structs
-     * @param numVectors - the number of elements in `vectors`, or -1
-     * @param messages - a pointer to an
-     * @param numMessages - number of elements in `messages`, or -1.
-     * @param flags - an int containing #GSocketMsgFlags flags, which may additionally
-     * @param timeoutUs - the maximum time (in microseconds) to wait, or -1
-     * @param bytesWritten - location to store the number of bytes that were written to the socket
-     * @param cancellable - a %GCancellable or %NULL
-     */
-    sendMessageWithTimeout(vectors: number[], numVectors: number, numMessages: number, flags: number, timeoutUs: number, address?: SocketAddress, messages?: SocketControlMessage[], bytesWritten?: Ref<number>, cancellable?: Cancellable): PollableReturn;
+     */
+    sendMessageWithTimeout(vectors: OutputVector[], numVectors: number, numMessages: number, flags: number, timeoutUs: number, address?: SocketAddress | null, messages?: SocketControlMessage[] | null, bytesWritten?: Ref<number> | null, cancellable?: Cancellable | null): PollableReturn;
     /**
      * Send multiple data messages from `socket` in one go.  This is the most
      * complicated and fully-featured version of this call. For easier use, see
@@ -774,34 +766,22 @@ export declare class Socket extends GObject.GObject {
      * On error -1 is returned and `error` is set accordingly. An error will only
      * be returned if zero messages could be sent; otherwise the number of messages
      * successfully sent before the error will be returned.
-     * @param messages - an array of #GOutputMessage structs
-     * @param numMessages - the number of elements in `messages`
-     * @param flags - an int containing #GSocketMsgFlags flags, which may additionally
-     * @param cancellable - a %GCancellable or %NULL
      */
-    sendMessages(messages: number[], numMessages: number, flags: number, cancellable?: Cancellable): number;
+    sendMessages(messages: OutputMessage[], numMessages: number, flags: number, cancellable?: Cancellable | null): number;
     /**
      * Tries to send `size` bytes from `buffer` to `address`. If `address` is
      * %NULL then the message is sent to the default receiver (set by
      * g_socket_connect()).
      *
      * See g_socket_send() for additional information.
-     * @param address - a #GSocketAddress, or %NULL
-     * @param buffer - the buffer
-     * @param size - the number of bytes to send
-     * @param cancellable - a %GCancellable or %NULL
      */
-    sendTo(buffer: number[], size: number, address?: SocketAddress, cancellable?: Cancellable): number;
+    sendTo(buffer: number[], size: number, address?: SocketAddress | null, cancellable?: Cancellable | null): number;
     /**
      * This behaves exactly the same as g_socket_send(), except that
      * the choice of blocking or non-blocking behavior is determined by
      * the `blocking` argument rather than by `socket`'s properties.
-     * @param buffer - the buffer
-     * @param size - the number of bytes to send
-     * @param blocking - whether to do blocking or non-blocking I/O
-     * @param cancellable - a %GCancellable or %NULL
      */
-    sendWithBlocking(buffer: number[], size: number, blocking: boolean, cancellable?: Cancellable): number;
+    sendWithBlocking(buffer: number[], size: number, blocking: boolean, cancellable?: Cancellable | null): number;
     /**
      * Sets the blocking mode of the socket. In blocking mode
      * all operations (which don’t take an explicit blocking parameter) block until
@@ -812,13 +792,11 @@ export declare class Socket extends GObject.GObject {
      * All sockets are created in blocking mode. However, note that the
      * platform level socket is always non-blocking, and blocking mode
      * is a GSocket level feature.
-     * @param blocking - Whether to use blocking I/O or not.
      */
     setBlocking(blocking: boolean): void;
     /**
      * Sets whether `socket` should allow sending to broadcast addresses.
      * This is %FALSE by default.
-     * @param broadcast - whether `socket` should allow sending to broadcast
      */
     setBroadcast(broadcast: boolean): void;
     /**
@@ -837,7 +815,6 @@ export declare class Socket extends GObject.GObject {
      * on a server socket if you want to allow clients to remain idle for long
      * periods of time, but also want to ensure that connections are eventually
      * garbage-collected if clients crash or become unreachable.
-     * @param keepalive - Value for the keepalive flag
      */
     setKeepalive(keepalive: boolean): void;
     /**
@@ -848,21 +825,18 @@ export declare class Socket extends GObject.GObject {
      *
      * Note that this must be called before g_socket_listen() and has no
      * effect if called after that.
-     * @param backlog - the maximum number of pending connections.
      */
     setListenBacklog(backlog: number): void;
     /**
      * Sets whether outgoing multicast packets will be received by sockets
      * listening on that multicast address on the same host. This is %TRUE
      * by default.
-     * @param loopback - whether `socket` should receive messages sent to its
      */
     setMulticastLoopback(loopback: boolean): void;
     /**
      * Sets the time-to-live for outgoing multicast datagrams on `socket`.
      * By default, this is 1, meaning that multicast packets will not leave
      * the local network.
-     * @param ttl - the time-to-live value for all multicast datagrams on `socket`
      */
     setMulticastTtl(ttl: number): void;
     /**
@@ -875,9 +849,6 @@ export declare class Socket extends GObject.GObject {
      * standard/portable socket options. For unusual socket protocols or
      * platform-dependent options, you may need to include additional
      * headers.
-     * @param level - the "API level" of the option (eg, `SOL_SOCKET`)
-     * @param optname - the "name" of the option (eg, `SO_BROADCAST`)
-     * @param value - the value to set the option to
      */
     setOption(level: number, optname: number, value: number): boolean;
     /**
@@ -901,13 +872,11 @@ export declare class Socket extends GObject.GObject {
      *
      * Note that if an I/O operation is interrupted by a signal, this may
      * cause the timeout to be reset.
-     * @param timeout - the timeout for `socket`, in seconds, or 0 for none
      */
     setTimeout(timeout: number): void;
     /**
      * Sets the time-to-live for outgoing unicast packets on `socket`.
      * By default the platform-specific default value is used.
-     * @param ttl - the time-to-live value for all unicast packets on `socket`
      */
     setTtl(ttl: number): void;
     /**
@@ -925,8 +894,6 @@ export declare class Socket extends GObject.GObject {
      * graceful disconnect for TCP connections where you close the sending side,
      * then wait for the other side to close the connection, thus ensuring that the
      * other side saw all sent data.
-     * @param shutdownRead - whether to shut down the read side
-     * @param shutdownWrite - whether to shut down the write side
      */
     shutdown(shutdownRead: boolean, shutdownWrite: boolean): boolean;
     /**
@@ -956,10 +923,8 @@ export declare class Socket extends GObject.GObject {
      * likely 0 unless cancellation happened at the same time as a condition
      * change). You can check for this in the callback using
      * g_cancellable_is_cancelled().
-     * @param condition - a #GIOCondition mask to monitor
-     * @param cancellable - a #GCancellable
      */
-    createSource(condition: GLib.IOCondition, cancellable?: Cancellable): GLib.Source;
+    createSource(condition: GLib.IOCondition, cancellable?: Cancellable | null): GLib.Source;
     /**
      * Initializes the object implementing the interface.
      *
@@ -999,9 +964,6 @@ export declare class Socket extends GObject.GObject {
      * In this pattern, a caller would expect to be able to call g_initable_init()
      * on the result of g_object_new(), regardless of whether it is in fact a new
      * instance.
-     * @param cancellable - optional #GCancellable object, %NULL to ignore.
      */
-    init(cancellable?: Cancellable): boolean;
-    connect(signal: "notify", handler: (self: Socket, pspec: GObject.ParamSpec) => void, after?: boolean): number;
-    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
+    init(cancellable?: Cancellable | null): boolean;
 }