import { EventEmitter } from 'eventemitter3';
import { P as PulseConfig, S as ScanInput, a as ScanOptions, V as Verdict, D as DetectorResult, b as PublicVerdict } from './types-BpZyHhFT.js';
export { c as SignalBundle, d as VerdictKind } from './types-BpZyHhFT.js';

/**
 * The main entry point for Pulse Protocol.
 *
 * @example
 * ```ts
 * const pulse = new PulseProtocol({
 *   heliusApiKey: process.env.HELIUS_API_KEY!,
 *   xApiKey: process.env.X_API_KEY!,
 * });
 *
 * const verdict = await pulse.scan({
 *   handle: "some_agent",
 *   wallet: "6ySH9oi...",
 * });
 * ```
 */
declare class PulseProtocol {
    readonly events: EventEmitter;
    private readonly helius;
    private readonly x;
    private readonly config;
    constructor(config: PulseConfig);
    /**
     * Run a full scan on a target and return a verdict.
     *
     * This fetches X posts, on-chain history, cross-correlates them, runs all
     * five detectors, and aggregates the result. A typical scan completes in
     * 2-8 seconds depending on source latency.
     */
    scan(input: ScanInput, options?: ScanOptions): Promise<Verdict>;
    /**
     * Scan a batch of targets concurrently. Respects the configured rate limits
     * on underlying sources. Use for watchlists.
     */
    scanMany(inputs: ScanInput[], options?: ScanOptions): Promise<Verdict[]>;
}

/**
 * Aggregate a set of detector results into a final verdict.
 *
 * The algorithm:
 *  1. Collect each detector's 0-100 score.
 *  2. Multiply by its weight and sum.
 *  3. Check for major disagreements between detectors.
 *  4. Map the aggregate to a three-state verdict.
 *  5. Compute a confidence based on distance to the nearest threshold.
 */
declare function aggregate(target: ScanInput, detectors: DetectorResult[], options?: ScanOptions): Verdict;

/**
 * Sign a verdict with an ed25519 private key. Returns a `PublicVerdict`
 * ready to publish on the feed.
 */
declare function signVerdict(verdict: Verdict, privateKeyHex: string, feedUrl: string): Promise<PublicVerdict>;
/**
 * Verify a public verdict was signed by the given ed25519 public key and
 * that its commitment hash still matches the claimed target.
 */
declare function verifyVerdict(publicVerdict: PublicVerdict, publicKeyHex: string): Promise<boolean>;

/**
 * Error hierarchy used throughout Pulse Protocol. All errors extend the base
 * `PulseError` class so consumers can catch everything with one instanceof.
 */
declare class PulseError extends Error {
    constructor(message: string);
}
/** A scan failed entirely (one or more detectors could not run). */
declare class ScanError extends PulseError {
    readonly detector?: string;
    constructor(message: string, detector?: string);
}
/** A data source (Helius, X, DexScreener) returned an error or timed out. */
declare class SourceError extends PulseError {
    readonly source: string;
    readonly status?: number;
    constructor(source: string, message: string, status?: number);
}
/** A published verdict failed signature verification. */
declare class SignatureError extends PulseError {
    constructor(message: string);
}

/**
 * Pulse Protocol — Autonomous AI agent scanner for Solana.
 *
 * @packageDocumentation
 * @see https://github.com/williambrowndev/pulse-protocol
 */

declare const VERSION = "0.9.3";

export { DetectorResult, PublicVerdict, PulseConfig, PulseError, PulseProtocol, ScanError, ScanInput, ScanOptions, SignatureError, SourceError, VERSION, Verdict, aggregate, signVerdict, verifyVerdict };