react-native-kookit 0.1.7 → 0.1.8

package/plugin/node_modules/@types/node/dgram.d.ts

@@ -1,596 +0,0 @@
-/**
- * The `node:dgram` module provides an implementation of UDP datagram sockets.
- *
- * ```js
- * import dgram from 'node:dgram';
- *
- * const server = dgram.createSocket('udp4');
- *
- * server.on('error', (err) => {
- *   console.error(`server error:\n${err.stack}`);
- *   server.close();
- * });
- *
- * server.on('message', (msg, rinfo) => {
- *   console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
- * });
- *
- * server.on('listening', () => {
- *   const address = server.address();
- *   console.log(`server listening ${address.address}:${address.port}`);
- * });
- *
- * server.bind(41234);
- * // Prints: server listening 0.0.0.0:41234
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/dgram.js)
- */
-declare module "dgram" {
-    import { AddressInfo } from "node:net";
-    import * as dns from "node:dns";
-    import { Abortable, EventEmitter } from "node:events";
-    interface RemoteInfo {
-        address: string;
-        family: "IPv4" | "IPv6";
-        port: number;
-        size: number;
-    }
-    interface BindOptions {
-        port?: number | undefined;
-        address?: string | undefined;
-        exclusive?: boolean | undefined;
-        fd?: number | undefined;
-    }
-    type SocketType = "udp4" | "udp6";
-    interface SocketOptions extends Abortable {
-        type: SocketType;
-        reuseAddr?: boolean | undefined;
-        /**
-         * @default false
-         */
-        ipv6Only?: boolean | undefined;
-        recvBufferSize?: number | undefined;
-        sendBufferSize?: number | undefined;
-        lookup?:
-            | ((
-                hostname: string,
-                options: dns.LookupOneOptions,
-                callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void,
-            ) => void)
-            | undefined;
-    }
-    /**
-     * Creates a `dgram.Socket` object. Once the socket is created, calling `socket.bind()` will instruct the socket to begin listening for datagram
-     * messages. When `address` and `port` are not passed to `socket.bind()` the
-     * method will bind the socket to the "all interfaces" address on a random port
-     * (it does the right thing for both `udp4` and `udp6` sockets). The bound address
-     * and port can be retrieved using `socket.address().address` and `socket.address().port`.
-     *
-     * If the `signal` option is enabled, calling `.abort()` on the corresponding `AbortController` is similar to calling `.close()` on the socket:
-     *
-     * ```js
-     * const controller = new AbortController();
-     * const { signal } = controller;
-     * const server = dgram.createSocket({ type: 'udp4', signal });
-     * server.on('message', (msg, rinfo) => {
-     *   console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
-     * });
-     * // Later, when you want to close the server.
-     * controller.abort();
-     * ```
-     * @since v0.11.13
-     * @param options Available options are:
-     * @param callback Attached as a listener for `'message'` events. Optional.
-     */
-    function createSocket(type: SocketType, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
-    function createSocket(options: SocketOptions, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
-    /**
-     * Encapsulates the datagram functionality.
-     *
-     * New instances of `dgram.Socket` are created using {@link createSocket}.
-     * The `new` keyword is not to be used to create `dgram.Socket` instances.
-     * @since v0.1.99
-     */
-    class Socket extends EventEmitter {
-        /**
-         * Tells the kernel to join a multicast group at the given `multicastAddress` and `multicastInterface` using the `IP_ADD_MEMBERSHIP` socket option. If the `multicastInterface` argument is not
-         * specified, the operating system will choose
-         * one interface and will add membership to it. To add membership to every
-         * available interface, call `addMembership` multiple times, once per interface.
-         *
-         * When called on an unbound socket, this method will implicitly bind to a random
-         * port, listening on all interfaces.
-         *
-         * When sharing a UDP socket across multiple `cluster` workers, the`socket.addMembership()` function must be called only once or an`EADDRINUSE` error will occur:
-         *
-         * ```js
-         * import cluster from 'node:cluster';
-         * import dgram from 'node:dgram';
-         *
-         * if (cluster.isPrimary) {
-         *   cluster.fork(); // Works ok.
-         *   cluster.fork(); // Fails with EADDRINUSE.
-         * } else {
-         *   const s = dgram.createSocket('udp4');
-         *   s.bind(1234, () => {
-         *     s.addMembership('224.0.0.114');
-         *   });
-         * }
-         * ```
-         * @since v0.6.9
-         */
-        addMembership(multicastAddress: string, multicastInterface?: string): void;
-        /**
-         * Returns an object containing the address information for a socket.
-         * For UDP sockets, this object will contain `address`, `family`, and `port` properties.
-         *
-         * This method throws `EBADF` if called on an unbound socket.
-         * @since v0.1.99
-         */
-        address(): AddressInfo;
-        /**
-         * For UDP sockets, causes the `dgram.Socket` to listen for datagram
-         * messages on a named `port` and optional `address`. If `port` is not
-         * specified or is `0`, the operating system will attempt to bind to a
-         * random port. If `address` is not specified, the operating system will
-         * attempt to listen on all addresses. Once binding is complete, a `'listening'` event is emitted and the optional `callback` function is
-         * called.
-         *
-         * Specifying both a `'listening'` event listener and passing a `callback` to the `socket.bind()` method is not harmful but not very
-         * useful.
-         *
-         * A bound datagram socket keeps the Node.js process running to receive
-         * datagram messages.
-         *
-         * If binding fails, an `'error'` event is generated. In rare case (e.g.
-         * attempting to bind with a closed socket), an `Error` may be thrown.
-         *
-         * Example of a UDP server listening on port 41234:
-         *
-         * ```js
-         * import dgram from 'node:dgram';
-         *
-         * const server = dgram.createSocket('udp4');
-         *
-         * server.on('error', (err) => {
-         *   console.error(`server error:\n${err.stack}`);
-         *   server.close();
-         * });
-         *
-         * server.on('message', (msg, rinfo) => {
-         *   console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
-         * });
-         *
-         * server.on('listening', () => {
-         *   const address = server.address();
-         *   console.log(`server listening ${address.address}:${address.port}`);
-         * });
-         *
-         * server.bind(41234);
-         * // Prints: server listening 0.0.0.0:41234
-         * ```
-         * @since v0.1.99
-         * @param callback with no parameters. Called when binding is complete.
-         */
-        bind(port?: number, address?: string, callback?: () => void): this;
-        bind(port?: number, callback?: () => void): this;
-        bind(callback?: () => void): this;
-        bind(options: BindOptions, callback?: () => void): this;
-        /**
-         * Close the underlying socket and stop listening for data on it. If a callback is
-         * provided, it is added as a listener for the `'close'` event.
-         * @since v0.1.99
-         * @param callback Called when the socket has been closed.
-         */
-        close(callback?: () => void): this;
-        /**
-         * Associates the `dgram.Socket` to a remote address and port. Every
-         * message sent by this handle is automatically sent to that destination. Also,
-         * the socket will only receive messages from that remote peer.
-         * Trying to call `connect()` on an already connected socket will result
-         * in an `ERR_SOCKET_DGRAM_IS_CONNECTED` exception. If `address` is not
-         * provided, `'127.0.0.1'` (for `udp4` sockets) or `'::1'` (for `udp6` sockets)
-         * will be used by default. Once the connection is complete, a `'connect'` event
-         * is emitted and the optional `callback` function is called. In case of failure,
-         * the `callback` is called or, failing this, an `'error'` event is emitted.
-         * @since v12.0.0
-         * @param callback Called when the connection is completed or on error.
-         */
-        connect(port: number, address?: string, callback?: () => void): void;
-        connect(port: number, callback: () => void): void;
-        /**
-         * A synchronous function that disassociates a connected `dgram.Socket` from
-         * its remote address. Trying to call `disconnect()` on an unbound or already
-         * disconnected socket will result in an `ERR_SOCKET_DGRAM_NOT_CONNECTED` exception.
-         * @since v12.0.0
-         */
-        disconnect(): void;
-        /**
-         * Instructs the kernel to leave a multicast group at `multicastAddress` using the `IP_DROP_MEMBERSHIP` socket option. This method is automatically called by the
-         * kernel when the socket is closed or the process terminates, so most apps will
-         * never have reason to call this.
-         *
-         * If `multicastInterface` is not specified, the operating system will attempt to
-         * drop membership on all valid interfaces.
-         * @since v0.6.9
-         */
-        dropMembership(multicastAddress: string, multicastInterface?: string): void;
-        /**
-         * This method throws `ERR_SOCKET_BUFFER_SIZE` if called on an unbound socket.
-         * @since v8.7.0
-         * @return the `SO_RCVBUF` socket receive buffer size in bytes.
-         */
-        getRecvBufferSize(): number;
-        /**
-         * This method throws `ERR_SOCKET_BUFFER_SIZE` if called on an unbound socket.
-         * @since v8.7.0
-         * @return the `SO_SNDBUF` socket send buffer size in bytes.
-         */
-        getSendBufferSize(): number;
-        /**
-         * @since v18.8.0, v16.19.0
-         * @return Number of bytes queued for sending.
-         */
-        getSendQueueSize(): number;
-        /**
-         * @since v18.8.0, v16.19.0
-         * @return Number of send requests currently in the queue awaiting to be processed.
-         */
-        getSendQueueCount(): number;
-        /**
-         * By default, binding a socket will cause it to block the Node.js process from
-         * exiting as long as the socket is open. The `socket.unref()` method can be used
-         * to exclude the socket from the reference counting that keeps the Node.js
-         * process active. The `socket.ref()` method adds the socket back to the reference
-         * counting and restores the default behavior.
-         *
-         * Calling `socket.ref()` multiples times will have no additional effect.
-         *
-         * The `socket.ref()` method returns a reference to the socket so calls can be
-         * chained.
-         * @since v0.9.1
-         */
-        ref(): this;
-        /**
-         * Returns an object containing the `address`, `family`, and `port` of the remote
-         * endpoint. This method throws an `ERR_SOCKET_DGRAM_NOT_CONNECTED` exception
-         * if the socket is not connected.
-         * @since v12.0.0
-         */
-        remoteAddress(): AddressInfo;
-        /**
-         * Broadcasts a datagram on the socket.
-         * For connectionless sockets, the destination `port` and `address` must be
-         * specified. Connected sockets, on the other hand, will use their associated
-         * remote endpoint, so the `port` and `address` arguments must not be set.
-         *
-         * The `msg` argument contains the message to be sent.
-         * Depending on its type, different behavior can apply. If `msg` is a `Buffer`,
-         * any `TypedArray` or a `DataView`,
-         * the `offset` and `length` specify the offset within the `Buffer` where the
-         * message begins and the number of bytes in the message, respectively.
-         * If `msg` is a `String`, then it is automatically converted to a `Buffer` with `'utf8'` encoding. With messages that
-         * contain multi-byte characters, `offset` and `length` will be calculated with
-         * respect to `byte length` and not the character position.
-         * If `msg` is an array, `offset` and `length` must not be specified.
-         *
-         * The `address` argument is a string. If the value of `address` is a host name,
-         * DNS will be used to resolve the address of the host. If `address` is not
-         * provided or otherwise nullish, `'127.0.0.1'` (for `udp4` sockets) or `'::1'` (for `udp6` sockets) will be used by default.
-         *
-         * If the socket has not been previously bound with a call to `bind`, the socket
-         * is assigned a random port number and is bound to the "all interfaces" address
-         * (`'0.0.0.0'` for `udp4` sockets, `'::0'` for `udp6` sockets.)
-         *
-         * An optional `callback` function may be specified to as a way of reporting
-         * DNS errors or for determining when it is safe to reuse the `buf` object.
-         * DNS lookups delay the time to send for at least one tick of the
-         * Node.js event loop.
-         *
-         * The only way to know for sure that the datagram has been sent is by using a `callback`. If an error occurs and a `callback` is given, the error will be
-         * passed as the first argument to the `callback`. If a `callback` is not given,
-         * the error is emitted as an `'error'` event on the `socket` object.
-         *
-         * Offset and length are optional but both _must_ be set if either are used.
-         * They are supported only when the first argument is a `Buffer`, a `TypedArray`,
-         * or a `DataView`.
-         *
-         * This method throws `ERR_SOCKET_BAD_PORT` if called on an unbound socket.
-         *
-         * Example of sending a UDP packet to a port on `localhost`;
-         *
-         * ```js
-         * import dgram from 'node:dgram';
-         * import { Buffer } from 'node:buffer';
-         *
-         * const message = Buffer.from('Some bytes');
-         * const client = dgram.createSocket('udp4');
-         * client.send(message, 41234, 'localhost', (err) => {
-         *   client.close();
-         * });
-         * ```
-         *
-         * Example of sending a UDP packet composed of multiple buffers to a port on`127.0.0.1`;
-         *
-         * ```js
-         * import dgram from 'node:dgram';
-         * import { Buffer } from 'node:buffer';
-         *
-         * const buf1 = Buffer.from('Some ');
-         * const buf2 = Buffer.from('bytes');
-         * const client = dgram.createSocket('udp4');
-         * client.send([buf1, buf2], 41234, (err) => {
-         *   client.close();
-         * });
-         * ```
-         *
-         * Sending multiple buffers might be faster or slower depending on the
-         * application and operating system. Run benchmarks to
-         * determine the optimal strategy on a case-by-case basis. Generally speaking,
-         * however, sending multiple buffers is faster.
-         *
-         * Example of sending a UDP packet using a socket connected to a port on `localhost`:
-         *
-         * ```js
-         * import dgram from 'node:dgram';
-         * import { Buffer } from 'node:buffer';
-         *
-         * const message = Buffer.from('Some bytes');
-         * const client = dgram.createSocket('udp4');
-         * client.connect(41234, 'localhost', (err) => {
-         *   client.send(message, (err) => {
-         *     client.close();
-         *   });
-         * });
-         * ```
-         * @since v0.1.99
-         * @param msg Message to be sent.
-         * @param offset Offset in the buffer where the message starts.
-         * @param length Number of bytes in the message.
-         * @param port Destination port.
-         * @param address Destination host name or IP address.
-         * @param callback Called when the message has been sent.
-         */
-        send(
-            msg: string | NodeJS.ArrayBufferView | readonly any[],
-            port?: number,
-            address?: string,
-            callback?: (error: Error | null, bytes: number) => void,
-        ): void;
-        send(
-            msg: string | NodeJS.ArrayBufferView | readonly any[],
-            port?: number,
-            callback?: (error: Error | null, bytes: number) => void,
-        ): void;
-        send(
-            msg: string | NodeJS.ArrayBufferView | readonly any[],
-            callback?: (error: Error | null, bytes: number) => void,
-        ): void;
-        send(
-            msg: string | NodeJS.ArrayBufferView,
-            offset: number,
-            length: number,
-            port?: number,
-            address?: string,
-            callback?: (error: Error | null, bytes: number) => void,
-        ): void;
-        send(
-            msg: string | NodeJS.ArrayBufferView,
-            offset: number,
-            length: number,
-            port?: number,
-            callback?: (error: Error | null, bytes: number) => void,
-        ): void;
-        send(
-            msg: string | NodeJS.ArrayBufferView,
-            offset: number,
-            length: number,
-            callback?: (error: Error | null, bytes: number) => void,
-        ): void;
-        /**
-         * Sets or clears the `SO_BROADCAST` socket option. When set to `true`, UDP
-         * packets may be sent to a local interface's broadcast address.
-         *
-         * This method throws `EBADF` if called on an unbound socket.
-         * @since v0.6.9
-         */
-        setBroadcast(flag: boolean): void;
-        /**
-         * _All references to scope in this section are referring to [IPv6 Zone Indices](https://en.wikipedia.org/wiki/IPv6_address#Scoped_literal_IPv6_addresses), which are defined by [RFC
-         * 4007](https://tools.ietf.org/html/rfc4007). In string form, an IP_
-         * _with a scope index is written as `'IP%scope'` where scope is an interface name_
-         * _or interface number._
-         *
-         * Sets the default outgoing multicast interface of the socket to a chosen
-         * interface or back to system interface selection. The `multicastInterface` must
-         * be a valid string representation of an IP from the socket's family.
-         *
-         * For IPv4 sockets, this should be the IP configured for the desired physical
-         * interface. All packets sent to multicast on the socket will be sent on the
-         * interface determined by the most recent successful use of this call.
-         *
-         * For IPv6 sockets, `multicastInterface` should include a scope to indicate the
-         * interface as in the examples that follow. In IPv6, individual `send` calls can
-         * also use explicit scope in addresses, so only packets sent to a multicast
-         * address without specifying an explicit scope are affected by the most recent
-         * successful use of this call.
-         *
-         * This method throws `EBADF` if called on an unbound socket.
-         *
-         * #### Example: IPv6 outgoing multicast interface
-         *
-         * On most systems, where scope format uses the interface name:
-         *
-         * ```js
-         * const socket = dgram.createSocket('udp6');
-         *
-         * socket.bind(1234, () => {
-         *   socket.setMulticastInterface('::%eth1');
-         * });
-         * ```
-         *
-         * On Windows, where scope format uses an interface number:
-         *
-         * ```js
-         * const socket = dgram.createSocket('udp6');
-         *
-         * socket.bind(1234, () => {
-         *   socket.setMulticastInterface('::%2');
-         * });
-         * ```
-         *
-         * #### Example: IPv4 outgoing multicast interface
-         *
-         * All systems use an IP of the host on the desired physical interface:
-         *
-         * ```js
-         * const socket = dgram.createSocket('udp4');
-         *
-         * socket.bind(1234, () => {
-         *   socket.setMulticastInterface('10.0.0.2');
-         * });
-         * ```
-         * @since v8.6.0
-         */
-        setMulticastInterface(multicastInterface: string): void;
-        /**
-         * Sets or clears the `IP_MULTICAST_LOOP` socket option. When set to `true`,
-         * multicast packets will also be received on the local interface.
-         *
-         * This method throws `EBADF` if called on an unbound socket.
-         * @since v0.3.8
-         */
-        setMulticastLoopback(flag: boolean): boolean;
-        /**
-         * Sets the `IP_MULTICAST_TTL` socket option. While TTL generally stands for
-         * "Time to Live", in this context it specifies the number of IP hops that a
-         * packet is allowed to travel through, specifically for multicast traffic. Each
-         * router or gateway that forwards a packet decrements the TTL. If the TTL is
-         * decremented to 0 by a router, it will not be forwarded.
-         *
-         * The `ttl` argument may be between 0 and 255\. The default on most systems is `1`.
-         *
-         * This method throws `EBADF` if called on an unbound socket.
-         * @since v0.3.8
-         */
-        setMulticastTTL(ttl: number): number;
-        /**
-         * Sets the `SO_RCVBUF` socket option. Sets the maximum socket receive buffer
-         * in bytes.
-         *
-         * This method throws `ERR_SOCKET_BUFFER_SIZE` if called on an unbound socket.
-         * @since v8.7.0
-         */
-        setRecvBufferSize(size: number): void;
-        /**
-         * Sets the `SO_SNDBUF` socket option. Sets the maximum socket send buffer
-         * in bytes.
-         *
-         * This method throws `ERR_SOCKET_BUFFER_SIZE` if called on an unbound socket.
-         * @since v8.7.0
-         */
-        setSendBufferSize(size: number): void;
-        /**
-         * Sets the `IP_TTL` socket option. While TTL generally stands for "Time to Live",
-         * in this context it specifies the number of IP hops that a packet is allowed to
-         * travel through. Each router or gateway that forwards a packet decrements the
-         * TTL. If the TTL is decremented to 0 by a router, it will not be forwarded.
-         * Changing TTL values is typically done for network probes or when multicasting.
-         *
-         * The `ttl` argument may be between 1 and 255\. The default on most systems
-         * is 64.
-         *
-         * This method throws `EBADF` if called on an unbound socket.
-         * @since v0.1.101
-         */
-        setTTL(ttl: number): number;
-        /**
-         * By default, binding a socket will cause it to block the Node.js process from
-         * exiting as long as the socket is open. The `socket.unref()` method can be used
-         * to exclude the socket from the reference counting that keeps the Node.js
-         * process active, allowing the process to exit even if the socket is still
-         * listening.
-         *
-         * Calling `socket.unref()` multiple times will have no additional effect.
-         *
-         * The `socket.unref()` method returns a reference to the socket so calls can be
-         * chained.
-         * @since v0.9.1
-         */
-        unref(): this;
-        /**
-         * Tells the kernel to join a source-specific multicast channel at the given `sourceAddress` and `groupAddress`, using the `multicastInterface` with the `IP_ADD_SOURCE_MEMBERSHIP` socket
-         * option. If the `multicastInterface` argument
-         * is not specified, the operating system will choose one interface and will add
-         * membership to it. To add membership to every available interface, call `socket.addSourceSpecificMembership()` multiple times, once per interface.
-         *
-         * When called on an unbound socket, this method will implicitly bind to a random
-         * port, listening on all interfaces.
-         * @since v13.1.0, v12.16.0
-         */
-        addSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string): void;
-        /**
-         * Instructs the kernel to leave a source-specific multicast channel at the given `sourceAddress` and `groupAddress` using the `IP_DROP_SOURCE_MEMBERSHIP` socket option. This method is
-         * automatically called by the kernel when the
-         * socket is closed or the process terminates, so most apps will never have
-         * reason to call this.
-         *
-         * If `multicastInterface` is not specified, the operating system will attempt to
-         * drop membership on all valid interfaces.
-         * @since v13.1.0, v12.16.0
-         */
-        dropSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string): void;
-        /**
-         * events.EventEmitter
-         * 1. close
-         * 2. connect
-         * 3. error
-         * 4. listening
-         * 5. message
-         */
-        addListener(event: string, listener: (...args: any[]) => void): this;
-        addListener(event: "close", listener: () => void): this;
-        addListener(event: "connect", listener: () => void): this;
-        addListener(event: "error", listener: (err: Error) => void): this;
-        addListener(event: "listening", listener: () => void): this;
-        addListener(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
-        emit(event: string | symbol, ...args: any[]): boolean;
-        emit(event: "close"): boolean;
-        emit(event: "connect"): boolean;
-        emit(event: "error", err: Error): boolean;
-        emit(event: "listening"): boolean;
-        emit(event: "message", msg: Buffer, rinfo: RemoteInfo): boolean;
-        on(event: string, listener: (...args: any[]) => void): this;
-        on(event: "close", listener: () => void): this;
-        on(event: "connect", listener: () => void): this;
-        on(event: "error", listener: (err: Error) => void): this;
-        on(event: "listening", listener: () => void): this;
-        on(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
-        once(event: string, listener: (...args: any[]) => void): this;
-        once(event: "close", listener: () => void): this;
-        once(event: "connect", listener: () => void): this;
-        once(event: "error", listener: (err: Error) => void): this;
-        once(event: "listening", listener: () => void): this;
-        once(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
-        prependListener(event: string, listener: (...args: any[]) => void): this;
-        prependListener(event: "close", listener: () => void): this;
-        prependListener(event: "connect", listener: () => void): this;
-        prependListener(event: "error", listener: (err: Error) => void): this;
-        prependListener(event: "listening", listener: () => void): this;
-        prependListener(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
-        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
-        prependOnceListener(event: "close", listener: () => void): this;
-        prependOnceListener(event: "connect", listener: () => void): this;
-        prependOnceListener(event: "error", listener: (err: Error) => void): this;
-        prependOnceListener(event: "listening", listener: () => void): this;
-        prependOnceListener(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
-        /**
-         * Calls `socket.close()` and returns a promise that fulfills when the socket has closed.
-         * @since v20.5.0
-         */
-        [Symbol.asyncDispose](): Promise<void>;
-    }
-}
-declare module "node:dgram" {
-    export * from "dgram";
-}