@mikkelscheike/email-provider-links/dist/provider-loader.d.ts

TypeScript library for email provider detection with 140 providers (259 domains), concurrent DNS resolution, alias normalization, and HTTPS login URL validation for login and password reset flows

/**
 * Email Provider Loader
 *
 * Integrates URL validation and hash verification to load and validate
 * email provider data with security checks.
 */
import type { EmailProvider } from './api';
type MiddlewareRequestLike = Record<string, unknown> & {
    secureProviders?: EmailProvider[];
    securityReport?: LoadResult['securityReport'];
};
type MiddlewareResponseLike = {
    status: (code: number) => {
        json: (body: unknown) => unknown;
    };
};
type MiddlewareNextLike = () => void;
export interface LoadResult {
    success: boolean;
    providers: EmailProvider[];
    domainMap?: Map<string, EmailProvider>;
    stats?: {
        loadTime: number;
        domainMapTime: number;
        providerCount: number;
        domainCount: number;
        fileSize: number;
    };
    securityReport: {
        hashVerification: boolean;
        urlValidation: boolean;
        totalProviders: number;
        validUrls: number;
        invalidUrls: number;
        securityLevel: 'SECURE' | 'WARNING' | 'CRITICAL';
        issues: string[];
    };
}
/**
 * Clear the cache (useful for testing or when providers file changes)
 */
export declare function clearCache(): void;
/**
 * Loads and validates email provider data with security checks
 *
 * @param providersPath - Path to the providers JSON file
 * @param expectedHash - Optional expected hash for verification
 * @returns Load result with validation details
 */
export declare function loadProviders(providersPath?: string, expectedHash?: string): LoadResult;
/**
 * Development utility to generate and display current hashes
 */
export declare function initializeSecurity(): Record<string, string>;
/**
 * Express-style middleware for provider loading with security checks.
 * Kept for advanced/server integrations; not part of the primary public API.
 */
interface SecurityMiddlewareOptions {
    expectedHash?: string;
    allowInvalidUrls?: boolean;
    onSecurityIssue?: (report: LoadResult['securityReport']) => void;
    getProviders?: () => LoadResult;
}
export declare function createSecurityMiddleware(options?: SecurityMiddlewareOptions): (req: MiddlewareRequestLike, res: MiddlewareResponseLike, next: MiddlewareNextLike) => void;
/**
 * Build domain map from providers
 */
export declare function buildDomainMap(providers: EmailProvider[]): Map<string, EmailProvider>;
/**
 * Get loading statistics from the last load operation
 */
export declare function getLoadingStats(): {
    loadTime: number;
    domainMapTime: number;
    providerCount: number;
    domainCount: number;
    fileSize: number;
} | null | undefined;
/**
 * Load providers with debug information (always reloads cache)
 */
export declare function loadProvidersDebug(): {
    domainMap: Map<string, EmailProvider>;
    stats: {
        loadTime: number;
        domainMapTime: number;
        providerCount: number;
        domainCount: number;
        fileSize: number;
    };
    success: boolean;
    providers: EmailProvider[];
    securityReport: {
        hashVerification: boolean;
        urlValidation: boolean;
        totalProviders: number;
        validUrls: number;
        invalidUrls: number;
        securityLevel: "SECURE" | "WARNING" | "CRITICAL";
        issues: string[];
    };
};
declare const _default: {
    loadProviders: typeof loadProviders;
    loadProvidersDebug: typeof loadProvidersDebug;
    buildDomainMap: typeof buildDomainMap;
    getLoadingStats: typeof getLoadingStats;
    initializeSecurity: typeof initializeSecurity;
    createSecurityMiddleware: typeof createSecurityMiddleware;
    clearCache: typeof clearCache;
};
export default _default;
//# sourceMappingURL=provider-loader.d.ts.map