@runlith/tagma 0.0.0-stage → 0.1.0

package/types/node/dgram.d.ts

@@ -0,0 +1,88 @@
+declare module "node:dgram" {
+    import { NonSharedBuffer } from "node:buffer";
+    import * as dns from "node:dns";
+    import { Abortable, EventEmitter, InternalEventEmitter } from "node:events";
+    import { AddressInfo, BlockList } from "node:net";
+    interface RemoteInfo {
+        address: string;
+        family: "IPv4" | "IPv6";
+        port: number;
+        size: number;
+    }
+    interface BindOptions {
+        port?: number | undefined;
+        address?: string | undefined;
+        exclusive?: boolean | undefined;
+        fd?: number | undefined;
+    }
+    type SocketType = "udp4" | "udp6";
+    interface SocketOptions extends Abortable {
+        type: SocketType;
+        reuseAddr?: boolean | undefined;
+        reusePort?: boolean | undefined;
+        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;
+        receiveBlockList?: BlockList | undefined;
+        sendBlockList?: BlockList | undefined;
+    }
+    function createSocket(type: SocketType, callback?: (msg: NonSharedBuffer, rinfo: RemoteInfo) => void): Socket;
+    function createSocket(options: SocketOptions, callback?: (msg: NonSharedBuffer, rinfo: RemoteInfo) => void): Socket;
+    interface SocketEventMap {
+        "close": [
+        ];
+        "connect": [
+        ];
+        "error": [
+            err: Error
+        ];
+        "listening": [
+        ];
+        "message": [
+            msg: NonSharedBuffer,
+            rinfo: RemoteInfo
+        ];
+    }
+    class Socket implements 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;
+        connect(port: number, address?: string, callback?: () => void): void;
+        connect(port: number, callback: () => void): void;
+        disconnect(): void;
+        dropMembership(multicastAddress: string, multicastInterface?: string): void;
+        getRecvBufferSize(): number;
+        getSendBufferSize(): number;
+        getSendQueueSize(): number;
+        getSendQueueCount(): number;
+        ref(): this;
+        remoteAddress(): AddressInfo;
+        send(msg: string | NodeJS.ArrayBufferView | readonly any[], port?: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
+        send(msg: string | NodeJS.ArrayBufferView | readonly any[], port?: number, callback?: (error: Error | null, bytes: number) => void): void;
+        send(msg: string | NodeJS.ArrayBufferView | readonly any[], callback?: (error: Error | null, bytes: number) => void): void;
+        send(msg: string | NodeJS.ArrayBufferView, offset: number, length: number, port?: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
+        send(msg: string | NodeJS.ArrayBufferView, offset: number, length: number, port?: number, callback?: (error: Error | null, bytes: number) => void): void;
+        send(msg: string | NodeJS.ArrayBufferView, 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;
+        setRecvBufferSize(size: number): void;
+        setSendBufferSize(size: number): void;
+        setTTL(ttl: number): number;
+        unref(): this;
+        addSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string): void;
+        dropSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string): void;
+        [Symbol.asyncDispose](): Promise<void>;
+    }
+    interface Socket extends InternalEventEmitter<SocketEventMap> {
+    }
+}
+declare module "dgram" {
+    export * from "node:dgram";
+}

package/types/node/diagnostics_channel.d.ts

@@ -0,0 +1,61 @@
+declare module "node:diagnostics_channel" {
+    import { AsyncLocalStorage } from "node:async_hooks";
+    function hasSubscribers(name: string | symbol): boolean;
+    function channel(name: string | symbol): Channel;
+    type ChannelListener = (message: unknown, name: string | symbol) => void;
+    function subscribe(name: string | symbol, onMessage: ChannelListener): void;
+    function unsubscribe(name: string | symbol, onMessage: ChannelListener): boolean;
+    function tracingChannel<StoreType = unknown, ContextType extends object = StoreType extends object ? StoreType : object>(nameOrChannels: string | TracingChannelCollection<StoreType, ContextType>): TracingChannel<StoreType, ContextType>;
+    class Channel<StoreType = unknown, ContextType = StoreType> {
+        readonly name: string | symbol;
+        readonly hasSubscribers: boolean;
+        private constructor(name: string | symbol);
+        publish(message: unknown): void;
+        subscribe(onMessage: ChannelListener): void;
+        unsubscribe(onMessage: ChannelListener): void;
+        bindStore(store: AsyncLocalStorage<StoreType>, transform?: (context: ContextType) => StoreType): void;
+        unbindStore(store: AsyncLocalStorage<StoreType>): boolean;
+        runStores<ThisArg = any, Args extends any[] = any[], Result = any>(context: ContextType, fn: (this: ThisArg, ...args: Args) => Result, thisArg?: ThisArg, ...args: Args): Result;
+    }
+    interface TracingChannelSubscribers<ContextType extends object> {
+        start: (message: ContextType) => void;
+        end: (message: ContextType & {
+            error?: unknown;
+            result?: unknown;
+        }) => void;
+        asyncStart: (message: ContextType & {
+            error?: unknown;
+            result?: unknown;
+        }) => void;
+        asyncEnd: (message: ContextType & {
+            error?: unknown;
+            result?: unknown;
+        }) => void;
+        error: (message: ContextType & {
+            error: unknown;
+        }) => void;
+    }
+    interface TracingChannelCollection<StoreType = unknown, ContextType = StoreType> {
+        start: Channel<StoreType, ContextType>;
+        end: Channel<StoreType, ContextType>;
+        asyncStart: Channel<StoreType, ContextType>;
+        asyncEnd: Channel<StoreType, ContextType>;
+        error: Channel<StoreType, ContextType>;
+    }
+    class TracingChannel<StoreType = unknown, ContextType extends object = {}> implements TracingChannelCollection {
+        start: Channel<StoreType, ContextType>;
+        end: Channel<StoreType, ContextType>;
+        asyncStart: Channel<StoreType, ContextType>;
+        asyncEnd: Channel<StoreType, ContextType>;
+        error: Channel<StoreType, ContextType>;
+        subscribe(subscribers: TracingChannelSubscribers<ContextType>): void;
+        unsubscribe(subscribers: TracingChannelSubscribers<ContextType>): void;
+        traceSync<ThisArg = any, Args extends any[] = any[], Result = any>(fn: (this: ThisArg, ...args: Args) => Result, context?: ContextType, thisArg?: ThisArg, ...args: Args): Result;
+        tracePromise<ThisArg = any, Args extends any[] = any[], Result = any>(fn: (this: ThisArg, ...args: Args) => Promise<Result>, context?: ContextType, thisArg?: ThisArg, ...args: Args): Promise<Result>;
+        traceCallback<ThisArg = any, Args extends any[] = any[], Result = any>(fn: (this: ThisArg, ...args: Args) => Result, position?: number, context?: ContextType, thisArg?: ThisArg, ...args: Args): Result;
+        readonly hasSubscribers: boolean;
+    }
+}
+declare module "diagnostics_channel" {
+    export * from "node:diagnostics_channel";
+}

package/types/node/dns/promises.d.ts

@@ -0,0 +1,94 @@
+declare module "node:dns/promises" {
+    import { AnyRecord, CaaRecord, LookupAddress, LookupAllOptions, LookupOneOptions, LookupOptions, MxRecord, NaptrRecord, RecordWithTtl, ResolveOptions, ResolverOptions, ResolveWithTtlOptions, SoaRecord, SrvRecord, TlsaRecord, } 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" | "AAAA" | "CNAME" | "NS" | "PTR"): Promise<string[]>;
+    function resolve(hostname: string, rrtype: "ANY"): Promise<AnyRecord[]>;
+    function resolve(hostname: string, rrtype: "CAA"): Promise<CaaRecord[]>;
+    function resolve(hostname: string, rrtype: "MX"): Promise<MxRecord[]>;
+    function resolve(hostname: string, rrtype: "NAPTR"): Promise<NaptrRecord[]>;
+    function resolve(hostname: string, rrtype: "SOA"): Promise<SoaRecord>;
+    function resolve(hostname: string, rrtype: "SRV"): Promise<SrvRecord[]>;
+    function resolve(hostname: string, rrtype: "TLSA"): Promise<TlsaRecord[]>;
+    function resolve(hostname: string, rrtype: "TXT"): Promise<string[][]>;
+    function resolve(hostname: string, rrtype: string): Promise<string[] | CaaRecord[] | MxRecord[] | NaptrRecord[] | SoaRecord | SrvRecord[] | TlsaRecord[] | 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 resolveTlsa(hostname: string): Promise<TlsaRecord[]>;
+    function resolveTxt(hostname: string): Promise<string[][]>;
+    function reverse(ip: string): Promise<string[]>;
+    function getDefaultResultOrder(): "ipv4first" | "verbatim";
+    function setServers(servers: readonly string[]): void;
+    function setDefaultResultOrder(order: "ipv4first" | "ipv6first" | "verbatim"): void;
+    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";
+    class Resolver {
+        constructor(options?: ResolverOptions);
+        cancel(): void;
+        getServers: typeof getServers;
+        resolve: typeof resolve;
+        resolve4: typeof resolve4;
+        resolve6: typeof resolve6;
+        resolveAny: typeof resolveAny;
+        resolveCaa: typeof resolveCaa;
+        resolveCname: typeof resolveCname;
+        resolveMx: typeof resolveMx;
+        resolveNaptr: typeof resolveNaptr;
+        resolveNs: typeof resolveNs;
+        resolvePtr: typeof resolvePtr;
+        resolveSoa: typeof resolveSoa;
+        resolveSrv: typeof resolveSrv;
+        resolveTlsa: typeof resolveTlsa;
+        resolveTxt: typeof resolveTxt;
+        reverse: typeof reverse;
+        setLocalAddress(ipv4?: string, ipv6?: string): void;
+        setServers: typeof setServers;
+    }
+}
+declare module "dns/promises" {
+    export * from "node:dns/promises";
+}

package/types/node/dns.d.ts

@@ -0,0 +1,276 @@
+declare module "node:dns" {
+    const ADDRCONFIG: number;
+    const V4MAPPED: number;
+    const ALL: number;
+    interface LookupOptions {
+        family?: number | "IPv4" | "IPv6" | undefined;
+        hints?: number | undefined;
+        all?: boolean | undefined;
+        order?: "ipv4first" | "ipv6first" | "verbatim" | undefined;
+        verbatim?: boolean | undefined;
+    }
+    interface LookupOneOptions extends LookupOptions {
+        all?: false | undefined;
+    }
+    interface LookupAllOptions extends LookupOptions {
+        all: true;
+    }
+    interface LookupAddress {
+        address: string;
+        family: number;
+    }
+    function lookup(hostname: string, family: number, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void): void;
+    function lookup(hostname: string, options: LookupOneOptions, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void): void;
+    function lookup(hostname: string, options: LookupAllOptions, callback: (err: NodeJS.ErrnoException | null, addresses: LookupAddress[]) => void): void;
+    function lookup(hostname: string, options: LookupOptions, callback: (err: NodeJS.ErrnoException | null, address: string | LookupAddress[], family: number) => void): void;
+    function lookup(hostname: string, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void): void;
+    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[]>;
+    }
+    function lookupService(address: string, port: number, callback: (err: NodeJS.ErrnoException | null, hostname: string, service: string) => void): void;
+    namespace lookupService {
+        function __promisify__(address: string, port: number): Promise<{
+            hostname: string;
+            service: string;
+        }>;
+    }
+    interface ResolveOptions {
+        ttl: boolean;
+    }
+    interface ResolveWithTtlOptions extends ResolveOptions {
+        ttl: true;
+    }
+    interface RecordWithTtl {
+        address: string;
+        ttl: number;
+    }
+    interface AnyARecord extends RecordWithTtl {
+        type: "A";
+    }
+    interface AnyAaaaRecord extends RecordWithTtl {
+        type: "AAAA";
+    }
+    interface CaaRecord {
+        critical: number;
+        issue?: string | undefined;
+        issuewild?: string | undefined;
+        iodef?: string | undefined;
+        contactemail?: string | undefined;
+        contactphone?: string | undefined;
+    }
+    interface AnyCaaRecord extends CaaRecord {
+        type: "CAA";
+    }
+    interface MxRecord {
+        priority: number;
+        exchange: string;
+    }
+    interface AnyMxRecord extends MxRecord {
+        type: "MX";
+    }
+    interface NaptrRecord {
+        flags: string;
+        service: string;
+        regexp: string;
+        replacement: string;
+        order: number;
+        preference: number;
+    }
+    interface AnyNaptrRecord extends NaptrRecord {
+        type: "NAPTR";
+    }
+    interface SoaRecord {
+        nsname: string;
+        hostmaster: string;
+        serial: number;
+        refresh: number;
+        retry: number;
+        expire: number;
+        minttl: number;
+    }
+    interface AnySoaRecord extends SoaRecord {
+        type: "SOA";
+    }
+    interface SrvRecord {
+        priority: number;
+        weight: number;
+        port: number;
+        name: string;
+    }
+    interface AnySrvRecord extends SrvRecord {
+        type: "SRV";
+    }
+    interface TlsaRecord {
+        certUsage: number;
+        selector: number;
+        match: number;
+        data: ArrayBuffer;
+    }
+    interface AnyTlsaRecord extends TlsaRecord {
+        type: "TLSA";
+    }
+    interface AnyTxtRecord {
+        type: "TXT";
+        entries: string[];
+    }
+    interface AnyNsRecord {
+        type: "NS";
+        value: string;
+    }
+    interface AnyPtrRecord {
+        type: "PTR";
+        value: string;
+    }
+    interface AnyCnameRecord {
+        type: "CNAME";
+        value: string;
+    }
+    type AnyRecord = AnyARecord | AnyAaaaRecord | AnyCaaRecord | AnyCnameRecord | AnyMxRecord | AnyNaptrRecord | AnyNsRecord | AnyPtrRecord | AnySoaRecord | AnySrvRecord | AnyTlsaRecord | AnyTxtRecord;
+    function resolve(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
+    function resolve(hostname: string, rrtype: "A" | "AAAA" | "CNAME" | "NS" | "PTR", callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
+    function resolve(hostname: string, rrtype: "ANY", callback: (err: NodeJS.ErrnoException | null, addresses: AnyRecord[]) => void): void;
+    function resolve(hostname: string, rrtype: "CAA", callback: (err: NodeJS.ErrnoException | null, address: CaaRecord[]) => void): void;
+    function resolve(hostname: string, rrtype: "MX", callback: (err: NodeJS.ErrnoException | null, addresses: MxRecord[]) => void): void;
+    function resolve(hostname: string, rrtype: "NAPTR", callback: (err: NodeJS.ErrnoException | null, addresses: NaptrRecord[]) => void): void;
+    function resolve(hostname: string, rrtype: "SOA", callback: (err: NodeJS.ErrnoException | null, addresses: SoaRecord) => void): void;
+    function resolve(hostname: string, rrtype: "SRV", callback: (err: NodeJS.ErrnoException | null, addresses: SrvRecord[]) => void): void;
+    function resolve(hostname: string, rrtype: "TLSA", callback: (err: NodeJS.ErrnoException | null, addresses: TlsaRecord[]) => void): void;
+    function resolve(hostname: string, rrtype: "TXT", callback: (err: NodeJS.ErrnoException | null, addresses: string[][]) => void): void;
+    function resolve(hostname: string, rrtype: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[] | CaaRecord[] | MxRecord[] | NaptrRecord[] | SoaRecord | SrvRecord[] | TlsaRecord[] | string[][] | AnyRecord[]) => void): void;
+    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[]>;
+        function __promisify__(hostname: string, rrtype: "MX"): Promise<MxRecord[]>;
+        function __promisify__(hostname: string, rrtype: "NAPTR"): Promise<NaptrRecord[]>;
+        function __promisify__(hostname: string, rrtype: "SOA"): Promise<SoaRecord>;
+        function __promisify__(hostname: string, rrtype: "SRV"): Promise<SrvRecord[]>;
+        function __promisify__(hostname: string, rrtype: "TLSA"): Promise<TlsaRecord[]>;
+        function __promisify__(hostname: string, rrtype: "TXT"): Promise<string[][]>;
+        function __promisify__(hostname: string, rrtype: string): Promise<string[] | CaaRecord[] | MxRecord[] | NaptrRecord[] | SoaRecord | SrvRecord[] | TlsaRecord[] | string[][] | AnyRecord[]>;
+    }
+    function resolve4(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
+    function resolve4(hostname: string, options: ResolveWithTtlOptions, callback: (err: NodeJS.ErrnoException | null, addresses: RecordWithTtl[]) => void): void;
+    function resolve4(hostname: string, options: ResolveOptions, callback: (err: NodeJS.ErrnoException | null, addresses: string[] | RecordWithTtl[]) => void): void;
+    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[]>;
+    }
+    function resolve6(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
+    function resolve6(hostname: string, options: ResolveWithTtlOptions, callback: (err: NodeJS.ErrnoException | null, addresses: RecordWithTtl[]) => void): void;
+    function resolve6(hostname: string, options: ResolveOptions, callback: (err: NodeJS.ErrnoException | null, addresses: string[] | RecordWithTtl[]) => void): void;
+    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[]>;
+    }
+    function resolveCname(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
+    namespace resolveCname {
+        function __promisify__(hostname: string): Promise<string[]>;
+    }
+    function resolveCaa(hostname: string, callback: (err: NodeJS.ErrnoException | null, records: CaaRecord[]) => void): void;
+    namespace resolveCaa {
+        function __promisify__(hostname: string): Promise<CaaRecord[]>;
+    }
+    function resolveMx(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: MxRecord[]) => void): void;
+    namespace resolveMx {
+        function __promisify__(hostname: string): Promise<MxRecord[]>;
+    }
+    function resolveNaptr(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: NaptrRecord[]) => void): void;
+    namespace resolveNaptr {
+        function __promisify__(hostname: string): Promise<NaptrRecord[]>;
+    }
+    function resolveNs(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
+    namespace resolveNs {
+        function __promisify__(hostname: string): Promise<string[]>;
+    }
+    function resolvePtr(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
+    namespace resolvePtr {
+        function __promisify__(hostname: string): Promise<string[]>;
+    }
+    function resolveSoa(hostname: string, callback: (err: NodeJS.ErrnoException | null, address: SoaRecord) => void): void;
+    namespace resolveSoa {
+        function __promisify__(hostname: string): Promise<SoaRecord>;
+    }
+    function resolveSrv(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: SrvRecord[]) => void): void;
+    namespace resolveSrv {
+        function __promisify__(hostname: string): Promise<SrvRecord[]>;
+    }
+    function resolveTlsa(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: TlsaRecord[]) => void): void;
+    namespace resolveTlsa {
+        function __promisify__(hostname: string): Promise<TlsaRecord[]>;
+    }
+    function resolveTxt(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[][]) => void): void;
+    namespace resolveTxt {
+        function __promisify__(hostname: string): Promise<string[][]>;
+    }
+    function resolveAny(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: AnyRecord[]) => void): void;
+    namespace resolveAny {
+        function __promisify__(hostname: string): Promise<AnyRecord[]>;
+    }
+    function reverse(ip: string, callback: (err: NodeJS.ErrnoException | null, hostnames: string[]) => void): void;
+    function getDefaultResultOrder(): "ipv4first" | "ipv6first" | "verbatim";
+    function setServers(servers: readonly string[]): void;
+    function getServers(): string[];
+    function setDefaultResultOrder(order: "ipv4first" | "ipv6first" | "verbatim"): void;
+    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 {
+        timeout?: number | undefined;
+        tries?: number | undefined;
+        maxTimeout?: number | undefined;
+    }
+    class Resolver {
+        constructor(options?: ResolverOptions);
+        cancel(): void;
+        getServers: typeof getServers;
+        resolve: typeof resolve;
+        resolve4: typeof resolve4;
+        resolve6: typeof resolve6;
+        resolveAny: typeof resolveAny;
+        resolveCaa: typeof resolveCaa;
+        resolveCname: typeof resolveCname;
+        resolveMx: typeof resolveMx;
+        resolveNaptr: typeof resolveNaptr;
+        resolveNs: typeof resolveNs;
+        resolvePtr: typeof resolvePtr;
+        resolveSoa: typeof resolveSoa;
+        resolveSrv: typeof resolveSrv;
+        resolveTlsa: typeof resolveTlsa;
+        resolveTxt: typeof resolveTxt;
+        reverse: typeof reverse;
+        setLocalAddress(ipv4?: string, ipv6?: string): void;
+        setServers: typeof setServers;
+    }
+}
+declare module "node:dns" {
+    export * as promises from "node:dns/promises";
+}
+declare module "dns" {
+    export * from "node:dns";
+}

package/types/node/domain.d.ts

@@ -0,0 +1,17 @@
+declare module "node:domain" {
+    import { EventEmitter } from "node:events";
+    class Domain extends EventEmitter {
+        members: EventEmitter[];
+        enter(): void;
+        exit(): void;
+        run<T>(fn: (...args: any[]) => T, ...args: any[]): T;
+        add(emitter: EventEmitter): void;
+        remove(emitter: EventEmitter): void;
+        bind<T extends Function>(callback: T): T;
+        intercept<T extends Function>(callback: T): T;
+    }
+    function create(): Domain;
+}
+declare module "domain" {
+    export * from "node:domain";
+}