@volter/tabnode 0.4.0 → 0.5.0

package/dist/shims/tls.d.ts

@@ -1,12 +1,740 @@
 /**
  * tls shim - TLS/SSL is not available in browser
- * Provides stubs that allow code to load without crashing
+ * No TLS transport is installed. A connection must fail asynchronously rather
+ * than pretending to connect and leaving Node's HTTPS client waiting forever.
  */
-import { EventEmitter } from '../node-lib/events-module';
-export declare class TLSSocket extends EventEmitter {
+/** Native TLS refusal keeps the requesting graph's Socket identity. */
+export declare function createTlsModule(require?: (name: string) => any): {
+    TLSSocket: {
+        new (_socket?: unknown, _options?: unknown): {
+            [key: string]: unknown;
+            authorized: boolean;
+            encrypted: boolean;
+            connect(..._args: unknown[]): /*elided*/ any;
+            getPeerCertificate(_detailed?: boolean): object;
+            getCipher(): {
+                name: string;
+                version: string;
+            } | null;
+            getProtocol(): string | null;
+            setServername(_name: string): void;
+            renegotiate(_options: unknown, _callback: (err: Error | null) => void): boolean;
+            connecting: boolean;
+            pending: boolean;
+            readyState: string;
+            bufferSize: number | undefined;
+            bytesRead: number;
+            bytesWritten: number | undefined;
+            localAddress: string | undefined;
+            localPort: number | undefined;
+            localFamily: string | undefined;
+            remoteAddress: string | undefined;
+            remotePort: number | undefined;
+            remoteFamily: string | undefined;
+            timeout?: number;
+            server: import("../node-lib/net-module").Server | null;
+            _server: import("../node-lib/net-module").Server | null;
+            _handle: import("../node-lib/binding/stream_wrap").LibuvStreamWrap | null;
+            address(): import("../node-lib/net-module").AddressInfo | Record<string, never>;
+            setTimeout(timeout: number, callback?: (() => void) | undefined): /*elided*/ any;
+            setNoDelay(enable?: boolean): /*elided*/ any;
+            setKeepAlive(enable?: boolean, initialDelay?: number): /*elided*/ any;
+            resetAndDestroy(): /*elided*/ any;
+            destroySoon(): void;
+            ref(): /*elided*/ any;
+            unref(): /*elided*/ any;
+            cork(): void;
+            uncork(): void;
+            push(chunk: unknown, encoding?: string): boolean;
+            read(size?: number): string | Uint8Array | null;
+            pause(): /*elided*/ any;
+            resume(): /*elided*/ any;
+            destroy(error?: Error): /*elided*/ any;
+            setEncoding(encoding: string): /*elided*/ any;
+            pipe(destination: unknown, options?: unknown): unknown;
+            on(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+            once(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+            emit(event: string, ...args: unknown[]): boolean;
+            readable: boolean;
+            readableEnded: boolean;
+            destroyed: boolean;
+            isTTY?: boolean;
+            write(chunk: unknown, encoding?: unknown, callback?: unknown): boolean;
+            end(chunk?: unknown, encoding?: unknown, callback?: unknown): /*elided*/ any;
+            writable: boolean;
+        };
+    };
+    Server: {
+        new (_options?: unknown, _connectionListener?: (socket: {
+            [key: string]: unknown;
+            authorized: boolean;
+            encrypted: boolean;
+            connect(..._args: unknown[]): /*elided*/ any;
+            getPeerCertificate(_detailed?: boolean): object;
+            getCipher(): {
+                name: string;
+                version: string;
+            } | null;
+            getProtocol(): string | null;
+            setServername(_name: string): void;
+            renegotiate(_options: unknown, _callback: (err: Error | null) => void): boolean;
+            connecting: boolean;
+            pending: boolean;
+            readyState: string;
+            bufferSize: number | undefined;
+            bytesRead: number;
+            bytesWritten: number | undefined;
+            localAddress: string | undefined;
+            localPort: number | undefined;
+            localFamily: string | undefined;
+            remoteAddress: string | undefined;
+            remotePort: number | undefined;
+            remoteFamily: string | undefined;
+            timeout?: number;
+            server: import("../node-lib/net-module").Server | null;
+            _server: import("../node-lib/net-module").Server | null;
+            _handle: import("../node-lib/binding/stream_wrap").LibuvStreamWrap | null;
+            address(): import("../node-lib/net-module").AddressInfo | Record<string, never>;
+            setTimeout(timeout: number, callback?: (() => void) | undefined): /*elided*/ any;
+            setNoDelay(enable?: boolean): /*elided*/ any;
+            setKeepAlive(enable?: boolean, initialDelay?: number): /*elided*/ any;
+            resetAndDestroy(): /*elided*/ any;
+            destroySoon(): void;
+            ref(): /*elided*/ any;
+            unref(): /*elided*/ any;
+            cork(): void;
+            uncork(): void;
+            push(chunk: unknown, encoding?: string): boolean;
+            read(size?: number): string | Uint8Array | null;
+            pause(): /*elided*/ any;
+            resume(): /*elided*/ any;
+            destroy(error?: Error): /*elided*/ any;
+            setEncoding(encoding: string): /*elided*/ any;
+            pipe(destination: unknown, options?: unknown): unknown;
+            on(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+            once(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+            emit(event: string, ...args: unknown[]): boolean;
+            readable: boolean;
+            readableEnded: boolean;
+            destroyed: boolean;
+            isTTY?: boolean;
+            write(chunk: unknown, encoding?: unknown, callback?: unknown): boolean;
+            end(chunk?: unknown, encoding?: unknown, callback?: unknown): /*elided*/ any;
+            writable: boolean;
+        }) => void): {
+            listen(..._args: unknown[]): /*elided*/ any;
+            close(_callback?: (err?: Error) => void): /*elided*/ any;
+            address(): {
+                port: number;
+                family: string;
+                address: string;
+            } | string | null;
+            getTicketKeys(): Buffer;
+            setTicketKeys(_keys: Buffer): void;
+            setSecureContext(_options: unknown): void;
+            addListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+            on(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+            once(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+            removeListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+            off(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+            removeAllListeners(event?: string | symbol): /*elided*/ any;
+            setMaxListeners(n: number): /*elided*/ any;
+            getMaxListeners(): number;
+            listeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+            rawListeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+            emit(event: string | symbol, ...args: unknown[]): boolean;
+            listenerCount(event: string | symbol, listener?: import("../node-lib/events-module").EventListener): number;
+            prependListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+            prependOnceListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+            eventNames(): Array<string | symbol>;
+        };
+    };
+    createServer: (_options?: unknown, _connectionListener?: (socket: {
+        [key: string]: unknown;
+        authorized: boolean;
+        encrypted: boolean;
+        connect(..._args: unknown[]): /*elided*/ any;
+        getPeerCertificate(_detailed?: boolean): object;
+        getCipher(): {
+            name: string;
+            version: string;
+        } | null;
+        getProtocol(): string | null;
+        setServername(_name: string): void;
+        renegotiate(_options: unknown, _callback: (err: Error | null) => void): boolean;
+        connecting: boolean;
+        pending: boolean;
+        readyState: string;
+        bufferSize: number | undefined;
+        bytesRead: number;
+        bytesWritten: number | undefined;
+        localAddress: string | undefined;
+        localPort: number | undefined;
+        localFamily: string | undefined;
+        remoteAddress: string | undefined;
+        remotePort: number | undefined;
+        remoteFamily: string | undefined;
+        timeout?: number;
+        server: import("../node-lib/net-module").Server | null;
+        _server: import("../node-lib/net-module").Server | null;
+        _handle: import("../node-lib/binding/stream_wrap").LibuvStreamWrap | null;
+        address(): import("../node-lib/net-module").AddressInfo | Record<string, never>;
+        setTimeout(timeout: number, callback?: (() => void) | undefined): /*elided*/ any;
+        setNoDelay(enable?: boolean): /*elided*/ any;
+        setKeepAlive(enable?: boolean, initialDelay?: number): /*elided*/ any;
+        resetAndDestroy(): /*elided*/ any;
+        destroySoon(): void;
+        ref(): /*elided*/ any;
+        unref(): /*elided*/ any;
+        cork(): void;
+        uncork(): void;
+        push(chunk: unknown, encoding?: string): boolean;
+        read(size?: number): string | Uint8Array | null;
+        pause(): /*elided*/ any;
+        resume(): /*elided*/ any;
+        destroy(error?: Error): /*elided*/ any;
+        setEncoding(encoding: string): /*elided*/ any;
+        pipe(destination: unknown, options?: unknown): unknown;
+        on(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+        once(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+        emit(event: string, ...args: unknown[]): boolean;
+        readable: boolean;
+        readableEnded: boolean;
+        destroyed: boolean;
+        isTTY?: boolean;
+        write(chunk: unknown, encoding?: unknown, callback?: unknown): boolean;
+        end(chunk?: unknown, encoding?: unknown, callback?: unknown): /*elided*/ any;
+        writable: boolean;
+    }) => void) => {
+        listen(..._args: unknown[]): /*elided*/ any;
+        close(_callback?: (err?: Error) => void): /*elided*/ any;
+        address(): {
+            port: number;
+            family: string;
+            address: string;
+        } | string | null;
+        getTicketKeys(): Buffer;
+        setTicketKeys(_keys: Buffer): void;
+        setSecureContext(_options: unknown): void;
+        addListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        on(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        once(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        removeListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        off(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        removeAllListeners(event?: string | symbol): /*elided*/ any;
+        setMaxListeners(n: number): /*elided*/ any;
+        getMaxListeners(): number;
+        listeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+        rawListeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+        emit(event: string | symbol, ...args: unknown[]): boolean;
+        listenerCount(event: string | symbol, listener?: import("../node-lib/events-module").EventListener): number;
+        prependListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        prependOnceListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        eventNames(): Array<string | symbol>;
+    };
+    connect: (_options: unknown, _callback?: () => void) => {
+        [key: string]: unknown;
+        authorized: boolean;
+        encrypted: boolean;
+        connect(..._args: unknown[]): /*elided*/ any;
+        getPeerCertificate(_detailed?: boolean): object;
+        getCipher(): {
+            name: string;
+            version: string;
+        } | null;
+        getProtocol(): string | null;
+        setServername(_name: string): void;
+        renegotiate(_options: unknown, _callback: (err: Error | null) => void): boolean;
+        connecting: boolean;
+        pending: boolean;
+        readyState: string;
+        bufferSize: number | undefined;
+        bytesRead: number;
+        bytesWritten: number | undefined;
+        localAddress: string | undefined;
+        localPort: number | undefined;
+        localFamily: string | undefined;
+        remoteAddress: string | undefined;
+        remotePort: number | undefined;
+        remoteFamily: string | undefined;
+        timeout?: number;
+        server: import("../node-lib/net-module").Server | null;
+        _server: import("../node-lib/net-module").Server | null;
+        _handle: import("../node-lib/binding/stream_wrap").LibuvStreamWrap | null;
+        address(): import("../node-lib/net-module").AddressInfo | Record<string, never>;
+        setTimeout(timeout: number, callback?: (() => void) | undefined): /*elided*/ any;
+        setNoDelay(enable?: boolean): /*elided*/ any;
+        setKeepAlive(enable?: boolean, initialDelay?: number): /*elided*/ any;
+        resetAndDestroy(): /*elided*/ any;
+        destroySoon(): void;
+        ref(): /*elided*/ any;
+        unref(): /*elided*/ any;
+        cork(): void;
+        uncork(): void;
+        push(chunk: unknown, encoding?: string): boolean;
+        read(size?: number): string | Uint8Array | null;
+        pause(): /*elided*/ any;
+        resume(): /*elided*/ any;
+        destroy(error?: Error): /*elided*/ any;
+        setEncoding(encoding: string): /*elided*/ any;
+        pipe(destination: unknown, options?: unknown): unknown;
+        on(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+        once(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+        emit(event: string, ...args: unknown[]): boolean;
+        readable: boolean;
+        readableEnded: boolean;
+        destroyed: boolean;
+        isTTY?: boolean;
+        write(chunk: unknown, encoding?: unknown, callback?: unknown): boolean;
+        end(chunk?: unknown, encoding?: unknown, callback?: unknown): /*elided*/ any;
+        writable: boolean;
+    };
+    createSecureContext: (_options?: unknown) => {};
+    getCiphers: () => string[];
+    DEFAULT_ECDH_CURVE: string;
+    DEFAULT_MAX_VERSION: string;
+    DEFAULT_MIN_VERSION: string;
+    rootCertificates: string[];
+};
+declare const tls: {
+    TLSSocket: {
+        new (_socket?: unknown, _options?: unknown): {
+            [key: string]: unknown;
+            authorized: boolean;
+            encrypted: boolean;
+            connect(..._args: unknown[]): /*elided*/ any;
+            getPeerCertificate(_detailed?: boolean): object;
+            getCipher(): {
+                name: string;
+                version: string;
+            } | null;
+            getProtocol(): string | null;
+            setServername(_name: string): void;
+            renegotiate(_options: unknown, _callback: (err: Error | null) => void): boolean;
+            connecting: boolean;
+            pending: boolean;
+            readyState: string;
+            bufferSize: number | undefined;
+            bytesRead: number;
+            bytesWritten: number | undefined;
+            localAddress: string | undefined;
+            localPort: number | undefined;
+            localFamily: string | undefined;
+            remoteAddress: string | undefined;
+            remotePort: number | undefined;
+            remoteFamily: string | undefined;
+            timeout?: number;
+            server: import("../node-lib/net-module").Server | null;
+            _server: import("../node-lib/net-module").Server | null;
+            _handle: import("../node-lib/binding/stream_wrap").LibuvStreamWrap | null;
+            address(): import("../node-lib/net-module").AddressInfo | Record<string, never>;
+            setTimeout(timeout: number, callback?: (() => void) | undefined): /*elided*/ any;
+            setNoDelay(enable?: boolean): /*elided*/ any;
+            setKeepAlive(enable?: boolean, initialDelay?: number): /*elided*/ any;
+            resetAndDestroy(): /*elided*/ any;
+            destroySoon(): void;
+            ref(): /*elided*/ any;
+            unref(): /*elided*/ any;
+            cork(): void;
+            uncork(): void;
+            push(chunk: unknown, encoding?: string): boolean;
+            read(size?: number): string | Uint8Array | null;
+            pause(): /*elided*/ any;
+            resume(): /*elided*/ any;
+            destroy(error?: Error): /*elided*/ any;
+            setEncoding(encoding: string): /*elided*/ any;
+            pipe(destination: unknown, options?: unknown): unknown;
+            on(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+            once(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+            emit(event: string, ...args: unknown[]): boolean;
+            readable: boolean;
+            readableEnded: boolean;
+            destroyed: boolean;
+            isTTY?: boolean;
+            write(chunk: unknown, encoding?: unknown, callback?: unknown): boolean;
+            end(chunk?: unknown, encoding?: unknown, callback?: unknown): /*elided*/ any;
+            writable: boolean;
+        };
+    };
+    Server: {
+        new (_options?: unknown, _connectionListener?: (socket: {
+            [key: string]: unknown;
+            authorized: boolean;
+            encrypted: boolean;
+            connect(..._args: unknown[]): /*elided*/ any;
+            getPeerCertificate(_detailed?: boolean): object;
+            getCipher(): {
+                name: string;
+                version: string;
+            } | null;
+            getProtocol(): string | null;
+            setServername(_name: string): void;
+            renegotiate(_options: unknown, _callback: (err: Error | null) => void): boolean;
+            connecting: boolean;
+            pending: boolean;
+            readyState: string;
+            bufferSize: number | undefined;
+            bytesRead: number;
+            bytesWritten: number | undefined;
+            localAddress: string | undefined;
+            localPort: number | undefined;
+            localFamily: string | undefined;
+            remoteAddress: string | undefined;
+            remotePort: number | undefined;
+            remoteFamily: string | undefined;
+            timeout?: number;
+            server: import("../node-lib/net-module").Server | null;
+            _server: import("../node-lib/net-module").Server | null;
+            _handle: import("../node-lib/binding/stream_wrap").LibuvStreamWrap | null;
+            address(): import("../node-lib/net-module").AddressInfo | Record<string, never>;
+            setTimeout(timeout: number, callback?: (() => void) | undefined): /*elided*/ any;
+            setNoDelay(enable?: boolean): /*elided*/ any;
+            setKeepAlive(enable?: boolean, initialDelay?: number): /*elided*/ any;
+            resetAndDestroy(): /*elided*/ any;
+            destroySoon(): void;
+            ref(): /*elided*/ any;
+            unref(): /*elided*/ any;
+            cork(): void;
+            uncork(): void;
+            push(chunk: unknown, encoding?: string): boolean;
+            read(size?: number): string | Uint8Array | null;
+            pause(): /*elided*/ any;
+            resume(): /*elided*/ any;
+            destroy(error?: Error): /*elided*/ any;
+            setEncoding(encoding: string): /*elided*/ any;
+            pipe(destination: unknown, options?: unknown): unknown;
+            on(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+            once(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+            emit(event: string, ...args: unknown[]): boolean;
+            readable: boolean;
+            readableEnded: boolean;
+            destroyed: boolean;
+            isTTY?: boolean;
+            write(chunk: unknown, encoding?: unknown, callback?: unknown): boolean;
+            end(chunk?: unknown, encoding?: unknown, callback?: unknown): /*elided*/ any;
+            writable: boolean;
+        }) => void): {
+            listen(..._args: unknown[]): /*elided*/ any;
+            close(_callback?: (err?: Error) => void): /*elided*/ any;
+            address(): {
+                port: number;
+                family: string;
+                address: string;
+            } | string | null;
+            getTicketKeys(): Buffer;
+            setTicketKeys(_keys: Buffer): void;
+            setSecureContext(_options: unknown): void;
+            addListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+            on(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+            once(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+            removeListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+            off(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+            removeAllListeners(event?: string | symbol): /*elided*/ any;
+            setMaxListeners(n: number): /*elided*/ any;
+            getMaxListeners(): number;
+            listeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+            rawListeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+            emit(event: string | symbol, ...args: unknown[]): boolean;
+            listenerCount(event: string | symbol, listener?: import("../node-lib/events-module").EventListener): number;
+            prependListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+            prependOnceListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+            eventNames(): Array<string | symbol>;
+        };
+    };
+    createServer: (_options?: unknown, _connectionListener?: (socket: {
+        [key: string]: unknown;
+        authorized: boolean;
+        encrypted: boolean;
+        connect(..._args: unknown[]): /*elided*/ any;
+        getPeerCertificate(_detailed?: boolean): object;
+        getCipher(): {
+            name: string;
+            version: string;
+        } | null;
+        getProtocol(): string | null;
+        setServername(_name: string): void;
+        renegotiate(_options: unknown, _callback: (err: Error | null) => void): boolean;
+        connecting: boolean;
+        pending: boolean;
+        readyState: string;
+        bufferSize: number | undefined;
+        bytesRead: number;
+        bytesWritten: number | undefined;
+        localAddress: string | undefined;
+        localPort: number | undefined;
+        localFamily: string | undefined;
+        remoteAddress: string | undefined;
+        remotePort: number | undefined;
+        remoteFamily: string | undefined;
+        timeout?: number;
+        server: import("../node-lib/net-module").Server | null;
+        _server: import("../node-lib/net-module").Server | null;
+        _handle: import("../node-lib/binding/stream_wrap").LibuvStreamWrap | null;
+        address(): import("../node-lib/net-module").AddressInfo | Record<string, never>;
+        setTimeout(timeout: number, callback?: (() => void) | undefined): /*elided*/ any;
+        setNoDelay(enable?: boolean): /*elided*/ any;
+        setKeepAlive(enable?: boolean, initialDelay?: number): /*elided*/ any;
+        resetAndDestroy(): /*elided*/ any;
+        destroySoon(): void;
+        ref(): /*elided*/ any;
+        unref(): /*elided*/ any;
+        cork(): void;
+        uncork(): void;
+        push(chunk: unknown, encoding?: string): boolean;
+        read(size?: number): string | Uint8Array | null;
+        pause(): /*elided*/ any;
+        resume(): /*elided*/ any;
+        destroy(error?: Error): /*elided*/ any;
+        setEncoding(encoding: string): /*elided*/ any;
+        pipe(destination: unknown, options?: unknown): unknown;
+        on(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+        once(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+        emit(event: string, ...args: unknown[]): boolean;
+        readable: boolean;
+        readableEnded: boolean;
+        destroyed: boolean;
+        isTTY?: boolean;
+        write(chunk: unknown, encoding?: unknown, callback?: unknown): boolean;
+        end(chunk?: unknown, encoding?: unknown, callback?: unknown): /*elided*/ any;
+        writable: boolean;
+    }) => void) => {
+        listen(..._args: unknown[]): /*elided*/ any;
+        close(_callback?: (err?: Error) => void): /*elided*/ any;
+        address(): {
+            port: number;
+            family: string;
+            address: string;
+        } | string | null;
+        getTicketKeys(): Buffer;
+        setTicketKeys(_keys: Buffer): void;
+        setSecureContext(_options: unknown): void;
+        addListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        on(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        once(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        removeListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        off(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        removeAllListeners(event?: string | symbol): /*elided*/ any;
+        setMaxListeners(n: number): /*elided*/ any;
+        getMaxListeners(): number;
+        listeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+        rawListeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+        emit(event: string | symbol, ...args: unknown[]): boolean;
+        listenerCount(event: string | symbol, listener?: import("../node-lib/events-module").EventListener): number;
+        prependListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        prependOnceListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        eventNames(): Array<string | symbol>;
+    };
+    connect: (_options: unknown, _callback?: () => void) => {
+        [key: string]: unknown;
+        authorized: boolean;
+        encrypted: boolean;
+        connect(..._args: unknown[]): /*elided*/ any;
+        getPeerCertificate(_detailed?: boolean): object;
+        getCipher(): {
+            name: string;
+            version: string;
+        } | null;
+        getProtocol(): string | null;
+        setServername(_name: string): void;
+        renegotiate(_options: unknown, _callback: (err: Error | null) => void): boolean;
+        connecting: boolean;
+        pending: boolean;
+        readyState: string;
+        bufferSize: number | undefined;
+        bytesRead: number;
+        bytesWritten: number | undefined;
+        localAddress: string | undefined;
+        localPort: number | undefined;
+        localFamily: string | undefined;
+        remoteAddress: string | undefined;
+        remotePort: number | undefined;
+        remoteFamily: string | undefined;
+        timeout?: number;
+        server: import("../node-lib/net-module").Server | null;
+        _server: import("../node-lib/net-module").Server | null;
+        _handle: import("../node-lib/binding/stream_wrap").LibuvStreamWrap | null;
+        address(): import("../node-lib/net-module").AddressInfo | Record<string, never>;
+        setTimeout(timeout: number, callback?: (() => void) | undefined): /*elided*/ any;
+        setNoDelay(enable?: boolean): /*elided*/ any;
+        setKeepAlive(enable?: boolean, initialDelay?: number): /*elided*/ any;
+        resetAndDestroy(): /*elided*/ any;
+        destroySoon(): void;
+        ref(): /*elided*/ any;
+        unref(): /*elided*/ any;
+        cork(): void;
+        uncork(): void;
+        push(chunk: unknown, encoding?: string): boolean;
+        read(size?: number): string | Uint8Array | null;
+        pause(): /*elided*/ any;
+        resume(): /*elided*/ any;
+        destroy(error?: Error): /*elided*/ any;
+        setEncoding(encoding: string): /*elided*/ any;
+        pipe(destination: unknown, options?: unknown): unknown;
+        on(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+        once(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+        emit(event: string, ...args: unknown[]): boolean;
+        readable: boolean;
+        readableEnded: boolean;
+        destroyed: boolean;
+        isTTY?: boolean;
+        write(chunk: unknown, encoding?: unknown, callback?: unknown): boolean;
+        end(chunk?: unknown, encoding?: unknown, callback?: unknown): /*elided*/ any;
+        writable: boolean;
+    };
+    createSecureContext: (_options?: unknown) => {};
+    getCiphers: () => string[];
+    DEFAULT_ECDH_CURVE: string;
+    DEFAULT_MAX_VERSION: string;
+    DEFAULT_MIN_VERSION: string;
+    rootCertificates: string[];
+};
+export declare const TLSSocket: {
+    new (_socket?: unknown, _options?: unknown): {
+        [key: string]: unknown;
+        authorized: boolean;
+        encrypted: boolean;
+        connect(..._args: unknown[]): /*elided*/ any;
+        getPeerCertificate(_detailed?: boolean): object;
+        getCipher(): {
+            name: string;
+            version: string;
+        } | null;
+        getProtocol(): string | null;
+        setServername(_name: string): void;
+        renegotiate(_options: unknown, _callback: (err: Error | null) => void): boolean;
+        connecting: boolean;
+        pending: boolean;
+        readyState: string;
+        bufferSize: number | undefined;
+        bytesRead: number;
+        bytesWritten: number | undefined;
+        localAddress: string | undefined;
+        localPort: number | undefined;
+        localFamily: string | undefined;
+        remoteAddress: string | undefined;
+        remotePort: number | undefined;
+        remoteFamily: string | undefined;
+        timeout?: number;
+        server: import("../node-lib/net-module").Server | null;
+        _server: import("../node-lib/net-module").Server | null;
+        _handle: import("../node-lib/binding/stream_wrap").LibuvStreamWrap | null;
+        address(): import("../node-lib/net-module").AddressInfo | Record<string, never>;
+        setTimeout(timeout: number, callback?: (() => void) | undefined): /*elided*/ any;
+        setNoDelay(enable?: boolean): /*elided*/ any;
+        setKeepAlive(enable?: boolean, initialDelay?: number): /*elided*/ any;
+        resetAndDestroy(): /*elided*/ any;
+        destroySoon(): void;
+        ref(): /*elided*/ any;
+        unref(): /*elided*/ any;
+        cork(): void;
+        uncork(): void;
+        push(chunk: unknown, encoding?: string): boolean;
+        read(size?: number): string | Uint8Array | null;
+        pause(): /*elided*/ any;
+        resume(): /*elided*/ any;
+        destroy(error?: Error): /*elided*/ any;
+        setEncoding(encoding: string): /*elided*/ any;
+        pipe(destination: unknown, options?: unknown): unknown;
+        on(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+        once(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+        emit(event: string, ...args: unknown[]): boolean;
+        readable: boolean;
+        readableEnded: boolean;
+        destroyed: boolean;
+        isTTY?: boolean;
+        write(chunk: unknown, encoding?: unknown, callback?: unknown): boolean;
+        end(chunk?: unknown, encoding?: unknown, callback?: unknown): /*elided*/ any;
+        writable: boolean;
+    };
+}, Server: {
+    new (_options?: unknown, _connectionListener?: (socket: {
+        [key: string]: unknown;
+        authorized: boolean;
+        encrypted: boolean;
+        connect(..._args: unknown[]): /*elided*/ any;
+        getPeerCertificate(_detailed?: boolean): object;
+        getCipher(): {
+            name: string;
+            version: string;
+        } | null;
+        getProtocol(): string | null;
+        setServername(_name: string): void;
+        renegotiate(_options: unknown, _callback: (err: Error | null) => void): boolean;
+        connecting: boolean;
+        pending: boolean;
+        readyState: string;
+        bufferSize: number | undefined;
+        bytesRead: number;
+        bytesWritten: number | undefined;
+        localAddress: string | undefined;
+        localPort: number | undefined;
+        localFamily: string | undefined;
+        remoteAddress: string | undefined;
+        remotePort: number | undefined;
+        remoteFamily: string | undefined;
+        timeout?: number;
+        server: import("../node-lib/net-module").Server | null;
+        _server: import("../node-lib/net-module").Server | null;
+        _handle: import("../node-lib/binding/stream_wrap").LibuvStreamWrap | null;
+        address(): import("../node-lib/net-module").AddressInfo | Record<string, never>;
+        setTimeout(timeout: number, callback?: (() => void) | undefined): /*elided*/ any;
+        setNoDelay(enable?: boolean): /*elided*/ any;
+        setKeepAlive(enable?: boolean, initialDelay?: number): /*elided*/ any;
+        resetAndDestroy(): /*elided*/ any;
+        destroySoon(): void;
+        ref(): /*elided*/ any;
+        unref(): /*elided*/ any;
+        cork(): void;
+        uncork(): void;
+        push(chunk: unknown, encoding?: string): boolean;
+        read(size?: number): string | Uint8Array | null;
+        pause(): /*elided*/ any;
+        resume(): /*elided*/ any;
+        destroy(error?: Error): /*elided*/ any;
+        setEncoding(encoding: string): /*elided*/ any;
+        pipe(destination: unknown, options?: unknown): unknown;
+        on(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+        once(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+        emit(event: string, ...args: unknown[]): boolean;
+        readable: boolean;
+        readableEnded: boolean;
+        destroyed: boolean;
+        isTTY?: boolean;
+        write(chunk: unknown, encoding?: unknown, callback?: unknown): boolean;
+        end(chunk?: unknown, encoding?: unknown, callback?: unknown): /*elided*/ any;
+        writable: boolean;
+    }) => void): {
+        listen(..._args: unknown[]): /*elided*/ any;
+        close(_callback?: (err?: Error) => void): /*elided*/ any;
+        address(): {
+            port: number;
+            family: string;
+            address: string;
+        } | string | null;
+        getTicketKeys(): Buffer;
+        setTicketKeys(_keys: Buffer): void;
+        setSecureContext(_options: unknown): void;
+        addListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        on(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        once(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        removeListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        off(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        removeAllListeners(event?: string | symbol): /*elided*/ any;
+        setMaxListeners(n: number): /*elided*/ any;
+        getMaxListeners(): number;
+        listeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+        rawListeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+        emit(event: string | symbol, ...args: unknown[]): boolean;
+        listenerCount(event: string | symbol, listener?: import("../node-lib/events-module").EventListener): number;
+        prependListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        prependOnceListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        eventNames(): Array<string | symbol>;
+    };
+}, createServer: (_options?: unknown, _connectionListener?: (socket: {
+    [key: string]: unknown;
     authorized: boolean;
     encrypted: boolean;
-    constructor(_socket?: unknown, _options?: unknown);
+    connect(..._args: unknown[]): /*elided*/ any;
     getPeerCertificate(_detailed?: boolean): object;
     getCipher(): {
         name: string;
@@ -15,11 +743,52 @@ export declare class TLSSocket extends EventEmitter {
     getProtocol(): string | null;
     setServername(_name: string): void;
     renegotiate(_options: unknown, _callback: (err: Error | null) => void): boolean;
-}
-export declare class Server extends EventEmitter {
-    constructor(_options?: unknown, _connectionListener?: (socket: TLSSocket) => void);
-    listen(..._args: unknown[]): this;
-    close(_callback?: (err?: Error) => void): this;
+    connecting: boolean;
+    pending: boolean;
+    readyState: string;
+    bufferSize: number | undefined;
+    bytesRead: number;
+    bytesWritten: number | undefined;
+    localAddress: string | undefined;
+    localPort: number | undefined;
+    localFamily: string | undefined;
+    remoteAddress: string | undefined;
+    remotePort: number | undefined;
+    remoteFamily: string | undefined;
+    timeout?: number;
+    server: import("../node-lib/net-module").Server | null;
+    _server: import("../node-lib/net-module").Server | null;
+    _handle: import("../node-lib/binding/stream_wrap").LibuvStreamWrap | null;
+    address(): import("../node-lib/net-module").AddressInfo | Record<string, never>;
+    setTimeout(timeout: number, callback?: (() => void) | undefined): /*elided*/ any;
+    setNoDelay(enable?: boolean): /*elided*/ any;
+    setKeepAlive(enable?: boolean, initialDelay?: number): /*elided*/ any;
+    resetAndDestroy(): /*elided*/ any;
+    destroySoon(): void;
+    ref(): /*elided*/ any;
+    unref(): /*elided*/ any;
+    cork(): void;
+    uncork(): void;
+    push(chunk: unknown, encoding?: string): boolean;
+    read(size?: number): string | Uint8Array | null;
+    pause(): /*elided*/ any;
+    resume(): /*elided*/ any;
+    destroy(error?: Error): /*elided*/ any;
+    setEncoding(encoding: string): /*elided*/ any;
+    pipe(destination: unknown, options?: unknown): unknown;
+    on(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+    once(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+    emit(event: string, ...args: unknown[]): boolean;
+    readable: boolean;
+    readableEnded: boolean;
+    destroyed: boolean;
+    isTTY?: boolean;
+    write(chunk: unknown, encoding?: unknown, callback?: unknown): boolean;
+    end(chunk?: unknown, encoding?: unknown, callback?: unknown): /*elided*/ any;
+    writable: boolean;
+}) => void) => {
+    listen(..._args: unknown[]): /*elided*/ any;
+    close(_callback?: (err?: Error) => void): /*elided*/ any;
     address(): {
         port: number;
         family: string;
@@ -28,25 +797,78 @@ export declare class Server extends EventEmitter {
     getTicketKeys(): Buffer;
     setTicketKeys(_keys: Buffer): void;
     setSecureContext(_options: unknown): void;
-}
-export declare function createServer(_options?: unknown, _connectionListener?: (socket: TLSSocket) => void): Server;
-export declare function connect(_options: unknown, _callback?: () => void): TLSSocket;
-export declare const createSecureContext: (_options?: unknown) => {};
-export declare const getCiphers: () => string[];
-export declare const DEFAULT_ECDH_CURVE = "auto";
-export declare const DEFAULT_MAX_VERSION = "TLSv1.3";
-export declare const DEFAULT_MIN_VERSION = "TLSv1.2";
-export declare const rootCertificates: string[];
-declare const _default: {
-    TLSSocket: typeof TLSSocket;
-    Server: typeof Server;
-    createServer: typeof createServer;
-    connect: typeof connect;
-    createSecureContext: (_options?: unknown) => {};
-    getCiphers: () => string[];
-    DEFAULT_ECDH_CURVE: string;
-    DEFAULT_MAX_VERSION: string;
-    DEFAULT_MIN_VERSION: string;
-    rootCertificates: string[];
-};
-export default _default;
+    addListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+    on(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+    once(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+    removeListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+    off(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+    removeAllListeners(event?: string | symbol): /*elided*/ any;
+    setMaxListeners(n: number): /*elided*/ any;
+    getMaxListeners(): number;
+    listeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+    rawListeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+    emit(event: string | symbol, ...args: unknown[]): boolean;
+    listenerCount(event: string | symbol, listener?: import("../node-lib/events-module").EventListener): number;
+    prependListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+    prependOnceListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+    eventNames(): Array<string | symbol>;
+}, connect: (_options: unknown, _callback?: () => void) => {
+    [key: string]: unknown;
+    authorized: boolean;
+    encrypted: boolean;
+    connect(..._args: unknown[]): /*elided*/ any;
+    getPeerCertificate(_detailed?: boolean): object;
+    getCipher(): {
+        name: string;
+        version: string;
+    } | null;
+    getProtocol(): string | null;
+    setServername(_name: string): void;
+    renegotiate(_options: unknown, _callback: (err: Error | null) => void): boolean;
+    connecting: boolean;
+    pending: boolean;
+    readyState: string;
+    bufferSize: number | undefined;
+    bytesRead: number;
+    bytesWritten: number | undefined;
+    localAddress: string | undefined;
+    localPort: number | undefined;
+    localFamily: string | undefined;
+    remoteAddress: string | undefined;
+    remotePort: number | undefined;
+    remoteFamily: string | undefined;
+    timeout?: number;
+    server: import("../node-lib/net-module").Server | null;
+    _server: import("../node-lib/net-module").Server | null;
+    _handle: import("../node-lib/binding/stream_wrap").LibuvStreamWrap | null;
+    address(): import("../node-lib/net-module").AddressInfo | Record<string, never>;
+    setTimeout(timeout: number, callback?: (() => void) | undefined): /*elided*/ any;
+    setNoDelay(enable?: boolean): /*elided*/ any;
+    setKeepAlive(enable?: boolean, initialDelay?: number): /*elided*/ any;
+    resetAndDestroy(): /*elided*/ any;
+    destroySoon(): void;
+    ref(): /*elided*/ any;
+    unref(): /*elided*/ any;
+    cork(): void;
+    uncork(): void;
+    push(chunk: unknown, encoding?: string): boolean;
+    read(size?: number): string | Uint8Array | null;
+    pause(): /*elided*/ any;
+    resume(): /*elided*/ any;
+    destroy(error?: Error): /*elided*/ any;
+    setEncoding(encoding: string): /*elided*/ any;
+    pipe(destination: unknown, options?: unknown): unknown;
+    on(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+    once(event: string, listener: (...args: never[]) => void): /*elided*/ any;
+    emit(event: string, ...args: unknown[]): boolean;
+    readable: boolean;
+    readableEnded: boolean;
+    destroyed: boolean;
+    isTTY?: boolean;
+    write(chunk: unknown, encoding?: unknown, callback?: unknown): boolean;
+    end(chunk?: unknown, encoding?: unknown, callback?: unknown): /*elided*/ any;
+    writable: boolean;
+}, createSecureContext: (_options?: unknown) => {}, getCiphers: () => string[], DEFAULT_ECDH_CURVE: string, DEFAULT_MAX_VERSION: string, DEFAULT_MIN_VERSION: string, rootCertificates: string[];
+export type TLSSocket = InstanceType<typeof TLSSocket>;
+export type Server = InstanceType<typeof Server>;
+export default tls;