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

package/dist/check-if-email-exists.d.ts

@@ -0,0 +1,205 @@
+import type { Cache } from './cache-interface';
+import { CheckIfEmailExistsCoreParams, CheckIfEmailExistsCoreResult, CheckIfEmailExistsSmtpOptions, EmailProvider, type EmailSyntaxResult, HeadlessOptions, MxLookupResult, SmtpVerificationResult, YahooApiOptions } from './email-verifier-types';
+export declare const checkIfEmailExistsConstants: {
+    gmailDomains: string[];
+    yahooDomains: string[];
+    hotmailDomains: string[];
+    defaultTimeout: number;
+    defaultSmtpPort: number;
+    defaultFromEmail: string;
+    defaultHelloName: string;
+};
+export { EmailProvider, SmtpVerificationResult, MxLookupResult, CheckIfEmailExistsCoreResult, CheckIfEmailExistsSmtpOptions, YahooApiOptions, HeadlessOptions, CheckIfEmailExistsCoreParams, };
+/**
+ * Extended interface for our implementation
+ */
+export interface CheckIfEmailExistsCoreParamsExtended extends CheckIfEmailExistsCoreParams {
+    cache?: Cache | null;
+    smtpTimeout?: number;
+    fromEmail?: string;
+    helloName?: string;
+    smtpOptions?: CheckIfEmailExistsSmtpOptions;
+    enableProviderOptimizations?: boolean;
+    useYahooApi?: boolean;
+    useYahooHeadless?: boolean;
+    yahooApiOptions?: YahooApiOptions;
+    headlessOptions?: HeadlessOptions;
+}
+/**
+ * Enhanced syntax validation with RFC 5321 compliance
+ */
+export declare function validateEmailSyntax(email: string): EmailSyntaxResult;
+/**
+ * Provider detection functions matching the original Rust implementation
+ */
+export declare function isGmail(host: string): boolean;
+export declare function isYahoo(host: string): boolean;
+export declare function isHotmailB2C(host: string): boolean;
+export declare function isHotmailB2B(host: string): boolean;
+export declare function isProofpoint(host: string): boolean;
+export declare function isMimecast(host: string): boolean;
+/**
+ * Provider detection from MX host (matching original implementation)
+ */
+export declare function getProviderFromMxHost(host: string): EmailProvider;
+/**
+ * Get provider type for known email providers (legacy function)
+ */
+export declare function getProviderType(domain: string): EmailProvider;
+/**
+ * Enhanced MX record lookup with caching support
+ */
+export declare function queryMxRecords(domain: string, options?: {
+    timeout?: number;
+    cache?: Cache | null;
+}): Promise<MxLookupResult>;
+/**
+ * Enhanced SMTP verification with provider-specific logic and catch-all detection
+ */
+export declare function verifySmtpConnection(email: string, domain: string, mxHost: string, options?: {
+    timeout?: number;
+    fromEmail?: string;
+    helloName?: string;
+    port?: number;
+    retries?: number;
+    useStartTls?: boolean;
+    proxy?: any;
+}, providerType?: EmailProvider): Promise<SmtpVerificationResult>;
+/**
+ * Main function to check if an email
+ */
+export declare function checkIfEmailExistsCore(params: CheckIfEmailExistsCoreParamsExtended): Promise<CheckIfEmailExistsCoreResult>;
+/**
+ * Yahoo API verification using HTTP requests to Yahoo signup endpoints
+ * This replicates the functionality from the original Rust implementation's yahoo/api.rs
+ */
+declare function verifyYahooApi(email: string, options?: YahooApiOptions): Promise<{
+    isValid: boolean;
+    isDeliverable: boolean;
+    error?: string;
+    details?: any;
+}>;
+/**
+ * Generic headless browser automation for email verification
+ * Based on the original Rust implementation's headless functionality
+ */
+interface HeadlessBrowserResult {
+    success: boolean;
+    email_exists?: boolean;
+    screenshot?: string;
+    error?: string;
+    details?: any;
+}
+declare class HeadlessBrowser {
+    private webdriverEndpoint;
+    private timeout;
+    private retryAttempts;
+    constructor(options?: HeadlessOptions);
+    /**
+     * Create a new browser session
+     */
+    private createSession;
+    /**
+     * Navigate to a URL
+     */
+    private navigate;
+    /**
+     * Take a screenshot
+     */
+    private takeScreenshot;
+    /**
+     * Execute JavaScript in the browser
+     */
+    private executeScript;
+    /**
+     * Find an element
+     */
+    private findElement;
+    /**
+     * Type text into an element
+     */
+    private typeText;
+    /**
+     * Click an element
+     */
+    private clickElement;
+    /**
+     * Wait for an element to be present
+     */
+    private waitForElement;
+    /**
+     * Delete the browser session
+     */
+    private deleteSession;
+    /**
+     * Generic headless verification method
+     */
+    verifyEmail(email: string, verificationSteps: Array<{
+        url: string;
+        actions: Array<{
+            type: 'navigate' | 'waitFor' | 'type' | 'click' | 'execute';
+            selector?: string;
+            text?: string;
+            script?: string;
+            using?: string;
+            timeout?: number;
+        }>;
+        successIndicators?: string[];
+        errorIndicators?: string[];
+    }>, screenshot?: boolean): Promise<HeadlessBrowserResult>;
+}
+/**
+ * Yahoo headless verification using browser automation
+ */
+declare function verifyYahooHeadless(email: string, options?: HeadlessOptions): Promise<HeadlessBrowserResult>;
+/**
+ * Gmail headless verification using browser automation
+ */
+declare function verifyGmailHeadless(email: string, options?: HeadlessOptions): Promise<HeadlessBrowserResult>;
+/**
+ * Provider-specific SMTP error parsing and analysis
+ * Based on the original Rust implementation's error parsing modules
+ */
+export interface ParsedSmtpError {
+    type: 'disabled' | 'full_inbox' | 'unknown' | 'invalid' | 'catch_all' | 'rate_limited' | 'blocked';
+    severity: 'permanent' | 'temporary' | 'unknown';
+    message: string;
+    originalMessage: string;
+    providerSpecific?: {
+        code?: string;
+        action?: string;
+        details?: string;
+    };
+}
+declare class SmtpErrorParser {
+    /**
+     * Parse SMTP error messages with provider-specific context
+     */
+    static parseError(smtpMessage: string, provider: EmailProvider, responseCode?: number): ParsedSmtpError;
+    /**
+     * Parse generic SMTP error patterns
+     */
+    private static parseGenericErrors;
+    /**
+     * Parse Gmail-specific SMTP errors
+     */
+    private static parseGmailError;
+    /**
+     * Parse Yahoo-specific SMTP errors
+     */
+    private static parseYahooError;
+    /**
+     * Parse Hotmail/Outlook-specific SMTP errors
+     */
+    private static parseHotmailError;
+    /**
+     * Parse Proofpoint-specific SMTP errors
+     */
+    private static parseProofpointError;
+    /**
+     * Parse Mimecast-specific SMTP errors
+     */
+    private static parseMimecastError;
+}
+export { verifyYahooApi, verifyYahooHeadless, verifyGmailHeadless, SmtpErrorParser };
+export { HeadlessBrowser };

package/dist/domain-suggester.d.ts

@@ -1,10 +1,10 @@
-import type { ICache } from './cache-interface';
-import type { DomainSuggestion, ISuggestDomainParams } from './types';
+import type { Cache } from './cache-interface';
+import type { DomainSuggestion, DomainSuggestionParams } from './types';
 /**
  * List of common email domains for typo detection
  * Includes popular free providers, business providers, and hosting services
  */
-export declare const COMMON_EMAIL_DOMAINS: string[];
+export declare const commonEmailDomains: string[];
 /**
  * Default domain suggestion method using string similarity (sync version)
  */
@@ -12,13 +12,13 @@ export declare function defaultDomainSuggestionMethod(domain: string, commonDoma
 /**
  * Async version of default domain suggestion method
  */
-export declare function defaultDomainSuggestionMethodAsync(domain: string, commonDomains?: string[], cache?: ICache): Promise<DomainSuggestion | null>;
+export declare function defaultDomainSuggestionMethodAsync(domain: string, commonDomains?: string[], cache?: Cache): Promise<DomainSuggestion | null>;
 /**
  * Suggest a corrected domain for a potentially misspelled email domain
  * @param params - Parameters including domain and optional custom method
  * @returns Domain suggestion with confidence score, or null if no suggestion
  */
-export declare function suggestDomain(params: ISuggestDomainParams): DomainSuggestion | null;
+export declare function suggestDomain(params: DomainSuggestionParams): DomainSuggestion | null;
 /**
  * Convenience function to suggest domain from email address
  * @param email - Email address to check for domain typos
@@ -26,7 +26,7 @@ export declare function suggestDomain(params: ISuggestDomainParams): DomainSugge
  * @param cache - Optional cache instance
  * @returns Domain suggestion with confidence score, or null if no suggestion
  */
-export declare function suggestEmailDomain(email: string, commonDomains?: string[], cache?: ICache): Promise<DomainSuggestion | null>;
+export declare function suggestEmailDomain(email: string, commonDomains?: string[], cache?: Cache): Promise<DomainSuggestion | null>;
 /**
  * Check if a domain is in the common domains list
  * @param domain - Domain to check

package/dist/{validator.d.ts → email-validator.d.ts}

@@ -1,8 +1,8 @@
-import type { ICache } from './cache-interface';
+import type { Cache } from './cache-interface';
 /**
  * Validates if email domain is valid TLD
  */
-export declare function isValidEmailDomain(emailOrDomain: string, cache?: ICache | null): Promise<boolean>;
+export declare function isValidEmailDomain(emailOrDomain: string, cache?: Cache | null): Promise<boolean>;
 /**
  * Validates email address format using RFC-compliant regex
  * @param emailAddress - The email address to validate

package/dist/email-verifier-types.d.ts

@@ -0,0 +1,225 @@
+/**
+ * Type definitions for email verification functionality
+ * Based on the original Rust implementation's type structure
+ */
+import type { Cache } from './cache-interface';
+/**
+ * Email providers with enhanced type safety
+ */
+export declare enum EmailProvider {
+    gmail = "gmail",
+    hotmailB2b = "hotmail_b2b",
+    hotmailB2c = "hotmail_b2c",
+    proofpoint = "proofpoint",
+    mimecast = "mimecast",
+    yahoo = "yahoo",
+    everythingElse = "everything_else"
+}
+/**
+ * Provider-specific configuration and capabilities
+ */
+export interface ProviderConfig {
+    provider: EmailProvider;
+    domains: readonly string[];
+    capabilities: {
+        plusAddressing: boolean;
+        dotsSignificant: boolean;
+        underscoresAllowed: boolean;
+        maxLocalLength: number;
+        supportsApi: boolean;
+        supportsHeadless: boolean;
+    };
+    smtpSettings: {
+        preferredPorts: readonly number[];
+        connectTimeout: number;
+        readTimeout: number;
+        requiresTls?: boolean;
+        customHeaders?: Record<string, string>;
+    };
+}
+/**
+ * SMTP verification result with enhanced typing
+ */
+export interface SmtpVerificationResult {
+    canConnectSmtp: boolean;
+    hasFullInbox: boolean;
+    isCatchAll: boolean;
+    isDeliverable: boolean;
+    isDisabled: boolean;
+    error?: string;
+    providerUsed?: EmailProvider;
+    success?: boolean;
+    canConnect?: boolean;
+    responseCode?: number;
+    providerSpecific?: {
+        errorCode?: string;
+        actionRequired?: string;
+        details?: string;
+    };
+}
+/**
+ * MX record lookup result
+ */
+export interface MxLookupResult {
+    success: boolean;
+    records: Array<{
+        exchange: string;
+        priority: number;
+    }>;
+    lowestPriority?: {
+        exchange: string;
+        priority: number;
+    };
+    error?: string;
+    code?: string;
+}
+/**
+ * Email syntax validation result
+ */
+export interface EmailSyntaxResult {
+    isValid: boolean;
+    email?: string;
+    localPart?: string;
+    domain?: string;
+    error?: string;
+}
+/**
+ * Complete check-if-email-exists result
+ */
+export interface CheckIfEmailExistsCoreResult {
+    email: string;
+    isReachable: 'safe' | 'invalid' | 'risky' | 'unknown';
+    syntax: {
+        isValid: boolean;
+        domain?: string;
+        localPart?: string;
+        error?: string;
+    };
+    mx: MxLookupResult | null;
+    smtp: SmtpVerificationResult | null;
+    misc: {
+        isDisposable: boolean;
+        isFree: boolean;
+        providerType: EmailProvider;
+    } | null;
+    duration: number;
+    error?: string;
+}
+/**
+ * SMTP connection options with enhanced typing
+ */
+export interface CheckIfEmailExistsSmtpOptions {
+    timeout?: number;
+    port?: number;
+    retries?: number;
+    fromEmail?: string;
+    helloName?: string;
+    useStartTls?: boolean;
+    useSsl?: boolean;
+    hostName?: string;
+    rejectUnauthorized?: boolean;
+}
+/**
+ * Yahoo API verification options
+ */
+export interface YahooApiOptions {
+    timeout?: number;
+    userAgent?: string;
+    retryAttempts?: number;
+    proxyUrl?: string;
+    headers?: Record<string, string>;
+    apiUrl?: string;
+}
+/**
+ * Headless browser verification options
+ */
+export interface HeadlessOptions {
+    webdriverEndpoint?: string;
+    timeout?: number;
+    retryAttempts?: number;
+    screenshot?: boolean;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    userAgent?: string;
+    acceptInsecureCerts?: boolean;
+}
+/**
+ * Error parsing types
+ */
+export interface ParsedSmtpError {
+    type: 'disabled' | 'full_inbox' | 'unknown' | 'invalid' | 'catch_all' | 'rate_limited' | 'blocked';
+    severity: 'permanent' | 'temporary' | 'unknown';
+    message: string;
+    originalMessage: string;
+    providerSpecific?: {
+        code?: string;
+        action?: string;
+        details?: string;
+    };
+}
+/**
+ * Enhanced verification parameters
+ */
+export interface CheckIfEmailExistsCoreParams {
+    emailAddress: string;
+    timeout?: number;
+    verifyMx?: boolean;
+    verifySmtp?: boolean;
+    debug?: boolean;
+    checkDisposable?: boolean;
+    checkFree?: boolean;
+    cache?: Cache | null;
+    smtpTimeout?: number;
+    fromEmail?: string;
+    helloName?: string;
+    smtpOptions?: CheckIfEmailExistsSmtpOptions;
+    enableProviderOptimizations?: boolean;
+    useYahooApi?: boolean;
+    useYahooHeadless?: boolean;
+    yahooApiOptions?: YahooApiOptions;
+    useHeadless?: boolean;
+    headlessOptions?: HeadlessOptions;
+}
+/**
+ * Test-specific types
+ */
+export interface EmailTestCase {
+    email: string;
+    expected: {
+        syntax: {
+            isValid: boolean;
+            domain?: string;
+            localPart?: string;
+        };
+        provider?: EmailProvider;
+        isDeliverable?: boolean;
+        error?: string;
+    };
+    description?: string;
+    category: 'valid' | 'invalid' | 'edge_case' | 'provider_specific';
+}
+export interface MockSmtpServer {
+    domain: string;
+    provider: EmailProvider;
+    responses: Map<string, {
+        code: number;
+        message: string;
+    }>;
+    connected: boolean;
+}
+/**
+ * Performance metrics
+ */
+export interface VerificationMetrics {
+    duration: number;
+    steps: {
+        syntax: number;
+        mx: number;
+        smtp: number;
+        misc: number;
+    };
+    cache_hits: number;
+    cache_misses: number;
+}

package/dist/index.d.ts

@@ -1,18 +1,18 @@
-import { type IDisposableEmailParams, type IFreeEmailParams, type IVerifyEmailParams, type VerificationResult } from './types';
+import { type DisposableEmailCheckParams, type FreeEmailCheckParams, type VerificationResult, type VerifyEmailParams } from './types';
 export * from './adapters/lru-adapter';
 export * from './adapters/redis-adapter';
-export { verifyEmailBatch } from './batch';
+export { verifyEmailBatch } from './batch-verifier';
 export * from './cache';
 export * from './cache-interface';
-export { COMMON_EMAIL_DOMAINS, defaultDomainSuggestionMethod, getDomainSimilarity, isCommonDomain, suggestDomain, suggestEmailDomain, } from './domain-suggester';
-export { cleanNameForAlgrothin, defaultNameDetectionMethod, detectName, detectNameForAlgrothin, detectNameFromEmail, } from './name-detector';
+export { commonEmailDomains, defaultDomainSuggestionMethod, getDomainSimilarity, isCommonDomain, suggestDomain, suggestEmailDomain, } from './domain-suggester';
+export { isValidEmail, isValidEmailDomain } from './email-validator';
+export { cleanNameForAlgorithm, defaultNameDetectionMethod, detectName, detectNameForAlgorithm, detectNameFromEmail, } from './name-detector';
 export * from './types';
-export { isValidEmail, isValidEmailDomain } from './validator';
 export { getDomainAge, getDomainRegistrationStatus } from './whois';
-export declare function isDisposableEmail(params: IDisposableEmailParams): Promise<boolean>;
-export declare function isFreeEmail(params: IFreeEmailParams): Promise<boolean>;
+export declare function isDisposableEmail(params: DisposableEmailCheckParams): Promise<boolean>;
+export declare function isFreeEmail(params: FreeEmailCheckParams): Promise<boolean>;
 export declare const domainPorts: Record<string, number>;
 /**
  * Verify email address
  */
-export declare function verifyEmail(params: IVerifyEmailParams): Promise<VerificationResult>;
+export declare function verifyEmail(params: VerifyEmailParams): Promise<VerificationResult>;