/** Where the finding came from. */
type ScoutSourceName = "github_trending" | "producthunt_ai" | "hackernews_ai" | "anthropic_announcements" | "openai_announcements" | "google_ai_announcements" | "mcp_registry" | "skills_registry" | "ai_newsletter_feeds" | "conference_announcements" | "firecrawl_changelog";
/** Coarse classification of what was discovered. */
type ScoutFindingKind = "tool" | "skill" | "library" | "mcp_server" | "github_repo" | "service" | "sdk_release" | "announcement" | "newsletter_item";
/** Recommended next action for a finding. */
type ScoutRecommendation = "adopt" | "prototype" | "evaluate" | "monitor" | "skip";
/**
 * A single normalised observation emitted by a Scout scanner. Scanners are
 * responsible for de-duping within their own source (stable `externalId`)
 * before returning. Cross-source deduplication happens in `Scout.dailyScan`.
 */
interface ScoutFinding {
    /** Stable per-source identifier — typically repo slug, post ID, URL hash. */
    externalId: string;
    source: ScoutSourceName;
    kind: ScoutFindingKind;
    title: string;
    url: string;
    /** One-sentence summary. Scorers and recommenders read this. */
    summary: string;
    /** Free-form provider-specific fields: stars, vendor, author, version. */
    metadata: Record<string, unknown>;
    /** When the upstream source published this. */
    publishedAt?: Date;
    discoveredAt: Date;
}
/**
 * The sub-agent registry is Scout's ground truth for relevance scoring.
 * Each entry says "this sub-agent exists, here's what it currently does,
 * here are the capability tags it owns."
 *
 * Augmentation matches boost relevance; net-new capability matches still
 * count but at a lower weight.
 */
interface SubAgentRegistryEntry {
    /** Canonical sub-agent name — e.g. "Vera", "Nyx", "Ledger". */
    name: string;
    /** Module path — e.g. "compliance-freshness", "relationship-cadence". */
    module: string;
    /** One-line description of what this sub-agent does. */
    role: string;
    /** Capability keywords used for relevance matching. */
    capabilityTags: string[];
    /** Optional pain points / known gaps that Scout should hunt for solutions to. */
    knownGaps?: string[];
}
/**
 * A finding after it has been scored by the three Scout scorers. This is
 * what gets handed to the recommender and the surfacer.
 */
interface ScoredScoutFinding {
    finding: ScoutFinding;
    relevanceScore: number;
    impactScore: number;
    integrationEffortDays: 1 | 5 | 20;
    /** Composite priority — higher = surface sooner. */
    priorityScore: number;
    /** Which registry entry (if any) drove the relevance score. */
    matchedSubAgent?: SubAgentRegistryEntry;
    /** Why this score — produced by the scorer for transparency. */
    rationale: {
        relevance: string;
        impact: string;
        effort: string;
    };
}
/**
 * Integration recommender output — a Markdown-ready briefing block that the
 * surfacer wraps into either the Telegram digest or the Insights inbox card.
 */
interface ScoutRecommenderOutput {
    finding: ScoredScoutFinding;
    recommendation: ScoutRecommendation;
    /** 2-4 sentence executive summary. */
    briefing: string;
    /** Bulleted list of switching benefits. */
    benefits: string[];
    /** One-line risk note. */
    risk: string;
    /** Tightly worded next action. */
    nextAction: string;
}
/** Enable/disable individual scanners. Default: all enabled. */
type ScoutSourcesConfig = Partial<Record<ScoutSourceName, boolean>>;
/**
 * Per-customer (or per-operator) override hook. Lets a deployment narrow
 * Scout's focus to specific verticals or sub-agent priorities.
 */
interface ScoutFocusOverride {
    operatorId: string;
    /** Vertical hint, e.g. ["financial_advisory", "smsf", "compliance"]. */
    focusVerticals?: string[];
    /** Sub-agent names to prioritise — boosts relevance for these only. */
    prioritisedSubAgents?: string[];
    /** Additional capability keywords to treat as high-relevance. */
    additionalTags?: string[];
}
/**
 * A Scout scanner — wraps a single ecosystem source. Implementations live
 * under `src/sub-agents/scout/scanners/`. Each must:
 *   - read no secrets without an explicit env var
 *   - return `[]` on transient errors (do not throw — log via logger)
 *   - de-dupe within its own source before returning
 */
interface ScoutScanner {
    readonly source: ScoutSourceName;
    /**
     * Fetch findings published or discovered since the given timestamp.
     * Implementations may ignore `since` if the upstream API does not support
     * date filtering — Scout will dedupe by externalId.
     */
    scan(since: Date): Promise<ScoutFinding[]>;
}
/**
 * HTTP layer indirection so tests can mock fetch deterministically.
 * Reference impl uses globalThis.fetch.
 */
interface ScoutHttpClient {
    get(url: string, headers?: Record<string, string>): Promise<{
        status: number;
        body: string;
        headers: Record<string, string>;
    }>;
}
interface ScoutLogger {
    info(message: string, ctx?: Record<string, unknown>): void;
    warn(message: string, ctx?: Record<string, unknown>): void;
    error(message: string, ctx?: Record<string, unknown>): void;
}
/**
 * Where Scout pushes findings for downstream consumption. The reference
 * impl uses the in-memory store; production deployments swap in a
 * Prisma-backed implementation.
 */
interface ScoutFindingStore {
    /** Returns true if this is a new finding (not previously stored). */
    isNew(source: ScoutSourceName, externalId: string): Promise<boolean>;
    upsert(scored: ScoredScoutFinding): Promise<void>;
    listSince(since: Date, limit?: number): Promise<ScoredScoutFinding[]>;
    /** Returns top-N by priorityScore since the given date. */
    listTopRanked(since: Date, limit: number): Promise<ScoredScoutFinding[]>;
}

/**
 * Minimal candidate-event shape Scout emits. Mirrors F0.10 CandidateEvent
 * without importing it as a hard dep. Each candidate carries the full
 * recommendation payload so dashboards can render the briefing inline.
 */
interface ScoutCandidateEvent {
    id: string;
    sourceName: "intel";
    /** Sub-agent badge — always "scout" so the UI can route the chip. */
    subAgentBadge: "scout";
    payload: {
        title: string;
        url: string;
        summary: string;
        recommendation: string;
        briefing: string;
        benefits: string[];
        risk: string;
        nextAction: string;
        relevanceScore: number;
        impactScore: number;
        integrationEffortDays: number;
        priorityScore: number;
        matchedSubAgent?: string;
        /** F0.10 RuleBasedRelevanceScorer reads this. 0-1 from priorityScore/100. */
        baseRelevance: number;
    };
    occurredAt: Date;
    expiresAt: Date;
}
type PushCandidateFn = (event: ScoutCandidateEvent) => Promise<void>;
interface InboxPusherOptions {
    /** Lifetime of a surfaced candidate. Default: 7 days. */
    expiryHours?: number;
    /** Optional custom push function — defaults to the in-memory queue. */
    pushCandidate?: PushCandidateFn;
}
declare class InboxPusher {
    /** Holds events pushed via the default in-memory queue. Test-friendly. */
    readonly inMemoryQueue: ScoutCandidateEvent[];
    private readonly push;
    private readonly expiryHours;
    constructor(opts?: InboxPusherOptions);
    pushAll(recommendations: ScoutRecommenderOutput[]): Promise<void>;
}

interface ScoutOptions {
    /** Override the default sub-agent registry. */
    subAgentRegistry?: SubAgentRegistryEntry[];
    /** Enable/disable scanners by name. Default: all on. */
    sources?: ScoutSourcesConfig;
    /** Per-operator focus override. */
    focus?: ScoutFocusOverride;
    /** Override the default fetch-based HTTP client. */
    http?: ScoutHttpClient;
    /** Override the default console logger. */
    logger?: ScoutLogger;
    /** Override the default in-memory finding store. */
    store?: ScoutFindingStore;
    /** Replace the default scanner set entirely. */
    scanners?: ScoutScanner[];
    /** GitHub PAT — raises rate limits on github_trending, skills_registry, anthropic SDK feeds. */
    githubToken?: string;
    /** ProductHunt OAuth token — enables that scanner. */
    productHuntToken?: string;
    /** Where to push surfaced candidates. Default: in-memory queue. */
    inboxPusher?: InboxPusher;
}
interface DailyScanResult {
    scanId: string;
    ranAt: Date;
    scannersRun: ScoutSourceName[];
    scannersSkipped: ScoutSourceName[];
    totalFindings: number;
    newFindings: number;
    topPicks: ScoutRecommenderOutput[];
    digest: string;
    durationMs: number;
}
interface WeeklyDigestResult {
    windowStart: Date;
    windowEnd: Date;
    totalFindings: number;
    topPicks: ScoutRecommenderOutput[];
    digest: string;
}
declare class Scout {
    private readonly subAgentRegistry;
    private readonly sourcesConfig;
    private readonly focus?;
    private readonly http;
    private readonly logger;
    private readonly store;
    private readonly scanners;
    private readonly relevanceScorer;
    private readonly impactScorer;
    private readonly effortScorer;
    private readonly recommender;
    private readonly digestBuilder;
    private readonly inboxPusher;
    constructor(opts?: ScoutOptions);
    /** Returns the inbox pusher so consumers can read its in-memory queue. */
    get inbox(): InboxPusher;
    /** Returns the finding store so consumers can inspect history. */
    get findings(): ScoutFindingStore;
    private defaultScanners;
    /**
     * Run every enabled scanner once, score everything, push to inbox, and
     * return a digest plus the top picks.
     */
    dailyScan(options?: {
        sinceHours?: number;
        topN?: number;
    }): Promise<DailyScanResult>;
    /**
     * Aggregate the last 7 days (configurable) into a weekly summary digest.
     */
    weeklyDigest(options?: {
        sinceHours?: number;
        topN?: number;
    }): Promise<WeeklyDigestResult>;
    /**
     * One-off evaluation of a specific URL. Builds a synthetic ScoutFinding,
     * scores it, and returns the recommendation. Used when an operator
     * wants Scout's view on a specific tool they encountered.
     */
    evaluateTool(url: string, options?: {
        title?: string;
        summary?: string;
        kind?: ScoutFinding["kind"];
        metadata?: Record<string, unknown>;
    }): Promise<ScoutRecommenderOutput>;
    private scoreFinding;
}

/**
 * Default registry — covers the F2-F7 modules currently shipped in
 * agent-kit. Consumers can extend or replace this list via the Scout
 * constructor's `subAgentRegistry` option.
 */
declare const DEFAULT_SUB_AGENT_REGISTRY: SubAgentRegistryEntry[];
/**
 * Flattened capability vocabulary — all tags across all registry entries,
 * lower-cased and deduplicated. Used as the relevance scorer's keyword
 * vector for fast O(n*m) string-in-text matching.
 */
declare function flattenedCapabilityTags(registry: SubAgentRegistryEntry[]): string[];

/** Default user agent string sent on every Scout HTTP request. */
declare const SCOUT_USER_AGENT = "ScoutSubAgent/0.35 (+https://github.com/bw-advisory/sentinel-ai-agent-kit)";
/**
 * Fetch-based HTTP client. Times out after the configured number of
 * milliseconds via AbortController.
 */
declare class FetchScoutHttpClient implements ScoutHttpClient {
    private readonly opts;
    constructor(opts?: {
        timeoutMs?: number;
    });
    get(url: string, headers?: Record<string, string>): Promise<{
        status: number;
        body: string;
        headers: Record<string, string>;
    }>;
}
/** Records calls in memory — for unit tests. */
declare class InMemoryScoutHttpClient implements ScoutHttpClient {
    private readonly responder;
    readonly calls: {
        url: string;
        headers?: Record<string, string>;
    }[];
    constructor(responder: (url: string) => {
        status: number;
        body: string;
        headers?: Record<string, string>;
    });
    get(url: string, headers?: Record<string, string>): Promise<{
        status: number;
        body: string;
        headers: Record<string, string>;
    }>;
}
/** Default no-prefix console logger. */
declare class ConsoleScoutLogger implements ScoutLogger {
    info(message: string, ctx?: Record<string, unknown>): void;
    warn(message: string, ctx?: Record<string, unknown>): void;
    error(message: string, ctx?: Record<string, unknown>): void;
}
/** Silent logger — useful for tests. */
declare class SilentScoutLogger implements ScoutLogger {
    info(): void;
    warn(): void;
    error(): void;
}

declare class InMemoryScoutFindingStore implements ScoutFindingStore {
    private readonly bySource;
    private key;
    isNew(source: ScoutSourceName, externalId: string): Promise<boolean>;
    upsert(scored: ScoredScoutFinding): Promise<void>;
    listSince(since: Date, limit?: number): Promise<ScoredScoutFinding[]>;
    listTopRanked(since: Date, limit: number): Promise<ScoredScoutFinding[]>;
}

interface RelevanceScoreResult {
    score: number;
    matchedSubAgent?: SubAgentRegistryEntry;
    rationale: string;
}
declare class RelevanceScorer {
    private readonly registry;
    private readonly focus?;
    constructor(registry: SubAgentRegistryEntry[], focus?: ScoutFocusOverride | undefined);
    score(finding: ScoutFinding): RelevanceScoreResult;
}

interface ImpactScoreResult {
    score: number;
    rationale: string;
    components: {
        costReduction: number;
        capabilityUnlock: number;
        customerFacing: number;
        brand: number;
    };
}
declare class ImpactScorer {
    score(finding: ScoutFinding): ImpactScoreResult;
}

interface IntegrationEffortResult {
    effortDays: 1 | 5 | 20;
    rationale: string;
}
declare class IntegrationEffortScorer {
    score(finding: ScoutFinding): IntegrationEffortResult;
}

declare class IntegrationRecommender {
    recommend(scored: ScoredScoutFinding): ScoutRecommenderOutput;
}

interface DigestBuilderOptions {
    /** How many picks to include. Default: 3. */
    topN?: number;
    /** Optional header line, e.g. "Scout's picks — 2026-05-29". */
    header?: string;
}
declare class DigestBuilder {
    private readonly opts;
    constructor(opts?: DigestBuilderOptions);
    build(recommendations: ScoutRecommenderOutput[]): string;
}

interface FeedConfig {
    name: string;
    url: string;
}
declare class AiNewsletterFeedsScanner implements ScoutScanner {
    private readonly http;
    private readonly logger;
    private readonly opts;
    readonly source: "ai_newsletter_feeds";
    constructor(http: ScoutHttpClient, logger: ScoutLogger, opts?: {
        feeds?: FeedConfig[];
    });
    scan(since: Date): Promise<ScoutFinding[]>;
}

declare class AnthropicAnnouncementsScanner implements ScoutScanner {
    private readonly http;
    private readonly logger;
    private readonly opts;
    readonly source: "anthropic_announcements";
    constructor(http: ScoutHttpClient, logger: ScoutLogger, opts?: {
        githubToken?: string;
        feeds?: string[];
    });
    scan(since: Date): Promise<ScoutFinding[]>;
}

interface ConferenceConfig {
    name: string;
    url: string;
    /** Regex group 1 = title of the announcement. */
    titleRegex: RegExp;
}
declare class ConferenceAnnouncementsScanner implements ScoutScanner {
    private readonly http;
    private readonly logger;
    private readonly opts;
    readonly source: "conference_announcements";
    constructor(http: ScoutHttpClient, logger: ScoutLogger, opts?: {
        conferences?: ConferenceConfig[];
    });
    scan(_since: Date): Promise<ScoutFinding[]>;
}

declare class FirecrawlChangelogScanner implements ScoutScanner {
    private readonly http;
    private readonly logger;
    private readonly opts;
    readonly source: "firecrawl_changelog";
    constructor(http: ScoutHttpClient, logger: ScoutLogger, opts?: {
        githubToken?: string;
    });
    scan(since: Date): Promise<ScoutFinding[]>;
}

declare class GithubTrendingScanner implements ScoutScanner {
    private readonly http;
    private readonly logger;
    private readonly opts;
    readonly source: "github_trending";
    constructor(http: ScoutHttpClient, logger: ScoutLogger, opts?: {
        githubToken?: string;
        maxResultsPerQuery?: number;
    });
    scan(since: Date): Promise<ScoutFinding[]>;
}

declare class GoogleAiAnnouncementsScanner implements ScoutScanner {
    private readonly http;
    private readonly logger;
    private readonly opts;
    readonly source: "google_ai_announcements";
    constructor(http: ScoutHttpClient, logger: ScoutLogger, opts?: {
        githubToken?: string;
    });
    scan(since: Date): Promise<ScoutFinding[]>;
}

declare class HackernewsAiScanner implements ScoutScanner {
    private readonly http;
    private readonly logger;
    private readonly opts;
    readonly source: "hackernews_ai";
    constructor(http: ScoutHttpClient, logger: ScoutLogger, opts?: {
        hitsPerQuery?: number;
        minPoints?: number;
    });
    scan(since: Date): Promise<ScoutFinding[]>;
}

interface McpRegistryOpts {
    /** Optional additional Markdown URLs to scan (e.g. an Awesome-MCP list). */
    extraReadmeUrls?: string[];
}
declare class McpRegistryScanner implements ScoutScanner {
    private readonly http;
    private readonly logger;
    private readonly opts;
    readonly source: "mcp_registry";
    constructor(http: ScoutHttpClient, logger: ScoutLogger, opts?: McpRegistryOpts);
    scan(_since: Date): Promise<ScoutFinding[]>;
}

declare class OpenaiAnnouncementsScanner implements ScoutScanner {
    private readonly http;
    private readonly logger;
    private readonly opts;
    readonly source: "openai_announcements";
    constructor(http: ScoutHttpClient, logger: ScoutLogger, opts?: {
        githubToken?: string;
    });
    scan(since: Date): Promise<ScoutFinding[]>;
}

declare class ProductHuntAiScanner implements ScoutScanner {
    private readonly http;
    private readonly logger;
    private readonly opts;
    readonly source: "producthunt_ai";
    constructor(http: ScoutHttpClient, logger: ScoutLogger, opts?: {
        token?: string;
    });
    scan(since: Date): Promise<ScoutFinding[]>;
}

declare class SkillsRegistryScanner implements ScoutScanner {
    private readonly http;
    private readonly logger;
    private readonly opts;
    readonly source: "skills_registry";
    constructor(http: ScoutHttpClient, logger: ScoutLogger, opts?: {
        githubToken?: string;
    });
    scan(_since: Date): Promise<ScoutFinding[]>;
}

type index_AiNewsletterFeedsScanner = AiNewsletterFeedsScanner;
declare const index_AiNewsletterFeedsScanner: typeof AiNewsletterFeedsScanner;
type index_AnthropicAnnouncementsScanner = AnthropicAnnouncementsScanner;
declare const index_AnthropicAnnouncementsScanner: typeof AnthropicAnnouncementsScanner;
type index_ConferenceAnnouncementsScanner = ConferenceAnnouncementsScanner;
declare const index_ConferenceAnnouncementsScanner: typeof ConferenceAnnouncementsScanner;
type index_ConsoleScoutLogger = ConsoleScoutLogger;
declare const index_ConsoleScoutLogger: typeof ConsoleScoutLogger;
declare const index_DEFAULT_SUB_AGENT_REGISTRY: typeof DEFAULT_SUB_AGENT_REGISTRY;
type index_DailyScanResult = DailyScanResult;
type index_DigestBuilder = DigestBuilder;
declare const index_DigestBuilder: typeof DigestBuilder;
type index_DigestBuilderOptions = DigestBuilderOptions;
type index_FetchScoutHttpClient = FetchScoutHttpClient;
declare const index_FetchScoutHttpClient: typeof FetchScoutHttpClient;
type index_FirecrawlChangelogScanner = FirecrawlChangelogScanner;
declare const index_FirecrawlChangelogScanner: typeof FirecrawlChangelogScanner;
type index_GithubTrendingScanner = GithubTrendingScanner;
declare const index_GithubTrendingScanner: typeof GithubTrendingScanner;
type index_GoogleAiAnnouncementsScanner = GoogleAiAnnouncementsScanner;
declare const index_GoogleAiAnnouncementsScanner: typeof GoogleAiAnnouncementsScanner;
type index_HackernewsAiScanner = HackernewsAiScanner;
declare const index_HackernewsAiScanner: typeof HackernewsAiScanner;
type index_ImpactScorer = ImpactScorer;
declare const index_ImpactScorer: typeof ImpactScorer;
type index_InMemoryScoutFindingStore = InMemoryScoutFindingStore;
declare const index_InMemoryScoutFindingStore: typeof InMemoryScoutFindingStore;
type index_InMemoryScoutHttpClient = InMemoryScoutHttpClient;
declare const index_InMemoryScoutHttpClient: typeof InMemoryScoutHttpClient;
type index_InboxPusher = InboxPusher;
declare const index_InboxPusher: typeof InboxPusher;
type index_InboxPusherOptions = InboxPusherOptions;
type index_IntegrationEffortScorer = IntegrationEffortScorer;
declare const index_IntegrationEffortScorer: typeof IntegrationEffortScorer;
type index_IntegrationRecommender = IntegrationRecommender;
declare const index_IntegrationRecommender: typeof IntegrationRecommender;
type index_McpRegistryScanner = McpRegistryScanner;
declare const index_McpRegistryScanner: typeof McpRegistryScanner;
type index_OpenaiAnnouncementsScanner = OpenaiAnnouncementsScanner;
declare const index_OpenaiAnnouncementsScanner: typeof OpenaiAnnouncementsScanner;
type index_ProductHuntAiScanner = ProductHuntAiScanner;
declare const index_ProductHuntAiScanner: typeof ProductHuntAiScanner;
type index_PushCandidateFn = PushCandidateFn;
type index_RelevanceScorer = RelevanceScorer;
declare const index_RelevanceScorer: typeof RelevanceScorer;
declare const index_SCOUT_USER_AGENT: typeof SCOUT_USER_AGENT;
type index_ScoredScoutFinding = ScoredScoutFinding;
type index_Scout = Scout;
declare const index_Scout: typeof Scout;
type index_ScoutCandidateEvent = ScoutCandidateEvent;
type index_ScoutFinding = ScoutFinding;
type index_ScoutFindingKind = ScoutFindingKind;
type index_ScoutFindingStore = ScoutFindingStore;
type index_ScoutFocusOverride = ScoutFocusOverride;
type index_ScoutHttpClient = ScoutHttpClient;
type index_ScoutLogger = ScoutLogger;
type index_ScoutOptions = ScoutOptions;
type index_ScoutRecommendation = ScoutRecommendation;
type index_ScoutRecommenderOutput = ScoutRecommenderOutput;
type index_ScoutScanner = ScoutScanner;
type index_ScoutSourceName = ScoutSourceName;
type index_ScoutSourcesConfig = ScoutSourcesConfig;
type index_SilentScoutLogger = SilentScoutLogger;
declare const index_SilentScoutLogger: typeof SilentScoutLogger;
type index_SkillsRegistryScanner = SkillsRegistryScanner;
declare const index_SkillsRegistryScanner: typeof SkillsRegistryScanner;
type index_SubAgentRegistryEntry = SubAgentRegistryEntry;
type index_WeeklyDigestResult = WeeklyDigestResult;
declare const index_flattenedCapabilityTags: typeof flattenedCapabilityTags;
declare namespace index {
  export { index_AiNewsletterFeedsScanner as AiNewsletterFeedsScanner, index_AnthropicAnnouncementsScanner as AnthropicAnnouncementsScanner, index_ConferenceAnnouncementsScanner as ConferenceAnnouncementsScanner, index_ConsoleScoutLogger as ConsoleScoutLogger, index_DEFAULT_SUB_AGENT_REGISTRY as DEFAULT_SUB_AGENT_REGISTRY, type index_DailyScanResult as DailyScanResult, index_DigestBuilder as DigestBuilder, type index_DigestBuilderOptions as DigestBuilderOptions, index_FetchScoutHttpClient as FetchScoutHttpClient, index_FirecrawlChangelogScanner as FirecrawlChangelogScanner, index_GithubTrendingScanner as GithubTrendingScanner, index_GoogleAiAnnouncementsScanner as GoogleAiAnnouncementsScanner, index_HackernewsAiScanner as HackernewsAiScanner, index_ImpactScorer as ImpactScorer, index_InMemoryScoutFindingStore as InMemoryScoutFindingStore, index_InMemoryScoutHttpClient as InMemoryScoutHttpClient, index_InboxPusher as InboxPusher, type index_InboxPusherOptions as InboxPusherOptions, index_IntegrationEffortScorer as IntegrationEffortScorer, index_IntegrationRecommender as IntegrationRecommender, index_McpRegistryScanner as McpRegistryScanner, index_OpenaiAnnouncementsScanner as OpenaiAnnouncementsScanner, index_ProductHuntAiScanner as ProductHuntAiScanner, type index_PushCandidateFn as PushCandidateFn, index_RelevanceScorer as RelevanceScorer, index_SCOUT_USER_AGENT as SCOUT_USER_AGENT, type index_ScoredScoutFinding as ScoredScoutFinding, index_Scout as Scout, type index_ScoutCandidateEvent as ScoutCandidateEvent, type index_ScoutFinding as ScoutFinding, type index_ScoutFindingKind as ScoutFindingKind, type index_ScoutFindingStore as ScoutFindingStore, type index_ScoutFocusOverride as ScoutFocusOverride, type index_ScoutHttpClient as ScoutHttpClient, type index_ScoutLogger as ScoutLogger, type index_ScoutOptions as ScoutOptions, type index_ScoutRecommendation as ScoutRecommendation, type index_ScoutRecommenderOutput as ScoutRecommenderOutput, type index_ScoutScanner as ScoutScanner, type index_ScoutSourceName as ScoutSourceName, type index_ScoutSourcesConfig as ScoutSourcesConfig, index_SilentScoutLogger as SilentScoutLogger, index_SkillsRegistryScanner as SkillsRegistryScanner, type index_SubAgentRegistryEntry as SubAgentRegistryEntry, type index_WeeklyDigestResult as WeeklyDigestResult, index_flattenedCapabilityTags as flattenedCapabilityTags };
}

export { AiNewsletterFeedsScanner as A, type ScoutScanner as B, ConferenceAnnouncementsScanner as C, DEFAULT_SUB_AGENT_REGISTRY as D, type ScoutSourceName as E, FetchScoutHttpClient as F, GithubTrendingScanner as G, HackernewsAiScanner as H, ImpactScorer as I, type ScoutSourcesConfig as J, SilentScoutLogger as K, SkillsRegistryScanner as L, McpRegistryScanner as M, type SubAgentRegistryEntry as N, OpenaiAnnouncementsScanner as O, ProductHuntAiScanner as P, flattenedCapabilityTags as Q, RelevanceScorer as R, SCOUT_USER_AGENT as S, index as T, type WeeklyDigestResult as W, AnthropicAnnouncementsScanner as a, ConsoleScoutLogger as b, type DailyScanResult as c, DigestBuilder as d, type DigestBuilderOptions as e, FirecrawlChangelogScanner as f, GoogleAiAnnouncementsScanner as g, InMemoryScoutFindingStore as h, InMemoryScoutHttpClient as i, InboxPusher as j, type InboxPusherOptions as k, IntegrationEffortScorer as l, IntegrationRecommender as m, type PushCandidateFn as n, type ScoredScoutFinding as o, Scout as p, type ScoutCandidateEvent as q, type ScoutFinding as r, type ScoutFindingKind as s, type ScoutFindingStore as t, type ScoutFocusOverride as u, type ScoutHttpClient as v, type ScoutLogger as w, type ScoutOptions as x, type ScoutRecommendation as y, type ScoutRecommenderOutput as z };
