linkedin-secret-sauce 0.4.0 → 0.5.1

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

@@ -0,0 +1,4 @@
+/**
+ * Authentication modules for enrichment providers
+ */
+export { getSmartLeadToken, getSmartLeadUser, clearSmartLeadToken, clearAllSmartLeadTokens, getSmartLeadTokenCacheStats, type SmartLeadCredentials, type SmartLeadAuthConfig, type SmartLeadUser, type SmartLeadLoginResponse, } from './smartlead-auth';

package/dist/enrichment/auth/index.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * Authentication modules for enrichment providers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSmartLeadTokenCacheStats = exports.clearAllSmartLeadTokens = exports.clearSmartLeadToken = exports.getSmartLeadUser = exports.getSmartLeadToken = void 0;
+var smartlead_auth_1 = require("./smartlead-auth");
+Object.defineProperty(exports, "getSmartLeadToken", { enumerable: true, get: function () { return smartlead_auth_1.getSmartLeadToken; } });
+Object.defineProperty(exports, "getSmartLeadUser", { enumerable: true, get: function () { return smartlead_auth_1.getSmartLeadUser; } });
+Object.defineProperty(exports, "clearSmartLeadToken", { enumerable: true, get: function () { return smartlead_auth_1.clearSmartLeadToken; } });
+Object.defineProperty(exports, "clearAllSmartLeadTokens", { enumerable: true, get: function () { return smartlead_auth_1.clearAllSmartLeadTokens; } });
+Object.defineProperty(exports, "getSmartLeadTokenCacheStats", { enumerable: true, get: function () { return smartlead_auth_1.getSmartLeadTokenCacheStats; } });

package/dist/enrichment/auth/smartlead-auth.d.ts

@@ -0,0 +1,50 @@
+/**
+ * SmartLead Authentication Client
+ *
+ * Handles JWT token acquisition via email/password login.
+ * Tokens are cached in-memory with automatic refresh before expiry.
+ */
+export interface SmartLeadCredentials {
+    email: string;
+    password: string;
+}
+export interface SmartLeadAuthConfig {
+    credentials: SmartLeadCredentials;
+    /** Login API URL (default: https://server.smartlead.ai/api/auth/login) */
+    loginUrl?: string;
+    /** Token refresh buffer in ms - refresh this much before expiry (default: 5 min) */
+    refreshBufferMs?: number;
+}
+export interface SmartLeadUser {
+    id: number;
+    uuid: string;
+    email: string;
+    name: string;
+    role: string;
+    api_key: string;
+    region: string;
+}
+export interface SmartLeadLoginResponse {
+    user: SmartLeadUser;
+    token: string;
+}
+export declare function getSmartLeadToken(config: SmartLeadAuthConfig): Promise<string>;
+/**
+ * Get SmartLead user info (from cached login)
+ */
+export declare function getSmartLeadUser(config: SmartLeadAuthConfig): Promise<SmartLeadUser>;
+/**
+ * Force clear cached token (e.g., on 401 error)
+ */
+export declare function clearSmartLeadToken(email: string): void;
+/**
+ * Clear all cached tokens
+ */
+export declare function clearAllSmartLeadTokens(): void;
+/**
+ * Get token cache stats (for debugging)
+ */
+export declare function getSmartLeadTokenCacheStats(): {
+    cachedEmails: string[];
+    totalCached: number;
+};

package/dist/enrichment/auth/smartlead-auth.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * SmartLead Authentication Client
+ *
+ * Handles JWT token acquisition via email/password login.
+ * Tokens are cached in-memory with automatic refresh before expiry.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSmartLeadToken = getSmartLeadToken;
+exports.getSmartLeadUser = getSmartLeadUser;
+exports.clearSmartLeadToken = clearSmartLeadToken;
+exports.clearAllSmartLeadTokens = clearAllSmartLeadTokens;
+exports.getSmartLeadTokenCacheStats = getSmartLeadTokenCacheStats;
+const DEFAULT_LOGIN_URL = 'https://server.smartlead.ai/api/auth/login';
+const DEFAULT_REFRESH_BUFFER_MS = 5 * 60 * 1000; // 5 minutes
+const TOKEN_LIFETIME_MS = 24 * 60 * 60 * 1000; // Assume 24h JWT lifetime (conservative)
+// In-memory token cache keyed by email
+const tokenCache = new Map();
+/**
+ * Parse JWT to extract expiration time
+ */
+function parseJwtExpiry(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3)
+            return null;
+        const payload = JSON.parse(Buffer.from(parts[1], 'base64').toString('utf8'));
+        if (payload.exp) {
+            return payload.exp * 1000; // Convert to ms
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Login to SmartLead and obtain JWT token
+ */
+async function login(config) {
+    const { credentials, loginUrl = DEFAULT_LOGIN_URL } = config;
+    const response = await fetch(loginUrl, {
+        method: 'POST',
+        headers: {
+            Accept: 'application/json, text/plain, */*',
+            'Content-Type': 'application/json',
+            Origin: 'https://app.smartlead.ai',
+            Referer: 'https://app.smartlead.ai/',
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36',
+        },
+        body: JSON.stringify({
+            email: credentials.email,
+            password: credentials.password,
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text().catch(() => '');
+        throw new Error(`SmartLead login failed: ${response.status} - ${errorText}`);
+    }
+    const data = (await response.json());
+    if (!data.token || !data.user) {
+        throw new Error('SmartLead login response missing token or user');
+    }
+    const now = Date.now();
+    // Try to parse expiry from JWT, fallback to assumed lifetime
+    let expiresAt = parseJwtExpiry(data.token);
+    if (!expiresAt) {
+        expiresAt = now + TOKEN_LIFETIME_MS;
+    }
+    return {
+        token: data.token,
+        user: data.user,
+        expiresAt,
+        obtainedAt: now,
+    };
+}
+/**
+ * Check if cached token is still valid (with buffer for refresh)
+ */
+function isTokenValid(cached, refreshBufferMs) {
+    const now = Date.now();
+    return cached.expiresAt - refreshBufferMs > now;
+}
+/**
+ * Get a valid SmartLead JWT token
+ *
+ * Returns cached token if still valid, otherwise performs fresh login.
+ * Thread-safe via promise deduplication.
+ */
+const pendingLogins = new Map();
+async function getSmartLeadToken(config) {
+    const { credentials, refreshBufferMs = DEFAULT_REFRESH_BUFFER_MS } = config;
+    const cacheKey = credentials.email.toLowerCase();
+    // Check cache first
+    const cached = tokenCache.get(cacheKey);
+    if (cached && isTokenValid(cached, refreshBufferMs)) {
+        return cached.token;
+    }
+    // Check if login already in progress (dedup concurrent requests)
+    const pending = pendingLogins.get(cacheKey);
+    if (pending) {
+        const result = await pending;
+        return result.token;
+    }
+    // Perform login
+    const loginPromise = login(config);
+    pendingLogins.set(cacheKey, loginPromise);
+    try {
+        const result = await loginPromise;
+        tokenCache.set(cacheKey, result);
+        return result.token;
+    }
+    finally {
+        pendingLogins.delete(cacheKey);
+    }
+}
+/**
+ * Get SmartLead user info (from cached login)
+ */
+async function getSmartLeadUser(config) {
+    const { credentials, refreshBufferMs = DEFAULT_REFRESH_BUFFER_MS } = config;
+    const cacheKey = credentials.email.toLowerCase();
+    // Check cache first
+    const cached = tokenCache.get(cacheKey);
+    if (cached && isTokenValid(cached, refreshBufferMs)) {
+        return cached.user;
+    }
+    // Perform login to get fresh user info
+    await getSmartLeadToken(config);
+    const freshCached = tokenCache.get(cacheKey);
+    if (!freshCached) {
+        throw new Error('SmartLead auth: failed to obtain user info');
+    }
+    return freshCached.user;
+}
+/**
+ * Force clear cached token (e.g., on 401 error)
+ */
+function clearSmartLeadToken(email) {
+    tokenCache.delete(email.toLowerCase());
+}
+/**
+ * Clear all cached tokens
+ */
+function clearAllSmartLeadTokens() {
+    tokenCache.clear();
+}
+/**
+ * Get token cache stats (for debugging)
+ */
+function getSmartLeadTokenCacheStats() {
+    return {
+        cachedEmails: Array.from(tokenCache.keys()),
+        totalCached: tokenCache.size,
+    };
+}

package/dist/enrichment/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Email Enrichment Module
+ *
+ * Provides email enrichment capabilities with multiple provider support,
+ * waterfall orchestration, and configurable options.
+ *
+ * @example
+ * ```typescript
+ * import { createEnrichmentClient } from 'linkedin-secret-sauce';
+ *
+ * const enricher = createEnrichmentClient({
+ *   providers: {
+ *     hunter: { apiKey: process.env.HUNTER_API_KEY },
+ *     apollo: { apiKey: process.env.APOLLO_API_KEY },
+ *   },
+ *   options: {
+ *     maxCostPerEmail: 0.05,
+ *     confidenceThreshold: 50,
+ *   },
+ * });
+ *
+ * const result = await enricher.enrich({
+ *   firstName: 'John',
+ *   lastName: 'Doe',
+ *   company: 'Acme Corp',
+ * });
+ * ```
+ */
+import type { EnrichmentClientConfig, EnrichmentClient } from "./types";
+/**
+ * Create an enrichment client with the given configuration
+ *
+ * @param config - Configuration for the enrichment client
+ * @returns An enrichment client with enrich and enrichBatch methods
+ */
+export declare function createEnrichmentClient(config: EnrichmentClientConfig): EnrichmentClient;
+export * from "./types";
+export { isPersonalEmail, isBusinessEmail, isPersonalDomain, PERSONAL_DOMAINS, } from "./utils/personal-domains";
+export { isDisposableEmail, isDisposableDomain, DISPOSABLE_DOMAINS, } from "./utils/disposable-domains";
+export { isValidEmailSyntax, isRoleAccount, asciiFold, cleanNamePart, hostnameFromUrl, extractLinkedInUsername, } from "./utils/validation";
+export { verifyEmailMx } from "./verification/mx";
+export { createConstructProvider, createLddProvider, createSmartProspectProvider, createHunterProvider, createApolloProvider, createDropcontactProvider, } from "./providers";
+export { enrichBusinessEmail, enrichBatch } from "./orchestrator";
+export { getSmartLeadToken, getSmartLeadUser, clearSmartLeadToken, clearAllSmartLeadTokens, getSmartLeadTokenCacheStats, type SmartLeadCredentials, type SmartLeadAuthConfig, type SmartLeadUser, type SmartLeadLoginResponse, } from "./auth";

package/dist/enrichment/index.js

@@ -0,0 +1,244 @@
+"use strict";
+/**
+ * Email Enrichment Module
+ *
+ * Provides email enrichment capabilities with multiple provider support,
+ * waterfall orchestration, and configurable options.
+ *
+ * @example
+ * ```typescript
+ * import { createEnrichmentClient } from 'linkedin-secret-sauce';
+ *
+ * const enricher = createEnrichmentClient({
+ *   providers: {
+ *     hunter: { apiKey: process.env.HUNTER_API_KEY },
+ *     apollo: { apiKey: process.env.APOLLO_API_KEY },
+ *   },
+ *   options: {
+ *     maxCostPerEmail: 0.05,
+ *     confidenceThreshold: 50,
+ *   },
+ * });
+ *
+ * const result = await enricher.enrich({
+ *   firstName: 'John',
+ *   lastName: 'Doe',
+ *   company: 'Acme Corp',
+ * });
+ * ```
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSmartLeadTokenCacheStats = exports.clearAllSmartLeadTokens = exports.clearSmartLeadToken = exports.getSmartLeadUser = exports.getSmartLeadToken = exports.enrichBatch = exports.enrichBusinessEmail = exports.createDropcontactProvider = exports.createApolloProvider = exports.createHunterProvider = exports.createSmartProspectProvider = exports.createLddProvider = exports.createConstructProvider = exports.verifyEmailMx = exports.extractLinkedInUsername = exports.hostnameFromUrl = exports.cleanNamePart = exports.asciiFold = exports.isRoleAccount = exports.isValidEmailSyntax = exports.DISPOSABLE_DOMAINS = exports.isDisposableDomain = exports.isDisposableEmail = exports.PERSONAL_DOMAINS = exports.isPersonalDomain = exports.isBusinessEmail = exports.isPersonalEmail = void 0;
+exports.createEnrichmentClient = createEnrichmentClient;
+const orchestrator_1 = require("./orchestrator");
+const construct_1 = require("./providers/construct");
+const ldd_1 = require("./providers/ldd");
+const smartprospect_1 = require("./providers/smartprospect");
+const hunter_1 = require("./providers/hunter");
+const apollo_1 = require("./providers/apollo");
+const dropcontact_1 = require("./providers/dropcontact");
+/**
+ * Default provider order
+ */
+const DEFAULT_ORDER = [
+    "construct",
+    "ldd",
+    "smartprospect",
+    "hunter",
+    "apollo",
+    "dropcontact",
+];
+/**
+ * Create an enrichment client with the given configuration
+ *
+ * @param config - Configuration for the enrichment client
+ * @returns An enrichment client with enrich and enrichBatch methods
+ */
+function createEnrichmentClient(config) {
+    const { providers: providerConfigs, options = {}, cache, onCost, logger, } = config;
+    // Build provider functions based on configuration
+    const providerFuncs = new Map();
+    // Always create construct provider (free, no API key needed)
+    providerFuncs.set("construct", (0, construct_1.createConstructProvider)(providerConfigs.construct));
+    // Create other providers if configured
+    if (providerConfigs.ldd) {
+        providerFuncs.set("ldd", (0, ldd_1.createLddProvider)(providerConfigs.ldd));
+    }
+    if (providerConfigs.smartprospect) {
+        providerFuncs.set("smartprospect", (0, smartprospect_1.createSmartProspectProvider)(providerConfigs.smartprospect));
+    }
+    if (providerConfigs.hunter) {
+        providerFuncs.set("hunter", (0, hunter_1.createHunterProvider)(providerConfigs.hunter));
+    }
+    if (providerConfigs.apollo) {
+        providerFuncs.set("apollo", (0, apollo_1.createApolloProvider)(providerConfigs.apollo));
+    }
+    if (providerConfigs.dropcontact) {
+        providerFuncs.set("dropcontact", (0, dropcontact_1.createDropcontactProvider)(providerConfigs.dropcontact));
+    }
+    // Build ordered provider list
+    const providerOrder = options.providerOrder ?? DEFAULT_ORDER;
+    const orderedProviders = [];
+    for (const name of providerOrder) {
+        const provider = providerFuncs.get(name);
+        if (provider) {
+            orderedProviders.push(provider);
+        }
+    }
+    // Orchestrator options
+    const orchestratorOptions = {
+        providers: orderedProviders,
+        maxCostPerEmail: options.maxCostPerEmail,
+        confidenceThreshold: options.confidenceThreshold,
+        retryMs: options.retryMs,
+        onCost,
+        logger,
+    };
+    return {
+        /**
+         * Enrich a single candidate with business email
+         */
+        async enrich(candidate) {
+            // Check cache first
+            if (cache) {
+                const cacheKey = buildCacheKey(candidate);
+                if (cacheKey) {
+                    try {
+                        const cached = await cache.get(cacheKey);
+                        if (cached) {
+                            logger?.debug?.("enrichment.cache.hit", { cacheKey });
+                            return cached;
+                        }
+                    }
+                    catch {
+                        // Ignore cache errors
+                    }
+                }
+            }
+            // Run enrichment
+            const result = await (0, orchestrator_1.enrichBusinessEmail)(candidate, orchestratorOptions);
+            // Store in cache
+            if (cache && result.business_email) {
+                const cacheKey = buildCacheKey(candidate);
+                if (cacheKey) {
+                    try {
+                        await cache.set(cacheKey, result, 30 * 24 * 60 * 60 * 1000); // 30 days TTL
+                    }
+                    catch {
+                        // Ignore cache errors
+                    }
+                }
+            }
+            return result;
+        },
+        /**
+         * Enrich multiple candidates in batches
+         */
+        async enrichBatch(candidates, batchOptions) {
+            return (0, orchestrator_1.enrichBatch)(candidates, {
+                ...orchestratorOptions,
+                ...batchOptions,
+            });
+        },
+    };
+}
+/**
+ * Build a cache key from candidate data
+ */
+function buildCacheKey(candidate) {
+    const parts = [];
+    // Use LinkedIn URL/username as primary key if available
+    const linkedinUrl = candidate.linkedinUrl || candidate.linkedin_url;
+    const linkedinUsername = candidate.linkedinUsername || candidate.linkedin_username;
+    const linkedinId = candidate.linkedinId || candidate.linkedin_id;
+    if (linkedinUrl) {
+        parts.push(`li:${linkedinUrl}`);
+    }
+    else if (linkedinUsername) {
+        parts.push(`li:${linkedinUsername}`);
+    }
+    else if (linkedinId) {
+        parts.push(`li:${linkedinId}`);
+    }
+    else {
+        // Fall back to name + domain/company
+        const firstName = candidate.firstName || candidate.first_name || candidate.first || "";
+        const lastName = candidate.lastName || candidate.last_name || candidate.last || "";
+        const domain = candidate.domain ||
+            candidate.companyDomain ||
+            candidate.company_domain ||
+            "";
+        const company = candidate.company ||
+            candidate.currentCompany ||
+            candidate.organization ||
+            "";
+        if (firstName && (domain || company)) {
+            parts.push(`name:${firstName.toLowerCase()}`);
+            if (lastName)
+                parts.push(lastName.toLowerCase());
+            if (domain)
+                parts.push(`dom:${domain.toLowerCase()}`);
+            else if (company)
+                parts.push(`co:${company.toLowerCase()}`);
+        }
+    }
+    if (parts.length === 0) {
+        return null;
+    }
+    return parts.join("|");
+}
+// Re-export types
+__exportStar(require("./types"), exports);
+// Re-export utilities
+var personal_domains_1 = require("./utils/personal-domains");
+Object.defineProperty(exports, "isPersonalEmail", { enumerable: true, get: function () { return personal_domains_1.isPersonalEmail; } });
+Object.defineProperty(exports, "isBusinessEmail", { enumerable: true, get: function () { return personal_domains_1.isBusinessEmail; } });
+Object.defineProperty(exports, "isPersonalDomain", { enumerable: true, get: function () { return personal_domains_1.isPersonalDomain; } });
+Object.defineProperty(exports, "PERSONAL_DOMAINS", { enumerable: true, get: function () { return personal_domains_1.PERSONAL_DOMAINS; } });
+var disposable_domains_1 = require("./utils/disposable-domains");
+Object.defineProperty(exports, "isDisposableEmail", { enumerable: true, get: function () { return disposable_domains_1.isDisposableEmail; } });
+Object.defineProperty(exports, "isDisposableDomain", { enumerable: true, get: function () { return disposable_domains_1.isDisposableDomain; } });
+Object.defineProperty(exports, "DISPOSABLE_DOMAINS", { enumerable: true, get: function () { return disposable_domains_1.DISPOSABLE_DOMAINS; } });
+var validation_1 = require("./utils/validation");
+Object.defineProperty(exports, "isValidEmailSyntax", { enumerable: true, get: function () { return validation_1.isValidEmailSyntax; } });
+Object.defineProperty(exports, "isRoleAccount", { enumerable: true, get: function () { return validation_1.isRoleAccount; } });
+Object.defineProperty(exports, "asciiFold", { enumerable: true, get: function () { return validation_1.asciiFold; } });
+Object.defineProperty(exports, "cleanNamePart", { enumerable: true, get: function () { return validation_1.cleanNamePart; } });
+Object.defineProperty(exports, "hostnameFromUrl", { enumerable: true, get: function () { return validation_1.hostnameFromUrl; } });
+Object.defineProperty(exports, "extractLinkedInUsername", { enumerable: true, get: function () { return validation_1.extractLinkedInUsername; } });
+// Re-export verification
+var mx_1 = require("./verification/mx");
+Object.defineProperty(exports, "verifyEmailMx", { enumerable: true, get: function () { return mx_1.verifyEmailMx; } });
+// Re-export providers (for advanced usage)
+var providers_1 = require("./providers");
+Object.defineProperty(exports, "createConstructProvider", { enumerable: true, get: function () { return providers_1.createConstructProvider; } });
+Object.defineProperty(exports, "createLddProvider", { enumerable: true, get: function () { return providers_1.createLddProvider; } });
+Object.defineProperty(exports, "createSmartProspectProvider", { enumerable: true, get: function () { return providers_1.createSmartProspectProvider; } });
+Object.defineProperty(exports, "createHunterProvider", { enumerable: true, get: function () { return providers_1.createHunterProvider; } });
+Object.defineProperty(exports, "createApolloProvider", { enumerable: true, get: function () { return providers_1.createApolloProvider; } });
+Object.defineProperty(exports, "createDropcontactProvider", { enumerable: true, get: function () { return providers_1.createDropcontactProvider; } });
+// Re-export orchestrator (for advanced usage)
+var orchestrator_2 = require("./orchestrator");
+Object.defineProperty(exports, "enrichBusinessEmail", { enumerable: true, get: function () { return orchestrator_2.enrichBusinessEmail; } });
+Object.defineProperty(exports, "enrichBatch", { enumerable: true, get: function () { return orchestrator_2.enrichBatch; } });
+// Re-export auth utilities (for advanced usage)
+var auth_1 = require("./auth");
+Object.defineProperty(exports, "getSmartLeadToken", { enumerable: true, get: function () { return auth_1.getSmartLeadToken; } });
+Object.defineProperty(exports, "getSmartLeadUser", { enumerable: true, get: function () { return auth_1.getSmartLeadUser; } });
+Object.defineProperty(exports, "clearSmartLeadToken", { enumerable: true, get: function () { return auth_1.clearSmartLeadToken; } });
+Object.defineProperty(exports, "clearAllSmartLeadTokens", { enumerable: true, get: function () { return auth_1.clearAllSmartLeadTokens; } });
+Object.defineProperty(exports, "getSmartLeadTokenCacheStats", { enumerable: true, get: function () { return auth_1.getSmartLeadTokenCacheStats; } });

package/dist/enrichment/orchestrator.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Email Enrichment Waterfall Orchestrator
+ *
+ * Runs providers in sequence until a verified email is found that meets
+ * the confidence threshold. Supports budget tracking and cost callbacks.
+ */
+import type { CanonicalEmail, EnrichmentCandidate, ProviderFunc, BatchEnrichmentOptions, CostCallback, EnrichmentLogger } from './types';
+export interface OrchestratorOptions {
+    /** Provider functions in order */
+    providers: ProviderFunc[];
+    /** Maximum cost per email in USD */
+    maxCostPerEmail?: number;
+    /** Minimum confidence threshold (0-100) */
+    confidenceThreshold?: number;
+    /** Retry delay in ms */
+    retryMs?: number;
+    /** Cost callback */
+    onCost?: CostCallback;
+    /** Logger */
+    logger?: EnrichmentLogger;
+}
+/**
+ * Enrich a single candidate with business email
+ */
+export declare function enrichBusinessEmail(candidate: EnrichmentCandidate, options: OrchestratorOptions): Promise<CanonicalEmail>;
+/**
+ * Enrich multiple candidates in batches
+ */
+export declare function enrichBatch(candidates: EnrichmentCandidate[], options: OrchestratorOptions & BatchEnrichmentOptions): Promise<Array<{
+    candidate: EnrichmentCandidate;
+} & CanonicalEmail>>;