@types/node 14.18.6 → 15.0.0

node v14.18/crypto.d.ts → node/crypto.d.ts

@@ -1,14 +1,20 @@
+declare module 'node:crypto' {
+    export * from 'crypto';
+}
+
 declare module 'crypto' {
-    import * as stream from 'stream';
+    import * as stream from 'node:stream';
 
     interface Certificate {
         /**
+         * @deprecated
          * @param spkac
          * @returns The challenge component of the `spkac` data structure,
          * which includes a public key and a challenge.
          */
         exportChallenge(spkac: BinaryLike): Buffer;
         /**
+         * @deprecated
          * @param spkac
          * @param encoding The encoding of the spkac string.
          * @returns The public key component of the `spkac` data structure,
@@ -16,6 +22,7 @@ declare module 'crypto' {
          */
         exportPublicKey(spkac: BinaryLike, encoding?: string): Buffer;
         /**
+         * @deprecated
          * @param spkac
          * @returns `true` if the given `spkac` data structure is valid,
          * `false` otherwise.
@@ -24,9 +31,29 @@ declare module 'crypto' {
     }
     const Certificate: Certificate & {
         /** @deprecated since v14.9.0 - Use static methods of `crypto.Certificate` instead. */
-        new (): Certificate;
+        new(): Certificate;
         /** @deprecated since v14.9.0 - Use static methods of `crypto.Certificate` instead. */
         (): Certificate;
+
+        /**
+         * @param spkac
+         * @returns The challenge component of the `spkac` data structure,
+         * which includes a public key and a challenge.
+         */
+        exportChallenge(spkac: BinaryLike): Buffer;
+        /**
+         * @param spkac
+         * @param encoding The encoding of the spkac string.
+         * @returns The public key component of the `spkac` data structure,
+         * which includes a public key and a challenge.
+         */
+        exportPublicKey(spkac: BinaryLike, encoding?: string): Buffer;
+        /**
+         * @param spkac
+         * @returns `true` if the given `spkac` data structure is valid,
+         * `false` otherwise.
+         */
+        verifySpkac(spkac: NodeJS.ArrayBufferView): boolean;
     };
 
     namespace constants {
@@ -130,7 +157,7 @@ declare module 'crypto' {
          * For XOF hash functions such as `shake256`, the
          * outputLength option can be used to specify the desired output length in bytes.
          */
-        outputLength?: number | undefined;
+        outputLength?: number;
     }
 
     /** @deprecated since v10.0.0 */
@@ -140,7 +167,7 @@ declare module 'crypto' {
     function createHmac(algorithm: string, key: BinaryLike | KeyObject, options?: stream.TransformOptions): Hmac;
 
     // https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings
-    type BinaryToTextEncoding = 'base64' | 'base64url' | 'hex';
+    type BinaryToTextEncoding = 'base64' | 'hex';
     type CharacterEncoding = 'utf8' | 'utf-8' | 'utf16le' | 'latin1';
     type LegacyCharacterEncoding = 'ascii' | 'binary' | 'ucs2' | 'ucs-2';
 
@@ -169,21 +196,21 @@ declare module 'crypto' {
     interface KeyExportOptions<T extends KeyFormat> {
         type: 'pkcs1' | 'spki' | 'pkcs8' | 'sec1';
         format: T;
-        cipher?: string | undefined;
-        passphrase?: string | Buffer | undefined;
+        cipher?: string;
+        passphrase?: string | Buffer;
     }
 
     class KeyObject {
         private constructor();
-        asymmetricKeyType?: KeyType | undefined;
+        asymmetricKeyType?: KeyType;
         /**
          * For asymmetric keys, this property represents the size of the embedded key in
          * bytes. This property is `undefined` for symmetric keys.
          */
-        asymmetricKeySize?: number | undefined;
+        asymmetricKeySize?: number;
         export(options: KeyExportOptions<'pem'>): string | Buffer;
         export(options?: KeyExportOptions<'der'>): Buffer;
-        symmetricKeySize?: number | undefined;
+        symmetricKeySize?: number;
         type: KeyObjectType;
     }
 
@@ -198,7 +225,7 @@ declare module 'crypto' {
         authTagLength: number;
     }
     interface CipherGCMOptions extends stream.TransformOptions {
-        authTagLength?: number | undefined;
+        authTagLength?: number;
     }
     /** @deprecated since v10.0.0 use `createCipheriv()` */
     function createCipher(algorithm: CipherCCMTypes, password: BinaryLike, options: CipherCCMOptions): CipherCCM;
@@ -295,15 +322,15 @@ declare module 'crypto' {
 
     interface PrivateKeyInput {
         key: string | Buffer;
-        format?: KeyFormat | undefined;
-        type?: 'pkcs1' | 'pkcs8' | 'sec1' | undefined;
-        passphrase?: string | Buffer | undefined;
+        format?: KeyFormat;
+        type?: 'pkcs1' | 'pkcs8' | 'sec1';
+        passphrase?: string | Buffer;
     }
 
     interface PublicKeyInput {
         key: string | Buffer;
-        format?: KeyFormat | undefined;
-        type?: 'pkcs1' | 'spki' | undefined;
+        format?: KeyFormat;
+        type?: 'pkcs1' | 'spki';
     }
 
     function createPrivateKey(key: PrivateKeyInput | string | Buffer): KeyObject;
@@ -318,16 +345,16 @@ declare module 'crypto' {
         /**
          * @See crypto.constants.RSA_PKCS1_PADDING
          */
-        padding?: number | undefined;
-        saltLength?: number | undefined;
-        dsaEncoding?: DSAEncoding | undefined;
+        padding?: number;
+        saltLength?: number;
+        dsaEncoding?: DSAEncoding;
     }
 
-    interface SignPrivateKeyInput extends PrivateKeyInput, SigningOptions {}
+    interface SignPrivateKeyInput extends PrivateKeyInput, SigningOptions { }
     interface SignKeyObjectInput extends SigningOptions {
         key: KeyObject;
     }
-    interface VerifyPublicKeyInput extends PublicKeyInput, SigningOptions {}
+    interface VerifyPublicKeyInput extends PublicKeyInput, SigningOptions { }
     interface VerifyKeyObjectInput extends SigningOptions {
         key: KeyObject;
     }
@@ -448,28 +475,14 @@ declare module 'crypto' {
         callback: (err: Error | null, buf: T) => void,
     ): void;
 
-    interface RandomUUIDOptions {
-        /**
-         * By default, to improve performance,
-         * Node.js will pre-emptively generate and persistently cache enough
-         * random data to generate up to 128 random UUIDs. To generate a UUID
-         * without using the cache, set `disableEntropyCache` to `true`.
-         *
-         * @default `false`
-         */
-        disableEntropyCache?: boolean | undefined;
-    }
-
-    function randomUUID(options?: RandomUUIDOptions): string;
-
     interface ScryptOptions {
-        cost?: number | undefined;
-        blockSize?: number | undefined;
-        parallelization?: number | undefined;
-        N?: number | undefined;
-        r?: number | undefined;
-        p?: number | undefined;
-        maxmem?: number | undefined;
+        cost?: number;
+        blockSize?: number;
+        parallelization?: number;
+        N?: number;
+        r?: number;
+        p?: number;
+        maxmem?: number;
     }
     function scrypt(
         password: BinaryLike,
@@ -488,17 +501,17 @@ declare module 'crypto' {
 
     interface RsaPublicKey {
         key: KeyLike;
-        padding?: number | undefined;
+        padding?: number;
     }
     interface RsaPrivateKey {
         key: KeyLike;
-        passphrase?: string | undefined;
+        passphrase?: string;
         /**
          * @default 'sha1'
          */
-        oaepHash?: string | undefined;
-        oaepLabel?: NodeJS.TypedArray | undefined;
-        padding?: number | undefined;
+        oaepHash?: string;
+        oaepLabel?: NodeJS.TypedArray;
+        padding?: number;
     }
     function publicEncrypt(key: RsaPublicKey | RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
     function publicDecrypt(key: RsaPublicKey | RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
@@ -514,7 +527,7 @@ declare module 'crypto' {
             key: BinaryLike,
             curve: string,
             inputEncoding?: BinaryToTextEncoding,
-            outputEncoding?: 'latin1' | 'hex' | 'base64' | 'base64url',
+            outputEncoding?: 'latin1' | 'hex' | 'base64',
             format?: 'uncompressed' | 'compressed' | 'hybrid',
         ): Buffer | string;
         generateKeys(): Buffer;
@@ -544,8 +557,8 @@ declare module 'crypto' {
 
     interface BasePrivateKeyEncodingOptions<T extends KeyFormat> {
         format: T;
-        cipher?: string | undefined;
-        passphrase?: string | undefined;
+        cipher?: string;
+        passphrase?: string;
     }
 
     interface KeyPairKeyObjectResult {
@@ -593,7 +606,7 @@ declare module 'crypto' {
         /**
          * @default 0x10001
          */
-        publicExponent?: number | undefined;
+        publicExponent?: number;
     }
 
     interface DSAKeyPairKeyObjectOptions {
@@ -616,7 +629,7 @@ declare module 'crypto' {
         /**
          * @default 0x10001
          */
-        publicExponent?: number | undefined;
+        publicExponent?: number;
 
         publicKeyEncoding: {
             type: 'pkcs1' | 'spki';
@@ -1183,7 +1196,79 @@ declare module 'crypto' {
      * 'dh' (for Diffie-Hellman), 'ec' (for ECDH), 'x448', or 'x25519' (for ECDH-ES).
      */
     function diffieHellman(options: { privateKey: KeyObject; publicKey: KeyObject }): Buffer;
-}
-declare module 'node:crypto' {
-    export * from 'crypto';
+
+    type CipherMode = 'cbc' | 'ccm' | 'cfb' | 'ctr' | 'ecb' | 'gcm' | 'ocb' | 'ofb' | 'stream' | 'wrap' | 'xts';
+
+    interface CipherInfoOptions {
+        /**
+         * A test key length.
+         */
+        keyLength?: number;
+        /**
+         * A test IV length.
+         */
+        ivLength?: number;
+    }
+
+    interface CipherInfo {
+        /**
+         * The name of the cipher.
+         */
+        name: string;
+        /**
+         * The nid of the cipher.
+         */
+        nid: number;
+        /**
+         * The block size of the cipher in bytes.
+         * This property is omitted when mode is 'stream'.
+         */
+        blockSize?: number;
+        /**
+         * The expected or default initialization vector length in bytes.
+         * This property is omitted if the cipher does not use an initialization vector.
+         */
+        ivLength?: number;
+        /**
+         * The expected or default key length in bytes.
+         */
+        keyLength: number;
+        /**
+         * The cipher mode.
+         */
+        mode: CipherMode;
+    }
+
+    /**
+     * Returns information about a given cipher.
+     *
+     * Some ciphers accept variable length keys and initialization vectors.
+     * By default, the `crypto.getCipherInfo()` method will return the default
+     * values for these ciphers. To test if a given key length or iv length
+     * is acceptable for given cipher, use the `keyLenth` and `ivLenth` options.
+     * If the given values are unacceptable, `undefined` will be returned.
+     * @param nameOrNid The name or nid of the cipher to query.
+     */
+    function getCipherInfo(nameOrNid: string | number, options?: CipherInfoOptions): CipherInfo | undefined;
+
+    /**
+     * HKDF is a simple key derivation function defined in RFC 5869.
+     * The given `key`, `salt` and `info` are used with the `digest` to derive a key of `keylen` bytes.
+     *
+     * The supplied `callback` function is called with two arguments: `err` and `derivedKey`.
+     * If an errors occurs while deriving the key, `err` will be set; otherwise `err` will be `null`.
+     * The successfully generated `derivedKey` will be passed to the callback as an [`ArrayBuffer`][].
+     * An error will be thrown if any of the input aguments specify invalid values or types.
+     */
+    function hkdf(digest: string, key: BinaryLike | KeyObject, salt: BinaryLike, info: BinaryLike, keylen: number, callback: (err: Error | null, derivedKey: ArrayBuffer) => any): void;
+
+    /**
+     * Provides a synchronous HKDF key derivation function as defined in RFC 5869.
+     * The given `key`, `salt` and `info` are used with the `digest` to derive a key of `keylen` bytes.
+     *
+     * The successfully generated `derivedKey` will be returned as an [`ArrayBuffer`][].
+     * An error will be thrown if any of the input aguments specify invalid values or types,
+     * or if the derived key cannot be generated.
+     */
+    function hkdfSync(digest: string, key: BinaryLike | KeyObject, salt: BinaryLike, info: BinaryLike, keylen: number): ArrayBuffer;
 }

node v14.18/dgram.d.ts → node/dgram.d.ts

@@ -1,7 +1,11 @@
+declare module 'node:dgram' {
+    export * from 'dgram';
+}
+
 declare module 'dgram' {
-    import { AddressInfo } from 'net';
-    import * as dns from 'dns';
-    import EventEmitter = require('events');
+    import { AddressInfo } from 'node:net';
+    import * as dns from 'node:dns';
+    import EventEmitter = require('node:events');
 
     interface RemoteInfo {
         address: string;
@@ -11,24 +15,24 @@ declare module 'dgram' {
     }
 
     interface BindOptions {
-        port?: number | undefined;
-        address?: string | undefined;
-        exclusive?: boolean | undefined;
-        fd?: number | undefined;
+        port?: number;
+        address?: string;
+        exclusive?: boolean;
+        fd?: number;
     }
 
     type SocketType = "udp4" | "udp6";
 
     interface SocketOptions {
         type: SocketType;
-        reuseAddr?: boolean | undefined;
+        reuseAddr?: boolean;
         /**
          * @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;
+        ipv6Only?: boolean;
+        recvBufferSize?: number;
+        sendBufferSize?: number;
+        lookup?: (hostname: string, options: dns.LookupOneOptions, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void) => void;
     }
 
     function createSocket(type: SocketType, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
@@ -37,11 +41,11 @@ declare module 'dgram' {
     class Socket extends EventEmitter {
         addMembership(multicastAddress: string, multicastInterface?: string): void;
         address(): AddressInfo;
-        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(callback?: () => void): this;
+        bind(port?: number, address?: string, callback?: () => void): void;
+        bind(port?: number, callback?: () => void): void;
+        bind(callback?: () => void): void;
+        bind(options: BindOptions, callback?: () => void): void;
+        close(callback?: () => void): void;
         connect(port: number, address?: string, callback?: () => void): void;
         connect(port: number, callback: () => void): void;
         disconnect(): void;
@@ -58,11 +62,11 @@ declare module 'dgram' {
         send(msg: string | Uint8Array, offset: number, length: number, callback?: (error: Error | null, bytes: number) => void): void;
         setBroadcast(flag: boolean): void;
         setMulticastInterface(multicastInterface: string): void;
-        setMulticastLoopback(flag: boolean): boolean;
-        setMulticastTTL(ttl: number): number;
+        setMulticastLoopback(flag: boolean): void;
+        setMulticastTTL(ttl: number): void;
         setRecvBufferSize(size: number): void;
         setSendBufferSize(size: number): void;
-        setTTL(ttl: number): number;
+        setTTL(ttl: number): void;
         unref(): this;
         /**
          * Tells the kernel to join a source-specific multicast channel at the given
@@ -139,6 +143,3 @@ declare module 'dgram' {
         prependOnceListener(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
     }
 }
-declare module 'node:dgram' {
-    export * from 'dgram';
-}

node/dns/promises.d.ts

@@ -0,0 +1,101 @@
+declare module "node:dns/promises" {
+    export * from "dns/promises";
+}
+
+declare module "dns/promises" {
+    import {
+        LookupAddress,
+        LookupOneOptions,
+        LookupAllOptions,
+        LookupOptions,
+        AnyRecord,
+        CaaRecord,
+        MxRecord,
+        NaptrRecord,
+        SoaRecord,
+        SrvRecord,
+        ResolveWithTtlOptions,
+        RecordWithTtl,
+        ResolveOptions,
+        ResolverOptions,
+    } from "node:dns";
+
+    function getServers(): string[];
+
+    function lookup(hostname: string, family: number): Promise<LookupAddress>;
+    function lookup(hostname: string, options: LookupOneOptions): Promise<LookupAddress>;
+    function lookup(hostname: string, options: LookupAllOptions): Promise<LookupAddress[]>;
+    function lookup(hostname: string, options: LookupOptions): Promise<LookupAddress | LookupAddress[]>;
+    function lookup(hostname: string): Promise<LookupAddress>;
+
+    function lookupService(address: string, port: number): Promise<{ hostname: string, service: string }>;
+
+    function resolve(hostname: string): Promise<string[]>;
+    function resolve(hostname: string, rrtype: "A"): Promise<string[]>;
+    function resolve(hostname: string, rrtype: "AAAA"): Promise<string[]>;
+    function resolve(hostname: string, rrtype: "ANY"): Promise<AnyRecord[]>;
+    function resolve(hostname: string, rrtype: "CAA"): Promise<CaaRecord[]>;
+    function resolve(hostname: string, rrtype: "CNAME"): Promise<string[]>;
+    function resolve(hostname: string, rrtype: "MX"): Promise<MxRecord[]>;
+    function resolve(hostname: string, rrtype: "NAPTR"): Promise<NaptrRecord[]>;
+    function resolve(hostname: string, rrtype: "NS"): Promise<string[]>;
+    function resolve(hostname: string, rrtype: "PTR"): Promise<string[]>;
+    function resolve(hostname: string, rrtype: "SOA"): Promise<SoaRecord>;
+    function resolve(hostname: string, rrtype: "SRV"): Promise<SrvRecord[]>;
+    function resolve(hostname: string, rrtype: "TXT"): Promise<string[][]>;
+    function resolve(hostname: string, rrtype: string): Promise<string[] | MxRecord[] | NaptrRecord[] | SoaRecord | SrvRecord[] | string[][] | AnyRecord[]>;
+
+    function resolve4(hostname: string): Promise<string[]>;
+    function resolve4(hostname: string, options: ResolveWithTtlOptions): Promise<RecordWithTtl[]>;
+    function resolve4(hostname: string, options: ResolveOptions): Promise<string[] | RecordWithTtl[]>;
+
+    function resolve6(hostname: string): Promise<string[]>;
+    function resolve6(hostname: string, options: ResolveWithTtlOptions): Promise<RecordWithTtl[]>;
+    function resolve6(hostname: string, options: ResolveOptions): Promise<string[] | RecordWithTtl[]>;
+
+    function resolveAny(hostname: string): Promise<AnyRecord[]>;
+
+    function resolveCaa(hostname: string): Promise<CaaRecord[]>;
+
+    function resolveCname(hostname: string): Promise<string[]>;
+
+    function resolveMx(hostname: string): Promise<MxRecord[]>;
+
+    function resolveNaptr(hostname: string): Promise<NaptrRecord[]>;
+
+    function resolveNs(hostname: string): Promise<string[]>;
+
+    function resolvePtr(hostname: string): Promise<string[]>;
+
+    function resolveSoa(hostname: string): Promise<SoaRecord>;
+
+    function resolveSrv(hostname: string): Promise<SrvRecord[]>;
+
+    function resolveTxt(hostname: string): Promise<string[][]>;
+
+    function reverse(ip: string): Promise<string[]>;
+
+    function setServers(servers: ReadonlyArray<string>): void;
+
+    class Resolver {
+        constructor(options?: ResolverOptions);
+
+        cancel(): void;
+        getServers: typeof getServers;
+        resolve: typeof resolve;
+        resolve4: typeof resolve4;
+        resolve6: typeof resolve6;
+        resolveAny: typeof resolveAny;
+        resolveCname: typeof resolveCname;
+        resolveMx: typeof resolveMx;
+        resolveNaptr: typeof resolveNaptr;
+        resolveNs: typeof resolveNs;
+        resolvePtr: typeof resolvePtr;
+        resolveSoa: typeof resolveSoa;
+        resolveSrv: typeof resolveSrv;
+        resolveTxt: typeof resolveTxt;
+        reverse: typeof reverse;
+        setLocalAddress(ipv4?: string, ipv6?: string): void;
+        setServers: typeof setServers;
+    }
+}