yq-dns 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -0,0 +1,1611 @@
+import { AnyARecord, AnyAaaaRecord, AnyCnameRecord, AnyMxRecord, AnyNaptrRecord, AnyNsRecord, AnyPtrRecord, AnySoaRecord, AnySrvRecord, AnyTlsaRecord, AnyTxtRecord, CaaRecord, MxRecord, NaptrRecord, RecordWithTtl, ResolveOptions, ResolveWithTtlOptions, SoaRecord, SrvRecord, TlsaRecord } from 'node:dns';
+
+/**
+ * Configuration for a DNS provider's concurrency and rate limiting.
+ */
+export interface ProviderConfig {
+	/**
+	 * Concurrency and rate limiting configuration.
+	 * Can be either a simple concurrency limit or include interval-based rate limiting.
+	 */
+	limit?: {
+		/** Maximum number of concurrent requests */
+		concurrency: number;
+		/** Time interval in milliseconds for rate limiting */
+		interval?: number;
+		/** Maximum number of requests per interval */
+		intervalCap?: number;
+		/**
+		 * Whether to carry over the concurrency count from the previous interval.
+		 * @default false
+		 */
+		carryoverConcurrencyCount?: boolean;
+	};
+	/**
+	 * Whether this provider is enabled.
+	 * @default true
+	 */
+	enabled?: boolean;
+}
+/**
+ * Configuration for all DNS providers.
+ */
+export interface YqConfig {
+	/** Configuration for the native Node.js DNS resolver */
+	native?: ProviderConfig;
+	/** Configuration for Google DNS-over-HTTPS */
+	google?: ProviderConfig;
+	/** Configuration for Cloudflare DNS-over-HTTPS */
+	cloudflare?: ProviderConfig;
+	/** Configuration for Quad9 DNS-over-HTTPS */
+	quad9?: ProviderConfig;
+}
+/**
+ * Union type of all possible DNS record types returned by ANY queries.
+ */
+export type AnyRecord = AnyARecord | AnyAaaaRecord | AnyCnameRecord | AnyMxRecord | AnyNaptrRecord | AnyNsRecord | AnyPtrRecord | AnySoaRecord | AnySrvRecord | AnyTlsaRecord | AnyTxtRecord;
+/**
+ * Available DNS provider names.
+ */
+export type ProviderName = "native" | "google" | "cloudflare" | "quad9";
+/**
+ * DNS record types supported by the resolver.
+ */
+export type RecordType = "A" | "AAAA" | "ANY" | "CAA" | "CNAME" | "MX" | "NAPTR" | "NS" | "PTR" | "SOA" | "SRV" | "TLSA" | "TXT";
+/**
+ * Error thrown when no providers are enabled.
+ */
+export declare class NoEnabledProvidersError extends Error {
+	constructor();
+}
+/**
+ * Error thrown when an invalid hostname is provided.
+ */
+export declare class InvalidHostnameError extends Error {
+	constructor(hostname: string);
+}
+/**
+ * Error thrown when a provider is not enabled.
+ */
+export declare class ProviderNotEnabledError extends Error {
+	constructor(provider: string);
+}
+/**
+ * Error thrown when an invalid provider name is specified.
+ */
+export declare class InvalidProviderError extends Error {
+	constructor(provider: string);
+}
+export interface IResolver {
+	/**
+	 * Resolves DNS records for a hostname without specifying record type (defaults to A records)
+	 * @param hostname - The hostname to resolve
+	 * @returns Promise resolving to an array of IPv4 addresses
+	 */
+	resolve(hostname: string): Promise<string[]>;
+	/**
+	 * Resolves DNS records for a hostname without specifying record type but with a specific provider
+	 * @param hostname - The hostname to resolve
+	 * @param provider - The DNS provider to use
+	 * @returns Promise resolving to an array of IPv4 addresses
+	 */
+	resolve(hostname: string, provider: ProviderName): Promise<string[]>;
+	/**
+	 * Resolves A records for a hostname
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "A"
+	 * @returns Promise resolving to an array of IPv4 addresses
+	 */
+	resolve(hostname: string, rrtype: "A"): Promise<string[]>;
+	/**
+	 * Resolves A records for a hostname with a specific provider
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "A"
+	 * @param provider - The DNS provider to use
+	 * @returns Promise resolving to an array of IPv4 addresses
+	 */
+	resolve(hostname: string, rrtype: "A", provider: ProviderName): Promise<string[]>;
+	/**
+	 * Resolves AAAA records for a hostname
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "AAAA"
+	 * @returns Promise resolving to an array of IPv6 addresses
+	 */
+	resolve(hostname: string, rrtype: "AAAA"): Promise<string[]>;
+	/**
+	 * Resolves AAAA records for a hostname with a specific provider
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "AAAA"
+	 * @param provider - The DNS provider to use
+	 * @returns Promise resolving to an array of IPv6 addresses
+	 */
+	resolve(hostname: string, rrtype: "AAAA", provider: ProviderName): Promise<string[]>;
+	/**
+	 * Resolves ANY records for a hostname
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "ANY"
+	 * @returns Promise resolving to an array of any DNS records
+	 */
+	resolve(hostname: string, rrtype: "ANY"): Promise<AnyRecord[]>;
+	/**
+	 * Resolves ANY records for a hostname with a specific provider
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "ANY"
+	 * @param provider - The DNS provider to use
+	 * @returns Promise resolving to an array of any DNS records
+	 */
+	resolve(hostname: string, rrtype: "ANY", provider: ProviderName): Promise<AnyRecord[]>;
+	/**
+	 * Resolves CAA records for a hostname
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "CAA"
+	 * @returns Promise resolving to an array of CAA records
+	 */
+	resolve(hostname: string, rrtype: "CAA"): Promise<CaaRecord[]>;
+	/**
+	 * Resolves CAA records for a hostname with a specific provider
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "CAA"
+	 * @param provider - The DNS provider to use
+	 * @returns Promise resolving to an array of CAA records
+	 */
+	resolve(hostname: string, rrtype: "CAA", provider: ProviderName): Promise<CaaRecord[]>;
+	/**
+	 * Resolves CNAME records for a hostname
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "CNAME"
+	 * @returns Promise resolving to an array of canonical names
+	 */
+	resolve(hostname: string, rrtype: "CNAME"): Promise<string[]>;
+	/**
+	 * Resolves CNAME records for a hostname with a specific provider
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "CNAME"
+	 * @param provider - The DNS provider to use
+	 * @returns Promise resolving to an array of canonical names
+	 */
+	resolve(hostname: string, rrtype: "CNAME", provider: ProviderName): Promise<string[]>;
+	/**
+	 * Resolves MX records for a hostname
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "MX"
+	 * @returns Promise resolving to an array of mail exchange records
+	 */
+	resolve(hostname: string, rrtype: "MX"): Promise<MxRecord[]>;
+	/**
+	 * Resolves MX records for a hostname with a specific provider
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "MX"
+	 * @param provider - The DNS provider to use
+	 * @returns Promise resolving to an array of mail exchange records
+	 */
+	resolve(hostname: string, rrtype: "MX", provider: ProviderName): Promise<MxRecord[]>;
+	/**
+	 * Resolves NAPTR records for a hostname
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "NAPTR"
+	 * @returns Promise resolving to an array of NAPTR records
+	 */
+	resolve(hostname: string, rrtype: "NAPTR"): Promise<NaptrRecord[]>;
+	/**
+	 * Resolves NAPTR records for a hostname with a specific provider
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "NAPTR"
+	 * @param provider - The DNS provider to use
+	 * @returns Promise resolving to an array of NAPTR records
+	 */
+	resolve(hostname: string, rrtype: "NAPTR", provider: ProviderName): Promise<NaptrRecord[]>;
+	/**
+	 * Resolves NS records for a hostname
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "NS"
+	 * @returns Promise resolving to an array of nameserver hostnames
+	 */
+	resolve(hostname: string, rrtype: "NS"): Promise<string[]>;
+	/**
+	 * Resolves NS records for a hostname with a specific provider
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "NS"
+	 * @param provider - The DNS provider to use
+	 * @returns Promise resolving to an array of nameserver hostnames
+	 */
+	resolve(hostname: string, rrtype: "NS", provider: ProviderName): Promise<string[]>;
+	/**
+	 * Resolves PTR records for a hostname
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "PTR"
+	 * @returns Promise resolving to an array of pointer records
+	 */
+	resolve(hostname: string, rrtype: "PTR"): Promise<string[]>;
+	/**
+	 * Resolves PTR records for a hostname with a specific provider
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "PTR"
+	 * @param provider - The DNS provider to use
+	 * @returns Promise resolving to an array of pointer records
+	 */
+	resolve(hostname: string, rrtype: "PTR", provider: ProviderName): Promise<string[]>;
+	/**
+	 * Resolves SOA record for a hostname
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "SOA"
+	 * @returns Promise resolving to a start of authority record
+	 */
+	resolve(hostname: string, rrtype: "SOA"): Promise<SoaRecord>;
+	/**
+	 * Resolves SOA record for a hostname with a specific provider
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "SOA"
+	 * @param provider - The DNS provider to use
+	 * @returns Promise resolving to a start of authority record
+	 */
+	resolve(hostname: string, rrtype: "SOA", provider: ProviderName): Promise<SoaRecord>;
+	/**
+	 * Resolves SRV records for a hostname
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "SRV"
+	 * @returns Promise resolving to an array of service records
+	 */
+	resolve(hostname: string, rrtype: "SRV"): Promise<SrvRecord[]>;
+	/**
+	 * Resolves SRV records for a hostname with a specific provider
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "SRV"
+	 * @param provider - The DNS provider to use
+	 * @returns Promise resolving to an array of service records
+	 */
+	resolve(hostname: string, rrtype: "SRV", provider: ProviderName): Promise<SrvRecord[]>;
+	/**
+	 * Resolves TLSA records for a hostname
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "TLSA"
+	 * @returns Promise resolving to an array of TLSA records
+	 */
+	resolve(hostname: string, rrtype: "TLSA"): Promise<TlsaRecord[]>;
+	/**
+	 * Resolves TLSA records for a hostname with a specific provider
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "TLSA"
+	 * @param provider - The DNS provider to use
+	 * @returns Promise resolving to an array of TLSA records
+	 */
+	resolve(hostname: string, rrtype: "TLSA", provider: ProviderName): Promise<TlsaRecord[]>;
+	/**
+	 * Resolves TXT records for a hostname
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "TXT"
+	 * @returns Promise resolving to an array of text record arrays
+	 */
+	resolve(hostname: string, rrtype: "TXT"): Promise<string[][]>;
+	/**
+	 * Resolves TXT records for a hostname with a specific provider
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - DNS record type "TXT"
+	 * @param provider - The DNS provider to use
+	 * @returns Promise resolving to an array of text record arrays
+	 */
+	resolve(hostname: string, rrtype: "TXT", provider: ProviderName): Promise<string[][]>;
+	/**
+	 * Uses the DNS protocol to resolve IPv4 addresses (`A` records) for the `hostname`. On success, the `Promise` is resolved with an array of IPv4
+	 * addresses (e.g. `['74.125.79.104', '74.125.79.105', '74.125.79.106']`).
+	 * @since v10.6.0
+	 * @param hostname Host name to resolve.
+	 */
+	resolve4(hostname: string): Promise<string[]>;
+	resolve4(hostname: string, options: ResolveWithTtlOptions): Promise<RecordWithTtl[]>;
+	resolve4(hostname: string, options: ResolveOptions): Promise<string[] | RecordWithTtl[]>;
+	/**
+	 * Uses the DNS protocol to resolve IPv4 addresses (`A` records) for the `hostname` using a specific provider.
+	 * @param hostname Host name to resolve.
+	 * @param provider The DNS provider to use for resolution.
+	 */
+	resolve4(hostname: string, provider: ProviderName): Promise<string[]>;
+	/**
+	 * Uses the DNS protocol to resolve IPv4 addresses (`A` records) for the `hostname` with TTL using a specific provider.
+	 * @param hostname Host name to resolve.
+	 * @param options Resolution options with TTL enabled.
+	 * @param provider The DNS provider to use for resolution.
+	 */
+	resolve4(hostname: string, options: ResolveWithTtlOptions, provider: ProviderName): Promise<RecordWithTtl[]>;
+	/**
+	 * Uses the DNS protocol to resolve IPv4 addresses (`A` records) for the `hostname` with options using a specific provider.
+	 * @param hostname Host name to resolve.
+	 * @param options Resolution options.
+	 * @param provider The DNS provider to use for resolution.
+	 */
+	resolve4(hostname: string, options: ResolveOptions, provider: ProviderName): Promise<string[] | RecordWithTtl[]>;
+	/**
+	 * Uses the DNS protocol to resolve IPv6 addresses (`AAAA` records) for the `hostname`. On success, the `Promise` is resolved with an array of IPv6
+	 * addresses.
+	 * @since v10.6.0
+	 * @param hostname Host name to resolve.
+	 */
+	resolve6(hostname: string): Promise<string[]>;
+	resolve6(hostname: string, options: ResolveWithTtlOptions): Promise<RecordWithTtl[]>;
+	resolve6(hostname: string, options: ResolveOptions): Promise<string[] | RecordWithTtl[]>;
+	/**
+	 * Uses the DNS protocol to resolve IPv6 addresses (`AAAA` records) for the `hostname` using a specific provider.
+	 * @param hostname Host name to resolve.
+	 * @param provider The DNS provider to use for resolution.
+	 */
+	resolve6(hostname: string, provider: ProviderName): Promise<string[]>;
+	/**
+	 * Uses the DNS protocol to resolve IPv6 addresses (`AAAA` records) for the `hostname` with TTL using a specific provider.
+	 * @param hostname Host name to resolve.
+	 * @param options Resolution options with TTL enabled.
+	 * @param provider The DNS provider to use for resolution.
+	 */
+	resolve6(hostname: string, options: ResolveWithTtlOptions, provider: ProviderName): Promise<RecordWithTtl[]>;
+	/**
+	 * Uses the DNS protocol to resolve IPv6 addresses (`AAAA` records) for the `hostname` with options using a specific provider.
+	 * @param hostname Host name to resolve.
+	 * @param options Resolution options.
+	 * @param provider The DNS provider to use for resolution.
+	 */
+	resolve6(hostname: string, options: ResolveOptions, provider: ProviderName): Promise<string[] | RecordWithTtl[]>;
+	/**
+	 * 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 of
+	 * records. Each object has a property `type` that indicates the type of the
+	 * current record. And depending on the `type`, additional properties will be
+	 * present on the object:
+	 *
+	 * <omitted>
+	 *
+	 * Here is an example of the result object:
+	 *
+	 * ```js
+	 * [ { type: 'A', address: '127.0.0.1', ttl: 299 },
+	 *   { type: 'CNAME', value: 'example.com' },
+	 *   { type: 'MX', exchange: 'alt4.aspmx.l.example.com', priority: 50 },
+	 *   { type: 'NS', value: 'ns1.example.com' },
+	 *   { type: 'TXT', entries: [ 'v=spf1 include:_spf.example.com ~all' ] },
+	 *   { type: 'SOA',
+	 *     nsname: 'ns1.example.com',
+	 *     hostmaster: 'admin.example.com',
+	 *     serial: 156696742,
+	 *     refresh: 900,
+	 *     retry: 900,
+	 *     expire: 1800,
+	 *     minttl: 60 } ]
+	 * ```
+	 * @since v10.6.0
+	 */
+	resolveAny(hostname: string): Promise<AnyRecord[]>;
+	/**
+	 * Uses the DNS protocol to resolve all records (also known as `ANY` or `*` query) using a specific provider.
+	 * @param hostname Host name to resolve.
+	 * @param provider The DNS provider to use for resolution.
+	 */
+	resolveAny(hostname: string, provider: ProviderName): Promise<AnyRecord[]>;
+	/**
+	 * Uses the DNS protocol to resolve `CAA` records for the `hostname`. On success,
+	 * the `Promise` is resolved with an array of objects containing available
+	 * certification authority authorization records 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
+	 */
+	resolveCaa(hostname: string): Promise<CaaRecord[]>;
+	/**
+	 * Uses the DNS protocol to resolve `CAA` records for the `hostname` using a specific provider.
+	 * @param hostname Host name to resolve.
+	 * @param provider The DNS provider to use for resolution.
+	 */
+	resolveCaa(hostname: string, provider: ProviderName): Promise<CaaRecord[]>;
+	/**
+	 * 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 for
+	 * the `hostname` (e.g. `['bar.example.com']`).
+	 * @since v10.6.0
+	 */
+	resolveCname(hostname: string): Promise<string[]>;
+	/**
+	 * Uses the DNS protocol to resolve `CNAME` records for the `hostname` using a specific provider.
+	 * @param hostname Host name to resolve.
+	 * @param provider The DNS provider to use for resolution.
+	 */
+	resolveCname(hostname: string, provider: ProviderName): Promise<string[]>;
+	/**
+	 * Uses the DNS protocol to resolve mail exchange records (`MX` records) for the `hostname`. On success, the `Promise` is resolved with an array of objects
+	 * containing both a `priority` and `exchange` property (e.g.`[{priority: 10, exchange: 'mx.example.com'}, ...]`).
+	 * @since v10.6.0
+	 */
+	resolveMx(hostname: string): Promise<MxRecord[]>;
+	/**
+	 * Uses the DNS protocol to resolve mail exchange records (`MX` records) for the `hostname` using a specific provider.
+	 * @param hostname Host name to resolve.
+	 * @param provider The DNS provider to use for resolution.
+	 */
+	resolveMx(hostname: string, provider: ProviderName): Promise<MxRecord[]>;
+	/**
+	 * Uses the DNS protocol to resolve regular expression-based records (`NAPTR` records) for the `hostname`. On success, the `Promise` is resolved with an array
+	 * of objects with the following properties:
+	 *
+	 * * `flags`
+	 * * `service`
+	 * * `regexp`
+	 * * `replacement`
+	 * * `order`
+	 * * `preference`
+	 *
+	 * ```js
+	 * {
+	 *   flags: 's',
+	 *   service: 'SIP+D2U',
+	 *   regexp: '',
+	 *   replacement: '_sip._udp.example.com',
+	 *   order: 30,
+	 *   preference: 100
+	 * }
+	 * ```
+	 * @since v10.6.0
+	 */
+	resolveNaptr(hostname: string): Promise<NaptrRecord[]>;
+	/**
+	 * Uses the DNS protocol to resolve regular expression-based records (`NAPTR` records) for the `hostname` using a specific provider.
+	 * @param hostname Host name to resolve.
+	 * @param provider The DNS provider to use for resolution.
+	 */
+	resolveNaptr(hostname: string, provider: ProviderName): Promise<NaptrRecord[]>;
+	/**
+	 * 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 server
+	 * records available for `hostname` (e.g.`['ns1.example.com', 'ns2.example.com']`).
+	 * @since v10.6.0
+	 */
+	resolveNs(hostname: string): Promise<string[]>;
+	/**
+	 * Uses the DNS protocol to resolve name server records (`NS` records) for the `hostname` using a specific provider.
+	 * @param hostname Host name to resolve.
+	 * @param provider The DNS provider to use for resolution.
+	 */
+	resolveNs(hostname: string, provider: ProviderName): Promise<string[]>;
+	/**
+	 * Uses the DNS protocol to resolve pointer records (`PTR` records) for the `hostname`. On success, the `Promise` is resolved with an array of strings
+	 * containing the reply records.
+	 * @since v10.6.0
+	 */
+	resolvePtr(hostname: string): Promise<string[]>;
+	/**
+	 * Uses the DNS protocol to resolve pointer records (`PTR` records) for the `hostname` using a specific provider.
+	 * @param hostname Host name to resolve.
+	 * @param provider The DNS provider to use for resolution.
+	 */
+	resolvePtr(hostname: string, provider: ProviderName): Promise<string[]>;
+	/**
+	 * Uses the DNS protocol to resolve a start of authority record (`SOA` record) for
+	 * the `hostname`. On success, the `Promise` is resolved with an object with the
+	 * following properties:
+	 *
+	 * * `nsname`
+	 * * `hostmaster`
+	 * * `serial`
+	 * * `refresh`
+	 * * `retry`
+	 * * `expire`
+	 * * `minttl`
+	 *
+	 * ```js
+	 * {
+	 *   nsname: 'ns.example.com',
+	 *   hostmaster: 'root.example.com',
+	 *   serial: 2013101809,
+	 *   refresh: 10000,
+	 *   retry: 2400,
+	 *   expire: 604800,
+	 *   minttl: 3600
+	 * }
+	 * ```
+	 * @since v10.6.0
+	 */
+	resolveSoa(hostname: string): Promise<SoaRecord>;
+	/**
+	 * Uses the DNS protocol to resolve a start of authority record (`SOA` record) for the `hostname` using a specific provider.
+	 * @param hostname Host name to resolve.
+	 * @param provider The DNS provider to use for resolution.
+	 */
+	resolveSoa(hostname: string, provider: ProviderName): Promise<SoaRecord>;
+	/**
+	 * Uses the DNS protocol to resolve service records (`SRV` records) for the `hostname`. On success, the `Promise` is resolved with an array of objects with
+	 * the following properties:
+	 *
+	 * * `priority`
+	 * * `weight`
+	 * * `port`
+	 * * `name`
+	 *
+	 * ```js
+	 * {
+	 *   priority: 10,
+	 *   weight: 5,
+	 *   port: 21223,
+	 *   name: 'service.example.com'
+	 * }
+	 * ```
+	 * @since v10.6.0
+	 */
+	resolveSrv(hostname: string): Promise<SrvRecord[]>;
+	/**
+	 * Uses the DNS protocol to resolve service records (`SRV` records) for the `hostname` using a specific provider.
+	 * @param hostname Host name to resolve.
+	 * @param provider The DNS provider to use for resolution.
+	 */
+	resolveSrv(hostname: string, provider: ProviderName): Promise<SrvRecord[]>;
+	/**
+	 * Uses the DNS protocol to resolve certificate associations (`TLSA` records) for
+	 * the `hostname`. On success, the `Promise` is resolved with an array of objectsAdd commentMore actions
+	 * with these properties:
+	 *
+	 * * `certUsage`
+	 * * `selector`
+	 * * `match`
+	 * * `data`
+	 *
+	 * ```js
+	 * {
+	 *   certUsage: 3,
+	 *   selector: 1,
+	 *   match: 1,
+	 *   data: [ArrayBuffer]
+	 * }
+	 * ```
+	 * @since v23.9.0, v22.15.0
+	 */
+	resolveTlsa(hostname: string): Promise<TlsaRecord[]>;
+	/**
+	 * Uses the DNS protocol to resolve certificate associations (`TLSA` records) for the `hostname` using a specific provider.
+	 * @param hostname Host name to resolve.
+	 * @param provider The DNS provider to use for resolution.
+	 */
+	resolveTlsa(hostname: string, provider: ProviderName): Promise<TlsaRecord[]>;
+	/**
+	 * Uses the DNS protocol to resolve text queries (`TXT` records) for the `hostname`. On success, the `Promise` is resolved with a two-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 of
+	 * one record. Depending on the use case, these could be either joined together or
+	 * treated separately.
+	 * @since v10.6.0
+	 */
+	resolveTxt(hostname: string): Promise<string[][]>;
+	/**
+	 * Uses the DNS protocol to resolve text queries (`TXT` records) for the `hostname` using a specific provider.
+	 * @param hostname Host name to resolve.
+	 * @param provider The DNS provider to use for resolution.
+	 */
+	resolveTxt(hostname: string, provider: ProviderName): Promise<string[][]>;
+	/**
+	 * Performs a reverse DNS query that resolves an IPv4 or IPv6 address to an
+	 * array of host names.
+	 *
+	 * On error, the `Promise` is rejected with an [`Error`](https://nodejs.org/docs/latest-v20.x/api/errors.html#class-error) object, where `err.code`
+	 * is one of the [DNS error codes](https://nodejs.org/docs/latest-v20.x/api/dns.html#error-codes).
+	 * @since v10.6.0
+	 */
+	reverse(ip: string): Promise<string[]>;
+	/**
+	 * Performs a reverse DNS query that resolves an IPv4 or IPv6 address to an array of host names using a specific provider.
+	 * @param ip IPv4 or IPv6 address to reverse resolve.
+	 * @param provider The DNS provider to use for resolution.
+	 */
+	reverse(ip: string, provider: ProviderName): Promise<string[]>;
+}
+declare const records: readonly [
+	{
+		readonly name: "Sohu";
+		readonly mx: "a.sohu.com";
+	},
+	{
+		readonly name: "Sohu";
+		readonly mx: "sohu.com";
+	},
+	{
+		readonly name: "Strato";
+		readonly mx: ".rzone.de";
+	},
+	{
+		readonly name: "Strato";
+		readonly mx: ".strato.de";
+	},
+	{
+		readonly name: "21cn";
+		readonly mx: ".21cn.com";
+	},
+	{
+		readonly name: "163";
+		readonly mx: ".netease.com";
+	},
+	{
+		readonly name: "Netvigator";
+		readonly mx: ".netvigator.com";
+	},
+	{
+		readonly name: "139";
+		readonly mx: ".mail.139.com";
+	},
+	{
+		readonly name: "Nate";
+		readonly mx: ".nate.com";
+	},
+	{
+		readonly name: "Naver";
+		readonly mx: ".naver.com";
+	},
+	{
+		readonly name: "Daum";
+		readonly mx: ".daum.kgslb.com";
+	},
+	{
+		readonly name: "Daum";
+		readonly mx: ".hanmail.net";
+	},
+	{
+		readonly name: "Ziggo";
+		readonly mx: ".ziggo.nl";
+	},
+	{
+		readonly name: "QQ";
+		readonly mx: ".qq.com";
+	},
+	{
+		readonly name: "263.net";
+		readonly mx: "263.net";
+	},
+	{
+		readonly name: "Sina";
+		readonly mx: ".vip.sina.com";
+	},
+	{
+		readonly name: "Sina";
+		readonly mx: ".sina.com.cn";
+	},
+	{
+		readonly name: "Aruba";
+		readonly mx: ".aruba.it";
+	},
+	{
+		readonly name: "Aliyun";
+		readonly mx: ".mxhichina.com";
+	},
+	{
+		readonly name: "Plala Webmail";
+		readonly mx: ".plala.or.jp";
+	},
+	{
+		readonly name: "AOL";
+		readonly mx: "mx-aol.mail";
+	},
+	{
+		readonly name: "Turbify";
+		readonly mx: "mx-biz.mail.am0.yahoodns.net";
+	},
+	{
+		readonly name: "Turbify";
+		readonly mx: "mx-biz.mail.am.yahoodns.net";
+	},
+	{
+		readonly name: "Turbify";
+		readonly mx: "mx-biz.mail.am1.yahoodns.net";
+	},
+	{
+		readonly name: "Turbify";
+		readonly mx: "mx1.biz.mail.yahoo.com";
+	},
+	{
+		readonly name: "Turbify";
+		readonly mx: "mx5.biz.mail.yahoo.com";
+	},
+	{
+		readonly name: "Turbify";
+		readonly mx: ".biz.mail.yahoo.com";
+	},
+	{
+		readonly name: "AT&T";
+		readonly mx: ".prodigy.net";
+	},
+	{
+		readonly name: "Yahoo";
+		readonly mx: ".yahoo.";
+	},
+	{
+		readonly name: "Zoho";
+		readonly mx: ".zoho.com";
+	},
+	{
+		readonly name: "Sitestar Webmail";
+		readonly mx: ".sitestar.everyone.net";
+		readonly webmail: "https://webmail.sitestar.net";
+	},
+	{
+		readonly name: "Outlook Web App (OWA)";
+		readonly mx: ".serverdata.net";
+		readonly webmail: "https://owa.serverdata.net";
+	},
+	{
+		readonly name: "1and1";
+		readonly mx: ".1and1.";
+	},
+	{
+		readonly name: "Outlook";
+		readonly mx: "olc.protection.outlook.com";
+	},
+	{
+		readonly name: "Outlook";
+		readonly mx: ".mail.outlook.com";
+	},
+	{
+		readonly name: "Outlook";
+		readonly mx: ".hotmail.";
+	},
+	{
+		readonly name: "Office 365";
+		readonly mx: "mail.protection.outlook.com";
+	},
+	{
+		readonly name: "Office 365";
+		readonly mx: ".outlook.com";
+	},
+	{
+		readonly name: "Office 365";
+		readonly mx: ".office365.com";
+	},
+	{
+		readonly name: "Gmail";
+		readonly mx: ".google.com";
+	},
+	{
+		readonly name: "Mail.ru";
+		readonly mx: ".mail.ru";
+	},
+	{
+		readonly name: "Mail.com";
+		readonly mx: ".mail.com";
+	},
+	{
+		readonly name: "Earthlink";
+		readonly mx: ".earthlink.net";
+	},
+	{
+		readonly name: "Earthlink";
+		readonly mx: ".oxsus-vadesecure.net";
+	},
+	{
+		readonly name: "Rackspace";
+		readonly mx: ".emailsrvr.com";
+	},
+	{
+		readonly name: "Mimecast";
+		readonly mx: ".mimecast.com";
+	},
+	{
+		readonly name: "Godaddy";
+		readonly mx: ".secureserver.net";
+	},
+	{
+		readonly name: "Comcast";
+		readonly mx: ".comcast.net";
+	},
+	{
+		readonly name: "Office 365";
+		readonly mx: ".ppe-hosted.com";
+	},
+	{
+		readonly name: "Office 365";
+		readonly mx: ".gslb.pphosted.com";
+	},
+	{
+		readonly name: "Office 365";
+		readonly mx: ".arsmtp.com";
+	},
+	{
+		readonly name: "Zoho";
+		readonly mx: ".zoho.com";
+	},
+	{
+		readonly name: "ProtonMail";
+		readonly mx: "mail.protonmail.ch";
+	},
+	{
+		readonly name: "Facebook";
+		readonly mx: ".facebook.com";
+	},
+	{
+		readonly name: "163";
+		readonly mx: ".netease.com";
+	},
+	{
+		readonly name: "163";
+		readonly mx: ".163.com";
+	},
+	{
+		readonly name: "263";
+		readonly mx: ".263.net";
+	},
+	{
+		readonly name: "Aliyun";
+		readonly mx: ".alibaba.com";
+	},
+	{
+		readonly name: "Aliyun";
+		readonly mx: ".aliyun.com";
+	},
+	{
+		readonly name: "Amazon";
+		readonly mx: ".amazon.com";
+	},
+	{
+		readonly name: "Amazon";
+		readonly mx: ".amazonaws.com";
+	},
+	{
+		readonly name: "Anazana";
+		readonly mx: ".anazana.com";
+	},
+	{
+		readonly name: "CoreMail";
+		readonly mx: ".icoremail.net";
+	},
+	{
+		readonly name: "GMX";
+		readonly mx: ".gmx.net";
+	},
+	{
+		readonly name: "GMX";
+		readonly mx: ".gmx.com";
+	},
+	{
+		readonly name: "Hinet";
+		readonly mx: ".hinet.";
+	},
+	{
+		readonly name: "iCloud";
+		readonly mx: ".icloud.com";
+	},
+	{
+		readonly name: "Iinet";
+		readonly mx: ".iinet.net.au";
+	},
+	{
+		readonly name: "Namecheap";
+		readonly mx: ".registrar-servers.com";
+	},
+	{
+		readonly name: "Network Solutions";
+		readonly mx: ".myregisteredsite.com";
+	},
+	{
+		readonly name: "Orange";
+		readonly mx: ".orange.";
+	},
+	{
+		readonly name: "QQ";
+		readonly mx: ".qq.com";
+	},
+	{
+		readonly name: "Synaq";
+		readonly mx: ".synaq.";
+	},
+	{
+		readonly name: "Web.de";
+		readonly mx: ".web.de";
+	},
+	{
+		readonly name: "Yandex";
+		readonly mx: ".yandex.";
+	},
+	{
+		readonly name: "Zmail";
+		readonly mx: ".zmail.";
+	},
+	{
+		readonly name: "Strato";
+		readonly mx: ".strato.de";
+	},
+	{
+		readonly name: "Apple";
+		readonly mx: ".apple.com";
+	},
+	{
+		readonly name: "Cox Webmail";
+		readonly mx: ".cloudfilter.net";
+	},
+	{
+		readonly name: "Fastmail";
+		readonly mx: ".messagingengine.com";
+	},
+	{
+		readonly name: "Mailgun";
+		readonly mx: ".mailgun.org";
+	},
+	{
+		readonly name: "Postmark";
+		readonly mx: ".pmta.postmarkapp.com";
+	},
+	{
+		readonly name: "SendGrid";
+		readonly mx: ".sendgrid.net";
+	},
+	{
+		readonly name: "Elastic Email";
+		readonly mx: ".elasticemail.com";
+	},
+	{
+		readonly name: "Zendesk";
+		readonly mx: ".zendesk.com";
+	},
+	{
+		readonly name: "Intermedia";
+		readonly mx: ".intermedia.net";
+	},
+	{
+		readonly name: "Mailjet";
+		readonly mx: ".mailjet.com";
+	},
+	{
+		readonly name: "Front";
+		readonly mx: ".frontapp.com";
+	},
+	{
+		readonly name: "Unknown";
+		readonly mx: "..................";
+	},
+	{
+		readonly name: "Webmail";
+		readonly mx: "..................";
+	},
+	{
+		readonly name: "Zimbra";
+		readonly mx: "..................";
+	},
+	{
+		readonly name: "Others";
+		readonly mx: "..................";
+	},
+	{
+		readonly name: "Aruba";
+		readonly mx: "..................";
+	},
+	{
+		readonly name: "Alibaba";
+		readonly mx: "..................";
+	},
+	{
+		readonly name: "IBM";
+		readonly mx: "..................";
+	},
+	{
+		readonly name: "Digitalocean";
+		readonly mx: "..................";
+	},
+	{
+		readonly name: "AWS Partner";
+		readonly mx: "..................";
+	},
+	{
+		readonly name: "Microsoft Exchange";
+		readonly mx: "..................";
+	},
+	{
+		readonly name: "Oracle Cloud";
+		readonly mx: "..................";
+	},
+	{
+		readonly name: "Roundcube Webmail";
+		readonly mx: "..................";
+	},
+	{
+		readonly name: "cPanel Webmail";
+		readonly mx: "..................";
+	},
+	{
+		readonly name: "Yahoo (External Provider)";
+		readonly mx: "..................";
+	}
+];
+type ProviderName$1 = typeof records[number]["name"];
+export interface ValidationConfig {
+	/**
+	 * @description This will enable deep validation of the email. slower than normal email validator as it triggers multiple dns requests, or travel to the ip address to get the domain name.
+	 * This is per request option, passing true to the getProvider without turning this ON, it wont work and vice versa.
+	 * @default false
+	 */
+	enableDeepValidation?: boolean;
+	/**
+	 * @description This will enable the ipResolver for the email validator on deep validation.
+	 * @default undefined
+	 */
+	ipResolver?: {
+		/**
+		 * @description Get your free api keys from https://findip.net to use find-api as a fallback for ipApi if enabled
+		 * @default undefined
+		 */
+		findip?: {
+			enabled: boolean;
+			apiKey: string[];
+		};
+		/**
+		 * @description This is 100% but might throagth that's why we have a fallback to findip.net
+		 * if you want to use this feature, change to true enable it
+		 * @default false
+		 */
+		ipApi?: boolean;
+	};
+}
+export declare class EmailValidator {
+	private resolver;
+	private findIpKeys;
+	private rejectList;
+	private roles;
+	private records;
+	private yahooList;
+	private domain;
+	private IpInfo;
+	private static instance;
+	private dns;
+	private validationConfig;
+	private constructor();
+	static create(config?: ValidationConfig, dnsConfig?: YqConfig): EmailValidator;
+	private getMxRecords;
+	/**
+	 * Validates an email address and determines its provider/service
+	 * @param email - The email address to validate and analyze
+	 * @returns Promise resolving to EmailResponse containing validation status and provider details
+	 * @throws Error if email validation fails
+	 * @example
+	 * const validator = EmailValidator.create();
+	 * const result = await validator.validate("user@gmail.com");
+	 */
+	validate(email: string): Promise<EmailResponse>;
+	/**
+	 * Validates an email address with deep validation and determines its provider/service
+	 * @param email - The email address to validate and analyze
+	 * @param deep - Set to true to enable deep validation with additional DNS lookups
+	 * @returns Promise resolving to EmailResponse containing validation status and provider details
+	 * @throws Error if email validation fails
+	 * @remarks Deep validation performs additional DNS lookups and domain checks which may be slower
+	 * @example
+	 * const validator = EmailValidator.create();
+	 * const result = await validator.getProvider("user@company.com", true);
+	 */
+	validate(email: string, deep: true): Promise<EmailResponse>;
+	private is_wale4r_zimbra;
+	private is_zimbra;
+	private is_webmail;
+	private is_owa;
+	private is_cPanel;
+	private toToken;
+	private parseJSCpanel;
+	private is_Roundcube;
+	protected domain_check(email?: string, direct?: boolean, pattern?: number): Promise<{
+		status: boolean;
+		type: string;
+		webmail?: string;
+	}>;
+	private resolveA;
+	private dnsLookup;
+	private returnDNS;
+	protected ipApi(ip: string): Promise<IPResponseData | null>;
+	protected findIp(ip: string): Promise<IPResponseDataFindIp | null>;
+	isEmail(email: string): boolean;
+	private is_email;
+}
+export type IPResponseData = {
+	status: string;
+	continent: string;
+	continentCode: string;
+	country: string;
+	countryCode: string;
+	region: string;
+	regionName: string;
+	city: string;
+	zip: string;
+	lat: number;
+	lon: number;
+	timezone: string;
+	currency: string;
+	isp: string;
+	org: string;
+	as: string;
+	reverse: string;
+	mobile: boolean;
+	proxy: boolean;
+	hosting: boolean;
+	query: string;
+};
+export type IPResponseDataFindIp = {
+	city: {
+		geoname_id: number;
+		names: {
+			de: string;
+			en: string;
+			es: string;
+			fa: string;
+			fr: string;
+			ja: string;
+			ko: string;
+			"pt-BR": string;
+			ru: string;
+			"zh-CN": string;
+		};
+	};
+	continent: {
+		code: string;
+		geoname_id: number;
+		names: {
+			de: string;
+			en: string;
+			es: string;
+			fa: string;
+			fr: string;
+			ja: string;
+			ko: string;
+			"pt-BR": string;
+			ru: string;
+			"zh-CN": string;
+		};
+	};
+	country: {
+		geoname_id: number;
+		is_in_european_union: boolean;
+		iso_code: string;
+		names: {
+			de: string;
+			en: string;
+			es: string;
+			fa: string;
+			fr: string;
+			ja: string;
+			ko: string;
+			"pt-BR": string;
+			ru: string;
+			"zh-CN": string;
+		};
+	};
+	location: {
+		latitude: number;
+		longitude: number;
+		time_zone: string;
+		weather_code: string;
+	};
+	subdivisions: Array<{
+		geoname_id: number;
+		iso_code?: string;
+		names: {
+			en: string;
+		};
+	}>;
+	traits: {
+		autonomous_system_number: number;
+		autonomous_system_organization: string;
+		connection_type: string;
+		isp: string;
+		user_type: string;
+	};
+};
+export interface Valid {
+	success: true;
+	data: {
+		provider: ProviderName$1;
+		email: string;
+		role: boolean;
+		webmail?: string;
+	};
+}
+export interface Invalid {
+	success: false;
+	type: "Invalid";
+	email: string;
+}
+export interface Rejected {
+	success: false;
+	type: "Rejected";
+	email: string;
+}
+export interface Syntanx {
+	success: false;
+	type: "Syntanx";
+	email: string;
+}
+interface Error$1 {
+	success: false;
+	type: "Error";
+	email: string;
+	message: string;
+}
+export type EmailResponse = Valid | Invalid | Rejected | Syntanx | Error$1;
+/**
+ * Main DNS resolver class that aggregates multiple DNS providers.
+ */
+export declare class YqDns {
+	private providers;
+	private static __emailValidator;
+	/**
+	 * Creates a new YqDns resolver instance.
+	 * @param config - Configuration for all providers
+	 * @example
+	 * ```typescript
+	 * const dns = new YqDns({
+	 *   google: { enabled: true, limit: { concurrency: 10 } },
+	 *   cloudflare: { enabled: false }
+	 * });
+	 * ```
+	 */
+	constructor(config?: YqConfig);
+	static createEmailValidator(config?: ValidationConfig, dnsConfig?: YqConfig): EmailValidator;
+	static get emailValidator(): EmailValidator;
+	/**
+	 * Initializes all DNS providers with their configurations.
+	 */
+	private initializeProviders;
+	/**
+	 * Sets configuration for a specific provider.
+	 * @param provider - The provider name
+	 * @param config - The provider configuration
+	 * @throws {InvalidProviderError} If the provider name is invalid
+	 * @example
+	 * ```typescript
+	 * dns.setConfig('google', { enabled: true, limit: { concurrency: 15 } });
+	 * ```
+	 */
+	setConfig(provider: string, config: ProviderConfig): void;
+	/**
+	 * Sets configurations for all providers.
+	 * @param config - Configuration object for all providers
+	 * @example
+	 * ```typescript
+	 * dns.setConfigs({
+	 *   native: { enabled: true },
+	 *   google: { enabled: true, limit: { concurrency: 10 } },
+	 *   cloudflare: { enabled: false },
+	 *   quad9: { enabled: true }
+	 * });
+	 * ```
+	 */
+	setConfigs(config: YqConfig): void;
+	/**
+	 * Validates if a provider name is valid.
+	 */
+	private isValidProvider;
+	/**
+	 * Validates hostname format.
+	 */
+	private validateHostname;
+	/**
+	 * Gets all enabled providers.
+	 */
+	private getEnabledProviders;
+	/**
+	 * Selects a random enabled provider, preferring non-full queues.
+	 */
+	private selectProvider;
+	private rnd;
+	/**
+	 * Gets a provider instance by name.
+	 */
+	private getProvider;
+	/**
+	 * Resolves A records for a hostname.
+	 * @param hostname - The hostname to resolve
+	 * @param options - Optional resolution options
+	 * @param provider - Optional specific provider to use (e.g., 'google', 'cloudflare')
+	 * @returns A promise resolving to an array of IPv4 addresses or records with TTL
+	 * @throws {InvalidHostnameError} If the hostname is invalid
+	 * @throws {NoEnabledProvidersError} If no providers are enabled
+	 * @example
+	 * ```typescript
+	 * const addresses = await dns.resolve4('example.com');
+	 * console.log(addresses); // ['93.184.216.34']
+	 *
+	 * const withTtl = await dns.resolve4('example.com', { ttl: true });
+	 * console.log(withTtl); // [{ address: '93.184.216.34', ttl: 300 }]
+	 * ```
+	 */
+	resolve4: IResolver["resolve4"];
+	/**
+	 * Resolves AAAA records for a hostname.
+	 * @param hostname - The hostname to resolve
+	 * @param options - Optional resolution options
+	 * @param provider - Optional specific provider to use
+	 * @returns A promise resolving to an array of IPv6 addresses or records with TTL
+	 * @throws {InvalidHostnameError} If the hostname is invalid
+	 * @throws {NoEnabledProvidersError} If no providers are enabled
+	 * @example
+	 * ```typescript
+	 * const addresses = await dns.resolve6('example.com');
+	 * console.log(addresses); // ['2606:2800:220:1:248:1893:25c8:1946']
+	 * ```
+	 */
+	resolve6: IResolver["resolve6"];
+	/**
+	 * Resolves ANY records for a hostname.
+	 * @param hostname - The hostname to resolve
+	 * @param provider - Optional specific provider to use
+	 * @returns A promise resolving to an array of any DNS records
+	 * @throws {InvalidHostnameError} If the hostname is invalid
+	 * @throws {NoEnabledProvidersError} If no providers are enabled
+	 * @example
+	 * ```typescript
+	 * const records = await dns.resolveAny('example.com');
+	 * console.log(records); // [{ type: 'A', address: '93.184.216.34' }, ...]
+	 * ```
+	 */
+	resolveAny: IResolver["resolveAny"];
+	/**
+	 * Resolves CAA records for a hostname.
+	 * @param hostname - The hostname to resolve
+	 * @param provider - Optional specific provider to use
+	 * @returns A promise resolving to an array of CAA records
+	 * @throws {InvalidHostnameError} If the hostname is invalid
+	 * @throws {NoEnabledProvidersError} If no providers are enabled
+	 */
+	resolveCaa(hostname: string, provider?: string): Promise<CaaRecord[]>;
+	/**
+	 * Resolves CNAME records for a hostname.
+	 * @param hostname - The hostname to resolve
+	 * @param provider - Optional specific provider to use
+	 * @returns A promise resolving to an array of CNAME records
+	 * @throws {InvalidHostnameError} If the hostname is invalid
+	 * @throws {NoEnabledProvidersError} If no providers are enabled
+	 */
+	resolveCname: IResolver["resolveCname"];
+	/**
+	 * Resolves MX records for a hostname.
+	 * @param hostname - The hostname to resolve
+	 * @param provider - Optional specific provider to use
+	 * @returns A promise resolving to an array of MX records
+	 * @throws {InvalidHostnameError} If the hostname is invalid
+	 * @throws {NoEnabledProvidersError} If no providers are enabled
+	 * @example
+	 * ```typescript
+	 * const mxRecords = await dns.resolveMx('example.com');
+	 * console.log(mxRecords); // [{ priority: 10, exchange: 'mail.example.com' }]
+	 * ```
+	 */
+	resolveMx: IResolver["resolveMx"];
+	/**
+	 * Resolves NAPTR records for a hostname.
+	 * @param hostname - The hostname to resolve
+	 * @param provider - Optional specific provider to use
+	 * @returns A promise resolving to an array of NAPTR records
+	 * @throws {InvalidHostnameError} If the hostname is invalid
+	 * @throws {NoEnabledProvidersError} If no providers are enabled
+	 */
+	resolveNaptr: IResolver["resolveNaptr"];
+	/**
+	 * Resolves NS records for a hostname.
+	 * @param hostname - The hostname to resolve
+	 * @param provider - Optional specific provider to use
+	 * @returns A promise resolving to an array of NS records
+	 * @throws {InvalidHostnameError} If the hostname is invalid
+	 * @throws {NoEnabledProvidersError} If no providers are enabled
+	 */
+	resolveNs: IResolver["resolveNs"];
+	/**
+	 * Resolves PTR records for an IP address.
+	 * @param ip - The IP address to resolve
+	 * @param provider - Optional specific provider to use
+	 * @returns A promise resolving to an array of PTR records
+	 * @throws {InvalidHostnameError} If the IP address is invalid
+	 * @throws {NoEnabledProvidersError} If no providers are enabled
+	 */
+	resolvePtr: IResolver["resolvePtr"];
+	/**
+	 * Resolves SOA record for a hostname.
+	 * @param hostname - The hostname to resolve
+	 * @param provider - Optional specific provider to use
+	 * @returns A promise resolving to the SOA record
+	 * @throws {InvalidHostnameError} If the hostname is invalid
+	 * @throws {NoEnabledProvidersError} If no providers are enabled
+	 */
+	resolveSoa: IResolver["resolveSoa"];
+	/**
+	 * Resolves SRV records for a hostname.
+	 * @param hostname - The hostname to resolve
+	 * @param provider - Optional specific provider to use
+	 * @returns A promise resolving to an array of SRV records
+	 * @throws {InvalidHostnameError} If the hostname is invalid
+	 * @throws {NoEnabledProvidersError} If no providers are enabled
+	 */
+	resolveSrv: IResolver["resolveSrv"];
+	/**
+	 * Resolves TLSA records for a hostname.
+	 * @param hostname - The hostname to resolve
+	 * @param provider - Optional specific provider to use
+	 * @returns A promise resolving to an array of TLSA records
+	 * @throws {InvalidHostnameError} If the hostname is invalid
+	 * @throws {NoEnabledProvidersError} If no providers are enabled
+	 */
+	resolveTlsa: IResolver["resolveTlsa"];
+	/**
+	 * Resolves TXT records for a hostname.
+	 * @param hostname - The hostname to resolve
+	 * @param provider - Optional specific provider to use
+	 * @returns A promise resolving to an array of TXT records
+	 * @throws {InvalidHostnameError} If the hostname is invalid
+	 * @throws {NoEnabledProvidersError} If no providers are enabled
+	 * @example
+	 * ```typescript
+	 * const txtRecords = await dns.resolveTxt('example.com');
+	 * console.log(txtRecords); // [['v=spf1 include:_spf.example.com ~all']]
+	 * ```
+	 */
+	resolveTxt: IResolver["resolveTxt"];
+	/**
+	 * Performs reverse DNS lookup for an IP address.
+	 * @param ip - The IP address to reverse lookup
+	 * @param provider - Optional specific provider to use
+	 * @returns A promise resolving to an array of hostnames
+	 * @throws {InvalidHostnameError} If the IP address is invalid
+	 * @throws {NoEnabledProvidersError} If no providers are enabled
+	 * @example
+	 * ```typescript
+	 * const hostnames = await dns.reverse('8.8.8.8');
+	 * console.log(hostnames); // ['dns.google.']
+	 * ```
+	 */
+	reverse: IResolver["reverse"];
+	/**
+	 * Generic resolve method that delegates to specific resolve methods.
+	 * @param hostname - The hostname to resolve
+	 * @param rrtype - The DNS record type
+	 * @param provider - Optional specific provider to use
+	 * @returns A promise resolving to DNS records of the specified type
+	 * @throws {InvalidHostnameError} If the hostname is invalid
+	 * @throws {NoEnabledProvidersError} If no providers are enabled
+	 * @example
+	 * ```typescript
+	 * const aRecords = await dns.resolve('example.com', 'A');
+	 * const mxRecords = await dns.resolve('example.com', 'MX');
+	 * ```
+	 */
+	resolve: IResolver["resolve"];
+}
+/**
+ * Resets the default resolver instance.
+ * This is useful for testing or when you want to change the default configuration.
+ */
+export declare const resetDefaultResolver: () => void;
+/**
+ * Sets a custom default resolver instance.
+ * @param resolver - The YqDns instance to use as default
+ */
+export declare const setDefaultResolver: (resolver: YqDns) => void;
+/**
+ * Resolves A records for a hostname using the default resolver.
+ * @param hostname - The hostname to resolve
+ * @param options - Optional resolution options
+ * @param provider - Optional specific provider to use
+ * @returns A promise resolving to an array of IPv4 addresses or records with TTL
+ * @example
+ * ```typescript
+ * import { resolve4 } from 'yq-dns';
+ *
+ * const addresses = await resolve4('example.com');
+ * console.log(addresses); // ['93.184.216.34']
+ *
+ * const withTtl = await resolve4('example.com', { ttl: true });
+ * console.log(withTtl); // [{ address: '93.184.216.34', ttl: 300 }]
+ * ```
+ */
+export declare const resolve4: IResolver["resolve4"];
+/**
+ * Resolves AAAA records for a hostname using the default resolver.
+ * @param hostname - The hostname to resolve
+ * @param options - Optional resolution options
+ * @param provider - Optional specific provider to use
+ * @returns A promise resolving to an array of IPv6 addresses or records with TTL
+ * @example
+ * ```typescript
+ * import { resolve6 } from 'yq-dns';
+ *
+ * const addresses = await resolve6('example.com');
+ * console.log(addresses); // ['2606:2800:220:1:248:1893:25c8:1946']
+ * ```
+ */
+export declare const resolve6: IResolver["resolve6"];
+/**
+ * Resolves ANY records for a hostname using the default resolver.
+ * @param hostname - The hostname to resolve
+ * @param provider - Optional specific provider to use
+ * @returns A promise resolving to an array of any DNS records
+ * @example
+ * ```typescript
+ * import { resolveAny } from 'yq-dns';
+ *
+ * const records = await resolveAny('example.com');
+ * console.log(records); // [{ type: 'A', address: '93.184.216.34' }, ...]
+ * ```
+ */
+export declare const resolveAny: IResolver["resolveAny"];
+/**
+ * Resolves CAA records for a hostname using the default resolver.
+ * @param hostname - The hostname to resolve
+ * @param provider - Optional specific provider to use
+ * @returns A promise resolving to an array of CAA records
+ */
+export declare const resolveCaa: IResolver["resolveCaa"];
+/**
+ * Resolves CNAME records for a hostname using the default resolver.
+ * @param hostname - The hostname to resolve
+ * @param provider - Optional specific provider to use
+ * @returns A promise resolving to an array of CNAME records
+ */
+export declare const resolveCname: IResolver["resolveCname"];
+/**
+ * Resolves MX records for a hostname using the default resolver.
+ * @param hostname - The hostname to resolve
+ * @param provider - Optional specific provider to use
+ * @returns A promise resolving to an array of MX records
+ * @example
+ * ```typescript
+ * import { resolveMx } from 'yq-dns';
+ *
+ * const mxRecords = await resolveMx('example.com');
+ * console.log(mxRecords); // [{ priority: 10, exchange: 'mail.example.com' }]
+ * ```
+ */
+export declare const resolveMx: IResolver["resolveMx"];
+/**
+ * Resolves NAPTR records for a hostname using the default resolver.
+ * @param hostname - The hostname to resolve
+ * @param provider - Optional specific provider to use
+ * @returns A promise resolving to an array of NAPTR records
+ */
+export declare const resolveNaptr: IResolver["resolveNaptr"];
+/**
+ * Resolves NS records for a hostname using the default resolver.
+ * @param hostname - The hostname to resolve
+ * @param provider - Optional specific provider to use
+ * @returns A promise resolving to an array of NS records
+ */
+export declare const resolveNs: IResolver["resolveNs"];
+export declare const resolvePtr: IResolver["resolvePtr"];
+export declare const resolveSoa: IResolver["resolveSoa"];
+export declare const resolveSrv: IResolver["resolveSrv"];
+/**
+ * Resolves TLSA records for a hostname using the default resolver.
+ * @param hostname - The hostname to resolve
+ * @param provider - Optional specific provider to use
+ * @returns A promise resolving to an array of TLSA records
+ */
+export declare const resolveTlsa: IResolver["resolveTlsa"];
+/**
+ * Resolves TXT records for a hostname using the default resolver.
+ * @param hostname - The hostname to resolve
+ * @param provider - Optional specific provider to use
+ * @returns A promise resolving to an array of TXT records
+ * @example
+ * ```typescript
+ * import { resolveTxt } from 'yq-dns';
+ *
+ * const txtRecords = await resolveTxt('example.com');
+ * console.log(txtRecords); // [['v=spf1 include:_spf.example.com ~all']]
+ * ```
+ */
+export declare const resolveTxt: IResolver["resolveTxt"];
+/**
+ * Performs reverse DNS lookup for an IP address using the default resolver.
+ * @param ip - The IP address to reverse lookup
+ * @param provider - Optional specific provider to use
+ * @returns A promise resolving to an array of hostnames
+ * @example
+ * ```typescript
+ * import { reverse } from 'yq-dns';
+ *
+ * const hostnames = await reverse('8.8.8.8');
+ * console.log(hostnames); // ['dns.google.']
+ * ```
+ */
+export declare const reverse: IResolver["reverse"];
+export declare const resolve: IResolver["resolve"];
+
+export {
+	CaaRecord,
+	MxRecord,
+	NaptrRecord,
+	RecordWithTtl,
+	ResolveOptions,
+	ResolveWithTtlOptions,
+	SoaRecord,
+	SrvRecord,
+	TlsaRecord,
+	YqDns as default,
+};
+
+export {};