/**
 * Email Provider Links
 *
 * A modern, robust email provider detection library with:
 * - 93+ verified email providers covering 180+ domains
 * - Concurrent DNS detection for business domains
 * - Zero runtime dependencies
 * - Comprehensive error handling with detailed context
 * - International email validation (IDN support)
 * - Email alias normalization and deduplication
 * - Enterprise-grade security features
 *
 * @author Email Provider Links Team
 * @license MIT
 * @version 2.7.0
 */
export { getEmailProvider, getEmailProviderSync, getEmailProviderFast, normalizeEmail, emailsMatch, Config } from './api';
export type { EmailProvider, EmailProviderResult } from './api';
export { loadProviders } from './loader';
export { detectProviderConcurrent } from './concurrent-dns';
export { validateInternationalEmail, emailToPunycode, domainToPunycode } from './idn';
export type { ConcurrentDNSConfig, ConcurrentDNSResult } from './concurrent-dns';
/**
 * Enhanced email validation with comprehensive error reporting
 *
 * @param email - Email address to validate
 * @returns Validation result with detailed error information
 *
 * @example
 * ```typescript
 * const result = validateEmailAddress('user@example.com');
 * if (result.isValid) {
 *   console.log('Email is valid');
 * } else {
 *   console.log('Error:', result.error.message);
 * }
 * ```
 */
export declare function validateEmailAddress(email: string): {
    isValid: boolean;
    normalizedEmail?: string;
    error?: {
        type: string;
        code: string;
        message: string;
    };
};
import { loadProviders } from './loader';
import { getEmailProvider, getEmailProviderSync, getEmailProviderFast, normalizeEmail, emailsMatch } from './api';
import { detectProviderConcurrent } from './concurrent-dns';
import { validateInternationalEmail } from './idn';
/**
 * Get comprehensive list of all supported email providers
 *
 * @returns Array of all email providers with metadata
 *
 * @example
 * ```typescript
 * const providers = getSupportedProviders();
 * console.log(`Supports ${providers.length} providers`);
 *
 * const gmailProvider = providers.find(p => p.domains.includes('gmail.com'));
 * console.log(gmailProvider?.companyProvider); // "Gmail"
 * ```
 */
export declare function getSupportedProviders(): import("./api").EmailProvider[];
/**
 * Check if an email provider is supported (synchronous)
 *
 * @param email - Email address to check
 * @returns true if the provider is supported
 *
 * @example
 * ```typescript
 * if (isEmailProviderSupported('user@gmail.com')) {
 *   console.log('Gmail is supported');
 * }
 * ```
 */
export declare function isEmailProviderSupported(email: string): boolean;
/**
 * Extract and normalize domain from email address
 *
 * @param email - Email address
 * @returns Normalized domain portion or null if invalid
 *
 * @example
 * ```typescript
 * const domain = extractDomain('USER@GMAIL.COM');
 * console.log(domain); // "gmail.com"
 *
 * const invalid = extractDomain('invalid-email');
 * console.log(invalid); // null
 * ```
 */
export declare function extractDomain(email: string): string | null;
/**
 * Validate email format using enhanced rules
 *
 * @param email - Email address to validate
 * @returns true if valid format
 *
 * @example
 * ```typescript
 * if (isValidEmail('user@example.com')) {
 *   console.log('Email format is valid');
 * }
 *
 * if (isValidEmail('user@münchen.de')) {
 *   console.log('International domain is valid');
 * }
 * ```
 */
export declare function isValidEmail(email: string): boolean;
/**
 * Get library metadata and statistics
 *
 * @returns Object with current library statistics
 *
 * @example
 * ```typescript
 * const stats = getLibraryStats();
 * console.log(`Supports ${stats.providerCount} providers across ${stats.domainCount} domains`);
 * ```
 */
export declare function getLibraryStats(): {
    providerCount: number;
    domainCount: number;
    version: string;
    supportsAsync: boolean;
    supportsIDN: boolean;
    supportsAliasDetection: boolean;
    supportsConcurrentDNS: boolean;
};
/**
 * Batch process multiple email addresses efficiently
 *
 * @param emails - Array of email addresses to process
 * @param options - Processing options
 * @returns Array of results in the same order as input
 *
 * @example
 * ```typescript
 * const emails = ['user@gmail.com', 'test@yahoo.com', 'invalid-email'];
 * const results = batchProcessEmails(emails);
 *
 * results.forEach((result, index) => {
 *   console.log(`${emails[index]}: ${result.isValid ? 'Valid' : 'Invalid'}`);
 * });
 * ```
 */
export declare function batchProcessEmails(emails: string[], options?: {
    includeProviderInfo?: boolean;
    normalizeEmails?: boolean;
    deduplicateAliases?: boolean;
}): Array<{
    email: string;
    isValid: boolean;
    provider?: string | null;
    loginUrl?: string | null;
    normalized?: string;
    isDuplicate?: boolean;
    error?: string;
}>;
/**
 * @deprecated Use validateEmailAddress instead for better error handling
 */
export declare const isValidEmailAddress: typeof isValidEmail;
/**
 * Library metadata (legacy constants)
 */
export declare const PROVIDER_COUNT = 93;
export declare const DOMAIN_COUNT = 178;
/**
 * Default export for convenience
 *
 * @example
 * ```typescript
 * import EmailProviderLinks from '@mikkelscheike/email-provider-links';
 *
 * const result = await EmailProviderLinks.getEmailProvider('user@gmail.com');
 * ```
 */
declare const _default: {
    getEmailProvider: typeof getEmailProvider;
    getEmailProviderSync: typeof getEmailProviderSync;
    getEmailProviderFast: typeof getEmailProviderFast;
    validateEmailAddress: typeof validateEmailAddress;
    isValidEmail: typeof isValidEmail;
    normalizeEmail: typeof normalizeEmail;
    emailsMatch: typeof emailsMatch;
    getSupportedProviders: typeof getSupportedProviders;
    isEmailProviderSupported: typeof isEmailProviderSupported;
    extractDomain: typeof extractDomain;
    getLibraryStats: typeof getLibraryStats;
    batchProcessEmails: typeof batchProcessEmails;
    loadProviders: typeof loadProviders;
    detectProviderConcurrent: typeof detectProviderConcurrent;
    validateInternationalEmail: typeof validateInternationalEmail;
    Config: {
        readonly DEFAULT_DNS_TIMEOUT: 5000;
        readonly MAX_DNS_REQUESTS_PER_MINUTE: 10;
        readonly SUPPORTED_PROVIDERS_COUNT: 93;
        readonly SUPPORTED_DOMAINS_COUNT: 180;
    };
    PROVIDER_COUNT: number;
    DOMAIN_COUNT: number;
};
export default _default;
/**
 * Version information
 */
export declare const VERSION = "2.7.0";
//# sourceMappingURL=index.d.ts.map