linkedin-secret-sauce 0.5.0 → 0.6.0

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

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

package/dist/enrichment/auth/index.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Authentication modules for enrichment providers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearFileCache = exports.isFileCacheEnabled = exports.disableFileCache = exports.enableFileCache = 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; } });
+// File cache utilities for development/testing
+Object.defineProperty(exports, "enableFileCache", { enumerable: true, get: function () { return smartlead_auth_1.enableFileCache; } });
+Object.defineProperty(exports, "disableFileCache", { enumerable: true, get: function () { return smartlead_auth_1.disableFileCache; } });
+Object.defineProperty(exports, "isFileCacheEnabled", { enumerable: true, get: function () { return smartlead_auth_1.isFileCacheEnabled; } });
+Object.defineProperty(exports, "clearFileCache", { enumerable: true, get: function () { return smartlead_auth_1.clearFileCache; } });

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

@@ -0,0 +1,82 @@
+/**
+ * SmartLead Authentication Client
+ *
+ * Handles JWT token acquisition via email/password login.
+ * Tokens are cached in-memory with automatic refresh before expiry.
+ *
+ * For development/testing, file-based caching is supported to avoid
+ * repeated logins during test runs. Enable via `enableFileCache()`.
+ */
+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;
+    fileCacheEnabled: boolean;
+    fileCachePath: string | null;
+};
+/**
+ * Enable file-based token caching for development/testing
+ *
+ * When enabled, tokens are persisted to ~/.smartlead-tokens.json
+ * This avoids repeated logins during test development.
+ *
+ * @example
+ * ```ts
+ * // In your test setup
+ * import { enableFileCache } from 'linkedin-secret-sauce/enrichment';
+ *
+ * enableFileCache(); // Now tokens persist between test runs
+ * ```
+ */
+export declare function enableFileCache(): void;
+/**
+ * Disable file-based token caching
+ */
+export declare function disableFileCache(): void;
+/**
+ * Check if file cache is enabled
+ */
+export declare function isFileCacheEnabled(): boolean;
+/**
+ * Clear the file cache
+ */
+export declare function clearFileCache(): void;

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

@@ -0,0 +1,321 @@
+"use strict";
+/**
+ * SmartLead Authentication Client
+ *
+ * Handles JWT token acquisition via email/password login.
+ * Tokens are cached in-memory with automatic refresh before expiry.
+ *
+ * For development/testing, file-based caching is supported to avoid
+ * repeated logins during test runs. Enable via `enableFileCache()`.
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSmartLeadToken = getSmartLeadToken;
+exports.getSmartLeadUser = getSmartLeadUser;
+exports.clearSmartLeadToken = clearSmartLeadToken;
+exports.clearAllSmartLeadTokens = clearAllSmartLeadTokens;
+exports.getSmartLeadTokenCacheStats = getSmartLeadTokenCacheStats;
+exports.enableFileCache = enableFileCache;
+exports.disableFileCache = disableFileCache;
+exports.isFileCacheEnabled = isFileCacheEnabled;
+exports.clearFileCache = clearFileCache;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+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,
+        fileCacheEnabled,
+        fileCachePath: fileCacheEnabled ? getFileCachePath() : null,
+    };
+}
+// =============================================================================
+// File-based Token Cache (for development/testing)
+// =============================================================================
+let fileCacheEnabled = false;
+const FILE_CACHE_NAME = '.smartlead-tokens.json';
+/**
+ * Get the file cache path
+ */
+function getFileCachePath() {
+    // Store in user's home directory or temp
+    const homeDir = os.homedir();
+    return path.join(homeDir, FILE_CACHE_NAME);
+}
+/**
+ * Load tokens from file cache
+ */
+function loadFileCache() {
+    const cache = new Map();
+    if (!fileCacheEnabled)
+        return cache;
+    try {
+        const filePath = getFileCachePath();
+        if (fs.existsSync(filePath)) {
+            const content = fs.readFileSync(filePath, 'utf8');
+            const data = JSON.parse(content);
+            for (const [key, value] of Object.entries(data)) {
+                // Validate structure
+                if (value && value.token && value.expiresAt && value.obtainedAt) {
+                    cache.set(key, value);
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore file read errors
+    }
+    return cache;
+}
+/**
+ * Save tokens to file cache
+ */
+function saveFileCache() {
+    if (!fileCacheEnabled)
+        return;
+    try {
+        const filePath = getFileCachePath();
+        const data = {};
+        for (const [key, value] of tokenCache.entries()) {
+            data[key] = value;
+        }
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
+    }
+    catch {
+        // Ignore file write errors
+    }
+}
+/**
+ * Enable file-based token caching for development/testing
+ *
+ * When enabled, tokens are persisted to ~/.smartlead-tokens.json
+ * This avoids repeated logins during test development.
+ *
+ * @example
+ * ```ts
+ * // In your test setup
+ * import { enableFileCache } from 'linkedin-secret-sauce/enrichment';
+ *
+ * enableFileCache(); // Now tokens persist between test runs
+ * ```
+ */
+function enableFileCache() {
+    fileCacheEnabled = true;
+    // Load existing tokens from file into memory cache
+    const fileTokens = loadFileCache();
+    for (const [key, value] of fileTokens.entries()) {
+        // Only load if not already in memory and still valid
+        if (!tokenCache.has(key) && isTokenValid(value, DEFAULT_REFRESH_BUFFER_MS)) {
+            tokenCache.set(key, value);
+        }
+    }
+}
+/**
+ * Disable file-based token caching
+ */
+function disableFileCache() {
+    fileCacheEnabled = false;
+}
+/**
+ * Check if file cache is enabled
+ */
+function isFileCacheEnabled() {
+    return fileCacheEnabled;
+}
+/**
+ * Clear the file cache
+ */
+function clearFileCache() {
+    try {
+        const filePath = getFileCachePath();
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+}
+// Patch the existing getSmartLeadToken to save to file cache after login
+const originalGetSmartLeadToken = getSmartLeadToken;
+// We need to modify the token caching behavior to persist to file
+// This is done by wrapping the cache set operation
+// Override tokenCache.set to also persist to file
+const originalSet = tokenCache.set.bind(tokenCache);
+tokenCache.set = function (key, value) {
+    const result = originalSet(key, value);
+    if (fileCacheEnabled) {
+        saveFileCache();
+    }
+    return result;
+};

package/dist/enrichment/index.d.ts

@@ -26,7 +26,7 @@
  * });
  * ```
  */
-import type { EnrichmentClientConfig, EnrichmentClient } from './types';
+import type { EnrichmentClientConfig, EnrichmentClient } from "./types";
 /**
  * Create an enrichment client with the given configuration
  *
@@ -34,10 +34,13 @@ import type { EnrichmentClientConfig, EnrichmentClient } from './types';
  * @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 * 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 { createSmartProspectClient, type SmartProspectClient, type SmartProspectLocationOptions, } from "./providers/smartprospect";
+export { enrichBusinessEmail, enrichBatch, enrichAllEmails, enrichAllBatch } from "./orchestrator";
+export { getSmartLeadToken, getSmartLeadUser, clearSmartLeadToken, clearAllSmartLeadTokens, getSmartLeadTokenCacheStats, enableFileCache, disableFileCache, isFileCacheEnabled, clearFileCache, type SmartLeadCredentials, type SmartLeadAuthConfig, type SmartLeadUser, type SmartLeadLoginResponse, } from "./auth";
+export { calculateMatchConfidence, classifyMatchQuality, findBestMatch, matchContacts, buildSmartProspectFiltersFromLinkedIn, parseLinkedInSearchResponse, enrichLinkedInContact, enrichLinkedInContactsBatch, createLinkedInEnricher, type LinkedInContact, type MatchResult, type MatchOptions, type LinkedInEnrichmentResult, type LinkedInEnrichmentOptions, } from "./matching";

package/dist/enrichment/index.js

@@ -42,7 +42,7 @@ 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.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.createLinkedInEnricher = exports.enrichLinkedInContactsBatch = exports.enrichLinkedInContact = exports.parseLinkedInSearchResponse = exports.buildSmartProspectFiltersFromLinkedIn = exports.matchContacts = exports.findBestMatch = exports.classifyMatchQuality = exports.calculateMatchConfidence = exports.clearFileCache = exports.isFileCacheEnabled = exports.disableFileCache = exports.enableFileCache = exports.getSmartLeadTokenCacheStats = exports.clearAllSmartLeadTokens = exports.clearSmartLeadToken = exports.getSmartLeadUser = exports.getSmartLeadToken = exports.enrichAllBatch = exports.enrichAllEmails = exports.enrichBatch = exports.enrichBusinessEmail = exports.createSmartProspectClient = 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");
@@ -55,12 +55,12 @@ const dropcontact_1 = require("./providers/dropcontact");
  * Default provider order
  */
 const DEFAULT_ORDER = [
-    'construct',
-    'ldd',
-    'smartprospect',
-    'hunter',
-    'apollo',
-    'dropcontact',
+    "construct",
+    "ldd",
+    "smartprospect",
+    "hunter",
+    "apollo",
+    "dropcontact",
 ];
 /**
  * Create an enrichment client with the given configuration
@@ -69,26 +69,26 @@ const DEFAULT_ORDER = [
  * @returns An enrichment client with enrich and enrichBatch methods
  */
 function createEnrichmentClient(config) {
-    const { providers: providerConfigs, options = {}, cache, onCost, logger } = 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));
+    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));
+        providerFuncs.set("ldd", (0, ldd_1.createLddProvider)(providerConfigs.ldd));
     }
     if (providerConfigs.smartprospect) {
-        providerFuncs.set('smartprospect', (0, smartprospect_1.createSmartProspectProvider)(providerConfigs.smartprospect));
+        providerFuncs.set("smartprospect", (0, smartprospect_1.createSmartProspectProvider)(providerConfigs.smartprospect));
     }
     if (providerConfigs.hunter) {
-        providerFuncs.set('hunter', (0, hunter_1.createHunterProvider)(providerConfigs.hunter));
+        providerFuncs.set("hunter", (0, hunter_1.createHunterProvider)(providerConfigs.hunter));
     }
     if (providerConfigs.apollo) {
-        providerFuncs.set('apollo', (0, apollo_1.createApolloProvider)(providerConfigs.apollo));
+        providerFuncs.set("apollo", (0, apollo_1.createApolloProvider)(providerConfigs.apollo));
     }
     if (providerConfigs.dropcontact) {
-        providerFuncs.set('dropcontact', (0, dropcontact_1.createDropcontactProvider)(providerConfigs.dropcontact));
+        providerFuncs.set("dropcontact", (0, dropcontact_1.createDropcontactProvider)(providerConfigs.dropcontact));
     }
     // Build ordered provider list
     const providerOrder = options.providerOrder ?? DEFAULT_ORDER;
@@ -120,7 +120,7 @@ function createEnrichmentClient(config) {
                     try {
                         const cached = await cache.get(cacheKey);
                         if (cached) {
-                            logger?.debug?.('enrichment.cache.hit', { cacheKey });
+                            logger?.debug?.("enrichment.cache.hit", { cacheKey });
                             return cached;
                         }
                     }
@@ -154,6 +154,25 @@ function createEnrichmentClient(config) {
                 ...batchOptions,
             });
         },
+        /**
+         * Enrich a single candidate and return ALL found emails from ALL providers
+         *
+         * Unlike `enrich()` which returns the first valid business email,
+         * this method queries all providers and returns every email found,
+         * including personal emails, with type classifications and scores.
+         */
+        async enrichAll(candidate) {
+            return (0, orchestrator_1.enrichAllEmails)(candidate, orchestratorOptions);
+        },
+        /**
+         * Enrich multiple candidates and return ALL found emails for each
+         */
+        async enrichAllBatch(candidates, batchOptions) {
+            return (0, orchestrator_1.enrichAllBatch)(candidates, {
+                ...orchestratorOptions,
+                ...batchOptions,
+            });
+        },
     };
 }
 /**
@@ -176,10 +195,16 @@ function buildCacheKey(candidate) {
     }
     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 || '';
+        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)
@@ -193,7 +218,7 @@ function buildCacheKey(candidate) {
     if (parts.length === 0) {
         return null;
     }
-    return parts.join('|');
+    return parts.join("|");
 }
 // Re-export types
 __exportStar(require("./types"), exports);
@@ -225,7 +250,37 @@ Object.defineProperty(exports, "createSmartProspectProvider", { enumerable: true
 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 SmartProspect client for direct API access
+var smartprospect_2 = require("./providers/smartprospect");
+Object.defineProperty(exports, "createSmartProspectClient", { enumerable: true, get: function () { return smartprospect_2.createSmartProspectClient; } });
 // 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; } });
+Object.defineProperty(exports, "enrichAllEmails", { enumerable: true, get: function () { return orchestrator_2.enrichAllEmails; } });
+Object.defineProperty(exports, "enrichAllBatch", { enumerable: true, get: function () { return orchestrator_2.enrichAllBatch; } });
+// 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; } });
+// File cache utilities for development/testing
+Object.defineProperty(exports, "enableFileCache", { enumerable: true, get: function () { return auth_1.enableFileCache; } });
+Object.defineProperty(exports, "disableFileCache", { enumerable: true, get: function () { return auth_1.disableFileCache; } });
+Object.defineProperty(exports, "isFileCacheEnabled", { enumerable: true, get: function () { return auth_1.isFileCacheEnabled; } });
+Object.defineProperty(exports, "clearFileCache", { enumerable: true, get: function () { return auth_1.clearFileCache; } });
+// Re-export matching utilities (LinkedIn <-> SmartProspect)
+var matching_1 = require("./matching");
+// Low-level matching functions
+Object.defineProperty(exports, "calculateMatchConfidence", { enumerable: true, get: function () { return matching_1.calculateMatchConfidence; } });
+Object.defineProperty(exports, "classifyMatchQuality", { enumerable: true, get: function () { return matching_1.classifyMatchQuality; } });
+Object.defineProperty(exports, "findBestMatch", { enumerable: true, get: function () { return matching_1.findBestMatch; } });
+Object.defineProperty(exports, "matchContacts", { enumerable: true, get: function () { return matching_1.matchContacts; } });
+Object.defineProperty(exports, "buildSmartProspectFiltersFromLinkedIn", { enumerable: true, get: function () { return matching_1.buildSmartProspectFiltersFromLinkedIn; } });
+Object.defineProperty(exports, "parseLinkedInSearchResponse", { enumerable: true, get: function () { return matching_1.parseLinkedInSearchResponse; } });
+// High-level enrichment functions
+Object.defineProperty(exports, "enrichLinkedInContact", { enumerable: true, get: function () { return matching_1.enrichLinkedInContact; } });
+Object.defineProperty(exports, "enrichLinkedInContactsBatch", { enumerable: true, get: function () { return matching_1.enrichLinkedInContactsBatch; } });
+Object.defineProperty(exports, "createLinkedInEnricher", { enumerable: true, get: function () { return matching_1.createLinkedInEnricher; } });