@emailcheck/email-validator-js 2.14.2 → 3.0.1-beta.0

package/dist/index.esm.js

@@ -3,6 +3,7 @@ import { lru } from 'tiny-lru';
 import { promises } from 'node:dns';
 import { stringSimilarity } from 'string-similarity-js';
 import * as net from 'node:net';
+import * as tls from 'node:tls';
 
 class LRUAdapter {
   constructor(maxSize = 1e3, ttlMs = 36e5) {
@@ -52,6 +53,8 @@ const DEFAULT_CACHE_OPTIONS = {
     // 24 hours
     smtp: 18e5,
     // 30 minutes
+    smtpPort: 36e5,
+    // 1 hour
     domainSuggestion: 864e5,
     // 24 hours
     whois: 36e5
@@ -63,6 +66,7 @@ const DEFAULT_CACHE_OPTIONS = {
     free: 1e3,
     domainValid: 1e3,
     smtp: 500,
+    smtpPort: 500,
     domainSuggestion: 1e3,
     whois: 200
   }
@@ -76,6 +80,7 @@ function getDefaultCache() {
       free: new LRUAdapter(DEFAULT_CACHE_OPTIONS.maxSize.free, DEFAULT_CACHE_OPTIONS.ttl.free),
       domainValid: new LRUAdapter(DEFAULT_CACHE_OPTIONS.maxSize.domainValid, DEFAULT_CACHE_OPTIONS.ttl.domainValid),
       smtp: new LRUAdapter(DEFAULT_CACHE_OPTIONS.maxSize.smtp, DEFAULT_CACHE_OPTIONS.ttl.smtp),
+      smtpPort: new LRUAdapter(DEFAULT_CACHE_OPTIONS.maxSize.smtpPort, DEFAULT_CACHE_OPTIONS.ttl.smtpPort),
       domainSuggestion: new LRUAdapter(DEFAULT_CACHE_OPTIONS.maxSize.domainSuggestion, DEFAULT_CACHE_OPTIONS.ttl.domainSuggestion),
       whois: new LRUAdapter(DEFAULT_CACHE_OPTIONS.maxSize.whois, DEFAULT_CACHE_OPTIONS.ttl.whois)
     };
@@ -92,6 +97,7 @@ function clearDefaultCache() {
     defaultCacheInstance.free.clear();
     defaultCacheInstance.domainValid.clear();
     defaultCacheInstance.smtp.clear();
+    defaultCacheInstance.smtpPort.clear();
     defaultCacheInstance.domainSuggestion.clear();
     defaultCacheInstance.whois.clear();
   }
@@ -1126,6 +1132,40 @@ function detectName(email) {
   return detectNameFromEmail({ email });
 }
 
+var VerificationErrorCode;
+(function(VerificationErrorCode2) {
+  VerificationErrorCode2["INVALID_FORMAT"] = "INVALID_FORMAT";
+  VerificationErrorCode2["INVALID_DOMAIN"] = "INVALID_DOMAIN";
+  VerificationErrorCode2["NO_MX_RECORDS"] = "NO_MX_RECORDS";
+  VerificationErrorCode2["SMTP_CONNECTION_FAILED"] = "SMTP_CONNECTION_FAILED";
+  VerificationErrorCode2["SMTP_TIMEOUT"] = "SMTP_TIMEOUT";
+  VerificationErrorCode2["MAILBOX_NOT_FOUND"] = "MAILBOX_NOT_FOUND";
+  VerificationErrorCode2["MAILBOX_FULL"] = "MAILBOX_FULL";
+  VerificationErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  VerificationErrorCode2["DISPOSABLE_EMAIL"] = "DISPOSABLE_EMAIL";
+  VerificationErrorCode2["FREE_EMAIL_PROVIDER"] = "FREE_EMAIL_PROVIDER";
+})(VerificationErrorCode || (VerificationErrorCode = {}));
+var SMTPStep;
+(function(SMTPStep2) {
+  SMTPStep2["GREETING"] = "GREETING";
+  SMTPStep2["EHLO"] = "EHLO";
+  SMTPStep2["HELO"] = "HELO";
+  SMTPStep2["STARTTLS"] = "STARTTLS";
+  SMTPStep2["MAIL_FROM"] = "MAIL_FROM";
+  SMTPStep2["RCPT_TO"] = "RCPT_TO";
+  SMTPStep2["VRFY"] = "VRFY";
+  SMTPStep2["QUIT"] = "QUIT";
+})(SMTPStep || (SMTPStep = {}));
+
+function isIPAddress(host) {
+  const ipv4Regex = /^(\d{1,3}\.){3}\d{1,3}$/;
+  if (ipv4Regex.test(host)) {
+    const octets = host.split(".");
+    return octets.every((octet) => parseInt(octet, 10) <= 255);
+  }
+  const ipv6Regex = /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|^(?:[0-9a-fA-F]{1,4}:){1,7}:$|^(?:[0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}$|^(?:[0-9a-fA-F]{1,4}:){1,5}(?::[0-9a-fA-F]{1,4}){1,2}$|^(?:[0-9a-fA-F]{1,4}:){1,4}(?::[0-9a-fA-F]{1,4}){1,3}$|^(?:[0-9a-fA-F]{1,4}:){1,3}(?::[0-9a-fA-F]{1,4}){1,4}$|^(?:[0-9a-fA-F]{1,4}:){1,2}(?::[0-9a-fA-F]{1,4}){1,5}$|^[0-9a-fA-F]{1,4}:(?:(?::[0-9a-fA-F]{1,4}){1,6})$|^::1(?::(?::[0-9a-fA-F]{1,4}){1,7})|$|:(?:(?::[0-9a-fA-F]{1,4}){1,7}:)$/;
+  return ipv6Regex.test(host);
+}
 function isOverQuota(smtpReply) {
   return Boolean(smtpReply && /(over quota)/gi.test(smtpReply));
 }
@@ -1135,135 +1175,382 @@ function isInvalidMailboxError(smtpReply) {
 function isMultilineGreet(smtpReply) {
   return Boolean(smtpReply && /^(250|220)-/.test(smtpReply));
 }
+const DEFAULT_PORTS = [25, 587, 465];
+const DEFAULT_TIMEOUT = 3e3;
+const DEFAULT_MAX_RETRIES = 1;
+const PORT_CONFIGS = {
+  25: { tls: false, starttls: true },
+  587: { tls: false, starttls: true },
+  465: { tls: true, starttls: false }
+};
 async function verifyMailboxSMTP(params) {
-  const { local, domain, mxRecords = [], timeout, debug, port = 25, retryAttempts = 1 } = params;
-  const log = debug ? console.debug : (..._args) => {
+  const { local, domain, mxRecords = [], options = {} } = params;
+  const { ports = DEFAULT_PORTS, timeout = DEFAULT_TIMEOUT, maxRetries = DEFAULT_MAX_RETRIES, tls: tlsConfig = true, hostname = "localhost", useVRFY = true, cache, debug = false, sequence } = options;
+  const log = debug ? (...args) => console.log("[SMTP]", ...args) : () => {
   };
   if (!mxRecords || mxRecords.length === 0) {
-    return false;
+    log("No MX records found");
+    return { result: false, cached: false, port: 0, portCached: false };
+  }
+  const mxHost = mxRecords[0];
+  log(`Verifying ${local}@${domain} via ${mxHost}`);
+  const smtpCacheStore = cache ? getCacheStore(cache, "smtp") : null;
+  if (smtpCacheStore) {
+    let cachedResult;
+    try {
+      cachedResult = await smtpCacheStore.get(`${mxHost}:${local}@${domain}`);
+      if (cachedResult !== void 0) {
+        log(`Using cached SMTP result: ${cachedResult}`);
+        return {
+          result: typeof cachedResult === "boolean" ? cachedResult : null,
+          cached: true,
+          port: 0,
+          portCached: false
+        };
+      }
+    } catch (_error) {
+      cachedResult = void 0;
+    }
   }
-  const mxIndex = 0;
-  const mxRecord = mxRecords[mxIndex];
-  for (let attempt = 0; attempt < retryAttempts; attempt++) {
-    const result = await attemptVerification({
-      mxRecord,
-      local,
-      domain,
-      port,
-      timeout,
-      log,
-      attempt
-    });
-    if (result !== null) {
-      return result;
+  const smtpPortCacheStore = cache ? getCacheStore(cache, "smtpPort") : null;
+  if (smtpPortCacheStore) {
+    let cachedPort;
+    try {
+      cachedPort = await smtpPortCacheStore.get(mxHost);
+    } catch (_error) {
+      cachedPort = null;
     }
-    if (attempt < retryAttempts - 1) {
-      await new Promise((resolve) => setTimeout(resolve, Math.min(1e3 * (attempt + 1), 3e3)));
+    if (cachedPort) {
+      log(`Using cached port: ${cachedPort}`);
+      const result = await testSMTPConnection({
+        mxHost,
+        port: cachedPort,
+        local,
+        domain,
+        timeout,
+        tlsConfig,
+        hostname,
+        useVRFY,
+        sequence,
+        log
+      });
+      if (smtpCacheStore && result !== void 0) {
+        try {
+          await smtpCacheStore.set(`${mxHost}:${local}@${domain}`, result);
+          log(`Cached SMTP result ${result} for ${local}@${domain} via ${mxHost}`);
+        } catch (_error) {
+        }
+      }
+      return { result, cached: false, port: cachedPort, portCached: true };
     }
   }
-  return null;
+  for (const port of ports) {
+    log(`Testing port ${port}`);
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      if (attempt > 0) {
+        const delay = Math.min(1e3 * 2 ** (attempt - 1), 5e3);
+        log(`Retry ${attempt + 1}, waiting ${delay}ms`);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+      const result = await testSMTPConnection({
+        mxHost,
+        port,
+        local,
+        domain,
+        timeout,
+        tlsConfig,
+        hostname,
+        useVRFY,
+        sequence,
+        log
+      });
+      if (smtpCacheStore && result !== void 0) {
+        try {
+          await smtpCacheStore.set(`${mxHost}:${local}@${domain}`, result);
+          log(`Cached SMTP result ${result} for ${local}@${domain} via ${mxHost}`);
+        } catch (_error) {
+        }
+      }
+      if (result !== null) {
+        if (smtpPortCacheStore) {
+          try {
+            await smtpPortCacheStore.set(mxHost, port);
+            log(`Cached port ${port} for ${mxHost}`);
+          } catch (_error) {
+          }
+        }
+        return { result, cached: false, port, portCached: false };
+      }
+    }
+  }
+  log("All ports failed");
+  return { result: null, cached: false, port: 0, portCached: false };
 }
-async function attemptVerification(params) {
-  const { mxRecord, local, domain, port, timeout, log, attempt } = params;
+async function testSMTPConnection(params) {
+  const { mxHost, port, local, domain, timeout, tlsConfig, hostname, useVRFY, sequence, log } = params;
+  const portConfig = PORT_CONFIGS[port] || { tls: false, starttls: false };
+  const useTLS = tlsConfig !== false && (portConfig.tls || portConfig.starttls);
+  const implicitTLS = portConfig.tls;
+  const defaultSequence = {
+    steps: [SMTPStep.GREETING, SMTPStep.EHLO, SMTPStep.MAIL_FROM, SMTPStep.RCPT_TO]
+  };
+  const activeSequence = sequence || defaultSequence;
+  if (port === 25) {
+    activeSequence.steps = activeSequence.steps.map((step) => step === SMTPStep.EHLO ? SMTPStep.HELO : step);
+  }
+  const tlsOptions = {
+    host: mxHost,
+    servername: isIPAddress(mxHost) ? void 0 : mxHost,
+    // Don't set servername for IP addresses
+    rejectUnauthorized: false,
+    minVersion: "TLSv1.2",
+    ...typeof tlsConfig === "object" ? tlsConfig : {}
+  };
   return new Promise((resolve) => {
-    log(`[verifyMailboxSMTP] connecting to ${mxRecord}:${port} (attempt ${attempt + 1})`);
-    const socket = net.connect({
-      host: mxRecord,
-      port
-    });
-    let resTimeout = null;
+    let socket;
+    let buffer = "";
+    let isTLS = implicitTLS;
+    let currentStepIndex = 0;
     let resolved = false;
-    let cleaned = false;
+    let supportsSTARTTLS = false;
+    let supportsVRFY = false;
     const cleanup = () => {
-      if (cleaned)
-        return;
-      cleaned = true;
-      if (resTimeout) {
-        clearTimeout(resTimeout);
-        resTimeout = null;
-      }
-      if (socket && !socket.destroyed) {
-        socket.removeAllListeners();
-        socket.destroy();
-      }
-    };
-    const ret = (result) => {
       if (resolved)
         return;
       resolved = true;
-      if (!(socket === null || socket === void 0 ? void 0 : socket.destroyed)) {
-        log("[verifyMailboxSMTP] closing socket");
+      try {
         socket === null || socket === void 0 ? void 0 : socket.write("QUIT\r\n");
-        socket === null || socket === void 0 ? void 0 : socket.end();
+      } catch {
       }
+      setTimeout(() => socket === null || socket === void 0 ? void 0 : socket.destroy(), 100);
+    };
+    const finish = (result, reason) => {
+      if (resolved)
+        return;
+      log(`${port}: ${reason || (result ? "valid" : "invalid")}`);
       cleanup();
       resolve(result);
     };
-    const messages = [`HELO ${domain}`, `MAIL FROM: <>`, `RCPT TO: <${local}@${domain}>`];
-    log("[verifyMailboxSMTP] writing messages", messages);
-    socket.on("data", (data) => {
-      const dataString = String(data);
-      log("[verifyMailboxSMTP] got data", dataString);
-      if (isInvalidMailboxError(dataString)) {
-        log("[verifyMailboxSMTP] invalid mailbox error detected");
-        return ret(false);
+    const sendCommand = (cmd) => {
+      if (resolved)
+        return;
+      log(`\u2192 ${cmd}`);
+      socket === null || socket === void 0 ? void 0 : socket.write(`${cmd}\r
+`);
+    };
+    const nextStep = () => {
+      currentStepIndex++;
+      if (currentStepIndex >= activeSequence.steps.length) {
+        finish(true, "sequence_complete");
+        return;
       }
-      if (isOverQuota(dataString)) {
-        log("[verifyMailboxSMTP] mailbox over quota");
-        return ret(false);
+      executeStep(activeSequence.steps[currentStepIndex]);
+    };
+    const executeStep = (step) => {
+      if (resolved)
+        return;
+      switch (step) {
+        case SMTPStep.EHLO:
+          sendCommand(`EHLO ${hostname}`);
+          break;
+        case SMTPStep.HELO:
+          sendCommand(`HELO ${domain}`);
+          break;
+        case SMTPStep.GREETING:
+          break;
+        case SMTPStep.STARTTLS:
+          sendCommand("STARTTLS");
+          break;
+        case SMTPStep.MAIL_FROM: {
+          const from = activeSequence.from || "<>";
+          sendCommand(`MAIL FROM:${from}`);
+          break;
+        }
+        case SMTPStep.RCPT_TO:
+          sendCommand(`RCPT TO:<${local}@${domain}>`);
+          break;
+        case SMTPStep.VRFY: {
+          const vrfyTarget = activeSequence.vrfyTarget || local;
+          sendCommand(`VRFY ${vrfyTarget}`);
+          break;
+        }
+        case SMTPStep.QUIT:
+          sendCommand("QUIT");
+          break;
       }
-      if (!dataString.includes("220") && !dataString.includes("250")) {
-        log("[verifyMailboxSMTP] unrecognized response, returning null");
-        return ret(null);
+    };
+    const processResponse = (response) => {
+      if (resolved)
+        return;
+      const code = response.substring(0, 3);
+      const isMultiline = response.length > 3 && response[3] === "-";
+      log(`\u2190 ${response}`);
+      if (isMultilineGreet(response)) {
+        return;
       }
-      if (isMultilineGreet(dataString))
+      if (isOverQuota(response)) {
+        finish(false, "over_quota");
         return;
-      if (messages.length > 0) {
-        const message = messages.shift();
-        log("[verifyMailboxSMTP] writing message", message);
-        return socket.write(`${message}\r
-`);
       }
-      ret(true);
-    });
-    socket.on("error", (err) => {
-      log("[verifyMailboxSMTP] error in socket", err);
-      ret(null);
-    });
-    socket.on("close", (err) => {
-      if (!resolved) {
-        log("[verifyMailboxSMTP] close socket", err);
-        ret(null);
+      if (isInvalidMailboxError(response)) {
+        finish(false, "not_found");
+        return;
       }
-    });
-    socket.on("timeout", () => {
-      log("[verifyMailboxSMTP] timeout socket");
-      ret(null);
-    });
-    resTimeout = setTimeout(() => {
-      log(`[verifyMailboxSMTP] timed out (${timeout} ms)`);
-      if (!resolved) {
-        socket.destroy();
-        ret(null);
+      if (isMultiline) {
+        const currentStep2 = activeSequence.steps[currentStepIndex];
+        if (currentStep2 === SMTPStep.EHLO && code === "250") {
+          const upper = response.toUpperCase();
+          if (upper.includes("STARTTLS"))
+            supportsSTARTTLS = true;
+          if (upper.includes("VRFY"))
+            supportsVRFY = true;
+        }
+        if (currentStep2 === SMTPStep.HELO && code === "250") {
+          const upper = response.toUpperCase();
+          if (upper.includes("VRFY"))
+            supportsVRFY = true;
+        }
+        return;
       }
-    }, timeout);
+      if (!response.includes("220") && !response.includes("250") && !response.includes("550") && !response.includes("552")) {
+        finish(null, "unrecognized_response");
+        return;
+      }
+      const currentStep = activeSequence.steps[currentStepIndex];
+      switch (currentStep) {
+        case SMTPStep.GREETING:
+          if (code.startsWith("220")) {
+            nextStep();
+          } else {
+            finish(null, "no_greeting");
+          }
+          break;
+        case SMTPStep.EHLO:
+          if (code.startsWith("250")) {
+            const hasSTARTTLS = activeSequence.steps.includes(SMTPStep.STARTTLS);
+            if (!isTLS && useTLS && supportsSTARTTLS && !implicitTLS && hasSTARTTLS) {
+              currentStepIndex = activeSequence.steps.indexOf(SMTPStep.STARTTLS);
+              executeStep(SMTPStep.STARTTLS);
+            } else {
+              nextStep();
+            }
+          } else {
+            finish(null, "ehlo_failed");
+          }
+          break;
+        case SMTPStep.HELO:
+          if (code.startsWith("250")) {
+            nextStep();
+          } else {
+            finish(null, "helo_failed");
+          }
+          break;
+        case SMTPStep.STARTTLS:
+          if (code.startsWith("220")) {
+            const plainSocket = socket;
+            socket = tls.connect({
+              ...tlsOptions,
+              socket: plainSocket,
+              servername: isIPAddress(mxHost) ? void 0 : mxHost
+            }, () => {
+              isTLS = true;
+              log("TLS upgraded");
+              buffer = "";
+              const starttlsIndex = activeSequence.steps.indexOf(SMTPStep.STARTTLS);
+              currentStepIndex = starttlsIndex;
+              nextStep();
+            });
+            socket.on("data", handleData);
+            socket.on("error", () => finish(null, "tls_error"));
+          } else {
+            nextStep();
+          }
+          break;
+        case SMTPStep.MAIL_FROM:
+          if (code.startsWith("250")) {
+            nextStep();
+          } else {
+            finish(null, "mail_from_rejected");
+          }
+          break;
+        case SMTPStep.RCPT_TO:
+          if (code.startsWith("250") || code.startsWith("251")) {
+            finish(true, "valid");
+          } else if (code.startsWith("552") || code.startsWith("452")) {
+            finish(false, "over_quota");
+          } else if (code.startsWith("4")) {
+            finish(null, "temporary_failure");
+          } else if (useVRFY && supportsVRFY && code.startsWith("5") && activeSequence.steps.includes(SMTPStep.VRFY)) {
+            currentStepIndex = activeSequence.steps.indexOf(SMTPStep.VRFY);
+            executeStep(SMTPStep.VRFY);
+          } else {
+            finish(null, "ambiguous");
+          }
+          break;
+        case SMTPStep.VRFY:
+          if (code.startsWith("250") || code.startsWith("252")) {
+            finish(true, "vrfy_valid");
+          } else if (code.startsWith("550")) {
+            finish(false, "vrfy_invalid");
+          } else {
+            finish(null, "vrfy_failed");
+          }
+          break;
+        case SMTPStep.QUIT:
+          if (code.startsWith("221")) {
+            finish(null, "quit_received");
+          }
+          break;
+      }
+    };
+    const handleData = (data) => {
+      if (resolved)
+        return;
+      buffer += data.toString();
+      let pos;
+      while ((pos = buffer.indexOf("\r\n")) !== -1) {
+        const line = buffer.substring(0, pos);
+        buffer = buffer.substring(pos + 2);
+        processResponse(line.trim());
+      }
+    };
+    if (port < 0 || port > 65535 || !Number.isInteger(port)) {
+      finish(null, "invalid_port");
+      return;
+    }
+    if (implicitTLS) {
+      const connectOptions = {
+        ...tlsOptions,
+        port,
+        servername: isIPAddress(mxHost) ? void 0 : mxHost
+      };
+      socket = tls.connect(connectOptions, () => {
+        log(`Connected to ${mxHost}:${port} with TLS`);
+        socket.on("data", handleData);
+      });
+    } else {
+      socket = net.connect({ host: mxHost, port }, () => {
+        log(`Connected to ${mxHost}:${port}`);
+        socket.on("data", handleData);
+      });
+    }
+    if (activeSequence.steps.length === 0) {
+      finish(true, "sequence_complete");
+      return;
+    }
+    const firstStep = activeSequence.steps[0];
+    if (firstStep !== SMTPStep.GREETING) {
+      executeStep(firstStep);
+    }
+    socket.setTimeout(timeout, () => finish(null, "timeout"));
+    socket.on("error", () => finish(null, "connection_error"));
+    socket.on("close", () => {
+      if (!resolved)
+        finish(null, "connection_closed");
+    });
   });
 }
 
-var VerificationErrorCode;
-(function(VerificationErrorCode2) {
-  VerificationErrorCode2["INVALID_FORMAT"] = "INVALID_FORMAT";
-  VerificationErrorCode2["INVALID_DOMAIN"] = "INVALID_DOMAIN";
-  VerificationErrorCode2["NO_MX_RECORDS"] = "NO_MX_RECORDS";
-  VerificationErrorCode2["SMTP_CONNECTION_FAILED"] = "SMTP_CONNECTION_FAILED";
-  VerificationErrorCode2["SMTP_TIMEOUT"] = "SMTP_TIMEOUT";
-  VerificationErrorCode2["MAILBOX_NOT_FOUND"] = "MAILBOX_NOT_FOUND";
-  VerificationErrorCode2["MAILBOX_FULL"] = "MAILBOX_FULL";
-  VerificationErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
-  VerificationErrorCode2["DISPOSABLE_EMAIL"] = "DISPOSABLE_EMAIL";
-  VerificationErrorCode2["FREE_EMAIL_PROVIDER"] = "FREE_EMAIL_PROVIDER";
-})(VerificationErrorCode || (VerificationErrorCode = {}));
-
 async function isValidEmailDomain(emailOrDomain, cache) {
   let [_, emailDomain] = (emailOrDomain === null || emailOrDomain === void 0 ? void 0 : emailOrDomain.split("@")) || [];
   if (!emailDomain) {
@@ -2356,17 +2643,22 @@ async function verifyEmail(params) {
               domainPort = domainPorts[mxDomain.domain];
             }
           }
-          const smtpResult = await verifyMailboxSMTP({
+          const { result: smtpResult, cached, portCached, port } = await verifyMailboxSMTP({
             local,
             domain,
             mxRecords,
-            timeout,
-            debug,
-            port: domainPort,
-            retryAttempts: params.retryAttempts
+            options: {
+              cache: params.cache,
+              ports: domainPort ? [domainPort] : void 0,
+              timeout,
+              debug,
+              maxRetries: params.retryAttempts
+            }
           });
           await smtpCacheInstance.set(cacheKey, smtpResult);
           result.validSmtp = smtpResult;
+          if (result.metadata)
+            result.metadata.cached = cached;
           log(`[verifyEmail] SMTP verification result: ${result.validSmtp} for ${emailAddress} (cached for future use)`);
         }
         if (result.validSmtp === false && result.metadata) {
@@ -2391,5 +2683,5 @@ async function verifyEmail(params) {
   return result;
 }
 
-export { COMMON_EMAIL_DOMAINS, DEFAULT_CACHE_OPTIONS, LRUAdapter, RedisAdapter, VerificationErrorCode, cleanNameForAlgrothin, clearDefaultCache, defaultDomainSuggestionMethod, defaultNameDetectionMethod, detectName, detectNameForAlgrothin, detectNameFromEmail, domainPorts, getCacheStore, getDefaultCache, getDomainAge, getDomainRegistrationStatus, getDomainSimilarity, isCommonDomain, isDisposableEmail, isFreeEmail, isValidEmail, isValidEmailDomain, resetDefaultCache, suggestDomain, suggestEmailDomain, verifyEmail, verifyEmailBatch };
+export { COMMON_EMAIL_DOMAINS, DEFAULT_CACHE_OPTIONS, LRUAdapter, RedisAdapter, SMTPStep, VerificationErrorCode, cleanNameForAlgrothin, clearDefaultCache, defaultDomainSuggestionMethod, defaultNameDetectionMethod, detectName, detectNameForAlgrothin, detectNameFromEmail, domainPorts, getCacheStore, getDefaultCache, getDomainAge, getDomainRegistrationStatus, getDomainSimilarity, isCommonDomain, isDisposableEmail, isFreeEmail, isValidEmail, isValidEmailDomain, resetDefaultCache, suggestDomain, suggestEmailDomain, verifyEmail, verifyEmailBatch };
 //# sourceMappingURL=index.esm.js.map