import { C as CandidateEvent, O as OperatorContext, R as RelevanceScore, T as TriggerSourceName, b as OperatorResponse, a as ChannelName, S as SurfacingMessage, U as Urgency } from './types-GeEw7wzC.js';
import { R as RelevanceScorer, C as CalibrationLearner, S as SurfacingChannel, T as TriggerSource } from './interfaces-elkYeYRS.js';
import Anthropic from '@anthropic-ai/sdk';
import { T as TelegramBot } from './types-CaN5aq6Y.js';

declare class RuleBasedRelevanceScorer implements RelevanceScorer {
    private readonly calibrationLearner;
    constructor(calibrationLearner: CalibrationLearner);
    score(candidate: CandidateEvent, operatorContext: OperatorContext): Promise<RelevanceScore>;
}

/** Configure which score range triggers the LLM sanity-check call. */
interface LlmBand {
    /** Scores below this are clearly irrelevant — LLM skipped. */
    lower: number;
    /** Scores above this are clearly relevant — LLM skipped. */
    upper: number;
}
declare class LLMAugmentedRelevanceScorer implements RelevanceScorer {
    private readonly baseScorer;
    private readonly anthropic;
    private readonly model;
    private readonly band;
    private readonly cacheTtlMs;
    private readonly cache;
    constructor(baseScorer: RelevanceScorer, anthropic: Anthropic, model?: string, band?: LlmBand, cacheTtlMs?: number);
    /**
     * Cache key for a (candidate, operator) pair. The candidate id is stable
     * across calls from the same TriggerSource within its short fetch window;
     * combining with operatorId isolates per-operator scoring.
     */
    private cacheKey;
    score(candidate: CandidateEvent, operatorContext: OperatorContext): Promise<RelevanceScore>;
    private callLlm;
}

/**
 * In-memory CalibrationLearner. Thread-safe within a single process.
 *
 * Replace with a Prisma-backed implementation in Batch 2 for persistence
 * across invocations and operators.
 */
declare class MemoryCalibrationLearner implements CalibrationLearner {
    /**
     * Outer key: operatorId. Inner key: sourceName.
     * Value: current calibration multiplier.
     */
    private readonly store;
    private getMultiplier;
    private setMultiplier;
    record(operatorId: string, sourceName: TriggerSourceName, _candidate: CandidateEvent, response: OperatorResponse): Promise<void>;
    getCalibration(operatorId: string, sourceName: TriggerSourceName): Promise<number>;
    /**
     * Inspect the internal state in tests without going through the public API.
     */
    snapshot(): Map<string, Map<TriggerSourceName, number>>;
}

interface TelegramSurfacingChannelConfig {
    bot: TelegramBot;
    /**
     * Fallback chat ID used when operatorContext.recentActivity.telegramChatId
     * is absent. Typically the operator's personal Telegram chat ID.
     */
    defaultChatId: number | string;
}
declare class TelegramSurfacingChannel implements SurfacingChannel {
    private readonly config;
    readonly name: ChannelName;
    constructor(config: TelegramSurfacingChannelConfig);
    format(candidate: CandidateEvent, score: RelevanceScore, _operatorContext: OperatorContext): SurfacingMessage;
    send(message: SurfacingMessage): Promise<{
        delivered: boolean;
        deliveredAt?: Date;
        error?: string;
    }>;
}
/**
 * Parse a `ps_<response>|<shortId>` callback_data string.
 *
 * Returns null if the string does not match the proactive surfacing format.
 * Consumers call this in their Telegram callback handler to detect surfacing
 * responses before routing to the generic proposal handler.
 */
declare function parseSurfacingCallback(callbackData: string): {
    response: "acted" | "dismissed" | "more_like_this" | "less_like_this";
    shortCandidateId: string;
} | null;

type SerializedSurfacingMessage = {
    /** Stable identifier for the queued message (not the CandidateEvent id). */
    id: string;
    operatorId: string;
    sourceName: string;
    /** Markdown-formatted body text. */
    body: string;
    cta?: {
        label: string;
        action: string;
    }[];
    /** Relevance score at the time of surfacing (0–1). */
    score: number;
    urgency: "now" | "morning_brief" | "weekly_brief";
    /** Original CandidateEvent payload for dashboard deep-links. */
    candidatePayload: Record<string, unknown>;
    enqueuedAt: Date;
    /** Set by markRead(); null/undefined while unread. */
    readAt?: Date;
};
interface SurfacingMessageQueue {
    enqueue(message: SerializedSurfacingMessage): Promise<void>;
    /**
     * List messages for an operator, newest-first.
     * @param operatorId — The operator whose inbox to read.
     * @param limit — Maximum number of messages to return. Default 50.
     */
    list(operatorId: string, limit?: number): Promise<SerializedSurfacingMessage[]>;
    /**
     * Mark a message as read.
     * No-op when operatorId or messageId is unknown.
     */
    markRead(operatorId: string, messageId: string): Promise<void>;
}
/**
 * InMemorySurfacingMessageQueue
 *
 * Reference implementation of `SurfacingMessageQueue` backed by a plain Map.
 * Safe for single-process use (the JS event loop serialises Map operations).
 *
 * Consumers that need multi-process or durable storage should implement
 * `SurfacingMessageQueue` against their Prisma schema (see README for the
 * recommended schema and a PrismaSurfacingMessageQueue skeleton).
 */
declare class InMemorySurfacingMessageQueue implements SurfacingMessageQueue {
    private readonly byOperator;
    enqueue(message: SerializedSurfacingMessage): Promise<void>;
    list(operatorId: string, limit?: number): Promise<SerializedSurfacingMessage[]>;
    markRead(operatorId: string, messageId: string): Promise<void>;
    /**
     * Return the raw internal map for test assertions.
     * Do not mutate the returned map.
     */
    snapshot(): Map<string, SerializedSurfacingMessage[]>;
}
/**
 * DashboardSurfacingChannel
 *
 * Implements `SurfacingChannel` for the Command Centre web dashboard.
 * Writes to a `SurfacingMessageQueue` instead of calling an external API.
 *
 * Usage:
 * ```typescript
 * const queue = new InMemorySurfacingMessageQueue(); // or PrismaQueue
 * const channel = new DashboardSurfacingChannel(queue);
 *
 * const pipeline = new ProactiveSurfacingPipeline(
 *   sources, scorer,
 *   new Map([["dashboard", channel]]),
 *   calibration,
 * );
 * ```
 */
declare class DashboardSurfacingChannel implements SurfacingChannel {
    private readonly queue;
    readonly name: ChannelName;
    /**
     * WeakMap captures the operatorId from format() so that send() can enqueue
     * to the correct operator inbox. The pipeline always calls format() then
     * send() in sequence on the same message object, so the entry is always
     * present by the time send() runs.
     */
    private readonly _operatorIds;
    constructor(queue: SurfacingMessageQueue);
    format(candidate: CandidateEvent, score: RelevanceScore, operatorContext: OperatorContext): SurfacingMessage;
    send(message: SurfacingMessage): Promise<{
        delivered: boolean;
        deliveredAt?: Date;
        error?: string;
    }>;
}

interface DebounceStore {
    recordSurfacingEvent(operatorId: string, sourceName: string, timestamp: Date): Promise<void>;
    /**
     * Count events within the last `windowMs` milliseconds for this
     * (operatorId, sourceName) pair.
     */
    countRecentEvents(operatorId: string, sourceName: string, windowMs: number): Promise<number>;
}
declare class InMemoryDebounceStore implements DebounceStore {
    private readonly store;
    private storeKey;
    private trimOlderThan24h;
    recordSurfacingEvent(operatorId: string, sourceName: string, timestamp: Date): Promise<void>;
    countRecentEvents(operatorId: string, sourceName: string, windowMs: number): Promise<number>;
}
interface QuietHours {
    /**
     * 24h hour at which the quiet period starts, inclusive.
     * E.g. 22 → quiet from 10pm.
     */
    start: number;
    /**
     * 24h hour at which the quiet period ends, exclusive.
     * E.g. 7 → quiet until 7am (surfacing resumes at 07:00).
     */
    end: number;
    /** IANA timezone identifier, e.g. "Australia/Perth". */
    tz: string;
}
interface DebounceConfig {
    /** Maximum surfacing events per source per hour. Default 5. */
    maxPerHour: number;
    /** Maximum surfacing events per source per day. Default 20. */
    maxPerDay: number;
    /** Optional quiet-hour window. Skipped for urgency === "now". */
    quietHours?: QuietHours;
}
declare class Debouncer {
    private readonly config;
    private readonly rateLimiter;
    constructor(store: DebounceStore, config?: Partial<DebounceConfig>);
    /**
     * Determine whether a candidate should be surfaced right now.
     *
     * Returns `{ allow: true }` when all guards pass, or
     * `{ allow: false, reason: "..." }` with the first blocking reason.
     */
    shouldSurface(operatorId: string, sourceName: string, candidateUrgency: Urgency): Promise<{
        allow: boolean;
        reason?: string;
    }>;
    /** Record that a candidate was surfaced. Call after successful delivery. */
    recordSurfaced(operatorId: string, sourceName: string): Promise<void>;
    private isInQuietHours;
}

declare class SurfacingAggregator {
    private readonly queues;
    private queueKey;
    /**
     * Enqueue a non-"now" candidate for batched delivery.
     *
     * If the queue hits VOLUME_THRESHOLD after this enqueue, the queue is
     * automatically flushed and the bundled SurfacingMessage(s) are returned.
     * Otherwise returns an empty array.
     *
     * "now" urgency items are passed through with a no-op (returns []) — the
     * caller is responsible for sending them immediately.
     */
    enqueue(candidate: CandidateEvent, score: RelevanceScore, channel: SurfacingChannel, operatorContext: OperatorContext): SurfacingMessage[];
    /**
     * Flush all queued candidates for an (operatorId, urgency) pair into a
     * single bundled SurfacingMessage. Returns [] if the queue is empty.
     *
     * Calling flush() for urgency === "now" is always a no-op (returns []).
     */
    flush(operatorId: string, urgency: Urgency): SurfacingMessage[];
    /**
     * Return the current queue length for an (operatorId, urgency) pair.
     * Useful for tests and monitoring.
     */
    queueLength(operatorId: string, urgency: Urgency): number;
}

/**
 * Per-operator overrides for the proactive surfacing pipeline.
 *
 * All fields are optional — absent fields fall back to pipeline defaults.
 */
interface OperatorPreferences {
    /**
     * Override the pipeline's global score threshold for this operator.
     * Range 0–1. E.g. 0.5 to surface more; 0.75 to surface only high-confidence signals.
     */
    scoreThreshold?: number;
    /**
     * Override the operator's preferred delivery channels.
     * Pipeline picks the first registered channel from this list.
     * When set, completely replaces the operatorContext.preferredChannels for this run.
     */
    preferredChannels?: ChannelName[];
    /**
     * Debounce configuration override for this operator.
     * Applied when the consumer wires a preference-aware Debouncer.
     * The default pipeline does not automatically apply debounceConfig from preferences.
     *
     * @see README — "Wiring per-operator debounce config"
     */
    debounceConfig?: Partial<DebounceConfig>;
    /**
     * Per-source enabled flag and score multiplier.
     *
     * Applied by the pipeline after scoring, before the threshold check:
     *   effectiveScore = originalScore × multiplier   (clamped to [0, 1])
     *
     * Setting enabled: false silences the source for this operator entirely.
     * Partial — you only need to specify sources you want to customise.
     */
    perSourceCalibration?: Partial<Record<TriggerSourceName, {
        enabled: boolean;
        multiplier: number;
    }>>;
    /**
     * Quiet hours override for this operator.
     * Applied when the consumer wires a preference-aware Debouncer.
     * The default pipeline does not automatically apply quietHours from preferences.
     *
     * @see README — "Wiring per-operator quiet hours"
     */
    quietHours?: QuietHours;
}
/**
 * Persistence contract for per-operator preferences.
 *
 * Reference implementation: `InMemoryOperatorPreferencesStore`.
 * Production use: implement against your Prisma schema (see README for schema).
 */
interface OperatorPreferencesStore {
    /**
     * Retrieve preferences for an operator.
     * Returns null when no preferences have been stored for this operatorId.
     */
    get(operatorId: string): Promise<OperatorPreferences | null>;
    /**
     * Create or update preferences for an operator.
     *
     * Merge semantics:
     *   - Top-level scalar fields (scoreThreshold, preferredChannels, quietHours)
     *     are replaced when present in `prefs`.
     *   - Nested objects (perSourceCalibration, debounceConfig) are shallow-merged:
     *     existing source keys are preserved; new keys are added or overridden.
     *
     * Returns the full merged preferences after the upsert.
     */
    upsert(operatorId: string, prefs: Partial<OperatorPreferences>): Promise<OperatorPreferences>;
}
/**
 * InMemoryOperatorPreferencesStore
 *
 * Reference implementation of `OperatorPreferencesStore` backed by a Map.
 * Suitable for tests and ephemeral processes.
 *
 * For production use, implement `OperatorPreferencesStore` against your
 * Prisma schema — see README for the recommended schema and skeleton.
 */
declare class InMemoryOperatorPreferencesStore implements OperatorPreferencesStore {
    private readonly store;
    get(operatorId: string): Promise<OperatorPreferences | null>;
    upsert(operatorId: string, prefs: Partial<OperatorPreferences>): Promise<OperatorPreferences>;
    /** Number of operators with stored preferences. Useful for test assertions. */
    size(): number;
    /** Clear all stored preferences (test teardown). */
    clear(): void;
}

/** Minimal logger interface — consumers inject console or a structured logger. */
interface PipelineLogger {
    info(message: string, meta?: Record<string, unknown>): void;
    warn(message: string, meta?: Record<string, unknown>): void;
    error(message: string, meta?: Record<string, unknown>): void;
}
interface ProactiveSurfacingPipelineOptions {
    /** Candidates scoring at or above this threshold are surfaced. Default 0.6. */
    scoreThreshold?: number;
    /**
     * Fallback channel when the operator has no preferredChannels or none of
     * the preferred channels are registered. Default "telegram".
     */
    fallbackChannel?: ChannelName;
    logger?: PipelineLogger;
    /**
     * Optional debouncer — rate-limits surfacing per (operatorId, sourceName).
     * When absent, no rate limiting is applied.
     */
    debouncer?: Debouncer;
    /**
     * Optional aggregator — batches morning_brief and weekly_brief candidates
     * into a single bundled message instead of sending them individually.
     * "now" urgency candidates always bypass the aggregator.
     */
    aggregator?: SurfacingAggregator;
    /**
     * Optional per-operator preferences store. When present, the pipeline reads
     * operator-specific preferences before each run and applies them as overrides
     * to pipeline defaults.
     *
     * Preferences applied automatically:
     *   scoreThreshold       — replaces options.scoreThreshold for this operator
     *   preferredChannels    — replaces operatorContext.preferredChannels
     *   perSourceCalibration — scales score post-scoring; enabled:false skips source
     *
     * Preferences that require custom wiring (see README):
     *   debounceConfig, quietHours — wire into a preference-aware Debouncer
     *
     * Precedence: operator preferences > pipeline defaults.
     */
    operatorPreferencesStore?: OperatorPreferencesStore;
}
declare class ProactiveSurfacingPipeline {
    private readonly triggerSources;
    private readonly scorer;
    private readonly channels;
    private readonly calibrationLearner;
    private readonly scoreThreshold;
    private readonly fallbackChannel;
    private readonly logger;
    private readonly debouncer;
    private readonly aggregator;
    private readonly operatorPreferencesStore;
    constructor(triggerSources: TriggerSource[], scorer: RelevanceScorer, channels: Map<ChannelName, SurfacingChannel>, calibrationLearner: CalibrationLearner, options?: ProactiveSurfacingPipelineOptions);
    /**
     * Run one pipeline cycle:
     *   0. Resolve per-operator preferences (if store is configured)
     *   1. Fetch candidates from all registered TriggerSources
     *   2. Filter expired candidates
     *   3. Score each candidate
     *   4. Apply perSourceCalibration (scale scores; skip disabled sources)
     *   5. Filter below effective threshold (pipeline default or operator override)
     *   6. For each above-threshold candidate:
     *      a. Check debouncer — skip if blocked
     *      b. Route through aggregator (non-now) or send immediately (now)
     *   7. Return all sent messages (immediate + auto-flushed bundles)
     */
    run(operatorContext: OperatorContext, since: Date): Promise<SurfacingMessage[]>;
    /**
     * Record an operator response for a previously surfaced candidate.
     * Delegates to CalibrationLearner — updates the multiplier for this
     * (operatorId, sourceName) pair.
     */
    recordResponse(operatorId: string, sourceName: TriggerSourceName, candidate: CandidateEvent, response: OperatorResponse): Promise<void>;
    /**
     * Pick the first channel from the operator's preferredChannels that is
     * registered, falling back to the configured fallback (default "telegram").
     */
    private pickChannel;
}

interface RateLimiterPerSourceConfig {
    maxPerHour?: number;
    maxPerDay?: number;
}
interface RateLimiterConfig {
    /** Defaults applied to every source without a perSource override. */
    default?: {
        maxPerHour: number;
        maxPerDay: number;
    };
    /** Per-source overrides keyed by sourceName. Partial — unset fields fall back to default. */
    perSource?: Record<string, RateLimiterPerSourceConfig>;
}
declare class RateLimiter {
    private readonly store;
    private readonly defaults;
    private readonly perSource;
    constructor(store: DebounceStore, config?: RateLimiterConfig);
    /**
     * Resolve the effective limits for a source — perSource override merged
     * over defaults.
     */
    private limitsFor;
    /**
     * Return `{ allow: true }` if both hourly and daily quotas have headroom;
     * `{ allow: false, reason }` with the first blocking quota otherwise.
     */
    allow(operatorId: string, sourceName: string): Promise<{
        allow: boolean;
        reason?: string;
    }>;
    /** Record a successful emission. Call after delivery succeeds. */
    record(operatorId: string, sourceName: string): Promise<void>;
}

/**
 * Structural type for the subset of a generated PrismaClient that
 * PrismaDebounceStore requires. Consumers pass their own PrismaClient;
 * TypeScript verifies structural compatibility at the call site.
 */
interface SurfacingPrismaClient {
    surfacingEmissionLog: {
        create(args: {
            data: {
                operatorId: string;
                sourceName: string;
                emittedAt: Date;
            };
        }): Promise<unknown>;
        count(args: {
            where: {
                operatorId: string;
                sourceName: string;
                emittedAt: {
                    gt: Date;
                };
            };
        }): Promise<number>;
    };
}
declare class PrismaDebounceStore implements DebounceStore {
    private readonly prisma;
    constructor(prisma: SurfacingPrismaClient);
    recordSurfacingEvent(operatorId: string, sourceName: string, timestamp: Date): Promise<void>;
    countRecentEvents(operatorId: string, sourceName: string, windowMs: number): Promise<number>;
}

/** A deal record returned by the consumer's CRM adapter. */
interface DealRecord {
    /** Stable deal identifier (CRM-native ID or UUID). */
    dealId: string;
    dealName: string;
    /** ISO timestamp of the most recent contact activity on this deal. */
    lastContactAt: Date;
    /** Optional: operator's deal stage label (e.g. "Proposal", "Negotiation"). */
    stage?: string;
    /** Optional: consumer-supplied relevance hint (0–1). Falls back to 0.6. */
    baseRelevance?: number;
    /** Optional: any additional signal text the scorer or formatter may use. */
    signalRationale?: string;
}
/** Consumer-supplied CRM adapter. Inject a real implementation at runtime. */
interface DealFetcher {
    fetchDeals(operatorId: string, since: Date): Promise<DealRecord[]>;
}
interface PipelineCoachingOptions {
    /**
     * Deals with last contact older than this threshold are considered cold.
     * Default 14 days.
     */
    coldThresholdDays?: number;
}
declare class PipelineCoachingTriggerSource implements TriggerSource {
    private readonly dealFetcher;
    readonly name: "pipeline";
    private readonly coldThresholdDays;
    constructor(dealFetcher: DealFetcher, options?: PipelineCoachingOptions);
    fetchCandidates(operatorContext: OperatorContext, since: Date): Promise<CandidateEvent[]>;
}
interface DummyCandidate {
    title: string;
    summary: string;
    baseRelevance: number;
    tags?: string[];
}
/**
 * DummyTriggerSource returns a fixed list of seeded CandidateEvents on
 * every fetchCandidates call. IDs are stable across calls if `stableIds`
 * is true (useful for asserting on callback data in tests).
 */
declare class DummyTriggerSource implements TriggerSource {
    readonly name: TriggerSourceName;
    private readonly candidates;
    private readonly stableIds;
    private cachedIds;
    constructor(name: TriggerSourceName, candidates: DummyCandidate[], options?: {
        stableIds?: boolean;
    });
    fetchCandidates(_operatorContext: OperatorContext, _since: Date): Promise<CandidateEvent[]>;
}
/**
 * Returns a pre-configured DummyTriggerSource with three representative
 * candidates across a range of relevance scores. Useful as a smoke-test
 * fixture when you need a quick pipeline that produces visible output.
 */
declare function makeDummyIntelSource(): DummyTriggerSource;

declare const index_CalibrationLearner: typeof CalibrationLearner;
declare const index_CandidateEvent: typeof CandidateEvent;
declare const index_ChannelName: typeof ChannelName;
type index_DashboardSurfacingChannel = DashboardSurfacingChannel;
declare const index_DashboardSurfacingChannel: typeof DashboardSurfacingChannel;
type index_DealFetcher = DealFetcher;
type index_DealRecord = DealRecord;
type index_DebounceConfig = DebounceConfig;
type index_DebounceStore = DebounceStore;
type index_Debouncer = Debouncer;
declare const index_Debouncer: typeof Debouncer;
type index_DummyCandidate = DummyCandidate;
type index_DummyTriggerSource = DummyTriggerSource;
declare const index_DummyTriggerSource: typeof DummyTriggerSource;
type index_InMemoryDebounceStore = InMemoryDebounceStore;
declare const index_InMemoryDebounceStore: typeof InMemoryDebounceStore;
type index_InMemoryOperatorPreferencesStore = InMemoryOperatorPreferencesStore;
declare const index_InMemoryOperatorPreferencesStore: typeof InMemoryOperatorPreferencesStore;
type index_InMemorySurfacingMessageQueue = InMemorySurfacingMessageQueue;
declare const index_InMemorySurfacingMessageQueue: typeof InMemorySurfacingMessageQueue;
type index_LLMAugmentedRelevanceScorer = LLMAugmentedRelevanceScorer;
declare const index_LLMAugmentedRelevanceScorer: typeof LLMAugmentedRelevanceScorer;
type index_LlmBand = LlmBand;
type index_MemoryCalibrationLearner = MemoryCalibrationLearner;
declare const index_MemoryCalibrationLearner: typeof MemoryCalibrationLearner;
declare const index_OperatorContext: typeof OperatorContext;
type index_OperatorPreferences = OperatorPreferences;
type index_OperatorPreferencesStore = OperatorPreferencesStore;
declare const index_OperatorResponse: typeof OperatorResponse;
type index_PipelineCoachingOptions = PipelineCoachingOptions;
type index_PipelineCoachingTriggerSource = PipelineCoachingTriggerSource;
declare const index_PipelineCoachingTriggerSource: typeof PipelineCoachingTriggerSource;
type index_PipelineLogger = PipelineLogger;
type index_PrismaDebounceStore = PrismaDebounceStore;
declare const index_PrismaDebounceStore: typeof PrismaDebounceStore;
type index_ProactiveSurfacingPipeline = ProactiveSurfacingPipeline;
declare const index_ProactiveSurfacingPipeline: typeof ProactiveSurfacingPipeline;
type index_ProactiveSurfacingPipelineOptions = ProactiveSurfacingPipelineOptions;
type index_QuietHours = QuietHours;
type index_RateLimiter = RateLimiter;
declare const index_RateLimiter: typeof RateLimiter;
type index_RateLimiterConfig = RateLimiterConfig;
type index_RateLimiterPerSourceConfig = RateLimiterPerSourceConfig;
declare const index_RelevanceScore: typeof RelevanceScore;
declare const index_RelevanceScorer: typeof RelevanceScorer;
type index_RuleBasedRelevanceScorer = RuleBasedRelevanceScorer;
declare const index_RuleBasedRelevanceScorer: typeof RuleBasedRelevanceScorer;
type index_SerializedSurfacingMessage = SerializedSurfacingMessage;
type index_SurfacingAggregator = SurfacingAggregator;
declare const index_SurfacingAggregator: typeof SurfacingAggregator;
declare const index_SurfacingChannel: typeof SurfacingChannel;
declare const index_SurfacingMessage: typeof SurfacingMessage;
type index_SurfacingMessageQueue = SurfacingMessageQueue;
type index_SurfacingPrismaClient = SurfacingPrismaClient;
type index_TelegramSurfacingChannel = TelegramSurfacingChannel;
declare const index_TelegramSurfacingChannel: typeof TelegramSurfacingChannel;
type index_TelegramSurfacingChannelConfig = TelegramSurfacingChannelConfig;
declare const index_TriggerSource: typeof TriggerSource;
declare const index_TriggerSourceName: typeof TriggerSourceName;
declare const index_Urgency: typeof Urgency;
declare const index_makeDummyIntelSource: typeof makeDummyIntelSource;
declare const index_parseSurfacingCallback: typeof parseSurfacingCallback;
declare namespace index {
  export { index_CalibrationLearner as CalibrationLearner, index_CandidateEvent as CandidateEvent, index_ChannelName as ChannelName, index_DashboardSurfacingChannel as DashboardSurfacingChannel, type index_DealFetcher as DealFetcher, type index_DealRecord as DealRecord, type index_DebounceConfig as DebounceConfig, type index_DebounceStore as DebounceStore, index_Debouncer as Debouncer, type index_DummyCandidate as DummyCandidate, index_DummyTriggerSource as DummyTriggerSource, index_InMemoryDebounceStore as InMemoryDebounceStore, index_InMemoryOperatorPreferencesStore as InMemoryOperatorPreferencesStore, index_InMemorySurfacingMessageQueue as InMemorySurfacingMessageQueue, index_LLMAugmentedRelevanceScorer as LLMAugmentedRelevanceScorer, type index_LlmBand as LlmBand, index_MemoryCalibrationLearner as MemoryCalibrationLearner, index_OperatorContext as OperatorContext, type index_OperatorPreferences as OperatorPreferences, type index_OperatorPreferencesStore as OperatorPreferencesStore, index_OperatorResponse as OperatorResponse, type index_PipelineCoachingOptions as PipelineCoachingOptions, index_PipelineCoachingTriggerSource as PipelineCoachingTriggerSource, type index_PipelineLogger as PipelineLogger, index_PrismaDebounceStore as PrismaDebounceStore, index_ProactiveSurfacingPipeline as ProactiveSurfacingPipeline, type index_ProactiveSurfacingPipelineOptions as ProactiveSurfacingPipelineOptions, type index_QuietHours as QuietHours, index_RateLimiter as RateLimiter, type index_RateLimiterConfig as RateLimiterConfig, type index_RateLimiterPerSourceConfig as RateLimiterPerSourceConfig, index_RelevanceScore as RelevanceScore, index_RelevanceScorer as RelevanceScorer, index_RuleBasedRelevanceScorer as RuleBasedRelevanceScorer, type index_SerializedSurfacingMessage as SerializedSurfacingMessage, index_SurfacingAggregator as SurfacingAggregator, index_SurfacingChannel as SurfacingChannel, index_SurfacingMessage as SurfacingMessage, type index_SurfacingMessageQueue as SurfacingMessageQueue, type index_SurfacingPrismaClient as SurfacingPrismaClient, index_TelegramSurfacingChannel as TelegramSurfacingChannel, type index_TelegramSurfacingChannelConfig as TelegramSurfacingChannelConfig, index_TriggerSource as TriggerSource, index_TriggerSourceName as TriggerSourceName, index_Urgency as Urgency, index_makeDummyIntelSource as makeDummyIntelSource, index_parseSurfacingCallback as parseSurfacingCallback };
}

export { DashboardSurfacingChannel as D, InMemoryDebounceStore as I, LLMAugmentedRelevanceScorer as L, MemoryCalibrationLearner as M, type OperatorPreferences as O, type PipelineCoachingOptions as P, type QuietHours as Q, RateLimiter as R, type SerializedSurfacingMessage as S, TelegramSurfacingChannel as T, type DealFetcher as a, type DealRecord as b, type DebounceConfig as c, type DebounceStore as d, Debouncer as e, type DummyCandidate as f, DummyTriggerSource as g, InMemoryOperatorPreferencesStore as h, InMemorySurfacingMessageQueue as i, type LlmBand as j, type OperatorPreferencesStore as k, PipelineCoachingTriggerSource as l, type PipelineLogger as m, PrismaDebounceStore as n, ProactiveSurfacingPipeline as o, type ProactiveSurfacingPipelineOptions as p, type RateLimiterConfig as q, type RateLimiterPerSourceConfig as r, RuleBasedRelevanceScorer as s, SurfacingAggregator as t, type SurfacingMessageQueue as u, type SurfacingPrismaClient as v, type TelegramSurfacingChannelConfig as w, index as x, makeDummyIntelSource as y, parseSurfacingCallback as z };
