dimaslanjaka / universal-framework

    import * as stream from "stream";

    import * as events from "events";

    import * as dns from "dns";

    type LookupFunction = (hostname: string, options: dns.LookupOneOptions, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void) => void;

    interface AddressInfo {

        address: string;

        family: string;

        port: number;

    }

    interface SocketConstructorOpts {

        fd?: number;

        allowHalfOpen?: boolean;

        readable?: boolean;

        writable?: boolean;

    }

    interface OnReadOpts {

        buffer: Uint8Array | (() => Uint8Array);

        /**

         * This function is called for every chunk of incoming data.

         * Two arguments are passed to it: the number of bytes written to buffer and a reference to buffer.

         * Return false from this function to implicitly pause() the socket.

         */

        callback(bytesWritten: number, buf: Uint8Array): boolean;

    }

    interface ConnectOpts {

        /**

         * If specified, incoming data is stored in a single buffer and passed to the supplied callback when data arrives on the socket.

         * Note: this will cause the streaming functionality to not provide any data, however events like 'error', 'end', and 'close' will

         * still be emitted as normal and methods like pause() and resume() will also behave as expected.

         */

        onread?: OnReadOpts;

    }

    interface TcpSocketConnectOpts extends ConnectOpts {

        port: number;

        host?: string;

        localAddress?: string;

        localPort?: number;

        hints?: number;

        family?: number;

        lookup?: LookupFunction;

    }

    interface IpcSocketConnectOpts extends ConnectOpts {

        path: string;

    }

    type SocketConnectOpts = TcpSocketConnectOpts | IpcSocketConnectOpts;

    interface ListenOptions {

        port?: number;

        host?: string;

        backlog?: number;

        path?: string;

        exclusive?: boolean;

        readableAll?: boolean;

        writableAll?: boolean;

        /**

         * @default false

         */

        ipv6Only?: boolean;

    }

    // https://github.com/nodejs/node/blob/master/lib/net.js

    class Server extends events.EventEmitter {

        constructor(connectionListener?: (socket: Socket) => void);

        constructor(options?: { allowHalfOpen?: boolean, pauseOnConnect?: boolean }, connectionListener?: (socket: Socket) => void);

        listen(port?: number, hostname?: string, backlog?: number, listeningListener?: () => void): this;

        listen(port?: number, hostname?: string, listeningListener?: () => void): this;

        listen(port?: number, backlog?: number, listeningListener?: () => void): this;

        listen(port?: number, listeningListener?: () => void): this;

        listen(path: string, backlog?: number, listeningListener?: () => void): this;

        listen(path: string, listeningListener?: () => void): this;

        listen(options: ListenOptions, listeningListener?: () => void): this;

        listen(handle: any, backlog?: number, listeningListener?: () => void): this;

        listen(handle: any, listeningListener?: () => void): this;

        close(callback?: (err?: Error) => void): this;

        address(): AddressInfo | string | null;

        getConnections(cb: (error: Error | null, count: number) => void): void;

        ref(): this;

        unref(): this;

        maxConnections: number;

        connections: number;

        listening: boolean;

        /**

         * events.EventEmitter

         *   1. close

         *   2. connection

         *   3. error

         *   4. listening

         */

        addListener(event: string, listener: (...args: any[]) => void): this;

        addListener(event: "close", listener: () => void): this;

        addListener(event: "connection", listener: (socket: Socket) => void): this;

        addListener(event: "error", listener: (err: Error) => void): this;

        addListener(event: "listening", listener: () => void): this;

        emit(event: string | symbol, ...args: any[]): boolean;

        emit(event: "close"): boolean;

        emit(event: "connection", socket: Socket): boolean;

        emit(event: "error", err: Error): boolean;

        emit(event: "listening"): boolean;

        on(event: string, listener: (...args: any[]) => void): this;

        on(event: "close", listener: () => void): this;

        on(event: "connection", listener: (socket: Socket) => void): this;

        on(event: "error", listener: (err: Error) => void): this;

        on(event: "listening", listener: () => void): this;

        once(event: string, listener: (...args: any[]) => void): this;

        once(event: "close", listener: () => void): this;

        once(event: "connection", listener: (socket: Socket) => void): this;

        once(event: "error", listener: (err: Error) => void): this;

        once(event: "listening", listener: () => void): this;

        prependListener(event: string, listener: (...args: any[]) => void): this;

        prependListener(event: "close", listener: () => void): this;

        prependListener(event: "connection", listener: (socket: Socket) => void): this;

        prependListener(event: "error", listener: (err: Error) => void): this;

        prependListener(event: "listening", listener: () => void): this;

        prependOnceListener(event: string, listener: (...args: any[]) => void): this;

        prependOnceListener(event: "close", listener: () => void): this;

        prependOnceListener(event: "connection", listener: (socket: Socket) => void): this;

        prependOnceListener(event: "error", listener: (err: Error) => void): this;

        prependOnceListener(event: "listening", listener: () => void): this;

    }

    interface TcpNetConnectOpts extends TcpSocketConnectOpts, SocketConstructorOpts {

        timeout?: number;

    }

    interface IpcNetConnectOpts extends IpcSocketConnectOpts, SocketConstructorOpts {

        timeout?: number;

    }

    type NetConnectOpts = TcpNetConnectOpts | IpcNetConnectOpts;

    function createServer(connectionListener?: (socket: Socket) => void): Server;

    function createServer(options?: { allowHalfOpen?: boolean, pauseOnConnect?: boolean }, connectionListener?: (socket: Socket) => void): Server;

    function connect(options: NetConnectOpts, connectionListener?: () => void): Socket;

    function connect(port: number, host?: string, connectionListener?: () => void): Socket;

    function connect(path: string, connectionListener?: () => void): Socket;

    function createConnection(options: NetConnectOpts, connectionListener?: () => void): Socket;

    function createConnection(port: number, host?: string, connectionListener?: () => void): Socket;

    function createConnection(path: string, connectionListener?: () => void): Socket;

    function isIP(input: string): number;

    function isIPv4(input: string): boolean;

    function isIPv6(input: string): boolean;

}