An alias of ok.

Indicates the failure of an assertion. All errors thrown by the node:assert module will be instances of the AssertionError class.

Strict assertion mode

Tests for deep equality between the actual and expected parameters."Deep" equality means that the enumerable "own" properties of child objectsare recursively evaluated also by the following rules.

Expects the string input not to match the regular expression.

Awaits the asyncFn promise or, if asyncFn is a function, immediatelycalls the function and awaits the returned promise to complete. It will thencheck that the promise is not rejected.

Asserts that the function fn does not throw an error.

Strict assertion mode

Throws an AssertionError with the provided error message or a defaulterror message. If the message parameter is an instance of an Error thenit will be thrown instead of the AssertionError.

Throws value if value is not undefined or null. This is useful whentesting the error argument in callbacks. The stack trace contains all framesfrom the error passed to ifError() including the potential new frames for ifError() itself.

Expects the string input to match the regular expression.

Strict assertion mode

Tests for deep strict inequality. Opposite of deepStrictEqual.

Strict assertion mode

Tests strict inequality between the actual and expected parameters asdetermined by Object.is().

Tests if value is truthy. It is equivalent to assert.equal(!!value, true, message).

Awaits the asyncFn promise or, if asyncFn is a function, immediatelycalls the function and awaits the returned promise to complete. It will thencheck that the promise is rejected.

In strict assertion mode, non-strict methods behave like their corresponding strict methods. For example,deepEqual will behave like deepStrictEqual.

Tests strict equality between the actual and expected parameters asdetermined by Object.is().

Expects the function fn to throw an error.

This feature is deprecated and will be removed in a future version.Please consider using alternatives such as the mock helper function.

This class creates stores that stay coherent through asynchronous operations.

The class AsyncResource is designed to be extended by the embedder's asyncresources. Using this, users can easily trigger the lifetime events of theirown resources.

Registers functions to be called for different lifetime events of each asyncoperation.

The ID returned from executionAsyncId() is related to execution timing, notcausality (which is covered by triggerAsyncId()):

Resource objects returned by executionAsyncResource() are most often internalNode.js handle objects with undocumented APIs. Using any functions or propertieson the object is likely to crash your application and should be avoided.

Promise contexts may not get valid triggerAsyncIds by default. Seethe section on promise execution tracking.

Decodes a string of Base64-encoded data into bytes, and encodes those bytesinto a string using Latin-1 (ISO-8859-1).

A Blob encapsulates immutable, raw data that can be safely shared acrossmultiple worker threads.

Decodes a string into bytes using Latin-1 (ISO-8859), and encodes those bytesinto a string using Base64.

Raw data is stored in instances of the Buffer class.A Buffer is similar to an array of integers but corresponds to a raw memory allocation outside the V8 heap. A Buffer cannot be resized.Valid string encodings: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'base64url'|'binary'(deprecated)|'hex'

A File provides information about files.

This function returns true if input contains only valid ASCII-encoded data,including the case in which input is empty.

This function returns true if input contains only valid UTF-8-encoded data,including the case in which input is empty.

Resolves a 'blob:nodedata:...' an associated Blob object registered usinga prior call to URL.createObjectURL().

Re-encodes the given Buffer or Uint8Array instance from one characterencoding to another. Returns a new Buffer instance.

Instances of the ChildProcess represent spawned child processes.

Spawns a shell then executes the command within that shell, buffering anygenerated output. The command string passed to the exec function is processeddirectly by the shell and special characters (vary based on shell)need to be dealt with accordingly:

The child_process.execFile() function is similar to exec except that it does not spawn a shell by default. Rather, the specifiedexecutable file is spawned directly as a new process making it slightly moreefficient than exec.

The child_process.execFileSync() method is generally identical to execFile with the exception that the method will notreturn until the child process has fully closed. When a timeout has beenencountered and killSignal is sent, the method won't return until the processhas completely exited.

The child_process.execSync() method is generally identical to exec with the exception that the method will not returnuntil the child process has fully closed. When a timeout has been encounteredand killSignal is sent, the method won't return until the process hascompletely exited. If the child process intercepts and handles the SIGTERM signal and doesn't exit, the parent process will wait until the child processhas exited.

The child_process.fork() method is a special case of spawn used specifically to spawn new Node.js processes.Like spawn, a ChildProcess object is returned. Thereturned ChildProcess will have an additional communication channelbuilt-in that allows messages to be passed back and forth between the parent andchild. See subprocess.send() for details.

The child_process.spawn() method spawns a new process using the given command, with command-line arguments in args. If omitted, args defaultsto an empty array.

The child_process.spawnSync() method is generally identical to spawn with the exception that the function will not returnuntil the child process has fully closed. When a timeout has been encounteredand killSignal is sent, the method won't return until the process hascompletely exited. If the process intercepts and handles the SIGTERM signaland doesn't exit, the parent process will wait until the child process hasexited.

A Worker object contains all public information and method about a worker.In the primary it can be obtained using cluster.workers. In a workerit can be obtained using cluster.worker.

The console module provides a simple debugging console that is similar to theJavaScript console mechanism provided by web browsers.

SPKAC is a Certificate Signing Request mechanism originally implemented byNetscape and was specified formally as part of HTML5's keygen element.

Checks the primality of the candidate.

Checks the primality of the candidate.

Instances of the Cipher class are used to encrypt data. The class can beused in one of two ways:

Specifies the active default cipher list used by the current Node.js process (colon-separated values).

Specifies the built-in default cipher list used by Node.js (colon-separated values).

Causes the salt length for RSA_PKCS1_PSS_PADDING to be determined automatically when verifying a signature.

Sets the salt length for RSA_PKCS1_PSS_PADDING to the digest size when signing or verifying.

Sets the salt length for RSA_PKCS1_PSS_PADDING to the maximum permissible value when signing data.

Applies multiple bug workarounds within OpenSSL. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html for detail.

Instructs OpenSSL to allow a non-[EC]DHE-based key exchange mode for TLS v1.3

Allows legacy insecure renegotiation between OpenSSL and unpatched clients or servers. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html.

Attempts to use the server's preferences instead of the client's when selecting a cipher. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html.

Instructs OpenSSL to use Cisco's version identifier of DTLS_BAD_VER.

Instructs OpenSSL to turn on cookie exchange.

Instructs OpenSSL to add server-hello extension from an early version of the cryptopro draft.

Instructs OpenSSL to disable a SSL 3.0/TLS 1.0 vulnerability workaround added in OpenSSL 0.9.6d.

Allows initial connection to servers that do not support RI.

Instructs OpenSSL to disable support for SSL/TLS compression.

Instructs OpenSSL to disable encrypt-then-MAC.

Instructs OpenSSL to disable renegotiation.

Instructs OpenSSL to always start a new session when performing renegotiation.

Instructs OpenSSL to turn off SSL v2

Instructs OpenSSL to turn off SSL v3

Instructs OpenSSL to disable use of RFC4507bis tickets.

Instructs OpenSSL to turn off TLS v1

Instructs OpenSSL to turn off TLS v1.1

Instructs OpenSSL to turn off TLS v1.2

Instructs OpenSSL to turn off TLS v1.3

Instructs OpenSSL server to prioritize ChaCha20-Poly1305 when the client does. This option has no effect if SSL_OP_CIPHER_SERVER_PREFERENCE is not enabled.

Instructs OpenSSL to disable version rollback attack detection.

Creates and returns a Cipher object, with the given algorithm, key andinitialization vector (iv).

Creates and returns a Decipher object that uses the given algorithm, key and initialization vector (iv).

Creates a DiffieHellman key exchange object using the supplied prime and anoptional specific generator.

An alias for getDiffieHellman

Creates an Elliptic Curve Diffie-Hellman (ECDH) key exchange object using apredefined curve specified by the curveName string. Use getCurves to obtain a list of available curve names. On recentOpenSSL releases, openssl ecparam -list_curves will also display the nameand description of each available elliptic curve.

Creates and returns a Hash object that can be used to generate hash digestsusing the given algorithm. Optional options argument controls streambehavior. For XOF hash functions such as 'shake256', the outputLength optioncan be used to specify the desired output length in bytes.

Creates and returns an Hmac object that uses the given algorithm and key.Optional options argument controls stream behavior.

Creates and returns a new key object containing a private key. If key is astring or Buffer, format is assumed to be 'pem'; otherwise, key must be an object with the properties described above.

Creates and returns a new key object containing a public key. If key is astring or Buffer, format is assumed to be 'pem'; if key is a KeyObject with type 'private', the public key is derived from the given private key;otherwise, key must be an object with the properties described above.

Creates and returns a new key object containing a secret key for symmetricencryption or Hmac.

Creates and returns a Sign object that uses the given algorithm. Use getHashes to obtain the names of the available digest algorithms.Optional options argument controls the stream.Writable behavior.

Creates and returns a Verify object that uses the given algorithm.Use getHashes to obtain an array of names of the availablesigning algorithms. Optional options argument controls the stream.Writable behavior.

Instances of the Decipher class are used to decrypt data. The class can beused in one of two ways:

The DiffieHellman class is a utility for creating Diffie-Hellman keyexchanges.

Computes the Diffie-Hellman secret based on a privateKey and a publicKey.Both keys must have the same asymmetricKeyType, which must be one of 'dh' (for Diffie-Hellman), 'ec' (for ECDH), 'x448', or 'x25519' (for ECDH-ES).

The ECDH class is a utility for creating Elliptic Curve Diffie-Hellman (ECDH)key exchanges.

Asynchronously generates a new random secret key of the given length. The type will determine which validations will be performed on the length.

Generates a new asymmetric key pair of the given type. RSA, RSA-PSS, DSA, EC,Ed25519, Ed448, X25519, X448, and DH are currently supported.

Generates a new asymmetric key pair of the given type. RSA, RSA-PSS, DSA, EC,Ed25519, Ed448, X25519, X448, and DH are currently supported.

Synchronously generates a new random secret key of the given length. The type will determine which validations will be performed on the length.

Generates a pseudorandom prime of size bits.

Generates a pseudorandom prime of size bits.

Returns information about a given cipher.

Creates a predefined DiffieHellmanGroup key exchange object. Thesupported groups are listed in the documentation for DiffieHellmanGroup.

A convenient alias for webcrypto.getRandomValues. Thisimplementation is not compliant with the Web Crypto spec, to writeweb-compatible code use webcrypto.getRandomValues instead.

The Hash class is a utility for creating hash digests of data. It can beused in one of two ways:

A utility for creating one-shot hash digests of data. It can be faster than the object-based crypto.createHash() when hashing a smaller amount of data(<= 5MB) that's readily available. If the data can be big or if it is streamed, it's still recommended to use crypto.createHash() instead. The algorithmis dependent on the available algorithms supported by the version of OpenSSL on the platform. Examples are 'sha256', 'sha512', etc. On recent releasesof OpenSSL, openssl list -digest-algorithms will display the available digest algorithms.

HKDF is a simple key derivation function defined in RFC 5869. The given ikm, salt and info are used with the digest to derive a key of keylen bytes.

Provides a synchronous HKDF key derivation function as defined in RFC 5869. Thegiven ikm, salt and info are used with the digest to derive a key of keylen bytes.

Node.js uses a KeyObject class to represent a symmetric or asymmetric key,and each kind of key exposes different functions. The createSecretKey, createPublicKey and createPrivateKey methods are used to create KeyObjectinstances. KeyObjectobjects are not to be created directly using the newkeyword.

Provides an asynchronous Password-Based Key Derivation Function 2 (PBKDF2)implementation. A selected HMAC digest algorithm specified by digest isapplied to derive a key of the requested byte length (keylen) from the password, salt and iterations.

Provides a synchronous Password-Based Key Derivation Function 2 (PBKDF2)implementation. A selected HMAC digest algorithm specified by digest isapplied to derive a key of the requested byte length (keylen) from the password, salt and iterations.

Decrypts buffer with privateKey. buffer was previously encrypted usingthe corresponding public key, for example using publicEncrypt.

Encrypts buffer with privateKey. The returned data can be decrypted usingthe corresponding public key, for example using publicDecrypt.

Decrypts buffer with key.buffer was previously encrypted usingthe corresponding private key, for example using privateEncrypt.

Encrypts the content of buffer with key and returns a new Buffer with encrypted content. The returned data can be decrypted usingthe corresponding private key, for example using privateDecrypt.

Generates cryptographically strong pseudorandom data. The size argumentis a number indicating the number of bytes to generate.

This function is similar to randomBytes but requires the firstargument to be a Buffer that will be filled. It alsorequires that a callback is passed in.

Synchronous version of randomFill.

Return a random integer n such that min <= n < max. Thisimplementation avoids modulo bias.

Generates a random RFC 4122 version 4 UUID. The UUID is generated using acryptographic pseudorandom number generator.

Provides an asynchronous scrypt implementation. Scrypt is a password-basedkey derivation function that is designed to be expensive computationally andmemory-wise in order to make brute-force attacks unrewarding.

Provides a synchronous scrypt implementation. Scrypt is a password-basedkey derivation function that is designed to be expensive computationally andmemory-wise in order to make brute-force attacks unrewarding.

Load and set the engine for some or all OpenSSL functions (selected by flags).

Enables the FIPS compliant crypto provider in a FIPS-enabled Node.js build.Throws an error if FIPS mode is not available.

The Sign class is a utility for generating signatures. It can be used in oneof two ways:

Calculates and returns the signature for data using the given private key andalgorithm. If algorithm is null or undefined, then the algorithm isdependent upon the key type (especially Ed25519 and Ed448).

A convenient alias for crypto.webcrypto.subtle.

This function compares the underlying bytes that represent the given ArrayBuffer, TypedArray, or DataView instances using a constant-timealgorithm.

The Verify class is a utility for verifying signatures. It can be used in oneof two ways:

Verifies the given signature for data using the given key and algorithm. If algorithm is null or undefined, then the algorithm is dependent upon thekey type (especially Ed25519 and Ed448).

Importing the webcrypto object (import { webcrypto } from 'node:crypto') gives an instance of the Crypto class.Crypto is a singleton that provides access to the remainder of the crypto API.

The CryptoKeyPair is a simple dictionary object with publicKey and privateKey properties, representing an asymmetric key pair.

Encapsulates an X509 certificate and provides read-only access toits information.

The Hmac class is a utility for creating cryptographic HMAC digests. It canbe used in one of two ways:

Creates a dgram.Socket object. Once the socket is created, calling socket.bind() will instruct the socket to begin listening for datagrammessages. When address and port are not passed to socket.bind() themethod 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 addressand port can be retrieved using socket.address().address and socket.address().port.

Encapsulates the datagram functionality.

The class Channel represents an individual named channel within the datapipeline. It is used to track subscribers and to publish messages when thereare subscribers present. It exists as a separate object to avoid channellookups at publish time, enabling very fast publish speeds and allowingfor heavy use while incurring very minimal cost. Channels are created with channel, constructing a channel directlywith new Channel(name) is not supported.

This is the primary entry-point for anyone wanting to publish to a namedchannel. It produces a channel object which is optimized to reduce overhead atpublish time as much as possible.

Check if there are active subscribers to the named channel. This is helpful ifthe message you want to send might be expensive to prepare.

Register a message handler to subscribe to this channel. This message handlerwill be run synchronously whenever a message is published to the channel. Anyerrors thrown in the message handler will trigger an 'uncaughtException'.

The class TracingChannel is a collection of TracingChannel Channels whichtogether express a single traceable action. It is used to formalize andsimplify the process of producing events for tracing application flow. tracingChannel is used to construct a TracingChannel. As with Channel it is recommended to create and reuse asingle TracingChannel at the top-level of the file rather than creating themdynamically.

Creates a TracingChannel wrapper for the given TracingChannel Channels. If a name is given, the corresponding tracingchannels will be created in the form of tracing:${name}:${eventType} where eventType corresponds to the types of TracingChannel Channels.

Remove a message handler previously registered to this channel with subscribe.

Limits returned address types to the types of non-loopback addresses configured on the system. For example, IPv4 addresses areonly returned if the current system has at least one IPv4 address configured.

If dns.V4MAPPED is specified, return resolved IPv6 addresses aswell as IPv4 mapped IPv6 addresses.

Get the default value for order in lookup and dnsPromises.lookup().The value could be:

Returns an array of IP address strings, formatted according to RFC 5952,that are currently configured for DNS resolution. A string will include a portsection if a custom port is used.

Resolves a host name (e.g. 'nodejs.org') into the first found A (IPv4) orAAAA (IPv6) record. All option properties are optional. If options is aninteger, then it must be 4 or 6 – if options is 0 or not provided, thenIPv4 and IPv6 addresses are both returned if found.

Resolves the given address and port into a host name and service usingthe operating system's underlying getnameinfo implementation.

The dns.promises API provides an alternative set of asynchronous DNS methodsthat return Promise objects rather than using callbacks. The API is accessiblevia import { promises as dnsPromises } from 'node:dns' or import dnsPromises from 'node:dns/promises'.

Get the default value for verbatim in lookup and dnsPromises.lookup().The value could be:

Returns an array of IP address strings, formatted according to RFC 5952,that are currently configured for DNS resolution. A string will include a portsection if a custom port is used.

Resolves a host name (e.g. 'nodejs.org') into the first found A (IPv4) orAAAA (IPv6) record. All option properties are optional. If options is aninteger, then it must be 4 or 6 – if options is not provided, then IPv4and IPv6 addresses are both returned if found.

Resolves the given address and port into a host name and service usingthe operating system's underlying getnameinfo implementation.

Uses the DNS protocol to resolve a host name (e.g. 'nodejs.org') into an arrayof the resource records. When successful, the Promise is resolved with anarray of resource records. The type and structure of individual results varybased on rrtype:

Uses the DNS protocol to resolve IPv4 addresses (A records) for the hostname. On success, the Promise is resolved with an array of IPv4addresses (e.g. ['74.125.79.104', '74.125.79.105', '74.125.79.106']).

Uses the DNS protocol to resolve IPv6 addresses (AAAA records) for the hostname. On success, the Promise is resolved with an array of IPv6addresses.

Uses the DNS protocol to resolve all records (also known as ANY or * query).On success, the Promise is resolved with an array containing various types ofrecords. Each object has a property type that indicates the type of thecurrent record. And depending on the type, additional properties will bepresent on the object:

Uses the DNS protocol to resolve CAA records for the hostname. On success,the Promise is resolved with an array of objects containing availablecertification authority authorization records available for the hostname (e.g. [{critical: 0, iodef: 'mailto:pki@example.com'},{critical: 128, issue: 'pki.example.com'}]).

Uses the DNS protocol to resolve CNAME records for the hostname. On success,the Promise is resolved with an array of canonical name records available forthe hostname (e.g. ['bar.example.com']).

Uses the DNS protocol to resolve mail exchange records (MX records) for the hostname. On success, the Promise is resolved with an array of objectscontaining both a priority and exchange property (e.g.[{priority: 10, exchange: 'mx.example.com'}, ...]).

Uses the DNS protocol to resolve regular expression-based records (NAPTR records) for the hostname. On success, the Promise is resolved with an arrayof objects with the following properties:

Uses the DNS protocol to resolve name server records (NS records) for the hostname. On success, the Promise is resolved with an array of name serverrecords available for hostname (e.g.['ns1.example.com', 'ns2.example.com']).

Uses the DNS protocol to resolve pointer records (PTR records) for the hostname. On success, the Promise is resolved with an array of stringscontaining the reply records.

An independent resolver for DNS requests.

Uses the DNS protocol to resolve a start of authority record (SOA record) forthe hostname. On success, the Promise is resolved with an object with thefollowing properties:

Uses the DNS protocol to resolve service records (SRV records) for the hostname. On success, the Promise is resolved with an array of objects withthe following properties:

Uses the DNS protocol to resolve text queries (TXT records) for the hostname. On success, the Promise is resolved with a two-dimensional arrayof the text records available for hostname (e.g.[ ['v=spf1 ip4:0.0.0.0 ', '~all' ] ]). Each sub-array contains TXT chunks ofone record. Depending on the use case, these could be either joined together ortreated separately.

Performs a reverse DNS query that resolves an IPv4 or IPv6 address to anarray of host names.

Set the default value of order in dns.lookup() and [lookup](././dns/~/lookup). The value could be:

Sets the IP address and port of servers to be used when performing DNSresolution. The servers argument is an array of RFC 5952 formattedaddresses. If the port is the IANA default DNS port (53) it can be omitted.

Uses the DNS protocol to resolve a host name (e.g. 'nodejs.org') into an arrayof the resource records. The callback function has arguments (err, records). When successful, records will be an array of resourcerecords. The type and structure of individual results varies based on rrtype:

Uses the DNS protocol to resolve a IPv4 addresses (A records) for the hostname. The addresses argument passed to the callback functionwill contain an array of IPv4 addresses (e.g.['74.125.79.104', '74.125.79.105', '74.125.79.106']).

Uses the DNS protocol to resolve IPv6 addresses (AAAA records) for the hostname. The addresses argument passed to the callback functionwill contain an array of IPv6 addresses.

Uses the DNS protocol to resolve all records (also known as ANY or * query).The ret argument passed to the callback function will be an array containingvarious types of records. Each object has a property type that indicates thetype of the current record. And depending on the type, additional propertieswill be present on the object:

Uses the DNS protocol to resolve CAA records for the hostname. The addresses argument passed to the callback functionwill contain an array of certification authority authorization recordsavailable for the hostname (e.g. [{critical: 0, iodef: 'mailto:pki@example.com'}, {critical: 128, issue: 'pki.example.com'}]).

Uses the DNS protocol to resolve CNAME records for the hostname. The addresses argument passed to the callback functionwill contain an array of canonical name records available for the hostname (e.g. ['bar.example.com']).

Uses the DNS protocol to resolve mail exchange records (MX records) for the hostname. The addresses argument passed to the callback function willcontain an array of objects containing both a priority and exchange property (e.g. [{priority: 10, exchange: 'mx.example.com'}, ...]).

Uses the DNS protocol to resolve regular expression-based records (NAPTR records) for the hostname. The addresses argument passed to the callback function will contain an array ofobjects with the following properties:

Uses the DNS protocol to resolve name server records (NS records) for the hostname. The addresses argument passed to the callback function willcontain an array of name server records available for hostname (e.g. ['ns1.example.com', 'ns2.example.com']).

Uses the DNS protocol to resolve pointer records (PTR records) for the hostname. The addresses argument passed to the callback function willbe an array of strings containing the reply records.

An independent resolver for DNS requests.

Uses the DNS protocol to resolve a start of authority record (SOA record) forthe hostname. The address argument passed to the callback function willbe an object with the following properties:

Uses the DNS protocol to resolve service records (SRV records) for the hostname. The addresses argument passed to the callback function willbe an array of objects with the following properties:

Uses the DNS protocol to resolve text queries (TXT records) for the hostname. The records argument passed to the callback function is atwo-dimensional array of the text records available for hostname (e.g.[ ['v=spf1 ip4:0.0.0.0 ', '~all' ] ]). Each sub-array contains TXT chunks ofone record. Depending on the use case, these could be either joined together ortreated separately.

Performs a reverse DNS query that resolves an IPv4 or IPv6 address to anarray of host names.

Set the default value of order in lookup and dnsPromises.lookup().The value could be:

Sets the IP address and port of servers to be used when performing DNSresolution. The servers argument is an array of RFC 5952 formattedaddresses. If the port is the IANA default DNS port (53) it can be omitted.

If the IPv6 family was specified, but no IPv6 addresses were found, then return IPv4 mapped IPv6 addresses. It is not supportedon some operating systems (e.g. FreeBSD 10.1).

Get the default value for verbatim in lookup and dnsPromises.lookup().The value could be:

Returns an array of IP address strings, formatted according to RFC 5952,that are currently configured for DNS resolution. A string will include a portsection if a custom port is used.

Resolves a host name (e.g. 'nodejs.org') into the first found A (IPv4) orAAAA (IPv6) record. All option properties are optional. If options is aninteger, then it must be 4 or 6 – if options is not provided, then IPv4and IPv6 addresses are both returned if found.

Resolves the given address and port into a host name and service usingthe operating system's underlying getnameinfo implementation.

Uses the DNS protocol to resolve a host name (e.g. 'nodejs.org') into an arrayof the resource records. When successful, the Promise is resolved with anarray of resource records. The type and structure of individual results varybased on rrtype:

Uses the DNS protocol to resolve IPv4 addresses (A records) for the hostname. On success, the Promise is resolved with an array of IPv4addresses (e.g. ['74.125.79.104', '74.125.79.105', '74.125.79.106']).

Uses the DNS protocol to resolve IPv6 addresses (AAAA records) for the hostname. On success, the Promise is resolved with an array of IPv6addresses.

Uses the DNS protocol to resolve all records (also known as ANY or * query).On success, the Promise is resolved with an array containing various types ofrecords. Each object has a property type that indicates the type of thecurrent record. And depending on the type, additional properties will bepresent on the object:

Uses the DNS protocol to resolve CAA records for the hostname. On success,the Promise is resolved with an array of objects containing availablecertification authority authorization records available for the hostname (e.g. [{critical: 0, iodef: 'mailto:pki@example.com'},{critical: 128, issue: 'pki.example.com'}]).

Uses the DNS protocol to resolve CNAME records for the hostname. On success,the Promise is resolved with an array of canonical name records available forthe hostname (e.g. ['bar.example.com']).

Uses the DNS protocol to resolve mail exchange records (MX records) for the hostname. On success, the Promise is resolved with an array of objectscontaining both a priority and exchange property (e.g.[{priority: 10, exchange: 'mx.example.com'}, ...]).

Uses the DNS protocol to resolve regular expression-based records (NAPTR records) for the hostname. On success, the Promise is resolved with an arrayof objects with the following properties:

Uses the DNS protocol to resolve name server records (NS records) for the hostname. On success, the Promise is resolved with an array of name serverrecords available for hostname (e.g.['ns1.example.com', 'ns2.example.com']).

Uses the DNS protocol to resolve pointer records (PTR records) for the hostname. On success, the Promise is resolved with an array of stringscontaining the reply records.

An independent resolver for DNS requests.

Uses the DNS protocol to resolve a start of authority record (SOA record) forthe hostname. On success, the Promise is resolved with an object with thefollowing properties:

Uses the DNS protocol to resolve service records (SRV records) for the hostname. On success, the Promise is resolved with an array of objects withthe following properties:

Uses the DNS protocol to resolve text queries (TXT records) for the hostname. On success, the Promise is resolved with a two-dimensional arrayof the text records available for hostname (e.g.[ ['v=spf1 ip4:0.0.0.0 ', '~all' ] ]). Each sub-array contains TXT chunks ofone record. Depending on the use case, these could be either joined together ortreated separately.

Performs a reverse DNS query that resolves an IPv4 or IPv6 address to anarray of host names.

Set the default value of order in dns.lookup() and [lookup](././dns/promises/~/lookup). The value could be:

Sets the IP address and port of servers to be used when performing DNSresolution. The servers argument is an array of RFC 5952 formattedaddresses. If the port is the IANA default DNS port (53) it can be omitted.

The Domain class encapsulates the functionality of routing errors anduncaught exceptions to the active Domain object.

The EventEmitter class is defined and exposed by the node:events module:

Integrates EventEmitter with AsyncResource for EventEmitters thatrequire manual async tracking. Specifically, all events emitted by instancesof events.EventEmitterAsyncResource will run within its async context.

Tests a user's permissions for the file or directory specified by path.The mode argument is an optional integer that specifies the accessibilitychecks to be performed. mode should be either the value fs.constants.F_OK or a mask consisting of the bitwise OR of any of fs.constants.R_OK, fs.constants.W_OK, and fs.constants.X_OK(e.g.fs.constants.W_OK | fs.constants.R_OK). Check File access constants forpossible values of mode.

Synchronously tests a user's permissions for the file or directory specifiedby path. The mode argument is an optional integer that specifies theaccessibility checks to be performed. mode should be either the value fs.constants.F_OK or a mask consisting of the bitwise OR of any of fs.constants.R_OK, fs.constants.W_OK, andfs.constants.X_OK (e.g.fs.constants.W_OK | fs.constants.R_OK). Check File access constants forpossible values of mode.

Asynchronously append data to a file, creating the file if it does not yetexist. data can be a string or a Buffer.

Synchronously append data to a file, creating the file if it does not yetexist. data can be a string or a Buffer.

Asynchronously changes the permissions of a file. No arguments other than apossible exception are given to the completion callback.

For detailed information, see the documentation of the asynchronous version ofthis API: chmod.

Asynchronously changes owner and group of a file. No arguments other than apossible exception are given to the completion callback.

Synchronously changes owner and group of a file. Returns undefined.This is the synchronous version of chown.

Closes the file descriptor. No arguments other than a possible exception aregiven to the completion callback.

Closes the file descriptor. Returns undefined.

Constant for fs.copyFile. Flag indicating the destination file should not be overwritten if it already exists.

Constant for fs.copyFile. copy operation will attempt to create a copy-on-write reflink.If the underlying platform does not support copy-on-write, then a fallback copy mechanism is used.

Constant for fs.copyFile. Copy operation will attempt to create a copy-on-write reflink.If the underlying platform does not support copy-on-write, then the operation will fail with an error.

Constant for fs.access(). File is visible to the calling process.

Constant for fs.open(). Flag indicating that data will be appended to the end of the file.

Constant for fs.open(). Flag indicating to create the file if it does not already exist.

Constant for fs.open(). When set, an attempt will be made to minimize caching effects of file I/O.

Constant for fs.open(). Flag indicating that the open should fail if the path is not a directory.

Constant for fs.open(). Flag indicating that the file is opened for synchronous I/O with write operations waiting for data integrity.

Constant for fs.open(). Flag indicating that opening a file should fail if the O_CREAT flag is set and the file already exists.

constant for fs.open().Flag indicating reading accesses to the file system will no longer result inan update to the atime information associated with the file.This flag is available on Linux operating systems only.

Constant for fs.open(). Flag indicating that if path identifies a terminal device,opening the path shall not cause that terminal to become the controlling terminal for the process(if the process does not already have one).

Constant for fs.open(). Flag indicating that the open should fail if the path is a symbolic link.

Constant for fs.open(). Flag indicating to open the file in nonblocking mode when possible.

Constant for fs.open(). Flag indicating to open a file for read-only access.

Constant for fs.open(). Flag indicating to open a file for read-write access.

Constant for fs.open(). Flag indicating to open the symbolic link itself rather than the resource it is pointing to.

Constant for fs.open(). Flag indicating that the file is opened for synchronous I/O.

Constant for fs.open(). Flag indicating that if the file exists and is a regular file, and the file is opened successfully for write access, its length shall be truncated to zero.

Constant for fs.open(). Flag indicating to open a file for write-only access.

Constant for fs.access(). File can be read by the calling process.

Constant for fs.Stats mode property for determining a file's type. File type constant for a block-oriented device file.

Constant for fs.Stats mode property for determining a file's type. File type constant for a character-oriented device file.

Constant for fs.Stats mode property for determining a file's type. File type constant for a directory.

Constant for fs.Stats mode property for determining a file's type. File type constant for a FIFO/pipe.

Constant for fs.Stats mode property for determining a file's type. File type constant for a symbolic link.

Constant for fs.Stats mode property for determining a file's type. Bit mask used to extract the file type code.

Constant for fs.Stats mode property for determining a file's type. File type constant for a regular file.

Constant for fs.Stats mode property for determining a file's type. File type constant for a socket.

Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating readable by group.

Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating readable by others.

Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating readable by owner.

Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating readable, writable and executable by group.

Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating readable, writable and executable by others.

Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating readable, writable and executable by owner.

Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating writable by group.

Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating writable by others.

Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating writable by owner.

Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating executable by group.

Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating executable by others.

Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating executable by owner.

When set, a memory file mapping is used to access the file. This flagis available on Windows operating systems only. On other operating systems,this flag is ignored.

Constant for fs.access(). File can be written by the calling process.

Constant for fs.access(). File can be executed by the calling process.

Asynchronously copies src to dest. By default, dest is overwritten if italready exists. No arguments other than a possible exception are given to thecallback function. Node.js makes no guarantees about the atomicity of the copyoperation. If an error occurs after the destination file has been opened forwriting, Node.js will attempt to remove the destination.

Synchronously copies src to dest. By default, dest is overwritten if italready exists. Returns undefined. Node.js makes no guarantees about theatomicity of the copy operation. If an error occurs after the destination filehas been opened for writing, Node.js will attempt to remove the destination.

Asynchronously copies the entire directory structure from src to dest,including subdirectories and files.

Synchronously copies the entire directory structure from src to dest,including subdirectories and files.

Unlike the 16 KiB default highWaterMark for a stream.Readable, the streamreturned by this method has a default highWaterMark of 64 KiB.

options may also include a start option to allow writing data at someposition past the beginning of the file, allowed values are in the[0, Number.MAX_SAFE_INTEGER] range. Modifying a file rather thanreplacing it may require the flags option to be set to r+ rather than thedefault w. The encoding can be any one of those accepted by Buffer.

A class representing a directory stream.

A representation of a directory entry, which can be a file or a subdirectorywithin the directory, as returned by reading from an fs.Dir. Thedirectory entry is a combination of the file name and file type pairs.

Returns true if the path exists, false otherwise.

Sets the permissions on the file. No arguments other than a possible exceptionare given to the completion callback.

Sets the permissions on the file. Returns undefined.

Sets the owner of the file. No arguments other than a possible exception aregiven to the completion callback.

Sets the owner of the file. Returns undefined.

Forces all currently queued I/O operations associated with the file to theoperating system's synchronized I/O completion state. Refer to the POSIX fdatasync(2) documentation for details. No arguments otherthan a possibleexception are given to the completion callback.

Forces all currently queued I/O operations associated with the file to theoperating system's synchronized I/O completion state. Refer to the POSIX fdatasync(2) documentation for details. Returns undefined.

Invokes the callback with the fs.Stats for the file descriptor.

Retrieves the fs.Stats for the file descriptor.

Request that all data for the open file descriptor is flushed to the storagedevice. The specific implementation is operating system and device specific.Refer to the POSIX fsync(2) documentation for more detail. No arguments otherthan a possible exception are given to the completion callback.

Request that all data for the open file descriptor is flushed to the storagedevice. The specific implementation is operating system and device specific.Refer to the POSIX fsync(2) documentation for more detail. Returns undefined.

Truncates the file descriptor. No arguments other than a possible exception aregiven to the completion callback.

Truncates the file descriptor. Returns undefined.

Change the file system timestamps of the object referenced by the supplied filedescriptor. See utimes.

Synchronous version of futimes. Returns undefined.

Retrieves the files matching the specified pattern.

Retrieves the files matching the specified pattern.

Set the owner of the symbolic link. No arguments other than a possibleexception are given to the completion callback.

Set the owner for the path. Returns undefined.

Creates a new link from the existingPath to the newPath. See the POSIX link(2) documentation for more detail. No arguments other thana possibleexception are given to the completion callback.

Creates a new link from the existingPath to the newPath. See the POSIX link(2) documentation for more detail. Returns undefined.

Retrieves the fs.Stats for the symbolic link referred to by the path.The callback gets two arguments (err, stats) where stats is a fs.Stats object. lstat() is identical to stat(), except that if path is a symboliclink, then the link itself is stat-ed, not the file that it refers to.

Synchronous lstat(2) - Get file status. Does not dereference symbolic links.

Changes the access and modification times of a file in the same way as utimes, with the difference that if the path refers to a symboliclink, then the link is not dereferenced: instead, the timestamps of thesymbolic link itself are changed.

Change the file system timestamps of the symbolic link referenced by path.Returns undefined, or throws an exception when parameters are incorrect orthe operation fails. This is the synchronous version of lutimes.

Asynchronously creates a directory.

Synchronously creates a directory. Returns undefined, or if recursive is true, the first directory path created.This is the synchronous version of mkdir.

Creates a unique temporary directory.

Returns the created directory path.

Asynchronous file open. See the POSIX open(2) documentation for more details.

Returns a Blob whose data is backed by the given file.

Asynchronously open a directory. See the POSIX opendir(3) documentation formore details.

Synchronously open a directory. See opendir(3).

Returns an integer representing the file descriptor.

Valid types for path values in "fs".

The fs/promises API provides asynchronous file system methods that returnpromises.

Tests a user's permissions for the file or directory specified by path.The mode argument is an optional integer that specifies the accessibilitychecks to be performed. mode should be either the value fs.constants.F_OK or a mask consisting of the bitwise OR of any of fs.constants.R_OK, fs.constants.W_OK, and fs.constants.X_OK(e.g.fs.constants.W_OK | fs.constants.R_OK). Check File access constants forpossible values of mode.

Asynchronously append data to a file, creating the file if it does not yetexist. data can be a string or a Buffer.

Changes the permissions of a file.

Changes the ownership of a file.

Asynchronously copies src to dest. By default, dest is overwritten if italready exists.

Asynchronously copies the entire directory structure from src to dest,including subdirectories and files.