@psnext/slingcli 3.1.20260904-1 → 3.3.20260911-1

package/node_modules/@types/node/dns.d.ts

@@ -1,21 +1,68 @@
-declare module "node:dns" {
+/**
+ * The `node:dns` module enables name resolution. For example, use it to look up IP
+ * addresses of host names.
+ *
+ * Although named for the [Domain Name System (DNS)](https://en.wikipedia.org/wiki/Domain_Name_System), it does not always use the
+ * DNS protocol for lookups. {@link lookup} uses the operating system
+ * facilities to perform name resolution. It may not need to perform any network
+ * communication. To perform name resolution the way other applications on the same
+ * system do, use {@link lookup}.
+ *
+ * ```js
+ * import dns from 'node:dns';
+ *
+ * dns.lookup('example.org', (err, address, family) => {
+ *   console.log('address: %j family: IPv%s', address, family);
+ * });
+ * // address: "93.184.216.34" family: IPv4
+ * ```
+ *
+ * All other functions in the `node:dns` module connect to an actual DNS server to
+ * perform name resolution. They will always use the network to perform DNS
+ * queries. These functions do not use the same set of configuration files used by {@link lookup} (e.g. `/etc/hosts`). Use these functions to always perform
+ * DNS queries, bypassing other name-resolution facilities.
+ *
+ * ```js
+ * import dns from 'node:dns';
+ *
+ * dns.resolve4('archive.org', (err, addresses) => {
+ *   if (err) throw err;
+ *
+ *   console.log(`addresses: ${JSON.stringify(addresses)}`);
+ *
+ *   addresses.forEach((a) => {
+ *     dns.reverse(a, (err, hostnames) => {
+ *       if (err) {
+ *         throw err;
+ *       }
+ *       console.log(`reverse for ${a}: ${JSON.stringify(hostnames)}`);
+ *     });
+ *   });
+ * });
+ * ```
+ *
+ * See the [Implementation considerations section](https://nodejs.org/docs/latest-v22.x/api/dns.html#implementation-considerations) for more information.
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/dns.js)
+ */
+declare module "dns" {
+    import * as dnsPromises from "node:dns/promises";
     // Supported getaddrinfo flags.
     /**
      * Limits returned address types to the types of non-loopback addresses configured on the system. For example, IPv4 addresses are
      * only returned if the current system has at least one IPv4 address configured.
      */
-    const ADDRCONFIG: number;
+    export const ADDRCONFIG: number;
     /**
      * If the IPv6 family was specified, but no IPv6 addresses were found, then return IPv4 mapped IPv6 addresses. It is not supported
      * on some operating systems (e.g. FreeBSD 10.1).
      */
-    const V4MAPPED: number;
+    export const V4MAPPED: number;
     /**
      * If `dns.V4MAPPED` is specified, return resolved IPv6 addresses as
      * well as IPv4 mapped IPv6 addresses.
      */
-    const ALL: number;
-    interface LookupOptions {
+    export const ALL: number;
+    export interface LookupOptions {
         /**
          * The record family. Must be `4`, `6`, or `0`. For backward compatibility reasons, `'IPv4'` and `'IPv6'` are interpreted
          * as `4` and `6` respectively. The value 0 indicates that either an IPv4 or IPv6 address is returned. If the value `0` is used
@@ -24,7 +71,7 @@ declare module "node:dns" {
          */
         family?: number | "IPv4" | "IPv6" | undefined;
         /**
-         * One or more [supported `getaddrinfo`](https://nodejs.org/docs/latest-v26.x/api/dns.html#supported-getaddrinfo-flags) flags. Multiple flags may be
+         * One or more [supported `getaddrinfo`](https://nodejs.org/docs/latest-v22.x/api/dns.html#supported-getaddrinfo-flags) flags. Multiple flags may be
          * passed by bitwise `OR`ing their values.
          */
         hints?: number | undefined;
@@ -34,10 +81,10 @@ declare module "node:dns" {
          */
         all?: boolean | undefined;
         /**
-         * When `verbatim`, the resolved addresses are returned unsorted. When `ipv4first`, the resolved addresses are sorted
+         * When `verbatim`, the resolved addresses are return unsorted. When `ipv4first`, the resolved addresses are sorted
          * by placing IPv4 addresses before IPv6 addresses. When `ipv6first`, the resolved addresses are sorted by placing IPv6
          * addresses before IPv4 addresses. Default value is configurable using
-         * {@link setDefaultResultOrder} or [`--dns-result-order`](https://nodejs.org/docs/latest-v26.x/api/cli.html#--dns-result-orderorder).
+         * {@link setDefaultResultOrder} or [`--dns-result-order`](https://nodejs.org/docs/latest-v22.x/api/cli.html#--dns-result-orderorder).
          * @default `verbatim` (addresses are not reordered)
          * @since v22.1.0
          */
@@ -51,13 +98,13 @@ declare module "node:dns" {
          */
         verbatim?: boolean | undefined;
     }
-    interface LookupOneOptions extends LookupOptions {
+    export interface LookupOneOptions extends LookupOptions {
         all?: false | undefined;
     }
-    interface LookupAllOptions extends LookupOptions {
+    export interface LookupAllOptions extends LookupOptions {
         all: true;
     }
-    interface LookupAddress {
+    export interface LookupAddress {
         /**
          * A string representation of an IPv4 or IPv6 address.
          */
@@ -86,7 +133,7 @@ declare module "node:dns" {
      * The implementation uses an operating system facility that can associate names
      * with addresses and vice versa. This implementation can have subtle but
      * important consequences on the behavior of any Node.js program. Please take some
-     * time to consult the [Implementation considerations section](https://nodejs.org/docs/latest-v26.x/api/dns.html#implementation-considerations)
+     * time to consult the [Implementation considerations section](https://nodejs.org/docs/latest-v22.x/api/dns.html#implementation-considerations)
      * before using `dns.lookup()`.
      *
      * Example usage:
@@ -108,35 +155,35 @@ declare module "node:dns" {
      * // addresses: [{"address":"2606:2800:220:1:248:1893:25c8:1946","family":6}]
      * ```
      *
-     * If this method is invoked as its [util.promisify()](https://nodejs.org/docs/latest-v26.x/api/util.html#utilpromisifyoriginal) ed
+     * If this method is invoked as its [util.promisify()](https://nodejs.org/docs/latest-v22.x/api/util.html#utilpromisifyoriginal) ed
      * version, and `all` is not set to `true`, it returns a `Promise` for an `Object` with `address` and `family` properties.
      * @since v0.1.90
      */
-    function lookup(
+    export function lookup(
         hostname: string,
         family: number,
         callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void,
     ): void;
-    function lookup(
+    export function lookup(
         hostname: string,
         options: LookupOneOptions,
         callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void,
     ): void;
-    function lookup(
+    export function lookup(
         hostname: string,
         options: LookupAllOptions,
         callback: (err: NodeJS.ErrnoException | null, addresses: LookupAddress[]) => void,
     ): void;
-    function lookup(
+    export function lookup(
         hostname: string,
         options: LookupOptions,
         callback: (err: NodeJS.ErrnoException | null, address: string | LookupAddress[], family: number) => void,
     ): void;
-    function lookup(
+    export function lookup(
         hostname: string,
         callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void,
     ): void;
-    namespace lookup {
+    export namespace lookup {
         function __promisify__(hostname: string, options: LookupAllOptions): Promise<LookupAddress[]>;
         function __promisify__(hostname: string, options?: LookupOneOptions | number): Promise<LookupAddress>;
         function __promisify__(hostname: string, options: LookupOptions): Promise<LookupAddress | LookupAddress[]>;
@@ -148,7 +195,7 @@ declare module "node:dns" {
      * If `address` is not a valid IP address, a `TypeError` will be thrown.
      * The `port` will be coerced to a number. If it is not a legal port, a `TypeError` will be thrown.
      *
-     * On an error, `err` is an [`Error`](https://nodejs.org/docs/latest-v26.x/api/errors.html#class-error) object,
+     * On an error, `err` is an [`Error`](https://nodejs.org/docs/latest-v22.x/api/errors.html#class-error) object,
      * where `err.code` is the error code.
      *
      * ```js
@@ -159,16 +206,16 @@ declare module "node:dns" {
      * });
      * ```
      *
-     * If this method is invoked as its [util.promisify()](https://nodejs.org/docs/latest-v26.x/api/util.html#utilpromisifyoriginal) ed
+     * If this method is invoked as its [util.promisify()](https://nodejs.org/docs/latest-v22.x/api/util.html#utilpromisifyoriginal) ed
      * version, it returns a `Promise` for an `Object` with `hostname` and `service` properties.
      * @since v0.11.14
      */
-    function lookupService(
+    export function lookupService(
         address: string,
         port: number,
         callback: (err: NodeJS.ErrnoException | null, hostname: string, service: string) => void,
     ): void;
-    namespace lookupService {
+    export namespace lookupService {
         function __promisify__(
             address: string,
             port: number,
@@ -177,23 +224,25 @@ declare module "node:dns" {
             service: string;
         }>;
     }
-    interface ResolveOptions {
+    export interface ResolveOptions {
         ttl: boolean;
     }
-    interface ResolveWithTtlOptions extends ResolveOptions {
+    export interface ResolveWithTtlOptions extends ResolveOptions {
         ttl: true;
     }
-    interface RecordWithTtl {
+    export interface RecordWithTtl {
         address: string;
         ttl: number;
     }
-    interface AnyARecord extends RecordWithTtl {
+    /** @deprecated Use `AnyARecord` or `AnyAaaaRecord` instead. */
+    export type AnyRecordWithTtl = AnyARecord | AnyAaaaRecord;
+    export interface AnyARecord extends RecordWithTtl {
         type: "A";
     }
-    interface AnyAaaaRecord extends RecordWithTtl {
+    export interface AnyAaaaRecord extends RecordWithTtl {
         type: "AAAA";
     }
-    interface CaaRecord {
+    export interface CaaRecord {
         critical: number;
         issue?: string | undefined;
         issuewild?: string | undefined;
@@ -201,17 +250,17 @@ declare module "node:dns" {
         contactemail?: string | undefined;
         contactphone?: string | undefined;
     }
-    interface AnyCaaRecord extends CaaRecord {
+    export interface AnyCaaRecord extends CaaRecord {
         type: "CAA";
     }
-    interface MxRecord {
+    export interface MxRecord {
         priority: number;
         exchange: string;
     }
-    interface AnyMxRecord extends MxRecord {
+    export interface AnyMxRecord extends MxRecord {
         type: "MX";
     }
-    interface NaptrRecord {
+    export interface NaptrRecord {
         flags: string;
         service: string;
         regexp: string;
@@ -219,10 +268,10 @@ declare module "node:dns" {
         order: number;
         preference: number;
     }
-    interface AnyNaptrRecord extends NaptrRecord {
+    export interface AnyNaptrRecord extends NaptrRecord {
         type: "NAPTR";
     }
-    interface SoaRecord {
+    export interface SoaRecord {
         nsname: string;
         hostmaster: string;
         serial: number;
@@ -231,44 +280,44 @@ declare module "node:dns" {
         expire: number;
         minttl: number;
     }
-    interface AnySoaRecord extends SoaRecord {
+    export interface AnySoaRecord extends SoaRecord {
         type: "SOA";
     }
-    interface SrvRecord {
+    export interface SrvRecord {
         priority: number;
         weight: number;
         port: number;
         name: string;
     }
-    interface AnySrvRecord extends SrvRecord {
+    export interface AnySrvRecord extends SrvRecord {
         type: "SRV";
     }
-    interface TlsaRecord {
+    export interface TlsaRecord {
         certUsage: number;
         selector: number;
         match: number;
         data: ArrayBuffer;
     }
-    interface AnyTlsaRecord extends TlsaRecord {
+    export interface AnyTlsaRecord extends TlsaRecord {
         type: "TLSA";
     }
-    interface AnyTxtRecord {
+    export interface AnyTxtRecord {
         type: "TXT";
         entries: string[];
     }
-    interface AnyNsRecord {
+    export interface AnyNsRecord {
         type: "NS";
         value: string;
     }
-    interface AnyPtrRecord {
+    export interface AnyPtrRecord {
         type: "PTR";
         value: string;
     }
-    interface AnyCnameRecord {
+    export interface AnyCnameRecord {
         type: "CNAME";
         value: string;
     }
-    type AnyRecord =
+    export type AnyRecord =
         | AnyARecord
         | AnyAaaaRecord
         | AnyCaaRecord
@@ -288,62 +337,62 @@ declare module "node:dns" {
      *
      * <omitted>
      *
-     * On error, `err` is an [`Error`](https://nodejs.org/docs/latest-v26.x/api/errors.html#class-error) object,
+     * On error, `err` is an [`Error`](https://nodejs.org/docs/latest-v22.x/api/errors.html#class-error) object,
      * where `err.code` is one of the `DNS error codes`.
      * @since v0.1.27
      * @param hostname Host name to resolve.
      * @param [rrtype='A'] Resource record type.
      */
-    function resolve(
+    export function resolve(
         hostname: string,
         callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void,
     ): void;
-    function resolve(
+    export function resolve(
         hostname: string,
         rrtype: "A" | "AAAA" | "CNAME" | "NS" | "PTR",
         callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void,
     ): void;
-    function resolve(
+    export function resolve(
         hostname: string,
         rrtype: "ANY",
         callback: (err: NodeJS.ErrnoException | null, addresses: AnyRecord[]) => void,
     ): void;
-    function resolve(
+    export function resolve(
         hostname: string,
         rrtype: "CAA",
         callback: (err: NodeJS.ErrnoException | null, address: CaaRecord[]) => void,
     ): void;
-    function resolve(
+    export function resolve(
         hostname: string,
         rrtype: "MX",
         callback: (err: NodeJS.ErrnoException | null, addresses: MxRecord[]) => void,
     ): void;
-    function resolve(
+    export function resolve(
         hostname: string,
         rrtype: "NAPTR",
         callback: (err: NodeJS.ErrnoException | null, addresses: NaptrRecord[]) => void,
     ): void;
-    function resolve(
+    export function resolve(
         hostname: string,
         rrtype: "SOA",
         callback: (err: NodeJS.ErrnoException | null, addresses: SoaRecord) => void,
     ): void;
-    function resolve(
+    export function resolve(
         hostname: string,
         rrtype: "SRV",
         callback: (err: NodeJS.ErrnoException | null, addresses: SrvRecord[]) => void,
     ): void;
-    function resolve(
+    export function resolve(
         hostname: string,
         rrtype: "TLSA",
         callback: (err: NodeJS.ErrnoException | null, addresses: TlsaRecord[]) => void,
     ): void;
-    function resolve(
+    export function resolve(
         hostname: string,
         rrtype: "TXT",
         callback: (err: NodeJS.ErrnoException | null, addresses: string[][]) => void,
     ): void;
-    function resolve(
+    export function resolve(
         hostname: string,
         rrtype: string,
         callback: (
@@ -360,7 +409,7 @@ declare module "node:dns" {
                 | AnyRecord[],
         ) => void,
     ): void;
-    namespace resolve {
+    export namespace resolve {
         function __promisify__(hostname: string, rrtype?: "A" | "AAAA" | "CNAME" | "NS" | "PTR"): Promise<string[]>;
         function __promisify__(hostname: string, rrtype: "ANY"): Promise<AnyRecord[]>;
         function __promisify__(hostname: string, rrtype: "CAA"): Promise<CaaRecord[]>;
@@ -391,21 +440,21 @@ declare module "node:dns" {
      * @since v0.1.16
      * @param hostname Host name to resolve.
      */
-    function resolve4(
+    export function resolve4(
         hostname: string,
         callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void,
     ): void;
-    function resolve4(
+    export function resolve4(
         hostname: string,
         options: ResolveWithTtlOptions,
         callback: (err: NodeJS.ErrnoException | null, addresses: RecordWithTtl[]) => void,
     ): void;
-    function resolve4(
+    export function resolve4(
         hostname: string,
         options: ResolveOptions,
         callback: (err: NodeJS.ErrnoException | null, addresses: string[] | RecordWithTtl[]) => void,
     ): void;
-    namespace resolve4 {
+    export namespace resolve4 {
         function __promisify__(hostname: string): Promise<string[]>;
         function __promisify__(hostname: string, options: ResolveWithTtlOptions): Promise<RecordWithTtl[]>;
         function __promisify__(hostname: string, options?: ResolveOptions): Promise<string[] | RecordWithTtl[]>;
@@ -416,21 +465,21 @@ declare module "node:dns" {
      * @since v0.1.16
      * @param hostname Host name to resolve.
      */
-    function resolve6(
+    export function resolve6(
         hostname: string,
         callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void,
     ): void;
-    function resolve6(
+    export function resolve6(
         hostname: string,
         options: ResolveWithTtlOptions,
         callback: (err: NodeJS.ErrnoException | null, addresses: RecordWithTtl[]) => void,
     ): void;
-    function resolve6(
+    export function resolve6(
         hostname: string,
         options: ResolveOptions,
         callback: (err: NodeJS.ErrnoException | null, addresses: string[] | RecordWithTtl[]) => void,
     ): void;
-    namespace resolve6 {
+    export namespace resolve6 {
         function __promisify__(hostname: string): Promise<string[]>;
         function __promisify__(hostname: string, options: ResolveWithTtlOptions): Promise<RecordWithTtl[]>;
         function __promisify__(hostname: string, options?: ResolveOptions): Promise<string[] | RecordWithTtl[]>;
@@ -440,11 +489,11 @@ declare module "node:dns" {
      * will contain an array of canonical name records available for the `hostname` (e.g. `['bar.example.com']`).
      * @since v0.3.2
      */
-    function resolveCname(
+    export function resolveCname(
         hostname: string,
         callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void,
     ): void;
-    namespace resolveCname {
+    export namespace resolveCname {
         function __promisify__(hostname: string): Promise<string[]>;
     }
     /**
@@ -453,11 +502,11 @@ declare module "node:dns" {
      * available for the `hostname` (e.g. `[{critical: 0, iodef: 'mailto:pki@example.com'}, {critical: 128, issue: 'pki.example.com'}]`).
      * @since v15.0.0, v14.17.0
      */
-    function resolveCaa(
+    export function resolveCaa(
         hostname: string,
         callback: (err: NodeJS.ErrnoException | null, records: CaaRecord[]) => void,
     ): void;
-    namespace resolveCaa {
+    export namespace resolveCaa {
         function __promisify__(hostname: string): Promise<CaaRecord[]>;
     }
     /**
@@ -465,11 +514,11 @@ declare module "node:dns" {
      * contain an array of objects containing both a `priority` and `exchange` property (e.g. `[{priority: 10, exchange: 'mx.example.com'}, ...]`).
      * @since v0.1.27
      */
-    function resolveMx(
+    export function resolveMx(
         hostname: string,
         callback: (err: NodeJS.ErrnoException | null, addresses: MxRecord[]) => void,
     ): void;
-    namespace resolveMx {
+    export namespace resolveMx {
         function __promisify__(hostname: string): Promise<MxRecord[]>;
     }
     /**
@@ -490,16 +539,16 @@ declare module "node:dns" {
      *   regexp: '',
      *   replacement: '_sip._udp.example.com',
      *   order: 30,
-     *   preference: 100,
+     *   preference: 100
      * }
      * ```
      * @since v0.9.12
      */
-    function resolveNaptr(
+    export function resolveNaptr(
         hostname: string,
         callback: (err: NodeJS.ErrnoException | null, addresses: NaptrRecord[]) => void,
     ): void;
-    namespace resolveNaptr {
+    export namespace resolveNaptr {
         function __promisify__(hostname: string): Promise<NaptrRecord[]>;
     }
     /**
@@ -507,11 +556,11 @@ declare module "node:dns" {
      * contain an array of name server records available for `hostname` (e.g. `['ns1.example.com', 'ns2.example.com']`).
      * @since v0.1.90
      */
-    function resolveNs(
+    export function resolveNs(
         hostname: string,
         callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void,
     ): void;
-    namespace resolveNs {
+    export namespace resolveNs {
         function __promisify__(hostname: string): Promise<string[]>;
     }
     /**
@@ -519,11 +568,11 @@ declare module "node:dns" {
      * be an array of strings containing the reply records.
      * @since v6.0.0
      */
-    function resolvePtr(
+    export function resolvePtr(
         hostname: string,
         callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void,
     ): void;
-    namespace resolvePtr {
+    export namespace resolvePtr {
         function __promisify__(hostname: string): Promise<string[]>;
     }
     /**
@@ -547,16 +596,16 @@ declare module "node:dns" {
      *   refresh: 10000,
      *   retry: 2400,
      *   expire: 604800,
-     *   minttl: 3600,
+     *   minttl: 3600
      * }
      * ```
      * @since v0.11.10
      */
-    function resolveSoa(
+    export function resolveSoa(
         hostname: string,
         callback: (err: NodeJS.ErrnoException | null, address: SoaRecord) => void,
     ): void;
-    namespace resolveSoa {
+    export namespace resolveSoa {
         function __promisify__(hostname: string): Promise<SoaRecord>;
     }
     /**
@@ -573,16 +622,16 @@ declare module "node:dns" {
      *   priority: 10,
      *   weight: 5,
      *   port: 21223,
-     *   name: 'service.example.com',
+     *   name: 'service.example.com'
      * }
      * ```
      * @since v0.1.27
      */
-    function resolveSrv(
+    export function resolveSrv(
         hostname: string,
         callback: (err: NodeJS.ErrnoException | null, addresses: SrvRecord[]) => void,
     ): void;
-    namespace resolveSrv {
+    export namespace resolveSrv {
         function __promisify__(hostname: string): Promise<SrvRecord[]>;
     }
     /**
@@ -600,16 +649,16 @@ declare module "node:dns" {
      *   certUsage: 3,
      *   selector: 1,
      *   match: 1,
-     *   data: [ArrayBuffer],
+     *   data: [ArrayBuffer]
      * }
      * ```
-     * @since v23.9.0, v22.15.0
+     * @since v22.15.0
      */
-    function resolveTlsa(
+    export function resolveTlsa(
         hostname: string,
         callback: (err: NodeJS.ErrnoException | null, addresses: TlsaRecord[]) => void,
     ): void;
-    namespace resolveTlsa {
+    export namespace resolveTlsa {
         function __promisify__(hostname: string): Promise<TlsaRecord[]>;
     }
     /**
@@ -619,11 +668,11 @@ declare module "node:dns" {
      * treated separately.
      * @since v0.1.27
      */
-    function resolveTxt(
+    export function resolveTxt(
         hostname: string,
         callback: (err: NodeJS.ErrnoException | null, addresses: string[][]) => void,
     ): void;
-    namespace resolveTxt {
+    export namespace resolveTxt {
         function __promisify__(hostname: string): Promise<string[][]>;
     }
     /**
@@ -650,33 +699,33 @@ declare module "node:dns" {
      *     refresh: 900,
      *     retry: 900,
      *     expire: 1800,
-     *     minttl: 60 } ];
+     *     minttl: 60 } ]
      * ```
      *
      * DNS server operators may choose not to respond to `ANY` queries. It may be better to call individual methods like {@link resolve4}, {@link resolveMx}, and so on. For more details, see
      * [RFC 8482](https://tools.ietf.org/html/rfc8482).
      */
-    function resolveAny(
+    export function resolveAny(
         hostname: string,
         callback: (err: NodeJS.ErrnoException | null, addresses: AnyRecord[]) => void,
     ): void;
-    namespace resolveAny {
+    export namespace resolveAny {
         function __promisify__(hostname: string): Promise<AnyRecord[]>;
     }
     /**
      * Performs a reverse DNS query that resolves an IPv4 or IPv6 address to an
      * array of host names.
      *
-     * On error, `err` is an [`Error`](https://nodejs.org/docs/latest-v26.x/api/errors.html#class-error) object, where `err.code` is
-     * one of the [DNS error codes](https://nodejs.org/docs/latest-v26.x/api/dns.html#error-codes).
+     * On error, `err` is an [`Error`](https://nodejs.org/docs/latest-v22.x/api/errors.html#class-error) object, where `err.code` is
+     * one of the [DNS error codes](https://nodejs.org/docs/latest-v22.x/api/dns.html#error-codes).
      * @since v0.1.16
      */
-    function reverse(
+    export function reverse(
         ip: string,
         callback: (err: NodeJS.ErrnoException | null, hostnames: string[]) => void,
     ): void;
     /**
-     * Get the default value for `order` in {@link lookup} and [`dnsPromises.lookup()`](https://nodejs.org/docs/latest-v26.x/api/dns.html#dnspromiseslookuphostname-options).
+     * Get the default value for `order` in {@link lookup} and [`dnsPromises.lookup()`](https://nodejs.org/docs/latest-v22.x/api/dns.html#dnspromiseslookuphostname-options).
      * The value could be:
      *
      * * `ipv4first`: for `order` defaulting to `ipv4first`.
@@ -684,7 +733,7 @@ declare module "node:dns" {
      * * `verbatim`: for `order` defaulting to `verbatim`.
      * @since v18.17.0
      */
-    function getDefaultResultOrder(): "ipv4first" | "ipv6first" | "verbatim";
+    export function getDefaultResultOrder(): "ipv4first" | "ipv6first" | "verbatim";
     /**
      * Sets the IP address and port of servers to be used when performing DNS
      * resolution. The `servers` argument is an array of [RFC 5952](https://tools.ietf.org/html/rfc5952#section-6) formatted
@@ -713,7 +762,7 @@ declare module "node:dns" {
      * @since v0.11.3
      * @param servers array of [RFC 5952](https://datatracker.ietf.org/doc/html/rfc5952#section-6) formatted addresses
      */
-    function setServers(servers: readonly string[]): void;
+    export function setServers(servers: readonly string[]): void;
     /**
      * Returns an array of IP address strings, formatted according to [RFC 5952](https://tools.ietf.org/html/rfc5952#section-6),
      * that are currently configured for DNS resolution. A string will include a port
@@ -729,9 +778,9 @@ declare module "node:dns" {
      * ```
      * @since v0.11.3
      */
-    function getServers(): string[];
+    export function getServers(): string[];
     /**
-     * Set the default value of `order` in {@link lookup} and [`dnsPromises.lookup()`](https://nodejs.org/docs/latest-v26.x/api/dns.html#dnspromiseslookuphostname-options).
+     * Set the default value of `order` in {@link lookup} and [`dnsPromises.lookup()`](https://nodejs.org/docs/latest-v22.x/api/dns.html#dnspromiseslookuphostname-options).
      * The value could be:
      *
      * * `ipv4first`: sets default `order` to `ipv4first`.
@@ -739,39 +788,39 @@ declare module "node:dns" {
      * * `verbatim`: sets default `order` to `verbatim`.
      *
      * The default is `verbatim` and {@link setDefaultResultOrder} have higher
-     * priority than [`--dns-result-order`](https://nodejs.org/docs/latest-v26.x/api/cli.html#--dns-result-orderorder). When using
-     * [worker threads](https://nodejs.org/docs/latest-v26.x/api/worker_threads.html), {@link setDefaultResultOrder} from the main
+     * priority than [`--dns-result-order`](https://nodejs.org/docs/latest-v22.x/api/cli.html#--dns-result-orderorder). When using
+     * [worker threads](https://nodejs.org/docs/latest-v22.x/api/worker_threads.html), {@link setDefaultResultOrder} from the main
      * thread won't affect the default dns orders in workers.
      * @since v16.4.0, v14.18.0
      * @param order must be `'ipv4first'`, `'ipv6first'` or `'verbatim'`.
      */
-    function setDefaultResultOrder(order: "ipv4first" | "ipv6first" | "verbatim"): void;
+    export function setDefaultResultOrder(order: "ipv4first" | "ipv6first" | "verbatim"): void;
     // Error codes
-    const NODATA: "ENODATA";
-    const FORMERR: "EFORMERR";
-    const SERVFAIL: "ESERVFAIL";
-    const NOTFOUND: "ENOTFOUND";
-    const NOTIMP: "ENOTIMP";
-    const REFUSED: "EREFUSED";
-    const BADQUERY: "EBADQUERY";
-    const BADNAME: "EBADNAME";
-    const BADFAMILY: "EBADFAMILY";
-    const BADRESP: "EBADRESP";
-    const CONNREFUSED: "ECONNREFUSED";
-    const TIMEOUT: "ETIMEOUT";
-    const EOF: "EOF";
-    const FILE: "EFILE";
-    const NOMEM: "ENOMEM";
-    const DESTRUCTION: "EDESTRUCTION";
-    const BADSTR: "EBADSTR";
-    const BADFLAGS: "EBADFLAGS";
-    const NONAME: "ENONAME";
-    const BADHINTS: "EBADHINTS";
-    const NOTINITIALIZED: "ENOTINITIALIZED";
-    const LOADIPHLPAPI: "ELOADIPHLPAPI";
-    const ADDRGETNETWORKPARAMS: "EADDRGETNETWORKPARAMS";
-    const CANCELLED: "ECANCELLED";
-    interface ResolverOptions {
+    export const NODATA: "ENODATA";
+    export const FORMERR: "EFORMERR";
+    export const SERVFAIL: "ESERVFAIL";
+    export const NOTFOUND: "ENOTFOUND";
+    export const NOTIMP: "ENOTIMP";
+    export const REFUSED: "EREFUSED";
+    export const BADQUERY: "EBADQUERY";
+    export const BADNAME: "EBADNAME";
+    export const BADFAMILY: "EBADFAMILY";
+    export const BADRESP: "EBADRESP";
+    export const CONNREFUSED: "ECONNREFUSED";
+    export const TIMEOUT: "ETIMEOUT";
+    export const EOF: "EOF";
+    export const FILE: "EFILE";
+    export const NOMEM: "ENOMEM";
+    export const DESTRUCTION: "EDESTRUCTION";
+    export const BADSTR: "EBADSTR";
+    export const BADFLAGS: "EBADFLAGS";
+    export const NONAME: "ENONAME";
+    export const BADHINTS: "EBADHINTS";
+    export const NOTINITIALIZED: "ENOTINITIALIZED";
+    export const LOADIPHLPAPI: "ELOADIPHLPAPI";
+    export const ADDRGETNETWORKPARAMS: "EADDRGETNETWORKPARAMS";
+    export const CANCELLED: "ECANCELLED";
+    export interface ResolverOptions {
         /**
          * Query timeout in milliseconds, or `-1` to use the default timeout.
          */
@@ -791,7 +840,7 @@ declare module "node:dns" {
      * An independent resolver for DNS requests.
      *
      * Creating a new resolver uses the default server settings. Setting
-     * the servers used for a resolver using [`resolver.setServers()`](https://nodejs.org/docs/latest-v26.x/api/dns.html#dnssetserversservers) does not affect
+     * the servers used for a resolver using [`resolver.setServers()`](https://nodejs.org/docs/latest-v22.x/api/dns.html#dnssetserversservers) does not affect
      * other resolvers:
      *
      * ```js
@@ -825,7 +874,7 @@ declare module "node:dns" {
      * * `resolver.setServers()`
      * @since v8.3.0
      */
-    class Resolver {
+    export class Resolver {
         constructor(options?: ResolverOptions);
         /**
          * Cancel all outstanding DNS queries made by this resolver. The corresponding
@@ -867,10 +916,8 @@ declare module "node:dns" {
         setLocalAddress(ipv4?: string, ipv6?: string): void;
         setServers: typeof setServers;
     }
+    export { dnsPromises as promises };
 }
 declare module "node:dns" {
-    export * as promises from "node:dns/promises";
-}
-declare module "dns" {
-    export * from "node:dns";
+    export * from "dns";
 }