type Provider = "stripe" | "braintree" | "github" | "slack";
type HeadersLike = Record<string, string | string[] | undefined>;
type NormalizedEvent = {
    id: string;
    source: Provider;
    type: string;
    createdAt: Date;
    payload: unknown;
    raw: Buffer;
    requestId?: string;
};
type VerifierConfig = {
    toleranceSec?: number;
    stripe?: {
        endpointSecret: string;
        useSdk?: boolean;
    };
    braintree?: {
        merchantId: string;
        publicKey: string;
        privateKey: string;
        environment?: "sandbox" | "production";
    };
    github?: {
        secret: string;
    };
    slack?: {
        signingSecret: string;
    };
};

declare function createVerifier(cfg: VerifierConfig): (source: Provider, headers: HeadersLike, raw: Buffer) => Promise<NormalizedEvent>;

interface DedupStore {
    seen(id: string, ttlSec?: number): Promise<boolean>;
}

declare class MemoryStore implements DedupStore {
    private ttl;
    private map;
    private timer?;
    constructor(opts?: {
        ttlSec?: number;
        sweepMs?: number;
    });
    seen(id: string, ttlSec?: number): Promise<boolean>;
    private gc;
}

declare class RedisStore implements DedupStore {
    private client;
    private clientReady;
    private prefix;
    constructor(opts: {
        url: string;
        keyPrefix?: string;
    });
    seen(id: string, ttlSec?: number): Promise<boolean>;
}

type Handler<T = unknown> = (evt: NormalizedEvent & {
    context?: T;
}) => Promise<void> | void;
declare function createDispatcher<T = unknown>(): {
    on(eventName: string, handler: Handler<T>): void;
    dispatch(eventName: string, evt: NormalizedEvent & {
        context?: T;
    }): Promise<void>;
};

export { MemoryStore, type NormalizedEvent, type Provider, RedisStore, type VerifierConfig, createDispatcher, createVerifier };