import type { CacheConfig } from './cache.cjs';
/** Address returned by a hostname lookup. */
export interface LookupAddress {
    address: string;
    family: number;
}
/** Options accepted by a hostname lookup. */
export interface LookupOptions {
    family?: number | 'IPv4' | 'IPv6' | undefined;
    hints?: number | undefined;
    all?: boolean | undefined;
    order?: 'ipv4first' | 'ipv6first' | 'verbatim' | undefined;
    /** @deprecated Use `order` instead. */
    verbatim?: boolean | undefined;
}
/** Options accepted by TTL-aware A and AAAA resolution. */
export interface ResolveOptions {
    ttl: boolean;
}
/** Resolution options that require TTL-bearing records. */
export interface ResolveWithTtlOptions extends ResolveOptions {
    ttl: true;
}
/** A resolved address and its remaining DNS TTL. */
export interface RecordWithTtl {
    address: string;
    ttl: number;
}
export interface AnyARecord extends RecordWithTtl {
    type: 'A';
}
export interface AnyAaaaRecord extends RecordWithTtl {
    type: 'AAAA';
}
export interface CaaRecord {
    critical: number;
    issue?: string | undefined;
    issuewild?: string | undefined;
    iodef?: string | undefined;
    contactemail?: string | undefined;
    contactphone?: string | undefined;
}
export interface AnyCaaRecord extends CaaRecord {
    type: 'CAA';
}
export interface MxRecord {
    priority: number;
    exchange: string;
}
export interface AnyMxRecord extends MxRecord {
    type: 'MX';
}
export interface NaptrRecord {
    flags: string;
    service: string;
    regexp: string;
    replacement: string;
    order: number;
    preference: number;
}
export interface AnyNaptrRecord extends NaptrRecord {
    type: 'NAPTR';
}
export interface SoaRecord {
    nsname: string;
    hostmaster: string;
    serial: number;
    refresh: number;
    retry: number;
    expire: number;
    minttl: number;
}
export interface AnySoaRecord extends SoaRecord {
    type: 'SOA';
}
export interface SrvRecord {
    priority: number;
    weight: number;
    port: number;
    name: string;
}
export interface AnySrvRecord extends SrvRecord {
    type: 'SRV';
}
export interface TlsaRecord {
    certUsage: number;
    selector: number;
    match: number;
    data: ArrayBuffer;
}
export interface AnyTlsaRecord extends TlsaRecord {
    type: 'TLSA';
}
export interface AnyTxtRecord {
    type: 'TXT';
    entries: string[];
}
export interface AnyNsRecord {
    type: 'NS';
    value: string;
}
export interface AnyPtrRecord {
    type: 'PTR';
    value: string;
}
export interface AnyCnameRecord {
    type: 'CNAME';
    value: string;
}
/**
 * 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 ZynorConfig {
    /** 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;
    /** Configuration for DNS result caching */
    cache?: CacheConfig;
}
/**
 * Union type of all possible DNS record types returned by ANY queries.
 */
export type AnyRecord = AnyARecord | AnyAaaaRecord | AnyCaaRecord | AnyCnameRecord | AnyMxRecord | AnyNaptrRecord | AnyNsRecord | AnyPtrRecord | AnySoaRecord | AnySrvRecord | AnyTlsaRecord | AnyTxtRecord;
/**
 * Available DNS provider names.
 */
export type ProviderName = 'native' | 'google' | 'cloudflare' | 'quad9';
/** Select one existing DNS provider from an options-bearing resolver call. */
export interface ProviderSelectionOptions {
    provider: ProviderName;
}
/**
 * DNS record types supported by the resolver.
 */
export type RecordType = 'A' | 'AAAA' | 'ANY' | 'CAA' | 'CNAME' | 'MX' | 'NAPTR' | 'NS' | 'PTR' | 'SOA' | 'SRV' | 'TLSA' | 'TXT';
/**
 * DoH response structure from DNS-over-HTTPS providers.
 */
export interface DoHResponse {
    Status: number;
    TC: boolean;
    RD: boolean;
    RA: boolean;
    AD: boolean;
    CD: boolean;
    Question: Array<{
        name: string;
        type: number;
    }>;
    Answer?: Array<{
        name: string;
        type: number;
        TTL: number;
        data: string;
    }>;
    Authority?: Array<{
        name: string;
        type: number;
        TTL: number;
        data: string;
    }>;
    Additional?: Array<{
        name: string;
        type: number;
        TTL: number;
        data: string;
    }>;
}
/**
 * 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);
}
/**
 * Options for aborting/timing out DNS operations.
 */
export interface AbortOptions {
    /** AbortSignal to cancel the operation (queue wait + fetch). */
    signal?: AbortSignal;
    /** Timeout in milliseconds for the entire operation (queue wait + fetch). */
    timeout?: number;
}
export interface QueueOptions {
    /** 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;
}