@konfeature/ap-email-guessr 0.1.0

package/dist/src/lib/common/http.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Minimal HTTPS client built on Node's `node:https` only (no dependencies).
+ * Used by the provider signal collectors (O365, Gravatar). Designed to fail
+ * soft: callers treat any network/timeout error as a neutral signal rather
+ * than a hard verdict.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpRequest = httpRequest;
+const node_https_1 = require("node:https");
+const DEFAULT_USER_AGENT = "Mozilla/5.0 (compatible; ap-email-guessr/0.2; +https://www.activepieces.com)";
+/**
+ * Perform a single HTTPS request. Resolves with the status code and (for
+ * non-HEAD requests) the response body. Rejects only on transport failure or
+ * timeout so callers can map those to a neutral signal.
+ */
+function httpRequest(options) {
+    const method = options.method ?? "GET";
+    const url = new URL(options.url);
+    return new Promise((resolve, reject) => {
+        const req = (0, node_https_1.request)({
+            protocol: url.protocol,
+            hostname: url.hostname,
+            port: url.port || 443,
+            path: `${url.pathname}${url.search}`,
+            method,
+            headers: {
+                "User-Agent": DEFAULT_USER_AGENT,
+                Accept: "*/*",
+                ...options.headers,
+            },
+        }, (res) => {
+            const status = res.statusCode ?? 0;
+            // HEAD has no body; drain and resolve immediately.
+            if (method === "HEAD") {
+                res.resume();
+                res.on("end", () => resolve({ status, body: "" }));
+                return;
+            }
+            const chunks = [];
+            let bytes = 0;
+            // Guard against unexpectedly large bodies (e.g. an avatar image
+            // if a caller forgets d=404). 256 KiB is ample for JSON APIs.
+            const maxBytes = 256 * 1024;
+            res.on("data", (chunk) => {
+                bytes += chunk.length;
+                if (bytes <= maxBytes) {
+                    chunks.push(chunk);
+                }
+                else {
+                    res.destroy();
+                }
+            });
+            res.on("end", () => resolve({ status, body: Buffer.concat(chunks).toString("utf8") }));
+            res.on("error", reject);
+        });
+        req.setTimeout(options.timeoutMs, () => {
+            req.destroy(new Error("http_timeout"));
+        });
+        req.on("error", reject);
+        if (options.body !== undefined && method === "POST") {
+            req.write(options.body);
+        }
+        req.end();
+    });
+}
+//# sourceMappingURL=http.js.map

package/dist/src/lib/common/mx-fingerprint.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Fingerprint a domain's mail provider from its MX hostnames.
+ *
+ * Two uses:
+ *  1. Routing — knowing a domain is Microsoft-backed tells us the O365 account
+ *     check is authoritative.
+ *  2. Confidence weighting — "security gateways" (Proofpoint, Mimecast, ...)
+ *     sit in front of the real mailserver and routinely accept every RCPT TO
+ *     before filtering later, so an SMTP "accepted" from them is weak evidence.
+ */
+export type MxProviderId = "google" | "microsoft" | "zoho" | "yahoo" | "yandex" | "fastmail" | "proofpoint" | "mimecast" | "barracuda" | "cisco_ironport" | "other" | "none";
+export interface MxProvider {
+    id: MxProviderId;
+    name: string;
+    /** Security gateway that tends to accept-all at RCPT time. */
+    isGateway: boolean;
+    /** Domain mailboxes are (likely) hosted on Microsoft 365 / Exchange Online. */
+    microsoftBacked: boolean;
+    /** Domain mailboxes are (likely) hosted on Google Workspace / Gmail. */
+    googleBacked: boolean;
+}
+/** Classify a domain's mail provider from its ordered MX hostnames. */
+export declare function fingerprintMx(mxHosts: string[]): MxProvider;
+/**
+ * True when the provider hosts its own non-Microsoft mailboxes, so a "Managed"
+ * Azure AD namespace there is only a leftover tenant artifact and the O365
+ * account check must NOT be trusted. Gateways are excluded: O365 sits behind them.
+ */
+export declare function hostsNonMicrosoftMailboxes(provider: MxProvider): boolean;
+//# sourceMappingURL=mx-fingerprint.d.ts.map

package/dist/src/lib/common/mx-fingerprint.js

@@ -0,0 +1,114 @@
+"use strict";
+/**
+ * Fingerprint a domain's mail provider from its MX hostnames.
+ *
+ * Two uses:
+ *  1. Routing — knowing a domain is Microsoft-backed tells us the O365 account
+ *     check is authoritative.
+ *  2. Confidence weighting — "security gateways" (Proofpoint, Mimecast, ...)
+ *     sit in front of the real mailserver and routinely accept every RCPT TO
+ *     before filtering later, so an SMTP "accepted" from them is weak evidence.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fingerprintMx = fingerprintMx;
+exports.hostsNonMicrosoftMailboxes = hostsNonMicrosoftMailboxes;
+// Ordered: gateways first so that, when a domain fronts its real provider with
+// a gateway, the gateway (the connection we actually probe) wins.
+const RULES = [
+    {
+        id: "proofpoint",
+        name: "Proofpoint",
+        needles: ["pphosted.com", "ppe-hosted.com", "proofpoint.com"],
+        isGateway: true,
+    },
+    {
+        id: "mimecast",
+        name: "Mimecast",
+        needles: ["mimecast.com", "mimecast.co.za", "mimecast-offshore.com"],
+        isGateway: true,
+    },
+    {
+        id: "barracuda",
+        name: "Barracuda",
+        needles: ["barracudanetworks.com", "cudaops.com", "cudamail.com"],
+        isGateway: true,
+    },
+    {
+        id: "cisco_ironport",
+        name: "Cisco IronPort",
+        needles: ["iphmx.com", "ironport.com"],
+        isGateway: true,
+    },
+    {
+        id: "microsoft",
+        name: "Microsoft 365",
+        needles: ["mail.protection.outlook.com", "olc.protection.outlook.com"],
+        microsoftBacked: true,
+    },
+    {
+        id: "google",
+        name: "Google Workspace",
+        needles: [
+            "aspmx.l.google.com",
+            "googlemail.com",
+            "aspmx.google.com",
+            "psmtp.com",
+        ],
+        googleBacked: true,
+    },
+    { id: "zoho", name: "Zoho Mail", needles: ["zoho.com", "zoho.eu", "zohomail"] },
+    { id: "yahoo", name: "Yahoo", needles: ["yahoodns.net"] },
+    { id: "yandex", name: "Yandex", needles: ["mx.yandex", "yandex.net"] },
+    {
+        id: "fastmail",
+        name: "Fastmail",
+        needles: ["messagingengine.com", "fastmail.com"],
+    },
+];
+const NONE = {
+    id: "none",
+    name: "None",
+    isGateway: false,
+    microsoftBacked: false,
+    googleBacked: false,
+};
+const OTHER = {
+    id: "other",
+    name: "Other / Unknown",
+    isGateway: false,
+    microsoftBacked: false,
+    googleBacked: false,
+};
+/** Classify a domain's mail provider from its ordered MX hostnames. */
+function fingerprintMx(mxHosts) {
+    if (mxHosts.length === 0) {
+        return NONE;
+    }
+    const hosts = mxHosts.map((host) => host.toLowerCase().replace(/\.$/, ""));
+    for (const rule of RULES) {
+        const hit = hosts.some((host) => rule.needles.some((needle) => host.includes(needle)));
+        if (hit) {
+            return {
+                id: rule.id,
+                name: rule.name,
+                isGateway: rule.isGateway ?? false,
+                microsoftBacked: rule.microsoftBacked ?? false,
+                googleBacked: rule.googleBacked ?? false,
+            };
+        }
+    }
+    return OTHER;
+}
+/**
+ * True when the provider hosts its own non-Microsoft mailboxes, so a "Managed"
+ * Azure AD namespace there is only a leftover tenant artifact and the O365
+ * account check must NOT be trusted. Gateways are excluded: O365 sits behind them.
+ */
+function hostsNonMicrosoftMailboxes(provider) {
+    return (provider.googleBacked ||
+        provider.id === "zoho" ||
+        provider.id === "yahoo" ||
+        provider.id === "yandex" ||
+        provider.id === "fastmail");
+}
+//# sourceMappingURL=mx-fingerprint.js.map

package/dist/src/lib/common/patterns.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Normalize a person's name and build candidate email addresses ordered by
+ * real-world corporate frequency.
+ *
+ * The order is load-bearing: the verifier checks candidates top-down and stops
+ * on the first hit, so the most likely patterns must come first to minimize
+ * paid verifications. "common" keeps only the leading high-probability slice.
+ */
+/** Lowercase, strip accents and keep only [a-z0-9]. */
+export declare function normalizeNamePart(value: string): string;
+/** Strip protocol, path, leading "@" and lowercase a domain input. */
+export declare function normalizeDomain(value: string): string;
+export type PatternSet = "common" | "all";
+export interface GenerateEmailsParams {
+    firstName: string;
+    lastName: string;
+    domain: string;
+    /** "common" keeps only the top, highest-probability patterns. Default "all". */
+    patternSet?: PatternSet;
+    /** Hard cap on candidates returned, applied after ordering. */
+    maxVariants?: number;
+}
+/**
+ * Generate a de-duplicated list of candidate emails ordered by likelihood.
+ * Returns an empty array when the domain or both name parts are missing.
+ */
+export declare function generateEmailCandidates(params: GenerateEmailsParams): string[];
+//# sourceMappingURL=patterns.d.ts.map

package/dist/src/lib/common/patterns.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * Normalize a person's name and build candidate email addresses ordered by
+ * real-world corporate frequency.
+ *
+ * The order is load-bearing: the verifier checks candidates top-down and stops
+ * on the first hit, so the most likely patterns must come first to minimize
+ * paid verifications. "common" keeps only the leading high-probability slice.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeNamePart = normalizeNamePart;
+exports.normalizeDomain = normalizeDomain;
+exports.generateEmailCandidates = generateEmailCandidates;
+function stripDiacritics(input) {
+    let result = "";
+    for (const char of input.normalize("NFKD")) {
+        const code = char.codePointAt(0) ?? 0;
+        // Drop combining diacritical marks (U+0300–U+036F).
+        if (code >= 0x0300 && code <= 0x036f) {
+            continue;
+        }
+        result += char;
+    }
+    return result;
+}
+/** Lowercase, strip accents and keep only [a-z0-9]. */
+function normalizeNamePart(value) {
+    return stripDiacritics(value ?? "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]/g, "");
+}
+/** Strip protocol, path, leading "@" and lowercase a domain input. */
+function normalizeDomain(value) {
+    return (value ?? "")
+        .trim()
+        .toLowerCase()
+        .replace(/^https?:\/\//, "")
+        .replace(/^@/, "")
+        .replace(/\/.*$/, "")
+        .replace(/\s+/g, "");
+}
+const LOCAL_PART_REGEX = /^[a-z0-9]([a-z0-9._-]*[a-z0-9])?$/;
+/** Leading patterns that cover the large majority of real corporate addresses. */
+const COMMON_LIMIT = 10;
+const join = (a, sep, b) => a && b ? `${a}${sep}${b}` : "";
+// Ordered by approximate real-world B2B frequency (most common first). Each
+// trailing comment names the produced local-part so the terse builders stay
+// readable. This order drives how many paid verifications an early-stop search
+// performs, so changing it changes credit cost.
+const PATTERNS = [
+    (p) => join(p.first, ".", p.last), // first.last
+    (p) => join(p.fi, "", p.last), //     flast
+    (p) => p.first, //                    first
+    (p) => join(p.first, "", p.last), //  firstlast
+    (p) => join(p.first, "_", p.last), // first_last
+    (p) => join(p.fi, ".", p.last), //    f.last
+    (p) => join(p.first, "-", p.last), // first-last
+    (p) => p.last, //                     last
+    (p) => join(p.last, ".", p.first), // last.first
+    (p) => join(p.first, "", p.li), //    firstl
+    (p) => join(p.fi, "", p.li), //       fl
+    (p) => join(p.last, "", p.first), //  lastfirst
+    (p) => join(p.last, "_", p.first), // last_first
+    (p) => join(p.last, "-", p.first), // last-first
+    (p) => join(p.fi, "_", p.last), //    f_last
+    (p) => join(p.fi, "-", p.last), //    f-last
+    (p) => join(p.last, "", p.fi), //     lastf
+    (p) => join(p.last, ".", p.fi), //    last.f
+    (p) => join(p.li, "", p.fi), //       lf
+    (p) => join(p.first, ".", p.li), //   first.l
+];
+/**
+ * Generate a de-duplicated list of candidate emails ordered by likelihood.
+ * Returns an empty array when the domain or both name parts are missing.
+ */
+function generateEmailCandidates(params) {
+    const first = normalizeNamePart(params.firstName);
+    const last = normalizeNamePart(params.lastName);
+    const domain = normalizeDomain(params.domain);
+    if (!domain || (!first && !last)) {
+        return [];
+    }
+    const parts = {
+        first,
+        last,
+        fi: first.charAt(0),
+        li: last.charAt(0),
+    };
+    const seen = new Set();
+    const locals = [];
+    for (const build of PATTERNS) {
+        const local = build(parts);
+        if (!local || seen.has(local) || !LOCAL_PART_REGEX.test(local)) {
+            continue;
+        }
+        seen.add(local);
+        locals.push(local);
+    }
+    const limit = params.maxVariants ??
+        (params.patternSet === "common" ? COMMON_LIMIT : locals.length);
+    return locals
+        .slice(0, Math.max(0, limit))
+        .map((local) => `${local}@${domain}`);
+}
+//# sourceMappingURL=patterns.js.map

package/dist/src/lib/common/providers/o365.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Microsoft 365 / Azure AD account-existence check.
+ *
+ * Two unauthenticated endpoints, used widely for O365 user enumeration:
+ *
+ *  1. getuserrealm.srf — classifies the domain's namespace:
+ *       Managed   → mailboxes live in Azure AD / Exchange Online (the account
+ *                   check below is authoritative).
+ *       Federated → auth is delegated to on-prem ADFS/Okta/etc.; the account
+ *                   check is unreliable, so we skip the verdict.
+ *       Unknown   → not a Microsoft domain.
+ *
+ *  2. GetCredentialType — returns `IfExistsResult`, which reveals whether a
+ *     given Azure AD / Microsoft account exists *without* SMTP. This is the
+ *     single most valuable non-SMTP signal because a large share of corporate
+ *     domains run on O365, including many that sit behind a security gateway.
+ *
+ * Everything fails soft: any network/throttle/parse problem yields an
+ * inconclusive result rather than a false verdict.
+ */
+export type O365Namespace = "Managed" | "Federated" | "Unknown" | null;
+export interface O365Result {
+    /** Whether GetCredentialType produced an interpretable verdict. */
+    checked: boolean;
+    /** true = account exists, false = does not exist, null = inconclusive. */
+    exists: boolean | null;
+    namespace: O365Namespace;
+    ifExistsResult: number | null;
+    reason: string;
+}
+export declare const O365_UNCHECKED: O365Result;
+export declare function isMicrosoftConsumerDomain(domain: string): boolean;
+/**
+ * Map an `IfExistsResult` code to an existence verdict.
+ *  0 → exists
+ *  1 → does not exist
+ *  6 → exists in a different Microsoft tenant (still a real account)
+ *  5 → different identity provider (ambiguous for this domain) → inconclusive
+ *  other → inconclusive
+ */
+export declare function interpretIfExists(code: number | null): boolean | null;
+/** Classify a domain's Microsoft namespace. Returns null on any failure. */
+export declare function getUserRealm(domain: string, timeoutMs: number): Promise<O365Namespace>;
+/**
+ * Run the account-existence check for one email, given a pre-resolved namespace
+ * for its domain. `applicable` should be true only when the domain is known to
+ * be Microsoft-backed (Managed namespace, Microsoft MX, or a consumer domain);
+ * otherwise GetCredentialType returns noise for unrelated domains.
+ */
+export declare function checkO365Account(email: string, namespace: O365Namespace, applicable: boolean, timeoutMs: number): Promise<O365Result>;
+//# sourceMappingURL=o365.d.ts.map

package/dist/src/lib/common/providers/o365.js

@@ -0,0 +1,171 @@
+"use strict";
+/**
+ * Microsoft 365 / Azure AD account-existence check.
+ *
+ * Two unauthenticated endpoints, used widely for O365 user enumeration:
+ *
+ *  1. getuserrealm.srf — classifies the domain's namespace:
+ *       Managed   → mailboxes live in Azure AD / Exchange Online (the account
+ *                   check below is authoritative).
+ *       Federated → auth is delegated to on-prem ADFS/Okta/etc.; the account
+ *                   check is unreliable, so we skip the verdict.
+ *       Unknown   → not a Microsoft domain.
+ *
+ *  2. GetCredentialType — returns `IfExistsResult`, which reveals whether a
+ *     given Azure AD / Microsoft account exists *without* SMTP. This is the
+ *     single most valuable non-SMTP signal because a large share of corporate
+ *     domains run on O365, including many that sit behind a security gateway.
+ *
+ * Everything fails soft: any network/throttle/parse problem yields an
+ * inconclusive result rather than a false verdict.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.O365_UNCHECKED = void 0;
+exports.isMicrosoftConsumerDomain = isMicrosoftConsumerDomain;
+exports.interpretIfExists = interpretIfExists;
+exports.getUserRealm = getUserRealm;
+exports.checkO365Account = checkO365Account;
+const http_1 = require("../http");
+exports.O365_UNCHECKED = {
+    checked: false,
+    exists: null,
+    namespace: null,
+    ifExistsResult: null,
+    reason: "not_checked",
+};
+// Consumer Microsoft domains (MSA). getuserrealm often reports these as
+// "Unknown", but GetCredentialType is still authoritative for them.
+const CONSUMER_DOMAINS = new Set([
+    "outlook.com",
+    "hotmail.com",
+    "live.com",
+    "msn.com",
+    "passport.com",
+    "windowslive.com",
+    "hotmail.co.uk",
+    "hotmail.fr",
+    "hotmail.de",
+    "hotmail.it",
+    "hotmail.es",
+    "live.co.uk",
+    "live.fr",
+    "live.de",
+    "outlook.fr",
+    "outlook.de",
+    "outlook.es",
+    "outlook.jp",
+]);
+function isMicrosoftConsumerDomain(domain) {
+    return CONSUMER_DOMAINS.has(domain.toLowerCase());
+}
+/**
+ * Map an `IfExistsResult` code to an existence verdict.
+ *  0 → exists
+ *  1 → does not exist
+ *  6 → exists in a different Microsoft tenant (still a real account)
+ *  5 → different identity provider (ambiguous for this domain) → inconclusive
+ *  other → inconclusive
+ */
+function interpretIfExists(code) {
+    if (code === 0 || code === 6) {
+        return true;
+    }
+    if (code === 1) {
+        return false;
+    }
+    return null;
+}
+/** Classify a domain's Microsoft namespace. Returns null on any failure. */
+async function getUserRealm(domain, timeoutMs) {
+    const login = encodeURIComponent(`probe@${domain}`);
+    try {
+        const res = await (0, http_1.httpRequest)({
+            url: `https://login.microsoftonline.com/getuserrealm.srf?login=${login}&json=1`,
+            method: "GET",
+            timeoutMs,
+        });
+        if (res.status !== 200) {
+            return null;
+        }
+        const data = JSON.parse(res.body);
+        const ns = data.NameSpaceType;
+        if (ns === "Managed" || ns === "Federated" || ns === "Unknown") {
+            return ns;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Query GetCredentialType for a single address. Returns null code on failure. */
+async function probeCredentialType(email, timeoutMs) {
+    try {
+        const res = await (0, http_1.httpRequest)({
+            url: "https://login.microsoftonline.com/common/GetCredentialType?mkt=en-US",
+            method: "POST",
+            headers: { "Content-Type": "application/json; charset=UTF-8" },
+            body: JSON.stringify({
+                Username: email,
+                isOtherIdpSupported: true,
+            }),
+            timeoutMs,
+        });
+        if (res.status !== 200) {
+            return { ifExistsResult: null, throttled: false };
+        }
+        const data = JSON.parse(res.body);
+        return {
+            ifExistsResult: typeof data.IfExistsResult === "number"
+                ? data.IfExistsResult
+                : null,
+            throttled: (data.ThrottleStatus ?? 0) !== 0,
+        };
+    }
+    catch {
+        return { ifExistsResult: null, throttled: false };
+    }
+}
+/**
+ * Run the account-existence check for one email, given a pre-resolved namespace
+ * for its domain. `applicable` should be true only when the domain is known to
+ * be Microsoft-backed (Managed namespace, Microsoft MX, or a consumer domain);
+ * otherwise GetCredentialType returns noise for unrelated domains.
+ */
+async function checkO365Account(email, namespace, applicable, timeoutMs) {
+    if (!applicable) {
+        return { ...exports.O365_UNCHECKED, namespace, reason: "not_microsoft_domain" };
+    }
+    const probe = await probeCredentialType(email, timeoutMs);
+    if (probe.throttled) {
+        return {
+            checked: false,
+            exists: null,
+            namespace,
+            ifExistsResult: probe.ifExistsResult,
+            reason: "throttled",
+        };
+    }
+    if (probe.ifExistsResult === null) {
+        return {
+            checked: false,
+            exists: null,
+            namespace,
+            ifExistsResult: null,
+            reason: "no_result",
+        };
+    }
+    const exists = interpretIfExists(probe.ifExistsResult);
+    return {
+        checked: exists !== null,
+        exists,
+        namespace,
+        ifExistsResult: probe.ifExistsResult,
+        reason: exists === true
+            ? "account_exists"
+            : exists === false
+                ? "account_not_found"
+                : "inconclusive",
+    };
+}
+//# sourceMappingURL=o365.js.map

package/dist/src/lib/common/verifier.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Provider-agnostic email-existence verifier.
+ *
+ * Both the direct O365 account check and the no2bounce API implement this, so
+ * the credit-saving search logic (early-stop, catch-all-stop) in `find-email`
+ * is identical regardless of which provider actually answers.
+ */
+export type VerifyVerdict = "valid" | "invalid" | "catch_all" | "unknown";
+export interface VerifyOutcome {
+    email: string;
+    verdict: VerifyVerdict;
+    /** Credits this single verification consumed (0 for the free O365 check). */
+    creditsUsed: number;
+    reason: string;
+    catchAll?: boolean;
+    raw?: unknown;
+}
+export interface Verifier {
+    readonly name: string;
+    verify(email: string): Promise<VerifyOutcome>;
+}
+//# sourceMappingURL=verifier.d.ts.map

package/dist/src/lib/common/verifier.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Provider-agnostic email-existence verifier.
+ *
+ * Both the direct O365 account check and the no2bounce API implement this, so
+ * the credit-saving search logic (early-stop, catch-all-stop) in `find-email`
+ * is identical regardless of which provider actually answers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=verifier.js.map

package/dist/src/lib/common/verifiers/no2bounce-verifier.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Verifier adapter for the no2bounce API (wire format confirmed against the
+ * live API).
+ *
+ * Async flow: POST a 1-email batch to get a `trackingId` (under `data`), then
+ * GET-poll `?trackingId=` until the *top-level* `overallStatus` is "Completed".
+ * For a single email the top-level count fields are that email's verdict.
+ * Billing is 1 credit per email (`creditDebited`), with no refund on undeliverable.
+ */
+import type { Verifier, VerifyVerdict } from "../verifier";
+export interface No2BounceOptions {
+    apitoken: string;
+    timeoutMs: number;
+    pollIntervalMs?: number;
+    maxWaitMs?: number;
+}
+interface PollResult {
+    overallStatus?: string;
+    percent?: number;
+    creditDebited?: number;
+    Deliverable?: number;
+    Undeliverable?: number;
+    "Deliverable/AcceptAll"?: number;
+    "UnDeliverable/AcceptAll"?: number;
+    "Risky/AcceptAll"?: number;
+}
+export interface DecodedResult {
+    verdict: VerifyVerdict;
+    catchAll: boolean;
+}
+export declare function decodeSingle(r: PollResult): DecodedResult;
+export declare function createNo2BounceVerifier(options: No2BounceOptions): Verifier;
+export {};
+//# sourceMappingURL=no2bounce-verifier.d.ts.map