type BriefingStatus = "DRAFT" | "PUBLISHED" | "SUPERSEDED" | "WITHDRAWN";
type CitationStatus = "current" | "superseded" | "withdrawn";
type Cadence = "daily" | "weekly" | "monthly";
type ImpactLevel = "informational" | "advisory" | "mandatory";
type DriftSeverity = "low" | "medium" | "high" | "critical";
type InterventionStatus = "DRAFT" | "APPROVED" | "REJECTED";
/** One regulatory body whose publications agents must track. */
interface RegulatorConfig {
    /** Stable abbreviation used as the primary key. E.g. "AUSTRAC", "ASIC". */
    id: string;
    name: string;
    /** ISO 3166-1 alpha-2 + optional subdivision. E.g. "AU", "AU-NSW". */
    jurisdiction: string;
    /** RSS feeds, notice pages, and API endpoints for this regulator. */
    publicationUrls: string[];
    /**
     * How often to poll for new publications.
     * Raise to "weekly" during high-churn rollouts (e.g. AUSTRAC Tranche 2).
     */
    cadence: Cadence;
    /** Domain tags for filtering and cross-reference. E.g. ["AML", "CTF"]. */
    tags: string[];
}
/**
 * A specific regulation, guidance document, or standard cited by a briefing.
 *
 * `version` encodes the publication's point-in-time identity: a document
 * version, effective date, or amendment number — whatever the regulator uses
 * to distinguish releases ("v3.2", "2024-01-15", "Amendment 5").
 */
interface CitationSource {
    id: string;
    regulatorId: string;
    title: string;
    url: string;
    version: string;
    effectiveDate?: Date;
    status: CitationStatus;
    /** When this snapshot was last confirmed against the live source. */
    observedAt: Date;
}
/**
 * A compliance briefing authored by an agent on behalf of an operator.
 *
 * Each briefing cites one or more CitationSources. When those sources move,
 * the briefing enters drift and the pipeline surfaces it for review.
 */
interface BriefingRecord {
    id: string;
    operatorId: string;
    title: string;
    status: BriefingStatus;
    citationIds: string[];
    content: string;
    version: number;
    createdAt: Date;
    updatedAt: Date;
    supersededById?: string;
}
/** One citation that has moved since the briefing was last reviewed. */
interface CitationDrift {
    citationId: string;
    regulatorId: string;
    previousVersion: string;
    currentVersion: string;
    changeDescription?: string;
    changeUrl?: string;
}
/** What DriftDetector found for a single briefing. */
interface DriftDetectionResult {
    briefingId: string;
    operatorId: string;
    outdatedCitations: CitationDrift[];
    /** Regulators whose rules interact with the updated ones (via CrossReferenceMap). */
    cascadingRegulatorIds: string[];
    severity: DriftSeverity;
    detectedAt: Date;
}
/** A publication or amendment detected from a regulator's feed. */
interface RegulatorUpdate {
    id: string;
    regulatorId: string;
    title: string;
    description?: string;
    url: string;
    publishedAt: Date;
    detectedAt: Date;
    /** Citation IDs this update supersedes, if determinable. */
    affectedCitationIds?: string[];
    newVersion?: string;
}
/** Encodes how one regulator's updates cascade to related regulatory areas. */
interface CrossReferenceRule {
    id: string;
    /** When this regulator updates, cascade checks to relatedRegulatorIds. */
    primaryRegulatorId: string;
    relatedRegulatorIds: string[];
    description: string;
    impactLevel: ImpactLevel;
}
/**
 * A pending briefing update produced by InterventionDrafter.
 *
 * Both draft fields are Markdown prose. Consumers route these through the
 * F0.6 ProposalStorage for operator approval before publishing.
 */
interface InterventionDraft {
    id: string;
    briefingId: string;
    operatorId: string;
    driftResult: DriftDetectionResult;
    /** Proposed replacement content for the briefing body. */
    briefingUpdateDraft: string;
    /** Concise client-facing summary for the approval notification. */
    clientNotificationDraft: string;
    status: InterventionStatus;
    createdAt: Date;
}
/** One entry in the audit trail of a briefing's lifecycle. */
interface VersionHistoryRecord {
    briefingId: string;
    version: number;
    status: BriefingStatus;
    content: string;
    reason?: string;
    createdAt: Date;
    supersededById?: string;
}
/** Persistence for CitationSource records. */
interface CitationStore {
    get(id: string): Promise<CitationSource | null>;
    listByIds(ids: string[]): Promise<CitationSource[]>;
    getByRegulator(regulatorId: string): Promise<CitationSource[]>;
    upsert(citation: CitationSource): Promise<CitationSource>;
}
/** Persistence for BriefingRecord documents. */
interface BriefingStore {
    get(id: string): Promise<BriefingRecord | null>;
    update(id: string, patch: Partial<BriefingRecord>): Promise<BriefingRecord>;
    listPublished(operatorId: string): Promise<BriefingRecord[]>;
    /** Return published briefings that reference any of the given citation IDs. */
    listByCitationIds(citationIds: string[]): Promise<BriefingRecord[]>;
}
/** Persistence for InterventionDraft records awaiting operator approval. */
interface InterventionStore {
    create(draft: Omit<InterventionDraft, "id" | "createdAt">): Promise<InterventionDraft>;
    get(id: string): Promise<InterventionDraft | null>;
    update(id: string, patch: Partial<InterventionDraft>): Promise<InterventionDraft>;
    listPending(): Promise<InterventionDraft[]>;
}
/** Append-only audit log for briefing version transitions. */
interface VersionHistoryStore {
    append(record: VersionHistoryRecord): Promise<void>;
    getHistory(briefingId: string): Promise<VersionHistoryRecord[]>;
    getLatest(briefingId: string): Promise<VersionHistoryRecord | null>;
}
/**
 * Adapter that retrieves new publications from a regulator's feed.
 *
 * Concrete implementations use Web Search, WebFetch, or regulator APIs.
 * The in-memory stub (InMemoryRegulatorPublicationFetcher) is supplied
 * for testing.
 */
interface RegulatorPublicationFetcher {
    fetchUpdates(regulatorId: string, since: Date): Promise<RegulatorUpdate[]>;
}

type PublicationClassification = "media-release" | "regulatory-guide" | "determination" | "ruling" | "guidance" | "standard-update" | "policy-update" | "notice" | "other";
type IndustryVertical = "financial-advisory" | "accounting" | "legal" | "real-estate" | "healthcare" | "gp" | "allied-health" | "dental" | "ndis-provider" | "all";
/**
 * Phase B scanner output. Superset of RegulatorUpdate that adds
 * scanner-level metadata (classification, citation ID, industry mapping,
 * dedup hash). A scanner-to-fetcher adapter projects this down to
 * RegulatorUpdate for consumption by Phase A's RegulatorWatcher.
 */
interface RegulatorPublication extends RegulatorUpdate {
    /** Citation identifier, e.g. "RG 99", "TR 2026/1", if extractable. */
    citationId?: string;
    classification: PublicationClassification;
    /** First ~500 chars of body, suitable for surfacing in notifications. */
    summary?: string;
    /** Full body if fetched (cache-friendly; optional). */
    rawBody?: string;
    /** sha256(title + publishedAt.toISOString() + sourceUrl). */
    hash: string;
    industryVerticals: IndustryVertical[];
    /** Canonical link. Alias of `url` for downstream-call clarity. */
    sourceUrl: string;
}
interface Scanner {
    /** Matches one of Phase A's KNOWN_AUSTRALIAN_REGULATORS ids. */
    regulatorId: string;
    /** Suggested polling interval (matches Phase A cadence translation). */
    intervalMinutes: number;
    scan(since?: Date): Promise<RegulatorPublication[]>;
}
/** Logger contract — fail-soft scanners emit warnings/errors through this. */
interface ScannerLogger {
    info(msg: string, ctx?: Record<string, unknown>): void;
    warn(msg: string, ctx?: Record<string, unknown>): void;
    error(msg: string, ctx?: Record<string, unknown>): void;
}

interface ScannerOrchestratorOptions {
    logger?: ScannerLogger;
    /** Cap dedup set to avoid memory leak in long-running processes. Default 10_000. */
    dedupCapacity?: number;
}
declare class ScannerOrchestrator {
    private readonly scanners;
    private readonly seen;
    private readonly timers;
    private readonly logger;
    private readonly dedupCapacity;
    constructor(options?: ScannerOrchestratorOptions);
    registerScanner(scanner: Scanner): void;
    listScanners(): Scanner[];
    /**
     * Run every registered scanner once, dedupe by hash, return only
     * publications not previously seen. Fail-soft per scanner.
     */
    runOnce(since?: Date): Promise<RegulatorPublication[]>;
    /**
     * Run a single registered scanner, dedupe, fail-soft.
     * Public so the fetcher adapter can call into one scanner at a time.
     */
    runScanner(regulatorId: string, since?: Date): Promise<RegulatorPublication[]>;
    /** Start per-scanner polling timers. Override interval applies to all. */
    start(intervalOverrideMinutes?: number): void;
    stop(): void;
    /** Drop dedup state (test hook + manual reset). */
    resetDedup(): void;
    /**
     * Project this orchestrator down to Phase A's RegulatorPublicationFetcher.
     * The watcher only sees the RegulatorUpdate fields; scanner-specific
     * metadata (citationId, hash, classification, industries) is stripped.
     */
    asFetcher(): RegulatorPublicationFetcher;
    private markSeen;
}

export { type BriefingRecord as B, type Cadence as C, type DriftDetectionResult as D, type ImpactLevel as I, type PublicationClassification as P, type RegulatorConfig as R, type Scanner as S, type VersionHistoryRecord as V, type BriefingStatus as a, type BriefingStore as b, type CitationDrift as c, type CitationSource as d, type CitationStatus as e, type CitationStore as f, type CrossReferenceRule as g, type DriftSeverity as h, type IndustryVertical as i, type InterventionDraft as j, type InterventionStatus as k, type InterventionStore as l, type RegulatorPublication as m, type RegulatorPublicationFetcher as n, type RegulatorUpdate as o, type ScannerLogger as p, ScannerOrchestrator as q, type ScannerOrchestratorOptions as r, type VersionHistoryStore as s };
