linkedin-secret-sauce 0.11.0 → 0.11.1

package/dist/enrichment/providers/index.js

@@ -3,7 +3,7 @@
  * Email Enrichment Providers
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearSnovioTokenCache = exports.verifyEmailWithSnovio = exports.findEmailsWithSnovio = exports.createSnovioProvider = exports.verifyEmailsBatch = exports.checkCatchAllDomain = exports.verifyEmailWithBouncer = exports.createBouncerProvider = exports.createDropcontactProvider = exports.createApolloProvider = exports.createHunterProvider = exports.createSmartProspectProvider = exports.createLddProvider = exports.createConstructProvider = void 0;
+exports.clearSnovioTokenCache = exports.verifyEmailWithSnovio = exports.findEmailsWithSnovio = exports.createSnovioProvider = exports.verifyEmailsBatch = exports.checkCatchAllDomain = exports.verifyEmailWithBouncer = exports.createBouncerProvider = exports.createDropcontactProvider = exports.createHunterProvider = exports.createSmartProspectProvider = exports.createLddProvider = exports.createConstructProvider = void 0;
 var construct_1 = require("./construct");
 Object.defineProperty(exports, "createConstructProvider", { enumerable: true, get: function () { return construct_1.createConstructProvider; } });
 var ldd_1 = require("./ldd");
@@ -12,8 +12,6 @@ var smartprospect_1 = require("./smartprospect");
 Object.defineProperty(exports, "createSmartProspectProvider", { enumerable: true, get: function () { return smartprospect_1.createSmartProspectProvider; } });
 var hunter_1 = require("./hunter");
 Object.defineProperty(exports, "createHunterProvider", { enumerable: true, get: function () { return hunter_1.createHunterProvider; } });
-var apollo_1 = require("./apollo");
-Object.defineProperty(exports, "createApolloProvider", { enumerable: true, get: function () { return apollo_1.createApolloProvider; } });
 var dropcontact_1 = require("./dropcontact");
 Object.defineProperty(exports, "createDropcontactProvider", { enumerable: true, get: function () { return dropcontact_1.createDropcontactProvider; } });
 var bouncer_1 = require("./bouncer");

package/dist/enrichment/providers/ldd.js

@@ -13,43 +13,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractNumericLinkedInId = extractNumericLinkedInId;
 exports.createLddProvider = createLddProvider;
 const validation_1 = require("../utils/validation");
-/**
- * Delay helper for retry logic
- */
-async function delay(ms) {
-    return new Promise((r) => setTimeout(r, ms));
-}
-/**
- * HTTP request with retry on 429 rate limit
- */
-async function requestWithRetry(url, token, retries = 1, backoffMs = 200) {
-    let lastErr;
-    for (let i = 0; i <= retries; i++) {
-        try {
-            const res = await fetch(url, {
-                method: "GET",
-                headers: {
-                    Authorization: `Bearer ${token}`,
-                    "Content-Type": "application/json",
-                },
-            });
-            // Retry on rate limit
-            if (res?.status === 429 && i < retries) {
-                await delay(backoffMs * Math.pow(2, i));
-                continue;
-            }
-            return res;
-        }
-        catch (err) {
-            lastErr = err;
-            if (i < retries) {
-                await delay(backoffMs * Math.pow(2, i));
-                continue;
-            }
-        }
-    }
-    throw lastErr ?? new Error("ldd_http_error");
-}
+const http_retry_1 = require("../utils/http-retry");
 /**
  * Extract numeric LinkedIn ID from various formats:
  * - Direct number: "307567"
@@ -162,11 +126,8 @@ function createLddProvider(config) {
     async function lookupByNumericId(numericId) {
         try {
             const endpoint = `${apiUrl}/api/v1/profiles/by-numeric-id/${encodeURIComponent(numericId)}`;
-            const response = await requestWithRetry(endpoint, apiToken, 1, 100);
-            if (!response.ok) {
-                return null;
-            }
-            return parseResponse(await response.json());
+            const response = await (0, http_retry_1.getWithRetry)(endpoint, { Authorization: `Bearer ${apiToken}` }, { retries: 1, backoffMs: 100 });
+            return parseResponse(response);
         }
         catch {
             return null;
@@ -175,11 +136,8 @@ function createLddProvider(config) {
     async function lookupByUsername(username) {
         try {
             const endpoint = `${apiUrl}/api/v1/profiles/by-username/${encodeURIComponent(username)}`;
-            const response = await requestWithRetry(endpoint, apiToken, 1, 100);
-            if (!response.ok) {
-                return null;
-            }
-            return parseResponse(await response.json());
+            const response = await (0, http_retry_1.getWithRetry)(endpoint, { Authorization: `Bearer ${apiToken}` }, { retries: 1, backoffMs: 100 });
+            return parseResponse(response);
         }
         catch {
             return null;

package/dist/enrichment/providers/smartprospect.js

@@ -17,13 +17,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSmartProspectProvider = createSmartProspectProvider;
 exports.createSmartProspectClient = createSmartProspectClient;
 const smartlead_auth_1 = require("../auth/smartlead-auth");
+const http_retry_1 = require("../utils/http-retry");
 const DEFAULT_API_URL = "https://prospect-api.smartlead.ai/api/search-email-leads";
-/**
- * Delay helper for retry logic
- */
-async function delay(ms) {
-    return new Promise((r) => setTimeout(r, ms));
-}
 const DEFAULT_POLLING_CONFIG = {
     initialDelay: 500,
     pollInterval: 1000,
@@ -40,7 +35,7 @@ async function requestWithRetry(url, options, retries = 2, backoffMs = 300) {
             const res = await fetch(url, options);
             // Retry on rate limit
             if (res.status === 429 && i < retries) {
-                await delay(backoffMs * Math.pow(2, i));
+                await (0, http_retry_1.delay)(backoffMs * Math.pow(2, i));
                 continue;
             }
             if (!res.ok) {
@@ -52,7 +47,7 @@ async function requestWithRetry(url, options, retries = 2, backoffMs = 300) {
         catch (err) {
             lastErr = err;
             if (i < retries) {
-                await delay(backoffMs * Math.pow(2, i));
+                await (0, http_retry_1.delay)(backoffMs * Math.pow(2, i));
                 continue;
             }
         }
@@ -214,7 +209,7 @@ function createSmartProspectProvider(config) {
     async function pollForContactResults(filterId, expectedCount) {
         const { initialDelay, pollInterval, maxAttempts, maxWaitTime } = DEFAULT_POLLING_CONFIG;
         const startTime = Date.now();
-        await delay(initialDelay);
+        await (0, http_retry_1.delay)(initialDelay);
         const makeRequest = async (token) => {
             return requestWithRetry(`${apiUrl}/get-contacts`, {
                 method: "POST",
@@ -243,13 +238,13 @@ function createSmartProspectProvider(config) {
                         return result;
                     }
                 }
-                await delay(pollInterval);
+                await (0, http_retry_1.delay)(pollInterval);
             }
             catch (err) {
                 if (err instanceof Error && err.message.includes("401") && hasCredentials) {
                     await handleAuthError();
                 }
-                await delay(pollInterval);
+                await (0, http_retry_1.delay)(pollInterval);
             }
         }
         // Return last result
@@ -628,7 +623,7 @@ function createSmartProspectClient(config) {
         const { initialDelay, pollInterval, maxAttempts, maxWaitTime } = pollingConfig;
         const startTime = Date.now();
         // Wait initial delay before first poll
-        await delay(initialDelay);
+        await (0, http_retry_1.delay)(initialDelay);
         const makeRequest = async (token) => {
             return requestWithRetry(`${apiUrl}/get-contacts`, {
                 method: "POST",
@@ -660,7 +655,7 @@ function createSmartProspectClient(config) {
                     }
                 }
                 // Wait before next poll
-                await delay(pollInterval);
+                await (0, http_retry_1.delay)(pollInterval);
             }
             catch (err) {
                 // On 401, clear token and retry
@@ -670,7 +665,7 @@ function createSmartProspectClient(config) {
                     await handleAuthError();
                 }
                 // Continue polling on errors
-                await delay(pollInterval);
+                await (0, http_retry_1.delay)(pollInterval);
             }
         }
         // Return last result even if not complete

package/dist/enrichment/types.d.ts

@@ -126,12 +126,6 @@ export interface EnrichmentCandidate {
 export interface HunterConfig {
     apiKey: string;
 }
-/**
- * Apollo.io provider configuration
- */
-export interface ApolloConfig {
-    apiKey: string;
-}
 /**
  * SmartProspect/Smartlead provider configuration
  *
@@ -277,6 +271,8 @@ export interface ConstructConfig {
     maxAttempts?: number;
     /** Timeout for MX verification in ms (default: 5000) */
     timeoutMs?: number;
+    /** Delay between SMTP verification checks in ms (default: 2000) */
+    smtpVerifyDelayMs?: number;
 }
 /**
  * All provider configurations
@@ -286,7 +282,6 @@ export interface ProvidersConfig {
     ldd?: LddConfig;
     smartprospect?: SmartProspectConfig;
     hunter?: HunterConfig;
-    apollo?: ApolloConfig;
     dropcontact?: DropcontactConfig;
     /** Bouncer.io for SMTP email verification (99%+ accuracy) */
     bouncer?: BouncerConfig;
@@ -301,7 +296,7 @@ export interface EnrichmentOptions {
     maxCostPerEmail?: number;
     /** Minimum confidence threshold 0-100 (default: 0) */
     confidenceThreshold?: number;
-    /** Provider order (default: ['construct', 'ldd', 'smartprospect', 'hunter', 'apollo', 'dropcontact']) */
+    /** Provider order (default: ['ldd', 'smartprospect', 'construct', 'bouncer', 'snovio', 'hunter']) */
     providerOrder?: ProviderName[];
     /** Retry delay in ms on transient errors (default: 200) */
     retryMs?: number;
@@ -370,30 +365,34 @@ export interface EnrichmentClient {
 /**
  * Available provider names
  */
-export type ProviderName = "construct" | "ldd" | "smartprospect" | "hunter" | "apollo" | "dropcontact" | "bouncer" | "snovio";
+export type ProviderName = "construct" | "ldd" | "smartprospect" | "hunter" | "dropcontact" | "bouncer" | "snovio";
 /**
- * Default provider order
+ * Default provider order - 2-Phase Strategy
+ *
+ * PHASE 1 - Free lookups (run in parallel):
+ *   - ldd: LinkedIn Data Dump - real verified emails (FREE with subscription)
+ *   - smartprospect: SmartLead API - real verified emails (FREE with subscription)
+ *   - construct: Pattern guessing + MX check (FREE)
+ *
+ * PHASE 2 - Paid verification/finding (only if Phase 1 inconclusive):
+ *   - bouncer: SMTP verify constructed emails ($0.006/email)
+ *   - snovio: Email finder for catch-all domains ($0.02/email)
+ *   - hunter: Hunter.io fallback ($0.005/email)
  *
- * Strategy:
- * 1. construct - FREE pattern guessing with MX check
- * 2. bouncer - SMTP verification of construct results ($0.006/email)
- * 3. ldd - FREE LinkedIn data dump lookup
- * 4. smartprospect - Paid SmartLead lookup ($0.01/email)
- * 5. snovio - Email finder for catch-all domains ($0.02/email)
- * 6. hunter - Hunter.io API ($0.005/email)
- * 7. apollo - FREE Apollo.io lookup
- * 8. dropcontact - Dropcontact API ($0.01/email)
+ * Note: dropcontact available but not in default order (expensive at $0.01)
  */
 export declare const DEFAULT_PROVIDER_ORDER: ProviderName[];
 /**
  * Provider costs in USD per lookup
  *
  * Costs based on 2025 pricing:
- * - Bouncer: $0.006/email at scale (best accuracy 99%+)
- * - Snov.io: $0.02/email (email finding + verification)
- * - Hunter: $0.005/email
- * - SmartProspect: $0.01/email
- * - Dropcontact: $0.01/email
+ * - ldd: FREE (subscription-based)
+ * - smartprospect: FREE (included in SmartLead subscription)
+ * - construct: FREE (pattern guessing + MX check)
+ * - bouncer: $0.006/email (SMTP verification, 99%+ accuracy)
+ * - snovio: $0.02/email (email finding + verification)
+ * - hunter: $0.005/email
+ * - dropcontact: $0.01/email (not in default order)
  */
 export declare const PROVIDER_COSTS: Record<ProviderName, number>;
 /**

package/dist/enrichment/types.js

@@ -8,44 +8,45 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SMARTPROSPECT_SUB_INDUSTRIES = exports.PROVIDER_COSTS = exports.DEFAULT_PROVIDER_ORDER = void 0;
 /**
- * Default provider order
+ * Default provider order - 2-Phase Strategy
  *
- * Strategy:
- * 1. construct - FREE pattern guessing with MX check
- * 2. bouncer - SMTP verification of construct results ($0.006/email)
- * 3. ldd - FREE LinkedIn data dump lookup
- * 4. smartprospect - Paid SmartLead lookup ($0.01/email)
- * 5. snovio - Email finder for catch-all domains ($0.02/email)
- * 6. hunter - Hunter.io API ($0.005/email)
- * 7. apollo - FREE Apollo.io lookup
- * 8. dropcontact - Dropcontact API ($0.01/email)
+ * PHASE 1 - Free lookups (run in parallel):
+ *   - ldd: LinkedIn Data Dump - real verified emails (FREE with subscription)
+ *   - smartprospect: SmartLead API - real verified emails (FREE with subscription)
+ *   - construct: Pattern guessing + MX check (FREE)
+ *
+ * PHASE 2 - Paid verification/finding (only if Phase 1 inconclusive):
+ *   - bouncer: SMTP verify constructed emails ($0.006/email)
+ *   - snovio: Email finder for catch-all domains ($0.02/email)
+ *   - hunter: Hunter.io fallback ($0.005/email)
+ *
+ * Note: dropcontact available but not in default order (expensive at $0.01)
  */
 exports.DEFAULT_PROVIDER_ORDER = [
-    "construct",
-    "bouncer",
     "ldd",
     "smartprospect",
+    "construct",
+    "bouncer",
     "snovio",
     "hunter",
-    "apollo",
-    "dropcontact",
 ];
 /**
  * Provider costs in USD per lookup
  *
  * Costs based on 2025 pricing:
- * - Bouncer: $0.006/email at scale (best accuracy 99%+)
- * - Snov.io: $0.02/email (email finding + verification)
- * - Hunter: $0.005/email
- * - SmartProspect: $0.01/email
- * - Dropcontact: $0.01/email
+ * - ldd: FREE (subscription-based)
+ * - smartprospect: FREE (included in SmartLead subscription)
+ * - construct: FREE (pattern guessing + MX check)
+ * - bouncer: $0.006/email (SMTP verification, 99%+ accuracy)
+ * - snovio: $0.02/email (email finding + verification)
+ * - hunter: $0.005/email
+ * - dropcontact: $0.01/email (not in default order)
  */
 exports.PROVIDER_COSTS = {
     construct: 0,
     ldd: 0,
-    smartprospect: 0.01,
+    smartprospect: 0,
     hunter: 0.005,
-    apollo: 0,
     dropcontact: 0.01,
     bouncer: 0.006,
     snovio: 0.02,

package/dist/enrichment/utils/http-retry.d.ts

@@ -0,0 +1,96 @@
+/**
+ * HTTP Retry Utilities
+ *
+ * Shared utilities for HTTP requests with retry logic, rate limit handling,
+ * and exponential backoff. Used across all enrichment providers.
+ */
+/**
+ * Delay execution for specified milliseconds
+ */
+export declare function delay(ms: number): Promise<void>;
+/**
+ * Check if a value is truthy (not null, undefined, or empty string)
+ */
+export declare function truthy(v: unknown): boolean;
+/**
+ * Map common verification status strings to boolean
+ */
+export declare function mapVerifiedStatus(status: string | undefined | null): boolean | undefined;
+/**
+ * Options for fetch with retry
+ */
+export interface FetchWithRetryOptions {
+    /** Number of retries (default: 1) */
+    retries?: number;
+    /** Initial backoff in ms (default: 200) */
+    backoffMs?: number;
+    /** Timeout in ms (default: 30000) */
+    timeoutMs?: number;
+    /** HTTP status codes that should trigger retry (default: [429, 502, 503, 504]) */
+    retryOnStatus?: number[];
+}
+/**
+ * Generic API response type
+ */
+export interface ApiResponse {
+    data?: unknown;
+    result?: unknown;
+    people?: unknown[];
+    matches?: unknown[];
+    emails?: unknown[];
+    success?: boolean;
+    message?: string;
+    [key: string]: unknown;
+}
+/**
+ * HTTP request with retry on rate limit and transient errors
+ *
+ * Features:
+ * - Exponential backoff on rate limit (429)
+ * - Retry on server errors (502, 503, 504)
+ * - Configurable timeout
+ * - Returns typed response
+ *
+ * @example
+ * ```typescript
+ * const response = await fetchWithRetry<MyApiResponse>(
+ *   'https://api.example.com/data',
+ *   {
+ *     method: 'POST',
+ *     headers: { 'Content-Type': 'application/json' },
+ *     body: JSON.stringify({ query: 'test' }),
+ *   },
+ *   { retries: 2, backoffMs: 300 }
+ * );
+ * ```
+ */
+export declare function fetchWithRetry<T = ApiResponse>(url: string, init?: RequestInit, options?: FetchWithRetryOptions): Promise<T>;
+/**
+ * Simpler GET request with retry (no request body)
+ *
+ * @example
+ * ```typescript
+ * const data = await getWithRetry<UserData>(
+ *   `https://api.example.com/users/${id}`,
+ *   { 'Authorization': `Bearer ${token}` }
+ * );
+ * ```
+ */
+export declare function getWithRetry<T = ApiResponse>(url: string, headers?: Record<string, string>, options?: FetchWithRetryOptions): Promise<T>;
+/**
+ * POST request with JSON body and retry
+ *
+ * @example
+ * ```typescript
+ * const result = await postWithRetry<SearchResult>(
+ *   'https://api.example.com/search',
+ *   { query: 'test', limit: 10 },
+ *   { 'X-Api-Key': apiKey }
+ * );
+ * ```
+ */
+export declare function postWithRetry<T = ApiResponse>(url: string, body: Record<string, unknown>, headers?: Record<string, string>, options?: FetchWithRetryOptions): Promise<T>;
+/**
+ * Safe JSON parse with fallback
+ */
+export declare function safeJsonParse<T>(str: string, fallback: T): T;

package/dist/enrichment/utils/http-retry.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * HTTP Retry Utilities
+ *
+ * Shared utilities for HTTP requests with retry logic, rate limit handling,
+ * and exponential backoff. Used across all enrichment providers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = delay;
+exports.truthy = truthy;
+exports.mapVerifiedStatus = mapVerifiedStatus;
+exports.fetchWithRetry = fetchWithRetry;
+exports.getWithRetry = getWithRetry;
+exports.postWithRetry = postWithRetry;
+exports.safeJsonParse = safeJsonParse;
+/**
+ * Delay execution for specified milliseconds
+ */
+async function delay(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+/**
+ * Check if a value is truthy (not null, undefined, or empty string)
+ */
+function truthy(v) {
+    return v !== undefined && v !== null && String(v).length > 0;
+}
+/**
+ * Map common verification status strings to boolean
+ */
+function mapVerifiedStatus(status) {
+    if (!status)
+        return undefined;
+    const s = String(status).toLowerCase();
+    if (s === 'valid' || s === 'verified' || s === 'deliverable')
+        return true;
+    if (s === 'invalid' || s === 'unverified' || s === 'undeliverable')
+        return false;
+    return undefined; // catch-all/unknown/webmail -> leave undefined
+}
+/**
+ * HTTP request with retry on rate limit and transient errors
+ *
+ * Features:
+ * - Exponential backoff on rate limit (429)
+ * - Retry on server errors (502, 503, 504)
+ * - Configurable timeout
+ * - Returns typed response
+ *
+ * @example
+ * ```typescript
+ * const response = await fetchWithRetry<MyApiResponse>(
+ *   'https://api.example.com/data',
+ *   {
+ *     method: 'POST',
+ *     headers: { 'Content-Type': 'application/json' },
+ *     body: JSON.stringify({ query: 'test' }),
+ *   },
+ *   { retries: 2, backoffMs: 300 }
+ * );
+ * ```
+ */
+async function fetchWithRetry(url, init, options) {
+    const { retries = 1, backoffMs = 200, timeoutMs = 30000, retryOnStatus = [429, 502, 503, 504], } = options ?? {};
+    let lastErr = null;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const res = await fetch(url, {
+                ...init,
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            // Check if we should retry based on status
+            if (retryOnStatus.includes(res.status) && attempt < retries) {
+                const waitMs = backoffMs * Math.pow(2, attempt);
+                await delay(waitMs);
+                continue;
+            }
+            // Handle non-OK responses
+            if (!res.ok) {
+                const errorText = await res.text().catch(() => '');
+                lastErr = new Error(`HTTP ${res.status}: ${res.statusText}${errorText ? ` - ${errorText.slice(0, 200)}` : ''}`);
+                break;
+            }
+            const json = await res.json();
+            return json;
+        }
+        catch (err) {
+            clearTimeout(timeoutId);
+            // Handle abort/timeout
+            if (err instanceof Error && err.name === 'AbortError') {
+                lastErr = new Error(`Request timeout after ${timeoutMs}ms`);
+            }
+            else {
+                lastErr = err instanceof Error ? err : new Error(String(err));
+            }
+            // Retry on network errors
+            if (attempt < retries) {
+                const waitMs = backoffMs * Math.pow(2, attempt);
+                await delay(waitMs);
+                continue;
+            }
+        }
+    }
+    throw lastErr ?? new Error('Request failed');
+}
+/**
+ * Simpler GET request with retry (no request body)
+ *
+ * @example
+ * ```typescript
+ * const data = await getWithRetry<UserData>(
+ *   `https://api.example.com/users/${id}`,
+ *   { 'Authorization': `Bearer ${token}` }
+ * );
+ * ```
+ */
+async function getWithRetry(url, headers, options) {
+    return fetchWithRetry(url, {
+        method: 'GET',
+        headers: {
+            'Accept': 'application/json',
+            ...headers,
+        },
+    }, options);
+}
+/**
+ * POST request with JSON body and retry
+ *
+ * @example
+ * ```typescript
+ * const result = await postWithRetry<SearchResult>(
+ *   'https://api.example.com/search',
+ *   { query: 'test', limit: 10 },
+ *   { 'X-Api-Key': apiKey }
+ * );
+ * ```
+ */
+async function postWithRetry(url, body, headers, options) {
+    return fetchWithRetry(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+            ...headers,
+        },
+        body: JSON.stringify(body),
+    }, options);
+}
+/**
+ * Safe JSON parse with fallback
+ */
+function safeJsonParse(str, fallback) {
+    try {
+        return JSON.parse(str);
+    }
+    catch {
+        return fallback;
+    }
+}

package/dist/enrichment/verification/index.d.ts

@@ -1,4 +1,4 @@
 /**
  * Email Verification Module
  */
-export { verifyEmailMx } from './mx';
+export { verifyEmailMx, checkDomainCatchAll, verifyEmailsExist } from './mx';

package/dist/enrichment/verification/index.js

@@ -3,6 +3,8 @@
  * Email Verification Module
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifyEmailMx = void 0;
+exports.verifyEmailsExist = exports.checkDomainCatchAll = exports.verifyEmailMx = void 0;
 var mx_1 = require("./mx");
 Object.defineProperty(exports, "verifyEmailMx", { enumerable: true, get: function () { return mx_1.verifyEmailMx; } });
+Object.defineProperty(exports, "checkDomainCatchAll", { enumerable: true, get: function () { return mx_1.checkDomainCatchAll; } });
+Object.defineProperty(exports, "verifyEmailsExist", { enumerable: true, get: function () { return mx_1.verifyEmailsExist; } });

package/dist/enrichment/verification/mx.d.ts

@@ -2,8 +2,25 @@
  * MX Record Resolution and Email Verification
  *
  * Provides MX record resolution with timeout support and confidence scoring.
+ * Includes SMTP-based catch-all detection using RCPT TO verification.
  */
 import type { VerificationResult } from '../types';
+/**
+ * Verify multiple email addresses with rate limiting
+ *
+ * @param emails - Array of email addresses to verify
+ * @param options - Options including delay between checks
+ * @returns Array of verification results
+ */
+export declare function verifyEmailsExist(emails: string[], options?: {
+    delayMs?: number;
+    timeoutMs?: number;
+}): Promise<Array<{
+    email: string;
+    exists: boolean | null;
+    mxHost: string | null;
+    error?: string;
+}>>;
 /**
  * Verify an email address via MX record lookup
  *
@@ -11,6 +28,22 @@ import type { VerificationResult } from '../types';
  * @param options - Verification options
  * @returns Verification result with confidence score
  */
+/**
+ * Check if a domain is a catch-all (accepts all email addresses)
+ *
+ * @param domain - Domain to check
+ * @param options - Options including timeout
+ * @returns Object with isCatchAll status and MX records
+ */
+export declare function checkDomainCatchAll(domain: string, options?: {
+    timeoutMs?: number;
+}): Promise<{
+    isCatchAll: boolean | null;
+    mxRecords: string[];
+    mxHost: string | null;
+    error?: string;
+}>;
 export declare function verifyEmailMx(email: string, options?: {
     timeoutMs?: number;
+    checkCatchAll?: boolean;
 }): Promise<VerificationResult>;