// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

import { nextTick } from "ext:deno_node/_next_tick.ts";
import { customPromisifyArgs } from "ext:deno_node/internal/util.mjs";
import {
  validateBoolean,
  validateFunction,
  validateNumber,
  validateOneOf,
  validateString,
} from "ext:deno_node/internal/validators.mjs";
import { isIP } from "ext:deno_node/internal/net.ts";
import {
  emitInvalidHostnameWarning,
  getDefaultResolver,
  getDefaultVerbatim,
  isFamily,
  isLookupCallback,
  isLookupOptions,
  isResolveCallback,
  Resolver as CallbackResolver,
  setDefaultResolver,
  setDefaultResultOrder,
  validateHints,
} from "ext:deno_node/internal/dns/utils.ts";
import type {
  AnyAaaaRecord,
  AnyARecord,
  AnyCnameRecord,
  AnyMxRecord,
  AnyNaptrRecord,
  AnyNsRecord,
  AnyPtrRecord,
  AnyRecord,
  AnySoaRecord,
  AnySrvRecord,
  AnyTxtRecord,
  CaaRecord,
  LookupAddress,
  LookupAllOptions,
  LookupOneOptions,
  LookupOptions,
  MxRecord,
  NaptrRecord,
  Records,
  RecordWithTtl,
  ResolveCallback,
  ResolveOptions,
  ResolverOptions,
  ResolveWithTtlOptions,
  SoaRecord,
  SrvRecord,
} from "ext:deno_node/internal/dns/utils.ts";
import promisesBase from "ext:deno_node/internal/dns/promises.ts";
import type { ErrnoException } from "ext:deno_node/internal/errors.ts";
import {
  dnsException,
  ERR_INVALID_ARG_TYPE,
  ERR_INVALID_ARG_VALUE,
} from "ext:deno_node/internal/errors.ts";
import {
  AI_ADDRCONFIG as ADDRCONFIG,
  AI_ALL as ALL,
  AI_V4MAPPED as V4MAPPED,
} from "ext:deno_node/internal_binding/ares.ts";
import {
  ChannelWrapQuery,
  getaddrinfo,
  GetAddrInfoReqWrap,
  QueryReqWrap,
} from "ext:deno_node/internal_binding/cares_wrap.ts";
import { toASCII } from "ext:deno_node/punycode.ts";
import { notImplemented } from "ext:deno_node/_utils.ts";

function onlookup(
  this: GetAddrInfoReqWrap,
  err: number | null,
  addresses: string[],
) {
  if (err) {
    return this.callback(dnsException(err, "getaddrinfo", this.hostname));
  }

  this.callback(null, addresses[0], this.family || isIP(addresses[0]));
}

function onlookupall(
  this: GetAddrInfoReqWrap,
  err: number | null,
  addresses: string[],
) {
  if (err) {
    return this.callback(dnsException(err, "getaddrinfo", this.hostname));
  }

  const family = this.family;
  const parsedAddresses = [];

  for (let i = 0; i < addresses.length; i++) {
    const addr = addresses[i];
    parsedAddresses[i] = {
      address: addr,
      family: family || isIP(addr),
    };
  }

  this.callback(null, parsedAddresses);
}

type LookupCallback = (
  err: ErrnoException | null,
  addressOrAddresses?: string | LookupAddress[] | null,
  family?: number,
) => void;

const validFamilies = [0, 4, 6];

// Easy DNS A/AAAA look up
// lookup(hostname, [options,] callback)
export function lookup(
  hostname: string,
  family: number,
  callback: (
    err: ErrnoException | null,
    address: string,
    family: number,
  ) => void,
): GetAddrInfoReqWrap | Record<string, never>;
export function lookup(
  hostname: string,
  options: LookupOneOptions,
  callback: (
    err: ErrnoException | null,
    address: string,
    family: number,
  ) => void,
): GetAddrInfoReqWrap | Record<string, never>;
export function lookup(
  hostname: string,
  options: LookupAllOptions,
  callback: (err: ErrnoException | null, addresses: LookupAddress[]) => void,
): GetAddrInfoReqWrap | Record<string, never>;
export function lookup(
  hostname: string,
  options: LookupOptions,
  callback: (
    err: ErrnoException | null,
    address: string | LookupAddress[],
    family: number,
  ) => void,
): GetAddrInfoReqWrap | Record<string, never>;
export function lookup(
  hostname: string,
  callback: (
    err: ErrnoException | null,
    address: string,
    family: number,
  ) => void,
): GetAddrInfoReqWrap | Record<string, never>;
export function lookup(
  hostname: string,
  options: unknown,
  callback?: unknown,
): GetAddrInfoReqWrap | Record<string, never> {
  let hints = 0;
  let family = 0;
  let all = false;
  let verbatim = getDefaultVerbatim();

  // Parse arguments
  if (hostname) {
    validateString(hostname, "hostname");
  }

  if (isLookupCallback(options)) {
    callback = options;
    family = 0;
  } else if (isFamily(options)) {
    validateFunction(callback, "callback");

    validateOneOf(options, "family", validFamilies);
    family = options;
  } else if (!isLookupOptions(options)) {
    validateFunction(arguments.length === 2 ? options : callback, "callback");

    throw new ERR_INVALID_ARG_TYPE("options", ["integer", "object"], options);
  } else {
    validateFunction(callback, "callback");

    if (options?.hints != null) {
      validateNumber(options.hints, "options.hints");
      hints = options.hints >>> 0;
      validateHints(hints);
    }

    if (options?.family != null) {
      validateOneOf(options.family, "options.family", validFamilies);
      family = options.family;
    }

    if (options?.all != null) {
      validateBoolean(options.all, "options.all");
      all = options.all;
    }

    if (options?.verbatim != null) {
      validateBoolean(options.verbatim, "options.verbatim");
      verbatim = options.verbatim;
    }
  }

  if (!hostname) {
    emitInvalidHostnameWarning(hostname);

    if (all) {
      nextTick(callback as LookupCallback, null, []);
    } else {
      nextTick(callback as LookupCallback, null, null, family === 6 ? 6 : 4);
    }

    return {};
  }

  const matchedFamily = isIP(hostname);

  if (matchedFamily) {
    if (all) {
      nextTick(callback as LookupCallback, null, [
        { address: hostname, family: matchedFamily },
      ]);
    } else {
      nextTick(callback as LookupCallback, null, hostname, matchedFamily);
    }

    return {};
  }

  const req = new GetAddrInfoReqWrap();
  req.callback = callback as LookupCallback;
  req.family = family;
  req.hostname = hostname;
  req.oncomplete = all ? onlookupall : onlookup;

  const err = getaddrinfo(req, toASCII(hostname), family, hints, verbatim);

  if (err) {
    nextTick(
      callback as LookupCallback,
      dnsException(err, "getaddrinfo", hostname),
    );

    return {};
  }

  return req;
}

Object.defineProperty(lookup, customPromisifyArgs, {
  value: ["address", "family"],
  enumerable: false,
});

function onresolve(
  this: QueryReqWrap,
  err: number,
  records: Records,
  ttls?: number[],
) {
  if (err) {
    this.callback(dnsException(err, this.bindingName, this.hostname));

    return;
  }

  const parsedRecords = ttls && this.ttl
    ? (records as string[]).map((address: string, index: number) => ({
      address,
      ttl: ttls[index],
    }))
    : records;

  this.callback(null, parsedRecords);
}

function resolver(bindingName: keyof ChannelWrapQuery) {
  function query(
    this: Resolver,
    name: string,
    options: unknown,
    callback?: unknown,
  ): QueryReqWrap {
    if (isResolveCallback(options)) {
      callback = options;
      options = {};
    }

    validateString(name, "name");
    validateFunction(callback, "callback");

    const req = new QueryReqWrap();
    req.bindingName = bindingName;
    req.callback = callback as ResolveCallback;
    req.hostname = name;
    req.oncomplete = onresolve;

    if (options && (options as ResolveOptions).ttl) {
      notImplemented("dns.resolve* with ttl option");
    }

    req.ttl = !!(options && (options as ResolveOptions).ttl);

    const err = this._handle[bindingName](req, toASCII(name));

    if (err) {
      throw dnsException(err, bindingName, name);
    }

    return req;
  }

  Object.defineProperty(query, "name", { value: bindingName });

  return query;
}

const resolveMap = Object.create(null);

export class Resolver extends CallbackResolver {
  constructor(options?: ResolverOptions) {
    super(options);
  }

  // deno-lint-ignore no-explicit-any
  [resolveMethod: string]: any;
}

Resolver.prototype.resolveAny = resolveMap.ANY = resolver("queryAny");
Resolver.prototype.resolve4 = resolveMap.A = resolver("queryA");
Resolver.prototype.resolve6 = resolveMap.AAAA = resolver("queryAaaa");
Resolver.prototype.resolveCaa = resolveMap.CAA = resolver("queryCaa");
Resolver.prototype.resolveCname = resolveMap.CNAME = resolver("queryCname");
Resolver.prototype.resolveMx = resolveMap.MX = resolver("queryMx");
Resolver.prototype.resolveNs = resolveMap.NS = resolver("queryNs");
Resolver.prototype.resolveTxt = resolveMap.TXT = resolver("queryTxt");
Resolver.prototype.resolveSrv = resolveMap.SRV = resolver("querySrv");
Resolver.prototype.resolvePtr = resolveMap.PTR = resolver("queryPtr");
Resolver.prototype.resolveNaptr = resolveMap.NAPTR = resolver("queryNaptr");
Resolver.prototype.resolveSoa = resolveMap.SOA = resolver("querySoa");
Resolver.prototype.reverse = resolver("getHostByAddr");
Resolver.prototype.resolve = _resolve;

function _resolve(
  this: Resolver,
  hostname: string,
  rrtype: unknown,
  callback?: unknown,
): QueryReqWrap {
  let resolver: Resolver;

  if (typeof hostname !== "string") {
    throw new ERR_INVALID_ARG_TYPE("name", "string", hostname);
  }

  if (typeof rrtype === "string") {
    resolver = resolveMap[rrtype];
  } else if (typeof rrtype === "function") {
    resolver = resolveMap.A;
    callback = rrtype;
  } else {
    throw new ERR_INVALID_ARG_TYPE("rrtype", "string", rrtype);
  }

  if (typeof resolver === "function") {
    return Reflect.apply(resolver, this, [hostname, callback]);
  }

  throw new ERR_INVALID_ARG_VALUE("rrtype", rrtype);
}

/**
 * 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
 * addresses. If the port is the IANA default DNS port (53) it can be omitted.
 *
 * ```js
 * dns.setServers([
 *   '4.4.4.4',
 *   '[2001:4860:4860::8888]',
 *   '4.4.4.4:1053',
 *   '[2001:4860:4860::8888]:1053',
 * ]);
 * ```
 *
 * An error will be thrown if an invalid address is provided.
 *
 * The `dns.setServers()` method must not be called while a DNS query is in
 * progress.
 *
 * The `setServers` method affects only `resolve`,`dns.resolve*()` and `reverse` (and specifically _not_ `lookup`).
 *
 * This method works much like [resolve.conf](https://man7.org/linux/man-pages/man5/resolv.conf.5.html).
 * That is, if attempting to resolve with the first server provided results in a
 * `NOTFOUND` error, the `resolve()` method will _not_ attempt to resolve with
 * subsequent servers provided. Fallback DNS servers will only be used if the
 * earlier ones time out or result in some other error.
 *
 * @param servers array of `RFC 5952` formatted addresses
 */
export function setServers(servers: ReadonlyArray<string>) {
  const resolver = new Resolver();

  resolver.setServers(servers);
  setDefaultResolver(resolver);
}

// The Node implementation uses `bindDefaultResolver` to set the follow methods
// on `module.exports` bound to the current `defaultResolver`. We don't have
// the same ability in ESM but can simulate this (at some cost) by explicitly
// exporting these methods which dynamically bind to the default resolver when
// called.

/**
 * 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
 * section if a custom port is used.
 *
 * ```js
 * [
 *   '4.4.4.4',
 *   '2001:4860:4860::8888',
 *   '4.4.4.4:1053',
 *   '[2001:4860:4860::8888]:1053',
 * ]
 * ```
 */
export function getServers(): string[] {
  return Resolver.prototype.getServers.bind(getDefaultResolver())();
}

/**
 * Uses the DNS protocol to resolve all records (also known as `ANY` or `*` query).
 * The `ret` argument passed to the `callback` function will be an array 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.
 *
 * Here is an example of the `ret` object passed to the callback:
 *
 * ```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 } ]
 * ```
 *
 * DNS server operators may choose not to respond to `ANY` queries. It may be
 * better to call individual methods like `resolve4`, `resolveMx`, and so on.
 * For more details, see [RFC 8482](https://tools.ietf.org/html/rfc8482).
 */
export function resolveAny(
  hostname: string,
  callback: (err: ErrnoException | null, addresses: AnyRecord[]) => void,
): QueryReqWrap;
export function resolveAny(...args: unknown[]): QueryReqWrap {
  return Resolver.prototype.resolveAny.bind(getDefaultResolver() as Resolver)(
    ...args,
  );
}

/**
 * Uses the DNS protocol to resolve a IPv4 addresses (`A` records) for the
 * `hostname`. The `addresses` argument passed to the `callback` function will
 * contain an array of IPv4 addresses (e.g. `['74.125.79.104', '74.125.79.105','74.125.79.106']`).
 *
 * @param hostname Host name to resolve.
 */
export function resolve4(
  hostname: string,
  callback: (err: ErrnoException | null, addresses: string[]) => void,
): void;
export function resolve4(
  hostname: string,
  options: ResolveWithTtlOptions,
  callback: (err: ErrnoException | null, addresses: RecordWithTtl[]) => void,
): void;
export function resolve4(
  hostname: string,
  options: ResolveOptions,
  callback: (
    err: ErrnoException | null,
    addresses: string[] | RecordWithTtl[],
  ) => void,
): void;
export function resolve4(
  hostname: string,
  options: unknown,
  callback?: unknown,
) {
  return Resolver.prototype.resolve4.bind(getDefaultResolver() as Resolver)(
    hostname,
    options,
    callback,
  );
}

/**
 * Uses the DNS protocol to resolve a IPv6 addresses (`AAAA` records) for the
 * `hostname`. The `addresses` argument passed to the `callback` function
 * will contain an array of IPv6 addresses.
 *
 * @param hostname Host name to resolve.
 */
export function resolve6(
  hostname: string,
  callback: (err: ErrnoException | null, addresses: string[]) => void,
): void;
export function resolve6(
  hostname: string,
  options: ResolveWithTtlOptions,
  callback: (err: ErrnoException | null, addresses: RecordWithTtl[]) => void,
): void;
export function resolve6(
  hostname: string,
  options: ResolveOptions,
  callback: (
    err: ErrnoException | null,
    addresses: string[] | RecordWithTtl[],
  ) => void,
): void;
export function resolve6(
  hostname: string,
  options: unknown,
  callback?: unknown,
) {
  return Resolver.prototype.resolve6.bind(getDefaultResolver() as Resolver)(
    hostname,
    options,
    callback,
  );
}

/**
 * Uses the DNS protocol to resolve `CAA` records for the `hostname`. The
 * `addresses` argument passed to the `callback` function will contain an array
 * of certification authority authorization records available for the
 * `hostname` (e.g. `[{critical: 0, iodef: 'mailto:pki@example.com'}, {critical: 128, issue: 'pki.example.com'}]`).
 */
export function resolveCaa(
  hostname: string,
  callback: (err: ErrnoException | null, records: CaaRecord[]) => void,
): QueryReqWrap;
export function resolveCaa(...args: unknown[]): QueryReqWrap {
  return Resolver.prototype.resolveCaa.bind(getDefaultResolver() as Resolver)(
    ...args,
  );
}

/**
 * Uses the DNS protocol to resolve `CNAME` records for the `hostname`. The
 * `addresses` argument passed to the `callback` function will contain an array
 * of canonical name records available for the `hostname`(e.g. `['bar.example.com']`).
 */
export function resolveCname(
  hostname: string,
  callback: (err: ErrnoException | null, addresses: string[]) => void,
): QueryReqWrap;
export function resolveCname(...args: unknown[]): QueryReqWrap {
  return Resolver.prototype.resolveCname.bind(getDefaultResolver() as Resolver)(
    ...args,
  );
}

/**
 * Uses the DNS protocol to resolve mail exchange records (`MX` records) for the
 * `hostname`. The `addresses` argument passed to the `callback` function will
 * contain an array of objects containing both a `priority` and `exchange`
 * property (e.g. `[{priority: 10, exchange: 'mx.example.com'}, ...]`).
 */
export function resolveMx(
  hostname: string,
  callback: (err: ErrnoException | null, addresses: MxRecord[]) => void,
): QueryReqWrap;
export function resolveMx(...args: unknown[]): QueryReqWrap {
  return Resolver.prototype.resolveMx.bind(getDefaultResolver() as Resolver)(
    ...args,
  );
}

/**
 * Uses the DNS protocol to resolve name server records (`NS` records) for the
 * `hostname`. The `addresses` argument passed to the `callback` function will
 * contain an array of name server records available for `hostname`
 * (e.g. `['ns1.example.com', 'ns2.example.com']`).
 */
export function resolveNs(
  hostname: string,
  callback: (err: ErrnoException | null, addresses: string[]) => void,
): QueryReqWrap;
export function resolveNs(...args: unknown[]): QueryReqWrap {
  return Resolver.prototype.resolveNs.bind(getDefaultResolver() as Resolver)(
    ...args,
  );
}

/**
 * Uses the DNS protocol to resolve text queries (`TXT` records) for the
 * `hostname`. The `records` argument passed to the `callback` function is 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.
 */
export function resolveTxt(
  hostname: string,
  callback: (err: ErrnoException | null, addresses: string[][]) => void,
): QueryReqWrap;
export function resolveTxt(...args: unknown[]): QueryReqWrap {
  return Resolver.prototype.resolveTxt.bind(getDefaultResolver() as Resolver)(
    ...args,
  );
}

/**
 * Uses the DNS protocol to resolve service records (`SRV` records) for the
 * `hostname`. The `addresses` argument passed to the `callback` function will
 * be an array of objects with the following properties:
 *
 * - `priority`
 * - `weight`
 * - `port`
 * - `name`
 *
 * ```js
 * {
 *   priority: 10,
 *   weight: 5,
 *   port: 21223,
 *   name: 'service.example.com'
 * }
 * ```
 */
export function resolveSrv(
  hostname: string,
  callback: (err: ErrnoException | null, addresses: SrvRecord[]) => void,
): QueryReqWrap;
export function resolveSrv(...args: unknown[]): QueryReqWrap {
  return Resolver.prototype.resolveSrv.bind(getDefaultResolver() as Resolver)(
    ...args,
  );
}

/**
 * Uses the DNS protocol to resolve pointer records (`PTR` records) for the
 * `hostname`. The `addresses` argument passed to the `callback` function will
 * be an array of strings containing the reply records.
 */
export function resolvePtr(
  hostname: string,
  callback: (err: ErrnoException | null, addresses: string[]) => void,
): QueryReqWrap;
export function resolvePtr(...args: unknown[]): QueryReqWrap {
  return Resolver.prototype.resolvePtr.bind(getDefaultResolver() as Resolver)(
    ...args,
  );
}

/**
 * Uses the DNS protocol to resolve regular expression based records (`NAPTR`
 * records) for the `hostname`. The `addresses` argument passed to the
 * `callback` function will contain an array 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
 * }
 * ```
 */
export function resolveNaptr(
  hostname: string,
  callback: (err: ErrnoException | null, addresses: NaptrRecord[]) => void,
): QueryReqWrap;
export function resolveNaptr(...args: unknown[]): QueryReqWrap {
  return Resolver.prototype.resolveNaptr.bind(getDefaultResolver() as Resolver)(
    ...args,
  );
}

/**
 * Uses the DNS protocol to resolve a start of authority record (`SOA` record) for
 * the `hostname`. The `address` argument passed to the `callback` function will
 * be 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
 * }
 * ```
 */
export function resolveSoa(
  hostname: string,
  callback: (err: ErrnoException | null, address: SoaRecord) => void,
): QueryReqWrap;
export function resolveSoa(...args: unknown[]): QueryReqWrap {
  return Resolver.prototype.resolveSoa.bind(getDefaultResolver() as Resolver)(
    ...args,
  );
}

/**
 * Performs a reverse DNS query that resolves an IPv4 or IPv6 address to an
 * array of host names.
 *
 * On error, `err` is an `Error` object, where `err.code` is
 * one of the `DNS error codes`.
 */
export function reverse(
  ip: string,
  callback: (err: ErrnoException | null, hostnames: string[]) => void,
): QueryReqWrap;
export function reverse(...args: unknown[]): QueryReqWrap {
  return Resolver.prototype.reverse.bind(getDefaultResolver() as Resolver)(
    ...args,
  );
}

/**
 * Uses the DNS protocol to resolve a host name (e.g. `'nodejs.org'`) into an array
 * of the resource records. The `callback` function has arguments`(err, records)`.]
 * When successful, `records` will be an array of resource
 * records. The type and structure of individual results varies based on `rrtype`.
 *
 * On error, `err` is an `Error` object, where `err.code` is one of the DNS error codes.
 *
 * @param hostname Host name to resolve.
 * @param [rrtype='A'] Resource record type.
 */
export function resolve(
  hostname: string,
  callback: (err: ErrnoException | null, addresses: string[]) => void,
): QueryReqWrap;
export function resolve(
  hostname: string,
  rrtype: "A",
  callback: (err: ErrnoException | null, addresses: string[]) => void,
): QueryReqWrap;
export function resolve(
  hostname: string,
  rrtype: "AAAA",
  callback: (err: ErrnoException | null, addresses: string[]) => void,
): QueryReqWrap;
export function resolve(
  hostname: string,
  rrtype: "ANY",
  callback: (err: ErrnoException | null, addresses: AnyRecord[]) => void,
): QueryReqWrap;
export function resolve(
  hostname: string,
  rrtype: "CNAME",
  callback: (err: ErrnoException | null, addresses: string[]) => void,
): QueryReqWrap;
export function resolve(
  hostname: string,
  rrtype: "MX",
  callback: (err: ErrnoException | null, addresses: MxRecord[]) => void,
): QueryReqWrap;
export function resolve(
  hostname: string,
  rrtype: "NAPTR",
  callback: (err: ErrnoException | null, addresses: NaptrRecord[]) => void,
): QueryReqWrap;
export function resolve(
  hostname: string,
  rrtype: "NS",
  callback: (err: ErrnoException | null, addresses: string[]) => void,
): QueryReqWrap;
export function resolve(
  hostname: string,
  rrtype: "PTR",
  callback: (err: ErrnoException | null, addresses: string[]) => void,
): QueryReqWrap;
export function resolve(
  hostname: string,
  rrtype: "SOA",
  callback: (err: ErrnoException | null, addresses: SoaRecord) => void,
): QueryReqWrap;
export function resolve(
  hostname: string,
  rrtype: "SRV",
  callback: (err: ErrnoException | null, addresses: SrvRecord[]) => void,
): QueryReqWrap;
export function resolve(
  hostname: string,
  rrtype: "TXT",
  callback: (err: ErrnoException | null, addresses: string[][]) => void,
): QueryReqWrap;
export function resolve(
  hostname: string,
  rrtype: string,
  callback: (
    err: ErrnoException | null,
    addresses:
      | string[]
      | MxRecord[]
      | NaptrRecord[]
      | SoaRecord
      | SrvRecord[]
      | string[][]
      | AnyRecord[],
  ) => void,
): QueryReqWrap;
export function resolve(hostname: string, rrtype: unknown, callback?: unknown) {
  return Resolver.prototype.resolve.bind(getDefaultResolver() as Resolver)(
    hostname,
    rrtype,
    callback,
  );
}

// ERROR CODES
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";

const promises = {
  ...promisesBase,
  setDefaultResultOrder,
  setServers,

  // ERROR CODES
  NODATA,
  FORMERR,
  SERVFAIL,
  NOTFOUND,
  NOTIMP,
  REFUSED,
  BADQUERY,
  BADNAME,
  BADFAMILY,
  BADRESP,
  CONNREFUSED,
  TIMEOUT,
  EOF,
  FILE,
  NOMEM,
  DESTRUCTION,
  BADSTR,
  BADFLAGS,
  NONAME,
  BADHINTS,
  NOTINITIALIZED,
  LOADIPHLPAPI,
  ADDRGETNETWORKPARAMS,
  CANCELLED,
};

export { ADDRCONFIG, ALL, promises, setDefaultResultOrder, V4MAPPED };

export type {
  AnyAaaaRecord,
  AnyARecord,
  AnyCnameRecord,
  AnyMxRecord,
  AnyNaptrRecord,
  AnyNsRecord,
  AnyPtrRecord,
  AnyRecord,
  AnySoaRecord,
  AnySrvRecord,
  AnyTxtRecord,
  CaaRecord,
  LookupAddress,
  LookupAllOptions,
  LookupOneOptions,
  LookupOptions,
  MxRecord,
  NaptrRecord,
  Records,
  RecordWithTtl,
  ResolveCallback,
  ResolveOptions,
  ResolverOptions,
  ResolveWithTtlOptions,
  SoaRecord,
  SrvRecord,
};

export default {
  ADDRCONFIG,
  ALL,
  V4MAPPED,
  lookup,
  getServers,
  resolveAny,
  resolve4,
  resolve6,
  resolveCaa,
  resolveCname,
  resolveMx,
  resolveNs,
  resolveTxt,
  resolveSrv,
  resolvePtr,
  resolveNaptr,
  resolveSoa,
  resolve,
  Resolver,
  reverse,
  setServers,
  setDefaultResultOrder,
  promises,
  NODATA,
  FORMERR,
  SERVFAIL,
  NOTFOUND,
  NOTIMP,
  REFUSED,
  BADQUERY,
  BADNAME,
  BADFAMILY,
  BADRESP,
  CONNREFUSED,
  TIMEOUT,
  EOF,
  FILE,
  NOMEM,
  DESTRUCTION,
  BADSTR,
  BADFLAGS,
  NONAME,
  BADHINTS,
  NOTINITIALIZED,
  LOADIPHLPAPI,
  ADDRGETNETWORKPARAMS,
  CANCELLED,
};