linkedin-secret-sauce 0.12.1 → 0.12.3

package/dist/enrichment/matching.d.ts

@@ -258,7 +258,7 @@ export declare function createLinkedInEnricher(smartProspectConfig: SmartProspec
 /**
  * Email source - where the email was found
  */
-export type EmailSource = "ldd" | "smartprospect" | "cosiall" | "linkedin" | "pattern" | "hunter" | "bouncer" | "snovio";
+export type EmailSource = "ldd" | "smartprospect" | "cosiall" | "trykitt" | "linkedin" | "pattern" | "hunter" | "bouncer" | "bounceban" | "snovio";
 /**
  * Email result from unified lookup
  */
@@ -309,6 +309,10 @@ export interface GetEmailsConfig {
     cosiall?: {
         enabled?: boolean;
     };
+    /** TryKitt.ai configuration (FREE for individuals - unlimited) */
+    trykitt?: {
+        apiKey: string;
+    };
     /** Company domain for email pattern guessing (optional - if not provided, will try to discover) */
     companyDomain?: string;
     /**
@@ -327,6 +331,12 @@ export interface GetEmailsConfig {
     bouncer?: {
         apiKey: string;
     };
+    /** BounceBan configuration (FREE single / catch-all specialist) */
+    bounceban?: {
+        apiKey: string;
+        useDeepVerify?: boolean;
+        useWaterfall?: boolean;
+    };
     /** Snov.io configuration (PAID - email finder) */
     snovio?: {
         userId: string;
@@ -343,11 +353,15 @@ export interface GetEmailsOptions {
     skipSmartProspect?: boolean;
     /** Skip Cosiall Profile Emails lookup (default: false) */
     skipCosiall?: boolean;
+    /** Skip TryKitt.ai lookup (default: false) */
+    skipTryKitt?: boolean;
     /** Skip email pattern guessing (default: false) */
     skipPatternGuessing?: boolean;
+    /** Skip BounceBan catch-all verification (default: false) */
+    skipBounceBan?: boolean;
     /** Skip LinkedIn company lookup for domain discovery (default: false) */
     skipLinkedInCompanyLookup?: boolean;
-    /** Skip paid providers Hunter/Apollo (default: false) */
+    /** Skip paid providers Hunter/Snovio (default: false) */
     skipPaidProviders?: boolean;
     /** Minimum match confidence for SmartProspect (default: 60) */
     minMatchConfidence?: number;

package/dist/enrichment/matching.js

@@ -780,7 +780,7 @@ function createLinkedInEnricher(smartProspectConfig, defaultOptions = {}) {
 async function getEmailsForLinkedInContact(contactOrLead, config, options = {}) {
     // Normalize input - accept either LinkedInContact or raw SalesLeadSearchResult
     const contact = normalizeToContact(contactOrLead);
-    const { skipLdd = false, skipSmartProspect = false, skipCosiall = false, skipPatternGuessing = false, skipPaidProviders = false, minMatchConfidence = 60, paidProviderThreshold = 80, includeCompany = true, } = options;
+    const { skipLdd = false, skipSmartProspect = false, skipCosiall = false, skipTryKitt = false, skipPatternGuessing = false, skipBounceBan = false, skipPaidProviders = false, minMatchConfidence = 60, paidProviderThreshold = 80, includeCompany = true, } = options;
     // Extract numeric ID from objectUrn
     const numericLinkedInId = (0, ldd_1.extractNumericLinkedInId)(contact.objectUrn);
     // Extract company domain from contact (LinkedIn data - often missing)
@@ -792,28 +792,75 @@ async function getEmailsForLinkedInContact(contactOrLead, config, options = {})
         providersQueried: [],
         errors: [],
     };
-    // Track seen emails to deduplicate
-    const seenEmails = new Set();
+    // Track all emails with their sources for confidence boosting
+    const emailsByAddress = new Map();
     const addEmail = (emailResult) => {
         const lower = emailResult.email.toLowerCase();
-        if (!seenEmails.has(lower)) {
-            seenEmails.add(lower);
-            result.emails.push(emailResult);
+        const existing = emailsByAddress.get(lower);
+        if (existing) {
+            // Email already found from another source - track for confidence boosting
+            existing.results.push(emailResult);
+            existing.sources.add(emailResult.source);
         }
+        else {
+            emailsByAddress.set(lower, {
+                results: [emailResult],
+                sources: new Set([emailResult.source]),
+            });
+        }
+    };
+    /**
+     * Merge emails and boost confidence when found from multiple sources
+     * - 2 sources: boost to at least 95% confidence
+     * - 3+ sources: boost to 100% confidence
+     */
+    const mergeAndBoostEmails = () => {
+        const mergedEmails = [];
+        for (const [_email, { results, sources }] of emailsByAddress) {
+            // Find the best result (highest confidence)
+            const bestResult = results.reduce((best, current) => current.confidence > best.confidence ? current : best);
+            // Boost confidence based on number of sources
+            let boostedConfidence = bestResult.confidence;
+            if (sources.size >= 3) {
+                boostedConfidence = 100;
+            }
+            else if (sources.size === 2) {
+                boostedConfidence = Math.max(boostedConfidence, 95);
+            }
+            // Create merged result
+            const mergedResult = {
+                ...bestResult,
+                confidence: boostedConfidence,
+                metadata: {
+                    ...bestResult.metadata,
+                    foundBySources: Array.from(sources),
+                    sourceCount: sources.size,
+                    confidenceBoosted: sources.size > 1,
+                    originalConfidence: bestResult.confidence,
+                },
+            };
+            // If verified by any source, mark as verified
+            if (results.some((r) => r.verified)) {
+                mergedResult.verified = true;
+            }
+            mergedEmails.push(mergedResult);
+        }
+        return mergedEmails;
     };
     // Track company domain discovered from SmartProspect (since LinkedIn doesn't provide it)
     let discoveredCompanyDomain = null;
     // ==========================================================================
-    // Phase 1: FREE providers in PARALLEL (LDD + SmartProspect + Cosiall)
+    // Phase 1: FREE database providers in PARALLEL (no LinkedIn API calls)
+    // LDD + SmartProspect + Cosiall - these are your own databases or already paid
     // ==========================================================================
     const freeProviderPromises = [];
-    // LDD lookup (FREE)
+    // LDD lookup (FREE - your ~500M database)
     if (!skipLdd && config.ldd?.apiUrl && config.ldd?.apiToken) {
         result.providersQueried.push("ldd");
         freeProviderPromises.push(queryLdd(contact, config.ldd, numericLinkedInId, addEmail, result));
     }
-    // SmartProspect lookup (FREE for FlexIQ)
-    // This also extracts company domain for pattern guessing
+    // SmartProspect lookup (FREE for FlexIQ - already paying monthly)
+    // This also extracts company domain for pattern guessing (no extra API call)
     if (!skipSmartProspect && config.smartprospect) {
         result.providersQueried.push("smartprospect");
         freeProviderPromises.push(querySmartProspect(contact, config.smartprospect, minMatchConfidence, includeCompany, addEmail, result).then((domain) => {
@@ -822,63 +869,86 @@ async function getEmailsForLinkedInContact(contactOrLead, config, options = {})
             }
         }));
     }
-    // Cosiall Profile Emails lookup (FREE)
+    // Cosiall Profile Emails lookup (FREE - your database)
     if (!skipCosiall && config.cosiall?.enabled !== false) {
         result.providersQueried.push("cosiall");
         freeProviderPromises.push(queryCosiall(contact, addEmail, result));
     }
-    // Wait for both free providers
+    // TryKitt.ai lookup (FREE for individuals - unlimited)
+    // AI-powered email finder with enterprise identity server catch-all verification
+    if (!skipTryKitt && config.trykitt?.apiKey) {
+        result.providersQueried.push("trykitt");
+        freeProviderPromises.push(queryTryKitt(contact, config.trykitt, linkedInCompanyDomain || discoveredCompanyDomain, addEmail, result));
+    }
+    // Wait for all Phase 1 free providers
     await Promise.all(freeProviderPromises);
-    // Check if we have good enough results already
-    const bestConfidenceAfterFreeProviders = result.emails.length > 0
+    // Merge emails and calculate best confidence after Phase 1
+    result.emails = mergeAndBoostEmails();
+    const phase1BestConfidence = result.emails.length > 0
         ? Math.max(...result.emails.map((e) => e.confidence))
         : 0;
     // ==========================================================================
-    // Phase 2: Domain Discovery (if needed for pattern guessing)
+    // Phase 2: Domain Discovery + Pattern Guessing
+    // ONLY if Phase 1 confidence < threshold (to minimize LinkedIn API calls)
     // ==========================================================================
-    // Priority: LinkedIn contact data > SmartProspect > LinkedIn Company API
     let companyDomain = linkedInCompanyDomain || discoveredCompanyDomain;
-    // If no domain yet and pattern guessing is enabled, try LinkedIn company lookup
-    if (!companyDomain &&
-        !skipPatternGuessing &&
-        !options.skipLinkedInCompanyLookup &&
-        config.linkedInCompanyLookup &&
-        bestConfidenceAfterFreeProviders < paidProviderThreshold) {
-        // Extract company ID from companyUrn
-        const companyUrn = contact.currentPositions?.[0]?.companyUrn;
-        if (companyUrn) {
-            const companyId = extractCompanyIdFromUrn(companyUrn);
-            if (companyId) {
-                result.providersQueried.push("linkedin");
-                try {
-                    const company = await config.linkedInCompanyLookup(companyId);
-                    if (company?.websiteUrl) {
-                        companyDomain = extractDomainFromUrl(company.websiteUrl);
-                        if (companyDomain) {
-                            discoveredCompanyDomain = companyDomain;
+    // Skip Phase 2 entirely if we already have high confidence emails
+    if (phase1BestConfidence < paidProviderThreshold) {
+        // Try LinkedIn Company Lookup for domain discovery (EXPENSIVE - uses LinkedIn API)
+        // Only if we don't have a domain yet
+        if (!companyDomain &&
+            !skipPatternGuessing &&
+            !options.skipLinkedInCompanyLookup &&
+            config.linkedInCompanyLookup) {
+            const companyUrn = contact.currentPositions?.[0]?.companyUrn;
+            if (companyUrn) {
+                const companyId = extractCompanyIdFromUrn(companyUrn);
+                if (companyId) {
+                    result.providersQueried.push("linkedin");
+                    try {
+                        const company = await config.linkedInCompanyLookup(companyId);
+                        if (company?.websiteUrl) {
+                            companyDomain = extractDomainFromUrl(company.websiteUrl);
+                            if (companyDomain) {
+                                discoveredCompanyDomain = companyDomain;
+                            }
                         }
                     }
-                }
-                catch (err) {
-                    result.errors?.push(`LinkedIn: ${err instanceof Error ? err.message : "Company lookup failed"}`);
+                    catch (err) {
+                        result.errors?.push(`LinkedIn: ${err instanceof Error ? err.message : "Company lookup failed"}`);
+                    }
                 }
             }
         }
+        // Store discovered domain in result for visibility
+        if (discoveredCompanyDomain && !linkedInCompanyDomain) {
+            result.discoveredCompanyDomain = discoveredCompanyDomain;
+        }
+        // Run pattern guessing if we have a domain (from LinkedIn contact, SmartProspect, or LinkedIn API)
+        if (!skipPatternGuessing && companyDomain) {
+            result.providersQueried.push("pattern");
+            await queryPatternGuessing(contact, companyDomain, addEmail, result);
+            // Re-merge after pattern guessing
+            result.emails = mergeAndBoostEmails();
+        }
+        // BounceBan catch-all verification (FREE single emails)
+        // Use BounceBan to verify pattern-guessed emails, especially on catch-all domains
+        if (!skipBounceBan &&
+            config.bounceban?.apiKey &&
+            result.emails.length > 0) {
+            // Only verify emails that are from pattern guessing or have low confidence
+            const emailsToVerify = result.emails
+                .filter((e) => e.source === "pattern" || (e.confidence < 80 && !e.verified))
+                .slice(0, 3); // Verify top 3 to save credits
+            if (emailsToVerify.length > 0) {
+                result.providersQueried.push("bounceban");
+                await queryBounceBan(emailsToVerify, config.bounceban, addEmail, result);
+                // Re-merge after BounceBan verification
+                result.emails = mergeAndBoostEmails();
+            }
+        }
     }
-    // Store discovered domain in result for visibility
-    if (discoveredCompanyDomain && !linkedInCompanyDomain) {
-        result.discoveredCompanyDomain = discoveredCompanyDomain;
-    }
-    // ==========================================================================
-    // Phase 3: Email pattern guessing with MX verification (FREE)
-    // ==========================================================================
-    if (!skipPatternGuessing &&
-        companyDomain &&
-        bestConfidenceAfterFreeProviders < paidProviderThreshold) {
-        result.providersQueried.push("pattern");
-        await queryPatternGuessing(contact, companyDomain, addEmail, result);
-    }
-    // Recalculate best confidence
+    // Calculate final best confidence
     const finalBestConfidence = result.emails.length > 0
         ? Math.max(...result.emails.map((e) => e.confidence))
         : 0;
@@ -887,27 +957,55 @@ async function getEmailsForLinkedInContact(contactOrLead, config, options = {})
     // ==========================================================================
     if (!skipPaidProviders && finalBestConfidence < paidProviderThreshold) {
         // Only use paid providers if we have low confidence or no results
-        // TODO: Implement Hunter, Bouncer, Snovio providers when needed
-        // For now, just mark that we would have queried them
-        if (config.hunter?.apiKey ||
-            config.bouncer?.apiKey ||
-            config.snovio?.userId) {
-            // result.providersQueried.push('hunter');
-            // result.providersQueried.push('bouncer');
-            // result.providersQueried.push('snovio');
-            // await queryPaidProviders(contact, config, addEmail, result);
+        // Hunter.io - Email Finder ($0.005/lookup)
+        if (config.hunter?.apiKey) {
+            result.providersQueried.push("hunter");
+            // Extract linkedin handle from contact if available
+            // Note: For best results, caller should fetch profile with getSalesNavigatorProfileFull
+            // and extract handle using extractLinkedInHandle(profile.flagshipProfileUrl)
+            let linkedinHandle = null;
+            // Try to extract from entityUrn or any linkedin URL fields
+            // (These won't typically have the vanity, but check anyway)
+            const contactAny = contact;
+            if (contactAny.linkedinHandle) {
+                linkedinHandle = String(contactAny.linkedinHandle);
+            }
+            else if (contactAny.flagshipProfileUrl) {
+                // Extract handle from flagship URL
+                const match = String(contactAny.flagshipProfileUrl).match(/linkedin\.com\/in\/([^\/\?]+)/i);
+                if (match)
+                    linkedinHandle = match[1];
+            }
+            await queryHunter(contact, config.hunter, companyDomain || null, linkedinHandle, addEmail, result);
+            // Re-merge after Hunter
+            result.emails = mergeAndBoostEmails();
+        }
+        // Snovio - Email Finder ($0.02/lookup) - best for catch-all domains
+        if (config.snovio?.userId && config.snovio?.apiSecret && companyDomain) {
+            result.providersQueried.push("snovio");
+            await querySnovio(contact, config.snovio, companyDomain, addEmail, result);
+            // Re-merge after Snovio
+            result.emails = mergeAndBoostEmails();
         }
+        // Note: Bouncer is a VERIFICATION provider (verifies existing emails).
+        // It's automatically used by the construct provider for SMTP verification.
+        // No need to call it separately here since pattern guessing already uses
+        // the built-in mx verification which is similar to Bouncer.
     }
+    // Final merge (in case paid providers added emails) and sort
+    result.emails = mergeAndBoostEmails();
     // Sort emails by confidence (highest first), then by source priority
     const sourcePriority = {
         ldd: 0, // Highest priority - your own data
         smartprospect: 1,
         cosiall: 2, // Cosiall Profile Emails (FREE)
-        linkedin: 3, // LinkedIn company lookup (for domain discovery, doesn't provide emails)
-        pattern: 4,
-        hunter: 5,
-        bouncer: 6,
-        snovio: 7,
+        trykitt: 3, // TryKitt.ai (FREE for individuals)
+        linkedin: 4, // LinkedIn company lookup (for domain discovery, doesn't provide emails)
+        pattern: 5,
+        bounceban: 6, // BounceBan catch-all verification (FREE single)
+        hunter: 7,
+        bouncer: 8,
+        snovio: 9,
     };
     result.emails.sort((a, b) => {
         if (b.confidence !== a.confidence) {
@@ -1041,6 +1139,117 @@ async function queryCosiall(contact, addEmail, result) {
         }
     }
 }
+/**
+ * Query TryKitt.ai provider (FREE for individuals)
+ * AI-powered email finder with enterprise identity server catch-all verification
+ */
+async function queryTryKitt(contact, trykittConfig, companyDomain, addEmail, result) {
+    try {
+        // Import TryKitt provider dynamically
+        const { createTryKittProvider } = await Promise.resolve().then(() => __importStar(require("./providers/trykitt")));
+        const trykittProvider = createTryKittProvider(trykittConfig);
+        // Build candidate with available data
+        const fullName = contact.fullName || `${contact.firstName} ${contact.lastName}`.trim();
+        // Need both name and domain to search
+        if (!fullName || !companyDomain) {
+            return; // Silently skip - missing required data
+        }
+        const candidate = {
+            fullName,
+            firstName: contact.firstName,
+            lastName: contact.lastName,
+            domain: companyDomain,
+        };
+        // Add LinkedIn URL if available (improves TryKitt accuracy)
+        if (contact.entityUrn) {
+            // entityUrn is like "urn:li:fs_salesProfile:..." - not useful for TryKitt
+        }
+        const trykittResult = await trykittProvider(candidate);
+        if (trykittResult) {
+            // Single result
+            if ("email" in trykittResult && trykittResult.email) {
+                addEmail({
+                    email: trykittResult.email,
+                    source: "trykitt",
+                    confidence: trykittResult.score ?? 80,
+                    type: "business",
+                    verified: trykittResult.verified ?? false,
+                    metadata: {
+                        provider: "trykitt",
+                        aiPowered: true,
+                    },
+                });
+            }
+            // Multi result
+            else if ("emails" in trykittResult) {
+                const multiResult = trykittResult;
+                for (const emailData of multiResult.emails) {
+                    addEmail({
+                        email: emailData.email,
+                        source: "trykitt",
+                        confidence: emailData.confidence ?? 70,
+                        type: "business",
+                        verified: emailData.verified ?? false,
+                        isCatchAll: emailData.isCatchAll,
+                        metadata: emailData.metadata,
+                    });
+                }
+            }
+        }
+    }
+    catch (err) {
+        result.errors?.push(`TryKitt: ${err instanceof Error ? err.message : "Unknown error"}`);
+    }
+}
+/**
+ * Query BounceBan for catch-all verification
+ * Verifies pattern-guessed emails with 85-95% accuracy on catch-all domains
+ */
+async function queryBounceBan(emailsToVerify, bouncebanConfig, addEmail, result) {
+    try {
+        // Import BounceBan provider dynamically
+        const { verifyEmailWithBounceBan } = await Promise.resolve().then(() => __importStar(require("./providers/bounceban")));
+        for (const emailResult of emailsToVerify) {
+            const verification = await verifyEmailWithBounceBan(emailResult.email, {
+                apiKey: bouncebanConfig.apiKey,
+                useDeepVerify: bouncebanConfig.useDeepVerify ?? false,
+                useWaterfall: bouncebanConfig.useWaterfall ?? true,
+            });
+            if (verification && verification.status === "success") {
+                // Map BounceBan result to confidence
+                let confidence = verification.score;
+                const verified = verification.result === "deliverable";
+                // Reduce confidence for catch-all domains even if deliverable
+                if (verification.is_accept_all && verified) {
+                    confidence = Math.min(confidence, 75);
+                }
+                // Only add if it's potentially deliverable
+                if (verification.result === "deliverable" ||
+                    verification.result === "risky") {
+                    addEmail({
+                        email: verification.email,
+                        source: "bounceban",
+                        confidence,
+                        type: "business",
+                        verified,
+                        isCatchAll: verification.is_accept_all,
+                        metadata: {
+                            bounceBanResult: verification.result,
+                            bounceBanScore: verification.score,
+                            smtpProvider: verification.smtp_provider,
+                            isDisposable: verification.is_disposable,
+                            isRole: verification.is_role,
+                            originalSource: emailResult.source,
+                        },
+                    });
+                }
+            }
+        }
+    }
+    catch (err) {
+        result.errors?.push(`BounceBan: ${err instanceof Error ? err.message : "Unknown error"}`);
+    }
+}
 /**
  * Query SmartProspect provider
  * Returns the company domain if found (for pattern guessing fallback)
@@ -1167,6 +1376,119 @@ async function queryPatternGuessing(contact, companyDomain, addEmail, result) {
         result.errors?.push(`Pattern: ${err instanceof Error ? err.message : "Unknown error"}`);
     }
 }
+/**
+ * Query Hunter.io Email Finder (PAID provider)
+ *
+ * Supports multiple modes:
+ * 1. linkedin_handle - Most accurate (requires getSalesNavigatorProfileFull to get handle)
+ * 2. domain + first_name + last_name
+ * 3. company + first_name + last_name
+ */
+async function queryHunter(contact, hunterConfig, companyDomain, linkedinHandle, addEmail, result) {
+    try {
+        // Import Hunter provider dynamically
+        const { createHunterProvider } = await Promise.resolve().then(() => __importStar(require("./providers/hunter")));
+        const hunterProvider = createHunterProvider(hunterConfig);
+        // Build candidate with all available data
+        const candidate = {
+            firstName: contact.firstName,
+            lastName: contact.lastName,
+        };
+        // Add linkedin_handle if available (best for Hunter)
+        if (linkedinHandle) {
+            candidate.linkedinHandle = linkedinHandle;
+        }
+        // Add domain if available
+        if (companyDomain) {
+            candidate.domain = companyDomain;
+        }
+        // Add company name if available
+        const companyName = contact.currentPositions?.[0]?.companyName;
+        if (companyName) {
+            candidate.company = companyName;
+        }
+        const hunterResult = await hunterProvider(candidate);
+        if (hunterResult) {
+            // Single result
+            if ("email" in hunterResult && hunterResult.email) {
+                addEmail({
+                    email: hunterResult.email,
+                    source: "hunter",
+                    confidence: hunterResult.score ?? 70,
+                    type: "business",
+                    verified: hunterResult.verified ?? false,
+                    metadata: {
+                        usedLinkedInHandle: !!linkedinHandle,
+                        usedDomain: !!companyDomain,
+                        usedCompany: !!companyName && !companyDomain && !linkedinHandle,
+                    },
+                });
+            }
+            // Multi result (from domain-search)
+            else if ("emails" in hunterResult && hunterResult.emails.length > 0) {
+                for (const emailData of hunterResult.emails) {
+                    addEmail({
+                        email: emailData.email,
+                        source: "hunter",
+                        confidence: emailData.confidence ?? 60,
+                        type: "business",
+                        verified: emailData.verified ?? false,
+                        metadata: emailData.metadata,
+                    });
+                }
+            }
+        }
+    }
+    catch (err) {
+        result.errors?.push(`Hunter: ${err instanceof Error ? err.message : "Unknown error"}`);
+    }
+}
+/**
+ * Query Snovio for email addresses
+ */
+async function querySnovio(contact, snovioConfig, companyDomain, addEmail, result) {
+    try {
+        // Import Snovio provider dynamically
+        const { createSnovioProvider } = await Promise.resolve().then(() => __importStar(require("./providers/snovio")));
+        const snovioProvider = createSnovioProvider(snovioConfig);
+        // Build candidate with available data
+        const candidate = {
+            firstName: contact.firstName,
+            lastName: contact.lastName,
+            domain: companyDomain,
+        };
+        const snovioResult = await snovioProvider(candidate);
+        if (snovioResult) {
+            // Single result
+            if ("email" in snovioResult && snovioResult.email) {
+                addEmail({
+                    email: snovioResult.email,
+                    source: "snovio",
+                    confidence: snovioResult.score ?? 70,
+                    type: "business",
+                    verified: snovioResult.verified ?? false,
+                });
+            }
+            // Multi result
+            else if ("emails" in snovioResult && snovioResult.emails.length > 0) {
+                for (const emailData of snovioResult.emails) {
+                    addEmail({
+                        email: emailData.email,
+                        source: "snovio",
+                        confidence: emailData.confidence ?? 60,
+                        type: "business",
+                        verified: emailData.verified ?? false,
+                        isCatchAll: emailData.isCatchAll,
+                        metadata: emailData.metadata,
+                    });
+                }
+            }
+        }
+    }
+    catch (err) {
+        result.errors?.push(`Snovio: ${err instanceof Error ? err.message : "Unknown error"}`);
+    }
+}
 /**
  * Get emails for multiple LinkedIn contacts in batch
  *

package/dist/enrichment/providers/bounceban.d.ts

@@ -0,0 +1,82 @@
+/**
+ * BounceBan Email Verification Provider
+ *
+ * Specializes in catch-all email verification with 85-95% accuracy
+ * using proprietary algorithms WITHOUT sending actual emails.
+ *
+ * Features:
+ * - Catch-all domain verification (industry-leading)
+ * - DeepVerify mode for pattern-guessed emails (+15-25% accuracy)
+ * - Waterfall endpoint with FREE 30-min retry window
+ * - Single email verification is FREE
+ * - GDPR compliant (no emails sent)
+ *
+ * API Endpoints:
+ * - GET /v1/verify/single - Standard single verification
+ * - GET https://api-waterfall.bounceban.com/v1/verify/single - Waterfall (recommended)
+ * - POST /v1/verify/bulk - Bulk verification
+ *
+ * Result values:
+ * - deliverable: Email verified (score 70-100)
+ * - risky: May work, often catch-all (score 30-70)
+ * - undeliverable: Email doesn't exist (score 0-30)
+ * - unknown: Could not determine
+ *
+ * @see https://bounceban.com
+ */
+import type { EnrichmentCandidate, ProviderResult, ProviderMultiResult, BounceBanConfig, BounceBanVerifyResponse } from "../types";
+/**
+ * Create the BounceBan verification provider
+ *
+ * This provider specializes in verifying emails on catch-all domains
+ * where traditional SMTP verification fails.
+ *
+ * Best used after construct provider generates email patterns.
+ */
+export declare function createBounceBanProvider(config: BounceBanConfig): (candidate: EnrichmentCandidate) => Promise<ProviderResult | ProviderMultiResult | null>;
+/**
+ * Standalone function to verify a single email via BounceBan
+ *
+ * Uses the waterfall endpoint by default for best catch-all handling.
+ *
+ * @example
+ * ```typescript
+ * const result = await verifyEmailWithBounceBan('john@catchall-domain.com', {
+ *   apiKey: process.env.BOUNCEBAN_API_KEY,
+ * });
+ * console.log(result.result); // "deliverable" | "risky" | "undeliverable" | "unknown"
+ * console.log(result.score); // 0-100
+ * console.log(result.is_accept_all); // true (catch-all domain)
+ * ```
+ */
+export declare function verifyEmailWithBounceBan(email: string, config: BounceBanConfig): Promise<BounceBanVerifyResponse | null>;
+/**
+ * Verify multiple emails in batch via BounceBan Bulk API
+ *
+ * More cost-effective for large volumes ($0.003/email vs single free).
+ * Uses async bulk API with polling for results.
+ *
+ * For small batches (< 5 emails), falls back to sequential single verification.
+ *
+ * @example
+ * ```typescript
+ * const results = await verifyEmailsBatchWithBounceBan(
+ *   ['john@example.com', 'jane@example.com'],
+ *   { apiKey: process.env.BOUNCEBAN_API_KEY }
+ * );
+ * ```
+ */
+export declare function verifyEmailsBatchWithBounceBan(emails: string[], config: BounceBanConfig): Promise<Map<string, BounceBanVerifyResponse | null>>;
+/**
+ * Check if a domain is catch-all via BounceBan
+ *
+ * Verifies a random non-existent email to detect catch-all behavior.
+ *
+ * @example
+ * ```typescript
+ * const isCatchAll = await checkCatchAllWithBounceBan('example.com', {
+ *   apiKey: process.env.BOUNCEBAN_API_KEY,
+ * });
+ * ```
+ */
+export declare function checkCatchAllWithBounceBan(domain: string, config: BounceBanConfig): Promise<boolean | null>;