@redsift/products 12.0.0-muiv7 → 12.1.0-muiv6

package/index.d.ts

@@ -196,4 +196,1606 @@ declare const RadarSimpleMenuButton: Comp<Omit<MenuButtonProps, 'children'> & {
     icon?: Omit<IconProps, 'ref'>;
 } & Pick<MenuButtonContentMenuProps, 'children'>, HTMLDivElement>;
 
-export { BaseRadarMenuButton, BaseRadarMenuButtonContent, Radar, RadarButton, RadarItem, RadarMenuButton, RadarMenuButtonContent, RadarMenuButtonContentFooter, RadarMenuButtonContentHeader, RadarMenuButtonContentMenu, RadarMenuButtonTrigger, RadarSimple, RadarSimpleMenuButton };
+/**
+ * Translation-related type definitions
+ * Separated to avoid circular dependencies between hooks and utils
+ */
+/**
+ * Parameters that can be passed to translation functions for interpolation
+ * Uses a flexible type to accommodate various i18n parameter patterns
+ */
+type TranslationParams = Record<string, any>;
+/** Translation function signature */
+type TranslationFn = (key: string, params?: TranslationParams) => string;
+
+/**
+ * Investigate API Type Definitions
+ *
+ * This file contains comprehensive type definitions for ALL Investigate API responses.
+ * These types are the source of truth for jmap, extsecrep, and investigate data structures.
+ *
+ * Based on: src/tools/types.ts (legacy location - types being migrated here)
+ *
+ * Data Sources & Use Cases:
+ * -------------------------
+ * These types define the shape of data consumed by signal cards, regardless of the
+ * actual API endpoint or data fetching mechanism (which happens at the application layer).
+ *
+ * 1. Email Analysis (Public & Private Investigate)
+ *    Type: PublicInvestigateResponseProps
+ *    Data includes: jmap.extsecrep with email authentication results
+ *    Cards: DMARC, SPF, DKIM, BIMI, TLS, FCrDNS, MTA-STS, Google/Yahoo, etc.
+ *    Private adds: DNSSEC, URLs, Threat Intelligence, IP Reputation, AMP
+ *
+ * 2. BIMI Checker (Domain Validation)
+ *    Type: BimiCheckerResponseProps
+ *    Data includes: Simple domain-level DMARC/SPF/BIMI checks
+ *    Cards: DMARC Domain (BIMI Checker), SPF Domain (BIMI Checker), BIMI
+ *
+ * 3. Domain Analyzer (Advanced Domain Analysis)
+ *    Type: DomainAnalyzerResponseProps
+ *    Data includes: Advanced SPF/DKIM domain analysis with DNS details
+ *    Cards: SPF Domain Analyzer, DKIM Domain Analyzer, Subdomain, Threat Intelligence
+ *
+ * Note: Actual API endpoints and data fetching logic are defined at the application layer,
+ *       not in this Design System. These types only define the expected data structure.
+ */
+/**
+ * Generic DNS lookup error structure
+ * Used for DNS-related errors in FCrDNS, EHLO, and other DNS lookup operations
+ */
+interface DnsLookupError {
+    code?: string;
+    errno?: number;
+    syscall?: string;
+    hostname?: string;
+    message?: string;
+}
+/**
+ * Generic API error that can be a string message, Error object, or structured error
+ */
+type ApiError = string | Error | DnsLookupError | {
+    message?: string;
+    code?: string;
+} | null;
+interface DmarcProps {
+    fromDomain?: string;
+    policyDomain?: string;
+    spfDomain?: string;
+    dkimDomain?: string;
+    spfIdentity?: string;
+    fromDns?: boolean;
+    raw?: string;
+    result?: 'none' | 'neutral' | 'pass' | 'fail' | 'temperror' | 'permerror' | 'policy' | 'warning';
+    policy?: {
+        v?: string;
+        p?: 'none' | 'quarantine' | 'reject';
+        sp?: 'none' | 'quarantine' | 'reject';
+        pct?: number;
+        rua?: {
+            uri?: string;
+        }[];
+        ruf?: {
+            uri?: string;
+        }[];
+        adkim?: 'r' | 'relaxed' | 's' | 'strict';
+        aspf?: 'r' | 'relaxed' | 's' | 'strict';
+        [key: string]: unknown;
+    };
+    alignDkim?: boolean;
+    alignSpf?: boolean;
+    dmarcErrors?: ('no-rua' | 'invalid-record' | 'failed')[];
+    report?: {
+        message?: string;
+        detail?: string;
+        text?: string;
+        [key: string]: unknown;
+    }[];
+    error?: {
+        err?: string;
+        pos?: number;
+    };
+    [key: string]: unknown;
+}
+type DecisionGraphProps = {
+    id?: number;
+    effectiveValue?: string;
+    raw?: string;
+    rfc4408DnsCount?: number;
+    children?: DecisionGraphProps[];
+    voidLookupCount?: number;
+    TTL?: number;
+    errors?: SPFEvaluationError[];
+};
+interface SpfProps {
+    voidCount?: number;
+    status?: string;
+    report?: {
+        status?: string;
+        message?: string;
+        [key: string]: unknown;
+    }[];
+    helo?: {
+        receivedSpf?: {
+            result?: 'none' | 'neutral' | 'pass' | 'fail' | 'softfail' | 'temperror' | 'permerror';
+            clientIp?: string;
+            identity?: string;
+            helo?: string;
+            receiver?: string;
+            [key: string]: unknown;
+        };
+        decisionGraph?: DecisionGraphProps | null;
+        matchedNodes?: number[];
+    };
+    mailfrom?: {
+        receivedSpf?: {
+            result?: 'none' | 'neutral' | 'pass' | 'fail' | 'softfail' | 'temperror' | 'permerror';
+            clientIp?: string;
+            identity?: string;
+            envelopeFrom?: string;
+            receiver?: string;
+            [key: string]: unknown;
+        };
+        decisionGraph?: DecisionGraphProps | null;
+        matchedNodes?: number[];
+    };
+    [key: string]: unknown;
+}
+type SPFEvaluationErrorKind = 'syntax' | 'dns' | 'validation' | 'unknown';
+type SPFEvaluationError = {
+    raw?: Error;
+    error?: string;
+    kind?: SPFEvaluationErrorKind;
+    detail?: string;
+};
+interface DkimProps {
+    order?: number;
+    code?: 'none' | 'neutral' | 'pass' | 'fail' | 'outdated_algorithm' | 'temperror' | 'permerror' | 'policy';
+    signature?: {
+        header?: string;
+        raw?: string;
+        algorithmId?: string;
+        hash?: string;
+        bodyHash?: string;
+        relaxedHeader?: boolean;
+        relaxedBody?: boolean;
+        signerDomain?: string;
+        selector?: string;
+        headers?: string[];
+        userId?: string;
+        arcInstance?: number;
+        length?: number;
+        ts?: string;
+        exp?: string;
+        arcCv?: string;
+        spf?: string;
+        dmarc?: string;
+        dkim?: string;
+        [key: string]: unknown;
+    } | null;
+    key?: {
+        raw?: string;
+        version?: string;
+        key_type?: string;
+        key?: string;
+        keyLength?: number;
+        testing?: boolean;
+        strict?: boolean;
+        ttl?: number;
+        [key: string]: unknown;
+    } | null;
+    error?: {
+        [key: string]: unknown;
+    } | null;
+    timestamp?: string;
+    [key: string]: unknown;
+}
+interface TlsProps {
+    version?: 512 | 768 | 769 | 770 | 771 | 772 | number;
+    cipherSuite?: 5 | 10 | 47 | 53 | 60 | 156 | 157 | 4865 | 4866 | 4867 | 4868 | 4869 | 49159 | 49161 | 49162 | 49169 | 49170 | 49171 | 49172 | 49187 | 49191 | 49195 | 49196 | 49199 | 49200 | 52392 | 52393 | number;
+}
+interface TlsRecordProps {
+    tlsReportRecordCompliant?: boolean;
+    domainPublished?: string;
+    recordTxt?: string;
+    txtExtractedFrom?: string;
+    status?: 'warning' | 'pass' | 'fail';
+    txt?: string;
+    text?: string;
+    domain?: string;
+    fromDomain?: string;
+}
+interface FcrdnsProps {
+    match?: boolean;
+    clientIp?: string;
+    helo?: string;
+    error?: string;
+    aRecords?: {
+        errors?: ApiError | null;
+        items?: {
+            [key: string]: {
+                address?: string;
+                family?: number;
+            }[];
+        };
+    };
+    ptrRecords?: {
+        error?: ApiError;
+        items?: string[];
+    };
+}
+interface EhloCheckProps {
+    match?: boolean;
+    senderIpMatchesEhloARecord?: boolean;
+    senderIpPtrRecordMatchesEhloDomain?: {
+        domain?: string;
+        domains?: string[];
+        err?: ApiError;
+    };
+    aRecords?: {
+        error?: ApiError;
+        items?: {
+            address: string;
+            family: number;
+        }[];
+    };
+    ptrRecords?: {
+        errors?: ApiError | null;
+        items?: {
+            [key: string]: string[];
+        };
+    };
+}
+interface EhloProps {
+    isAddrDomain?: boolean;
+    clientIp?: string;
+}
+declare enum BimiRecordStatus {
+    DeclinationToPublish = "declination-to-publish",
+    NoRecordTxt = "noRecordTxt",
+    InvalidRecordTxt = "invalidRecordTxt",
+    CertNotFound = "certNotFound",
+    Valid = "valid",
+    PresentWithErrors = "presentWithErrors",
+    CertInvalid = "certInvalid",
+    CertForbidden = "certForbidden",
+    NotVMC = "notVMC"
+}
+type BimiSvgError = 'invalid-svg' | 'invalid-svg-version' | 'invalid-svg-profile' | 'invalid-svg-root-element' | 'invalid-svg-attribute-xy' | 'invalid-svg-reference' | 'invalid-svg-missing-title' | 'invalid-svg-size' | 'invalid-svg-content-type' | 'invalid-svg-id-name' | 'invalid-svg-attribute' | 'invalid-svg-element-style' | 'invalid-svg-element-script' | 'invalid-svg-element-link' | 'invalid-svg-element-image' | 'invalid-svg-element-foreign-object' | 'invalid-xml-12' | 'logo-and-evidence-mismatch' | 'logo-extract-error' | 'unknown-svg-error';
+type BimiRecordValidationError = 'bimi-error-missing-v' | 'bimi-error-missing-a' | 'bimi-error-missing-l' | 'bimi-error-invalid-a' | 'bimi-error-invalid-l' | 'bimi-error-unsupported-values' | 'bimi-error-incorrect-v' | 'bimi-error-cert-not-valid' | 'bimi-error-invalid-record' | 'bimi-error-unknown';
+type BimiPemError = 'cert-not-found' | 'cert-not-url' | 'cert-not-file' | 'cert-not-https' | 'cert-not-pem' | 'cert-forbidden' | 'cert-bad-date' | 'cert-not-valid' | 'cert-bad-signature' | 'cert-unknown-error';
+interface BimiProps {
+    dmarcCompliant?: boolean;
+    domainPublished?: string;
+    recordTxt?: string;
+    txtExtractedFrom?: string;
+    bimiRecordStatus?: BimiRecordStatus;
+    recordValidationErrors?: BimiRecordValidationError[];
+    imageSource?: 'image-source-vmc' | 'image-source-logo' | 'image-source-notthere';
+    imageUrl?: string;
+    svgErrors?: BimiSvgError[];
+    pemUrl?: string;
+    vmc?: {
+        assertionMarkType?: 'CMC' | 'VMC';
+        assertionMark?: 'Prior Use Mark' | 'Registered Mark' | 'Modified Registered Mark' | 'Government Mark';
+        logoSrc?: string;
+        expiryDate?: string;
+        validDomains?: string[];
+        issuer?: string[];
+        trademarkAuthority?: string[];
+        compliant?: boolean;
+        logoErrors?: BimiSvgError[];
+        pemErrors?: BimiPemError[];
+        errors?: {
+            message: string;
+            code: string;
+        }[];
+    };
+}
+interface MtaStsRecordProps {
+    mtaStsRecordCompliant?: boolean;
+    domainPublished?: string;
+    recordTxt?: string;
+    txtExtractedFrom?: string;
+    txt?: string;
+    status?: 'warning' | 'pass' | 'fail';
+    text?: string;
+    domain?: string;
+    fromDomain?: string;
+}
+interface MtaStsPolicyProps {
+    policy?: {
+        version?: string;
+        mode?: string;
+        mx?: string[];
+        maxAge?: string;
+        mxRecords?: string[];
+    };
+    fromDomain?: string;
+    txtExtractedFrom?: string;
+    status?: 'warning' | 'pass' | 'fail';
+    ok?: boolean;
+    text?: string;
+    result?: {
+        version?: string;
+        mode?: string;
+        mx?: string[];
+        max_age?: number;
+        maxAge?: number;
+        mxRecords?: string[];
+    } | null;
+    message?: string;
+    domain?: string;
+}
+interface MtaStsCertificateProps {
+    status: 'warning' | 'pass' | 'fail';
+    isRenewalAtRisk?: boolean;
+    certificateExpiry?: string | null;
+    content?: string | null;
+    name?: string | null;
+}
+interface MtaProps {
+    result?: 'fail' | 'success' | 'warning';
+    tlsRecord?: TlsRecordProps;
+    mtaStsRecord?: MtaStsRecordProps;
+    mtaStsPolicy?: MtaStsPolicyProps;
+    mtaStsCertificate?: MtaStsCertificateProps;
+}
+interface DnsSecurityProps {
+    result?: 'pass' | 'fail';
+}
+interface LookalikeDomainsProps {
+    number?: number;
+}
+interface EmailProviderProps {
+    provider?: 'Microsoft Office 365' | 'Google Workspace' | string;
+    useOnInbox?: boolean;
+}
+interface UnsubscribeProps {
+    result?: 'pass' | 'fail';
+}
+/**
+ * ExtSecRep (External Security Report) - Contains all email authentication results
+ */
+interface ExtsecrepProps {
+    ehlo?: EhloProps;
+    tls?: TlsProps;
+    spf?: SpfProps;
+    dkim?: DkimProps | DkimProps[];
+    dmarc?: DmarcProps;
+    bimi?: BimiProps;
+    mta?: MtaProps;
+    dnsSecurity?: DnsSecurityProps;
+    lookalikeDomains?: LookalikeDomainsProps;
+    emailProvider?: EmailProviderProps;
+    unsubscribe?: UnsubscribeProps;
+    tl?: {
+        ip?: string[];
+        domain?: string[];
+    };
+}
+/**
+ * Investigate Data - Contains FCrDNS and EHLO check results
+ */
+interface InvestigateProps {
+    fcrdns?: FcrdnsProps;
+    ehloCheck?: EhloCheckProps;
+    urls?: string[];
+}
+/**
+ * JMAP - JSON Meta Application Protocol
+ * Main container for email metadata and security results
+ */
+interface JmapProps {
+    subject?: string;
+    date?: string;
+    user?: string;
+    from?: {
+        name?: string;
+        email?: string;
+    };
+    email?: string;
+    extsecrep?: ExtsecrepProps;
+}
+/**
+ * Domain Analyzer SPF Props
+ * Advanced SPF analysis for Domain Analyzer tool
+ * Includes DNS lookup counting, void lookup detection, and Dynamic SPF analysis
+ */
+interface DomainAnalyzerSpfProps {
+    domain?: string;
+    domainPublished?: string;
+    txtExtractedFrom?: string;
+    raw?: string | string[];
+    status?: 'pass' | 'fail' | 'warning';
+    count?: number;
+    voidCount?: number;
+    subdoCount?: number;
+    records?: Array<{
+        domain?: string;
+        include?: string;
+        record?: string;
+        raw?: string;
+    }>;
+    report?: Array<{
+        message?: string;
+        spfError?: string;
+        status?: string;
+        [key: string]: unknown;
+    }>;
+}
+/**
+ * Domain Analyzer DKIM Props
+ * Advanced DKIM analysis for Domain Analyzer tool
+ * Includes selector records, CNAME chains, key validation, and issues detection
+ */
+interface DomainAnalyzerDkimProps {
+    status?: 'pass' | 'fail' | 'warning';
+    records?: Array<{
+        id?: string;
+        selector?: string;
+        entry?: string;
+        cname?: string;
+        raw?: string[];
+        records?: {
+            v?: string;
+            k?: string;
+            p?: string;
+            [key: string]: unknown;
+        };
+        keyStatus?: {
+            isValid?: boolean;
+            keySize?: number;
+        };
+        issues?: Array<{
+            status?: string;
+            message?: string;
+            nested?: string;
+            [key: string]: unknown;
+        }>;
+    }>;
+    report?: Array<{
+        status?: string;
+        message?: string;
+        [key: string]: unknown;
+    }>;
+}
+
+/**
+ * Card Status System - Consolidated status mapping and utilities
+ *
+ * This module provides a single source of truth for card status handling:
+ * - Status values and types
+ * - Normalization from various input formats
+ * - Visual mappings (colors, icons)
+ * - UI component mappings (DetailedCard colors)
+ *
+ * @example
+ * ```ts
+ * import { CardStatus, normalizeStatus, getStatusColor, getStatusIcon } from '../constants/card-status';
+ *
+ * const status = normalizeStatus('pass'); // 'good'
+ * const color = getStatusColor('good'); // '#1ba86c'
+ * const icon = getStatusIcon('warning'); // mdiAlert
+ * ```
+ */
+/**
+ * Canonical card status values (lowercase).
+ * These are the only valid status values used throughout the system.
+ */
+declare const CARD_STATUS: {
+    readonly GOOD: "good";
+    readonly WARNING: "warning";
+    readonly DANGER: "danger";
+    readonly INFO: "info";
+    readonly UNKNOWN: "unknown";
+};
+type CardStatus = (typeof CARD_STATUS)[keyof typeof CARD_STATUS];
+/**
+ * Normalizes any status value to a canonical CardStatus.
+ * Handles various formats from API responses, legacy code, and user input.
+ *
+ * @param value - The value to normalize (string, null, undefined, or any)
+ * @returns A canonical CardStatus value
+ *
+ * @example
+ * normalizeStatus('pass') // 'good'
+ * normalizeStatus('FAIL') // 'danger'
+ * normalizeStatus(null)   // 'unknown'
+ */
+declare function normalizeStatus(value: unknown): CardStatus;
+/**
+ * Status color palette.
+ * These colors match the design system specifications.
+ */
+declare const STATUS_COLORS: Record<CardStatus, string>;
+/**
+ * MDI icon paths for each status.
+ */
+declare const STATUS_ICONS: Record<CardStatus, string>;
+/**
+ * Combined status icon styles (color + icon).
+ * Used by SignalCardList sidebar and other status indicators.
+ */
+declare const STATUS_ICON_STYLES: Record<CardStatus, {
+    color: string;
+    icon: string;
+}>;
+/**
+ * Gets the color for a given status.
+ * @param status - A CardStatus value or string to normalize
+ * @returns The hex color string
+ */
+declare function getStatusColor(status: CardStatus | string): string;
+/**
+ * Gets the MDI icon path for a given status.
+ * @param status - A CardStatus value or string to normalize
+ * @returns The MDI icon path string
+ */
+declare function getStatusIcon(status: CardStatus | string): string;
+/**
+ * Gets both color and icon for a given status.
+ * @param status - A CardStatus value or string to normalize
+ * @returns Object with color and icon properties
+ */
+declare function getStatusIconStyle(status: CardStatus | string): {
+    color: string;
+    icon: string;
+};
+/**
+ * Maps CardStatus to DetailedCard color prop values.
+ * Used by SignalCardNormal for the card banner color.
+ */
+type DetailedCardColor = 'success' | 'error' | 'warning' | 'info' | undefined;
+/**
+ * Maps a card status to DetailedCard color prop.
+ * @param status - A CardStatus value or string to normalize
+ * @returns DetailedCard color value or undefined
+ */
+declare function mapStatusToDetailedCardColor(status?: CardStatus | string | null): DetailedCardColor;
+/**
+ * Type guard to check if a value is a valid CardStatus.
+ */
+declare function isCardStatus(value: unknown): value is CardStatus;
+/**
+ * Type guard to check if a status indicates success.
+ */
+declare function isSuccessStatus(status: CardStatus | string): boolean;
+/**
+ * Type guard to check if a status indicates failure.
+ */
+declare function isFailureStatus(status: CardStatus | string): boolean;
+/**
+ * Type guard to check if a status indicates a warning.
+ */
+declare function isWarningStatus(status: CardStatus | string): boolean;
+
+/**
+ * Theme for icons and visual elements within items.
+ * - 'email': Email envelope icon
+ * - 'dns': Globe/earth icon
+ * - 'info': Information icon
+ */
+type ItemTheme = 'email' | 'dns' | 'info' | string;
+/**
+ * Item type determining icon and styling.
+ * - 'good': Green checkmark
+ * - 'info': Information icon (themed by ItemTheme)
+ * - 'warning': Orange alert icon
+ * - 'danger': Red X icon
+ * - '': No icon
+ */
+type ItemType = 'good' | 'info' | 'warning' | 'danger' | '' | string;
+/**
+ * Individual item within a category (extracted data or checklist item).
+ */
+interface CategoryItem {
+    /** Item type for icon/color. */
+    type?: ItemType;
+    /** Visual theme for icons. */
+    theme?: ItemTheme;
+    /** Label text or React element. */
+    label?: React.ReactNode;
+    /** Main content text or React element. */
+    text?: React.ReactNode;
+    /** If true, renders in inline grid; if false, renders as full-width block. */
+    inline?: boolean;
+    /** Wrap text content in monospace code block. */
+    useCodeBlock?: boolean;
+    /** Additional subtext items displayed below main text. */
+    subtexts?: Array<{
+        label?: React.ReactNode;
+        text?: React.ReactNode;
+    }>;
+    /** Extraction box configuration for displaying code/DNS records. */
+    extractionBox?: {
+        /** Caption type for extraction box (e.g., 'dns-txt', 'dns-cname'). */
+        caption?: string;
+    };
+}
+/**
+ * Category containing a group of related items with optional title and caption.
+ */
+interface ItemCategory {
+    /** Category title (e.g., "Extracted from your DNS configuration"). */
+    title?: string;
+    /** Optional caption text below title. */
+    caption?: string;
+    /** Array of items within this category. */
+    items?: CategoryItem[];
+    /** Category type for special layout handling (e.g., 'dmarc-domain', 'dmarc-policy'). */
+    categoryType?: string;
+    /** Extraction box configuration for the entire category. */
+    extractionBox?: {
+        /** Caption type for extraction box (e.g., 'dns', 'email', 'dns-details'). */
+        caption?: string;
+    };
+}
+
+/**
+ * Common props shared by all signal card components. These cover layout options
+ * that ultimately map to `SignalCardNormal`.
+ */
+interface SignalCardSharedProps extends Omit<ComponentProps<'div'>, 'children' | 'ref'> {
+    /** Callback fired whenever the card reports a height change. */
+    onHeightChange?: () => void;
+    /** Custom footer renderer appended below the standard card content. */
+    renderFooter?: () => ReactNode;
+    /** Toggle Investigate-specific color palette overrides. */
+    useInvestigateColors?: boolean;
+    /** Select the banner variant to display above the card body. */
+    bannerVariant?: 'standard' | 'condensed' | 'none';
+    /** Enable collapsible sections inside the card header and body. */
+    isCollapsible?: boolean;
+    /** Controlled collapsed state for all sections. */
+    areAllCollapsed?: boolean;
+    /** Callback fired when the collapse-all toggle changes. */
+    onCollapseAll?: (areAllCollapsed: boolean) => void;
+}
+
+/**
+ * Component props.
+ */
+interface SignalCardGoogleYahooComplianceProps extends SignalCardSharedProps {
+    /**
+     * Domain name (currently not used but maintained for API compatibility)
+     */
+    domain?: string | null;
+    /**
+     * JMAP extsecrep data containing authentication results
+     */
+    jmap?: JmapProps | null;
+    /**
+     * Investigate data with FCrDNS and EHLO check results
+     */
+    investigate?: InvestigateProps | null;
+}
+
+/**
+ * Component props.
+ */
+interface SignalCardUrlsProps extends SignalCardSharedProps {
+    /**
+     * Investigate data containing extracted URLs
+     */
+    investigate?: InvestigateProps | null;
+}
+
+/**
+ * External security report data structure
+ */
+interface ExtsecrepData {
+    /** SPF check data */
+    spf?: SpfProps | null;
+    /** DMARC policy data */
+    dmarc?: DmarcProps | null;
+    /** DKIM signature data - can be array or object */
+    dkim?: DkimProps | DkimProps[] | null;
+}
+/**
+ * Component props.
+ */
+interface SignalCardAmpProps extends SignalCardSharedProps {
+    /** JMAP data containing authentication information */
+    jmap: {
+        /** External security report with SPF, DMARC, DKIM data */
+        extsecrep: ExtsecrepData;
+        /** From email address information */
+        from?: {
+            email?: string | null;
+        } | null;
+    };
+}
+
+/**
+ * Component props.
+ */
+interface SignalCardDnssecProps extends SignalCardSharedProps {
+    /** JMAP data containing DNS security information */
+    jmap?: {
+        extsecrep?: {
+            dnsSecurity?: DnsSecurityProps | null;
+        } | null;
+    } | null;
+    /** Custom short description (overrides default based on result) */
+    shortDescription?: ReactNode;
+}
+
+type ExtsecrepThreatLevel = ExtsecrepProps;
+type FromInfo = {
+    name?: string | null;
+    email?: string | null;
+} | null;
+/**
+ * Component props.
+ */
+interface SignalCardThreatInvProps extends SignalCardSharedProps {
+    /** JMAP email data containing threat intelligence information */
+    jmap: {
+        extsecrep: ExtsecrepThreatLevel;
+        from?: FromInfo;
+    };
+    /** Whether this is being used in domain analyzer mode */
+    isDomainAnalyzer?: boolean;
+}
+
+type SubdoReportEntry = {
+    message?: string;
+    spfError?: string;
+    raw?: string;
+    value?: unknown;
+    details?: unknown;
+    [key: string]: unknown;
+};
+/**
+ * Component props.
+ */
+interface SignalCardSubdoProps extends SignalCardSharedProps {
+    /**
+     * JMAP data containing SPF subdomain takeover report
+     */
+    jmap?: {
+        extsecrep?: {
+            spf?: {
+                domain?: string | null;
+                report?: SubdoReportEntry[] | null;
+            } | null;
+        } | null;
+    } | null;
+}
+
+/**
+ * Caption types for ExtractionBox component
+ * Maps to predefined caption text shown at bottom-right of grey boxes
+ */
+type ExtractionCaptionType = 'email' | 'dns' | 'dns-details' | 'policy' | 'email-details';
+
+type ChecklistItem = {
+    type: 'good' | 'info' | 'warning' | 'danger' | 'unknown' | string;
+    theme?: 'email' | 'dns' | string;
+    text: React__default.ReactNode;
+    subtexts?: {
+        text: React__default.ReactNode;
+    }[];
+    link?: Record<string, unknown>;
+    hasWarning?: boolean;
+    /**
+     * Wraps item in grey extraction box with optional caption
+     * Used for DNS records, email data, policy files, etc.
+     */
+    extractionBox?: {
+        caption?: ExtractionCaptionType;
+    };
+};
+
+/**
+ * Component props.
+ */
+interface SignalCardMtaStsProps extends SignalCardSharedProps {
+    /** JMAP email data containing MTA-STS information */
+    jmap?: {
+        extsecrep?: {
+            mta?: MtaProps | null;
+        } | null;
+    } | null;
+    /** Domain to analyze */
+    domain?: string;
+}
+
+/**
+ * Component props.
+ */
+interface SignalCardBimiProps extends SignalCardSharedProps {
+    /**
+     * JMAP data containing BIMI and DMARC information from the email security report.
+     */
+    jmap: {
+        extsecrep: {
+            bimi?: any;
+            dmarc?: any;
+        };
+    };
+    /**
+     * Optional callback invoked when the component mounts.
+     */
+    onComponentMount?: () => void;
+}
+
+type DmarcData$1 = {
+    domain?: string | null;
+} | null;
+/**
+ * Props for the SignalCardDkimDomainAnalyzer component.
+ *
+ * Advanced DKIM Domain Analyzer with selector dropdown, key validation, and DNS record display.
+ */
+interface SignalCardDkimDomainAnalyzerProps extends SignalCardSharedProps {
+    /**
+     * JMAP data containing DKIM analysis results
+     */
+    jmap: {
+        extsecrep: {
+            dmarc?: DmarcData$1;
+            dkim?: DomainAnalyzerDkimProps;
+        };
+    };
+}
+
+/**
+ * Component props.
+ */
+interface SignalCardSpfDomainAnalyzerProps extends SignalCardSharedProps {
+    /**
+     * JMAP data containing SPF analysis results
+     */
+    jmap: {
+        extsecrep: {
+            spf: DomainAnalyzerSpfProps;
+            originator?: {
+                domain?: string | null;
+                orgDomain?: string | null;
+            } | null;
+        };
+    };
+}
+
+interface SpfDetails {
+    raw?: string | string[] | null;
+    status?: string | null;
+    txtExtractedFrom?: string | null;
+    [key: string]: unknown;
+}
+/**
+ * Props for the SignalCardSpfDomain component.
+ *
+ * Simplified SPF Domain Card for BIMI Checker - shows only pass/fail status and raw SPF record.
+ */
+interface SignalCardSpfDomainProps extends SignalCardSharedProps {
+    /**
+     * JMAP data containing SPF authentication results
+     */
+    jmap?: {
+        extsecrep?: {
+            spf?: SpfDetails | null;
+        } | null;
+    } | null;
+}
+
+type DmarcResult$1 = {
+    status?: CardStatus | string | null;
+    errors?: string[] | null;
+};
+type DmarcData = {
+    raw?: string | null;
+    result?: DmarcResult$1 | null;
+    txtExtractedFrom?: string | null;
+    policyDomain?: string | null;
+    fromDomain?: string | null;
+    domainPublished?: string | null;
+};
+type Originator = {
+    domain?: string | null;
+    orgDomain?: string | null;
+} | null;
+interface SignalCardDmarcDomainProps extends SignalCardSharedProps {
+    jmap: {
+        extsecrep: {
+            dmarc: DmarcData;
+            originator?: Originator;
+        };
+    };
+}
+
+type TlsCardType = 'good' | 'warning' | 'danger';
+type InfoSeverity$1 = TlsCardType | 'info';
+type Subtext$3 = {
+    text: ReactNode;
+};
+type InfoItem$3 = {
+    id?: string;
+    type: InfoSeverity$1;
+    label?: ReactNode;
+    text: ReactNode;
+    subtexts?: Subtext$3[];
+};
+type InfoItemCategory = {
+    title?: ReactNode;
+    caption?: ReactNode;
+    items: InfoItem$3[];
+};
+type ExtractedItem$3 = {
+    type?: string;
+    label: ReactNode;
+    text: ReactNode;
+    inline?: boolean;
+    useCodeBlock?: boolean;
+};
+type ExtractedItemCategory$2 = {
+    title?: ReactNode;
+    caption?: ReactNode;
+    categoryType?: 'dmarc-domain' | 'dmarc-policy' | 'dkim-details';
+    extractionBox?: {
+        caption: 'dns' | 'email' | 'policy';
+    };
+    items: ExtractedItem$3[];
+};
+type ExtractedData = {
+    cardType: TlsCardType;
+    extractedItemsCategories: ExtractedItemCategory$2[];
+    infoItemsCategories: InfoItemCategory[];
+    error: null | string;
+};
+/**
+ * Component props.
+ */
+interface SignalCardTlsProps extends SignalCardSharedProps {
+    /** JMAP email data containing TLS information */
+    jmap: {
+        extsecrep: {
+            tls?: TlsProps;
+        };
+    };
+}
+
+/**
+ * Info item subtext with visualization
+ */
+interface Subtext$2 {
+    text: ReactNode;
+}
+/**
+ * Individual information item in card
+ */
+interface InfoItem$2 {
+    type: 'good' | 'warning' | 'info' | 'danger';
+    text: ReactNode;
+    subtexts?: Subtext$2[];
+}
+/**
+ * Extracted item for display
+ */
+interface ExtractedItem$2 {
+    type?: '' | 'warning' | 'info';
+    label: ReactNode;
+    text: ReactNode;
+    inline?: boolean;
+    extractionBox?: {
+        caption: 'dns' | 'email';
+    };
+}
+/**
+ * Category of extracted items
+ */
+interface ExtractedItemCategory$1 {
+    title: string;
+    extractionBox?: {
+        caption: 'dns' | 'email';
+    };
+    items: ExtractedItem$2[];
+}
+/**
+ * Result from extractData function
+ */
+interface ExtractDataResult$3 {
+    cardType: 'good' | 'warning' | 'unknown';
+    extractedItemsCategories?: ExtractedItemCategory$1[];
+    infoItemsCategories?: Array<{
+        title?: string;
+        items: InfoItem$2[];
+    }>;
+    error?: null;
+}
+/**
+ * Component props.
+ */
+interface SignalCardFcrdnsProps extends SignalCardSharedProps {
+    /** JMAP data containing EHLO information */
+    jmap: {
+        extsecrep: {
+            ehlo?: EhloProps;
+        };
+    };
+    /** Investigation data with FCrDNS and EHLO check results */
+    investigate?: {
+        fcrdns?: FcrdnsProps | null;
+        ehloCheck?: EhloCheckProps | null;
+    };
+}
+
+/**
+ * Main extractor function for FCRDNS card data.
+ * Orchestrates handlers for sender IP and EHLO validation.
+ */
+declare const extractData$3: (fcrdns: FcrdnsProps | null | undefined, ehloCheck: EhloCheckProps | null | undefined, ehlo: EhloProps | undefined, t: TranslationFn) => ExtractDataResult$3;
+
+type InfoItemType = CardStatus | 'info' | 'error';
+type Subtext$1 = {
+    text: ReactNode;
+};
+type InfoItem$1 = {
+    type: InfoItemType;
+    text: ReactNode;
+    subtexts?: Subtext$1[] | null;
+};
+type ExtractedItem$1 = {
+    type?: InfoItemType;
+    label?: ReactNode;
+    text?: ReactNode;
+    inline?: boolean;
+    useCodeBlock?: boolean;
+    theme?: string;
+};
+type ExtractedItemCategory = {
+    title: string;
+    extractionBox?: {
+        caption: 'dns' | 'email' | 'email-details';
+    };
+    items: ExtractedItem$1[];
+    categoryType?: string;
+};
+type DkimResult = DkimProps;
+type DmarcResult = DmarcProps | null;
+type ExtractDataResult$2 = {
+    cardType: CardStatus;
+    extractedItemsCategories: ExtractedItemCategory[];
+    infoItems: InfoItem$1[];
+    infoItemsCategoriesDkim?: ExtractedItemCategory[];
+};
+/**
+ * Component props.
+ */
+interface SignalCardDkimProps extends SignalCardSharedProps {
+    /** JMAP email data containing DKIM, DMARC information */
+    jmap: {
+        extsecrep: {
+            dkim?: DkimResult | DkimResult[] | null;
+            dmarc?: DmarcResult;
+        };
+    };
+}
+
+/**
+ * Main DKIM data extraction function using handler pattern
+ */
+declare const extractData$2: (dkim: DkimProps | null | undefined, t: TranslationFn) => ExtractDataResult$2;
+
+type SpfIdentity$1 = 'helo' | 'mailfrom';
+type SpfData$1 = SpfProps;
+type InfoSeverity = CardStatus | 'info';
+type Subtext = {
+    text: ReactNode;
+};
+type InfoItem = {
+    type?: InfoSeverity;
+    text: ReactNode;
+    subtexts?: Subtext[] | null;
+};
+type ExtractedItem = {
+    type?: InfoSeverity;
+    label?: ReactNode;
+    text?: ReactNode;
+    inline?: boolean;
+    useCodeBlock?: boolean;
+    extractionBox?: {
+        caption: 'dns' | 'email' | 'policy';
+    };
+};
+type ExtractedItemsCategory = {
+    title: string;
+    extractionBox?: {
+        caption: 'dns' | 'email' | 'policy';
+    };
+    items: ExtractedItem[];
+};
+type InfoItemsCategory = {
+    title: string;
+    items: InfoItem[];
+};
+type ExtractDataResult$1 = {
+    cardType: CardStatus;
+    extractedItemsCategories: ExtractedItemsCategory[];
+    infoItems: InfoItemsCategory[];
+    error: null;
+};
+/**
+ * Component props.
+ */
+interface SignalCardSpfProps extends SignalCardSharedProps {
+    /** JMAP email data containing SPF information */
+    jmap: {
+        extsecrep: {
+            spf?: SpfData$1;
+        };
+    };
+}
+
+/**
+ * Main SPF data extraction function (orchestrated version)
+ */
+declare const extractData$1: (spf: SpfProps | undefined, identity: SpfIdentity$1, t: TranslationFn) => ExtractDataResult$1;
+
+/**
+ * Extended JMAP props for DMARC card including required extsecrep data
+ */
+interface SignalCardDmarcJmapProps extends JmapProps {
+    extsecrep: {
+        dmarc?: DmarcProps;
+        dkim?: DkimProps | DkimProps[];
+        spf?: SpfProps;
+    };
+}
+/**
+ * Component props.
+ */
+interface SignalCardDmarcProps extends SignalCardSharedProps {
+    /**
+     * JMAP email data containing DMARC, DKIM, SPF information
+     */
+    jmap: SignalCardDmarcJmapProps;
+    /**
+     * Whether this is being used in domain analyzer mode
+     */
+    isDomainAnalyzer?: boolean;
+}
+
+/**
+ * Result from the DMARC extractor
+ */
+type ExtractDataResult = {
+    cardType: CardStatus;
+    extractedItemsCategories: ItemCategory[];
+    infoItemsCategories: ItemCategory[];
+    error?: unknown;
+};
+
+/**
+ * Glossary terms for Investigate reports
+ *
+ * This module provides localized glossary term components that link to
+ * the Red Sift community glossary documentation.
+ */
+
+/**
+ * Creates a link to the glossary documentation for a specific term
+ */
+declare const createGlossaryLink: ({ glossaryPage, label, }: {
+    glossaryPage?: string | undefined;
+    label: string;
+}) => string;
+/**
+ * Mapping of glossary label IDs to their internal names
+ */
+declare const glossaryLabelIds: {
+    readonly ATAG: "aTag";
+    readonly A_RECORD: "aRecord";
+    readonly BIMI_RECORD: "bimiRecord";
+    readonly CANONICALIZATION: "canonicalization";
+    readonly CNAME_RECORD: "cnameRecord";
+    readonly DKIM: "dkim";
+    readonly DKIM_ALGORITHM: "dkimAlgorithm";
+    readonly DKIM_ALIGNMENT: "dkimAlignment";
+    readonly DKIM_SELECTOR: "dkimSelector";
+    readonly DKIM_SIGNATURE: "dkimSignature";
+    readonly DKIM_SIGNATURE_HEADER: "dkimSignatureHeader";
+    readonly DKIM_SIGNING_DOMAIN: "dkimSigningDomain";
+    readonly DMARC: "dmarc";
+    readonly DMARC_COMPLIANT: "dmarcCompliant";
+    readonly DMARC_POLICY: "dmarcPolicy";
+    readonly EHLO: "ehlo";
+    readonly FROM: "from";
+    readonly ITAG: "iTag";
+    readonly KEY_LENGTH: "keyLength";
+    readonly MTA_FILE_MAX_AGE: "maxAge";
+    readonly MTA_FILE_MODE: "mode";
+    readonly MTA_FILE_MX: "mx";
+    readonly MTA_FILE_VERSION: "version";
+    readonly MTA_STS_POLICY_FILE: "mtaStsPolicyFile";
+    readonly MTA_STS_CERTIFICATE: "mtaStsCertificate";
+    readonly MTA_STS_CERTIFICATE_EXPIRY: "mtaStsCertificateExpiry";
+    readonly MTA_STS_CERTIFICATE_CNAME_NAME: "mtaStsCertificateCnameName";
+    readonly MTA_STS_CERTIFICATE_CNAME_VALUE: "mtaStsCertificateCnameValue";
+    readonly MTA_STS_CERTIFICATE_CNAME_TYPE: "mtaStsCertificateCnameType";
+    readonly MTA_STS_RECORD: "mtaStsRecord";
+    readonly PCT: "pct";
+    readonly PTR_RECORD: "ptrRecord";
+    readonly RETURN_PATH: "returnPath";
+    readonly RUA: "rua";
+    readonly RUF: "ruf";
+    readonly SENDER_IP: "senderIp";
+    readonly SIGNED_HEADERS: "signedHeaders";
+    readonly SIGNER_DOMAIN: "signerDomain";
+    readonly SP: "sp";
+    readonly SPF: "spf";
+    readonly SPF_ALIGNMENT: "spfAlignment";
+    readonly SPF_DOMAIN: "spfDomain";
+    readonly SPF_DOMAINS: "spfDomains";
+    readonly SPF_RECORD: "spfRecord";
+    readonly TLS: "tls";
+    readonly SSL: "ssl";
+    readonly CIPHER_SUITE: "cipherSuite";
+    readonly SUBDOMAIN_POLICY: "subdomainPolicy";
+    readonly SVG: "svg";
+    readonly TLS_RPT_RECORD: "tlsRptRecord";
+    readonly TTL: "ttl";
+    readonly TXT_RECORD: "txtRecord";
+    readonly TXT_RECORDS: "txtRecord";
+    readonly VMC: "vmc";
+    readonly CMC: "cmc";
+};
+interface GlossaryTermProps {
+    label: string;
+    glossaryLabel?: string;
+    context?: string;
+    value?: string | number;
+}
+/**
+ * GlossaryTerm component with React Aria i18n hooks
+ */
+declare const GlossaryTerm: React__default.FC<GlossaryTermProps>;
+
+interface GlossaryComponentProps {
+    label?: string;
+    context?: string;
+    value?: string | number;
+    glossaryLabel?: string;
+}
+declare const SenderIp: React__default.FC<GlossaryComponentProps>;
+declare const Ehlo: React__default.FC<GlossaryComponentProps>;
+declare const PtrRecord: React__default.FC<GlossaryComponentProps>;
+declare const ARecord: React__default.FC<GlossaryComponentProps>;
+declare const SpfRecord: React__default.FC<GlossaryComponentProps>;
+declare const TxtRecord: React__default.FC<GlossaryComponentProps>;
+declare const TxtRecords: React__default.FC<GlossaryComponentProps>;
+declare const CnameRecord: React__default.FC<GlossaryComponentProps>;
+declare const Dkim: React__default.FC<GlossaryComponentProps>;
+declare const SignerDomain: React__default.FC<GlossaryComponentProps>;
+declare const DkimSelector: React__default.FC<GlossaryComponentProps>;
+declare const Canonicalization: React__default.FC<GlossaryComponentProps>;
+declare const SignedHeaders: React__default.FC<GlossaryComponentProps>;
+declare const DkimSignature: React__default.FC<GlossaryComponentProps>;
+declare const KeyLength: React__default.FC<GlossaryComponentProps>;
+declare const Ttl: React__default.FC<GlossaryComponentProps>;
+declare const DkimAlgorithm: React__default.FC<GlossaryComponentProps>;
+declare const From: React__default.FC<GlossaryComponentProps>;
+declare const ReturnPath: React__default.FC<GlossaryComponentProps>;
+declare const DmarcPolicy: React__default.FC<GlossaryComponentProps>;
+declare const Pct: React__default.FC<GlossaryComponentProps>;
+declare const Sp: React__default.FC<GlossaryComponentProps>;
+declare const Rua: React__default.FC<GlossaryComponentProps>;
+declare const Ruf: React__default.FC<GlossaryComponentProps>;
+declare const DkimSigningDomain: React__default.FC<GlossaryComponentProps>;
+declare const SpfDomain: React__default.FC<GlossaryComponentProps>;
+declare const SubdomainPolicy: React__default.FC<GlossaryComponentProps>;
+declare const DkimAlignment: React__default.FC<GlossaryComponentProps>;
+declare const SpfAlignment: React__default.FC<GlossaryComponentProps>;
+declare const Spf: React__default.FC<GlossaryComponentProps>;
+declare const Tls: React__default.FC<GlossaryComponentProps>;
+declare const Ssl: React__default.FC<GlossaryComponentProps>;
+declare const CipherSuite: React__default.FC<GlossaryComponentProps>;
+declare const BimiRecord: React__default.FC<GlossaryComponentProps>;
+declare const DmarcCompliant: React__default.FC<GlossaryComponentProps>;
+declare const SVG: React__default.FC<GlossaryComponentProps>;
+declare const VMC: React__default.FC<GlossaryComponentProps>;
+declare const CMC: React__default.FC<GlossaryComponentProps>;
+declare const ITAG: React__default.FC<GlossaryComponentProps>;
+declare const ATAG: React__default.FC<GlossaryComponentProps>;
+declare const Dmarc: React__default.FC<GlossaryComponentProps>;
+declare const TlsRptRecord: React__default.FC<GlossaryComponentProps>;
+declare const MtaStsRecord: React__default.FC<GlossaryComponentProps>;
+declare const MtaStsPolicyFile: React__default.FC<GlossaryComponentProps>;
+declare const Version: React__default.FC<GlossaryComponentProps>;
+declare const Mode: React__default.FC<GlossaryComponentProps>;
+declare const Mx: React__default.FC<GlossaryComponentProps>;
+declare const MaxAge: React__default.FC<GlossaryComponentProps>;
+declare const MtaStsCertificate: React__default.FC<GlossaryComponentProps>;
+declare const MtaStsCertificateExpiry: React__default.FC<GlossaryComponentProps>;
+declare const MtaStsCertificateCnameName: React__default.FC<GlossaryComponentProps>;
+declare const MtaStsCertificateCnameValue: React__default.FC<GlossaryComponentProps>;
+declare const MtaStsCertificateCnameType: React__default.FC<GlossaryComponentProps>;
+/**
+ * Type for glossary icon identifiers (kebab-case).
+ * Used as keys in extractors to reference icons without coupling to React components.
+ */
+type GlossaryIconType = 'sender-ip' | 'ehlo' | 'ptr-record' | 'a-record' | 'spf' | 'spf-record' | 'spf-domain' | 'spf-alignment' | 'dkim' | 'dkim-signing-domain' | 'dkim-selector' | 'dkim-signature' | 'dkim-algorithm' | 'canonicalization' | 'signed-headers' | 'signer-domain' | 'key-length' | 'ttl' | 'dkim-alignment' | 'from' | 'return-path' | 'dmarc-policy' | 'pct' | 'rua' | 'ruf' | 'subdomain-policy' | 'dmarc' | 'tls' | 'ssl' | 'cipher-suite' | 'txt-record' | 'cname-record' | 'bimi-record' | 'dmarc-compliant' | 'svg' | 'vmc' | 'cmc' | 'itag' | 'atag' | 'tls-rpt-record' | 'mta-sts-record' | 'mta-sts-policy-file' | 'mta-file-version' | 'mta-file-mode' | 'mta-file-mx' | 'mta-file-max-age' | 'mta-sts-certificate' | 'mta-sts-certificate-expiry' | null;
+/**
+ * Map from icon type identifiers (kebab-case) to glossary icon components.
+ * This is the single source of truth for icon mapping.
+ * Covers all signal card types (DMARC, DKIM, SPF, FCRDNS, TLS, BIMI, MTA-STS).
+ */
+declare const GLOSSARY_ICON_MAP: Record<NonNullable<GlossaryIconType>, React__default.FC<GlossaryComponentProps>>;
+
+/**
+ * Extended DMARC props with additional fields from API
+ */
+type ExtendedDmarcProps = DmarcProps & {
+    report?: {
+        message?: string;
+        detail?: string;
+        text?: string;
+    }[];
+    dkimAlignment?: string;
+    spfAlignment?: string;
+    effectivePolicy?: string;
+    isWeaker?: boolean;
+};
+
+/**
+ * Main orchestrator function that coordinates all handlers
+ */
+declare const extractDataOrchestrated: (dmarc: ExtendedDmarcProps | null | undefined, dkim: DkimProps | DkimProps[] | null | undefined, spf: SpfProps | undefined, jmap: JmapProps, t: TranslationFn, isDomainAnalyzer?: boolean | undefined) => ExtractDataResult;
+
+type SignalData = {
+    signalType: string;
+    jmap?: {
+        extsecrep?: Record<string, any>;
+        [key: string]: unknown;
+    };
+    shortDescription?: unknown;
+    [key: string]: unknown;
+};
+type ErrorLike = {
+    name?: string;
+    message?: string;
+    stack?: string;
+};
+type CardEnabledOverrides = Record<string, boolean | undefined>;
+interface SignalCardListProps extends Omit<ComponentProps<'div'>, 'children'> {
+    /** Array of signal data objects containing DMARC, DKIM, SPF information */
+    signals?: SignalData[];
+    /** Error object to display if signal loading fails */
+    error?: ErrorLike | null;
+    /** Map of signal types to enabled/disabled state */
+    isCardEnabledMap?: CardEnabledOverrides;
+    /** Signal types to display in the priority section (shown first). Defaults to DMARC, DKIM, SPF */
+    prioritySignalTypes?: string[];
+    /** Initial selected signal type for external selection control */
+    initialSelectedSignalType?: string | null;
+    /** Callback when a signal card is selected */
+    onSelectSignalType?: (signalType: string) => void;
+    /** Custom footer renderer for adding content at the bottom of each card */
+    renderCardFooter?: (signal: SignalData) => React.ReactNode;
+    /**
+     * Heading text for the priority signals section.
+     * Defaults to "Required for the selected compliance profile"
+     */
+    prioritySectionHeading?: string;
+    /**
+     * Heading text for the remaining signals section.
+     * Defaults to "Not required for the selected compliance profile"
+     */
+    remainingSectionHeading?: string;
+    /** Use Investigate handbook colors instead of Design System CSS variables */
+    useInvestigateColors?: boolean;
+}
+
+type ExtSecrep = Omit<ExtsecrepProps, 'spf' | 'dkim'> & {
+    spf?: SpfProps | DomainAnalyzerSpfProps | null;
+    dkim?: DkimProps | DkimProps[] | DomainAnalyzerDkimProps | null;
+    [key: string]: any;
+};
+type InvestigateData = Omit<InvestigateProps, 'urls'> & {
+    urls?: any;
+    [key: string]: any;
+};
+type GetSignalStatusArgs = {
+    signalType: string;
+    signal?: SignalData;
+    extsecrep?: ExtSecrep;
+    investigate?: InvestigateData;
+    domain?: string | null;
+    isDomainAnalyzer?: boolean;
+};
+/**
+ * Get the status of a signal card using lightweight quick status functions.
+ *
+ * This function determines the card status (good/warning/danger/info/unknown)
+ * without running full extractors, improving performance for sidebar rendering.
+ */
+declare const getSignalStatus: ({ signalType, signal, extsecrep, investigate, isDomainAnalyzer, }: GetSignalStatusArgs) => CardStatus;
+
+declare const SIGNAL_TYPES: {
+    readonly DMARC: "DMARC";
+    readonly SUBDO: "SUBDO";
+    readonly SPF: "SPF";
+    readonly DKIM: "DKIM";
+    readonly TLS: "TLS";
+    readonly FCRDNS: "FCRDNS";
+    readonly URLS: "URLS";
+    readonly THREATINV: "THREATINV";
+    readonly BIMI: "BIMI";
+    readonly MTA_STS: "MTA_STS";
+    readonly DNSSEC: "DNSSEC";
+    readonly AMP: "AMP";
+    readonly GOOGLE_YAHOO_COMPLIANCE: "GOOGLE_YAHOO_COMPLIANCE";
+};
+type SignalType = (typeof SIGNAL_TYPES)[keyof typeof SIGNAL_TYPES];
+/**
+ * Signal types available in the BIMI Checker tool.
+ * These are simplified domain validation cards for BIMI compliance checking.
+ */
+declare const BIMI_CHECKER_SIGNAL_TYPES: {
+    readonly DMARC: "DMARC_DOMAIN";
+    readonly SPF: "SPF_DOMAIN";
+    readonly BIMI: "BIMI";
+};
+type BimiCheckerSignalType = (typeof BIMI_CHECKER_SIGNAL_TYPES)[keyof typeof BIMI_CHECKER_SIGNAL_TYPES];
+/**
+ * Signal types available in the Domain Analyzer tool.
+ * These include advanced domain analysis features like DNS lookup counting,
+ * CNAME resolution chains, Dynamic SPF detection, etc.
+ */
+declare const DOMAIN_ANALYZER_SIGNAL_TYPES: {
+    readonly DMARC: "DMARC";
+    readonly BIMI: "BIMI";
+    readonly MTA_STS: "MTA_STS";
+    readonly SUBDO: "SUBDO_DOMAIN_ANALYZER";
+    readonly SPF: "SPF_DOMAIN_ANALYZER";
+    readonly DKIM: "DKIM_DOMAIN_ANALYZER";
+    readonly THREATINV: "THREATINV_DOMAIN_ANALYZER";
+};
+type DomainAnalyzerSignalType = (typeof DOMAIN_ANALYZER_SIGNAL_TYPES)[keyof typeof DOMAIN_ANALYZER_SIGNAL_TYPES];
+/**
+ * Signal types available in the Public Investigate tool (website).
+ * This is a subset of SIGNAL_TYPES - only core authentication and security cards.
+ *
+ * Excluded from public (internal/sensitive data):
+ * - DNSSEC: Internal DNS security validation
+ * - URLS: Extracted URLs from email body
+ * - THREATINV: Threat intelligence data
+ * - AMP: Accelerated Mobile Pages validation
+ */
+declare const PUBLIC_INVESTIGATE_SIGNAL_TYPES: {
+    readonly DMARC: "DMARC";
+    readonly SPF: "SPF";
+    readonly DKIM: "DKIM";
+    readonly TLS: "TLS";
+    readonly FCRDNS: "FCRDNS";
+    readonly BIMI: "BIMI";
+    readonly MTA_STS: "MTA_STS";
+    readonly GOOGLE_YAHOO_COMPLIANCE: "GOOGLE_YAHOO_COMPLIANCE";
+    readonly SUBDO: "SUBDO";
+};
+type PublicInvestigateSignalType = (typeof PUBLIC_INVESTIGATE_SIGNAL_TYPES)[keyof typeof PUBLIC_INVESTIGATE_SIGNAL_TYPES];
+
+/**
+ * Signal Cards Theme Configuration
+ *
+ * This context provides theme configuration to signal card components,
+ * eliminating the need to pass `useInvestigateColors` through every component layer.
+ */
+interface SignalCardTheme {
+    /**
+     * Whether to use Investigate-specific colors and fonts.
+     * When true, applies custom fonts and color palette for the Investigate tool.
+     */
+    useInvestigateColors: boolean;
+}
+interface SignalCardThemeProviderProps {
+    children: ReactNode;
+    /**
+     * Theme configuration to apply to all signal card descendants
+     */
+    theme?: Partial<SignalCardTheme>;
+}
+/**
+ * Provider component for Signal Card theming.
+ *
+ * Wrap signal card components with this provider to set theme options
+ * without passing props through every component level.
+ *
+ * This provider injects CSS custom properties (--sc-*) that components use for styling.
+ *
+ * @example
+ * ```tsx
+ * <SignalCardThemeProvider theme={{ useInvestigateColors: true }}>
+ *   <SignalCardList signals={signals} />
+ * </SignalCardThemeProvider>
+ * ```
+ */
+declare const SignalCardThemeProvider: React__default.FC<SignalCardThemeProviderProps>;
+/**
+ * Hook to access the current signal card theme.
+ *
+ * Components can use this hook to access theme configuration
+ * without requiring explicit props.
+ *
+ * @example
+ * ```tsx
+ * const { useInvestigateColors } = useSignalCardTheme();
+ * ```
+ */
+declare const useSignalCardTheme: () => SignalCardTheme;
+/**
+ * Hook that combines prop value with context value.
+ * Prop value takes precedence over context when explicitly provided.
+ *
+ * Components can receive useInvestigateColors via props or context.
+ *
+ * @param propValue - Explicitly passed prop value (takes precedence)
+ * @returns Resolved theme configuration
+ */
+declare const useResolvedTheme: (propValue?: boolean) => SignalCardTheme;
+
+interface ReceivedSpfResult {
+    result?: string;
+    [key: string]: unknown;
+}
+interface SpfIdentity {
+    receivedSpf?: ReceivedSpfResult | null;
+    [key: string]: unknown;
+}
+interface SpfData {
+    helo?: SpfIdentity | null;
+    mailfrom?: SpfIdentity | null;
+    [key: string]: unknown;
+}
+declare function getHeloOrMailFrom(spf?: SpfData | null): SpfIdentity | null;
+
+/**
+ * Main extractor function for TLS card data.
+ * Orchestrates handlers for version and cipher validation.
+ */
+declare const extractData: (tls: TlsProps | undefined, t: TranslationFn) => ExtractedData;
+
+/**
+ * Signal Cards Components (@redsift/products)
+ *
+ * Email security signal visualization components for the Investigate tool.
+ * Part of the Red Sift Design System Products package.
+ *
+ * @packageDocumentation
+ * @module SignalCards
+ *
+ * @example
+ * ```tsx
+ * import { SignalCardList, SignalCardThemeProvider } from '@redsift/products';
+ *
+ * // Basic usage with SignalCardList
+ * <SignalCardThemeProvider>
+ *   <SignalCardList signals={signals} />
+ * </SignalCardThemeProvider>
+ *
+ * // Individual card usage
+ * <SignalCardDmarc jmap={emailData.jmap} />
+ * ```
+ */
+declare const SignalCardList: _redsift_design_system.Comp<SignalCardListProps, HTMLDivElement>;
+declare const SignalCardDmarc: _redsift_design_system.Comp<SignalCardDmarcProps, HTMLDivElement>;
+declare const SignalCardSpf: _redsift_design_system.Comp<SignalCardSpfProps, HTMLDivElement>;
+declare const SignalCardDkim: _redsift_design_system.Comp<SignalCardDkimProps, HTMLDivElement>;
+declare const SignalCardFcrdns: _redsift_design_system.Comp<SignalCardFcrdnsProps, HTMLDivElement>;
+declare const SignalCardTls: _redsift_design_system.Comp<SignalCardTlsProps, HTMLDivElement>;
+declare const SignalCardDmarcDomain: _redsift_design_system.Comp<SignalCardDmarcDomainProps, HTMLDivElement>;
+declare const SignalCardSpfDomain: _redsift_design_system.Comp<SignalCardSpfDomainProps, HTMLDivElement>;
+declare const SignalCardSpfDomainAnalyzer: _redsift_design_system.Comp<SignalCardSpfDomainAnalyzerProps, HTMLDivElement>;
+declare const SignalCardDkimDomainAnalyzer: _redsift_design_system.Comp<SignalCardDkimDomainAnalyzerProps, HTMLDivElement>;
+declare const SignalCardBimi: _redsift_design_system.Comp<SignalCardBimiProps, HTMLDivElement>;
+declare const SignalCardMtaSts: _redsift_design_system.Comp<SignalCardMtaStsProps, HTMLDivElement>;
+declare const SignalCardSubdo: _redsift_design_system.Comp<SignalCardSubdoProps, HTMLDivElement>;
+declare const SignalCardThreatInv: _redsift_design_system.Comp<SignalCardThreatInvProps, HTMLDivElement>;
+declare const SignalCardDnssec: _redsift_design_system.Comp<SignalCardDnssecProps, HTMLDivElement>;
+declare const SignalCardAmp: _redsift_design_system.Comp<SignalCardAmpProps, HTMLDivElement>;
+declare const SignalCardUrls: _redsift_design_system.Comp<SignalCardUrlsProps, HTMLDivElement>;
+declare const SignalCardGoogleYahooCompliance: _redsift_design_system.Comp<SignalCardGoogleYahooComplianceProps, HTMLDivElement>;
+
+export { ARecord, ATAG, BIMI_CHECKER_SIGNAL_TYPES, BaseRadarMenuButton, BaseRadarMenuButtonContent, BimiCheckerSignalType, BimiRecord, CARD_STATUS, CMC, Canonicalization, ChecklistItem, CipherSuite, CnameRecord, DOMAIN_ANALYZER_SIGNAL_TYPES, Dkim, DkimAlgorithm, DkimAlignment, DkimSelector, DkimSignature, DkimSigningDomain, Dmarc, DmarcCompliant, DmarcPolicy, DomainAnalyzerSignalType, Ehlo, From, GLOSSARY_ICON_MAP, GlossaryIconType, GlossaryTerm, ITAG, KeyLength, MaxAge, Mode, MtaStsCertificate, MtaStsCertificateCnameName, MtaStsCertificateCnameType, MtaStsCertificateCnameValue, MtaStsCertificateExpiry, MtaStsPolicyFile, MtaStsRecord, Mx, PUBLIC_INVESTIGATE_SIGNAL_TYPES, Pct, PtrRecord, PublicInvestigateSignalType, Radar, RadarButton, RadarItem, RadarMenuButton, RadarMenuButtonContent, RadarMenuButtonContentFooter, RadarMenuButtonContentHeader, RadarMenuButtonContentMenu, RadarMenuButtonTrigger, RadarSimple, RadarSimpleMenuButton, ReturnPath, Rua, Ruf, SIGNAL_TYPES, STATUS_COLORS, STATUS_ICONS, STATUS_ICON_STYLES, SVG, SenderIp, SignalCardAmp, SignalCardAmpProps, SignalCardBimi, SignalCardBimiProps, SignalCardDkim, SignalCardDkimDomainAnalyzer, SignalCardDkimDomainAnalyzerProps, SignalCardDkimProps, SignalCardDmarc, SignalCardDmarcDomain, SignalCardDmarcDomainProps, SignalCardDmarcProps, SignalCardDnssec, SignalCardDnssecProps, SignalCardFcrdns, SignalCardFcrdnsProps, SignalCardGoogleYahooCompliance, SignalCardGoogleYahooComplianceProps, SignalCardList, SignalCardListProps, SignalCardMtaSts, SignalCardMtaStsProps, SignalCardSpf, SignalCardSpfDomain, SignalCardSpfDomainAnalyzer, SignalCardSpfDomainAnalyzerProps, SignalCardSpfDomainProps, SignalCardSpfProps, SignalCardSubdo, SignalCardSubdoProps, SignalCardTheme, SignalCardThemeProvider, SignalCardThemeProviderProps, SignalCardThreatInv, SignalCardThreatInvProps, SignalCardTls, SignalCardTlsProps, SignalCardUrls, SignalCardUrlsProps, SignalData, SignalType, SignedHeaders, SignerDomain, Sp, Spf, SpfAlignment, SpfDomain, SpfRecord, Ssl, SubdomainPolicy, Tls, TlsRptRecord, Ttl, TxtRecord, TxtRecords, VMC, Version, createGlossaryLink, extractData$2 as extractDKIMdata, extractDataOrchestrated as extractDMARCdata, extractData$3 as extractFCrDNSdata, extractData$1 as extractSPFdata, extractData as extractTLSdata, getHeloOrMailFrom, getSignalStatus, getStatusColor, getStatusIcon, getStatusIconStyle, glossaryLabelIds, isCardStatus, isFailureStatus, isSuccessStatus, isWarningStatus, mapStatusToDetailedCardColor, normalizeStatus, useResolvedTheme, useSignalCardTheme };